diff --git a/.gitattributes b/.gitattributes
index a6344aac8c09253b3b630fb776ae94478aa0275b..c64b2e8d6b1c323afb4a0d50fbe025e164500bdf 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+kortex_api/lib/release/KortexApiCpp_without_protobuf.lib filter=lfs diff=lfs merge=lfs -text
+kortex_api/lib/release/KortexApiCpp.lib filter=lfs diff=lfs merge=lfs -text
diff --git a/kortex_api/include/client/FrameHandler.h b/kortex_api/include/client/FrameHandler.h
new file mode 100644
index 0000000000000000000000000000000000000000..cbd56f0d2d3b40435414aca8f898f84dc0aae693
--- /dev/null
+++ b/kortex_api/include/client/FrameHandler.h
@@ -0,0 +1,67 @@
+#ifndef _FRAME_HANDLER_H_
+#define _FRAME_HANDLER_H_
+#undef _HAS_STD_BYTE
+#include <iostream>
+#include <list>
+#include <future>
+#include <memory>
+#include <queue>
+#include <chrono>
+
+#include "common/HeaderInfo.h"
+#include "messages/Frame.pb.h"
+
+using namespace std::chrono;
+
+namespace Kinova {
+    namespace Api {
+        struct CallbackTimeoutStruct {
+            uint32_t m_timeout;
+            steady_clock::time_point m_registeredTimePoint;
+
+            explicit CallbackTimeoutStruct(uint32_t timeout)
+                : m_timeout(timeout) {
+                m_registeredTimePoint = time_point_cast<milliseconds>(steady_clock::now());
+            }
+
+            bool checkExpiry() {
+                uint32_t duration = duration_cast<milliseconds>(steady_clock::now() - m_registeredTimePoint).count();
+                return (duration >= m_timeout);
+            }
+        };
+
+        typedef std::function<void (const Kinova::Api::Frame &)> MessageCallback;
+        typedef std::queue<std::pair<uint32_t, CallbackTimeoutStruct> > TimeoutClockByMeesageCallbackQueue;
+
+        class FrameHandler {
+        public:
+            explicit FrameHandler(uint32_t maxCallbackTimeout = 60000);
+
+            ~FrameHandler() = default;
+
+            std::future<Frame> registerMessage(uint32_t msgId);
+
+            // TODO sfforget 2018-05-30 Add error callback
+            void registerMessageCallback(uint32_t msgId, const MessageCallback &callback);
+
+            Error manageReceivedMessage(Frame &msgFrame);
+
+            void setMessageException(HeaderInfo &headerInfo, Error &error);
+
+        private:
+            void cleanDanglingCallback();
+
+            std::mutex m_mutex;
+            uint32_t m_maxCallbackTimeout;
+            // IdGenerator<uint32_t> m_apiIdGenerator;
+
+            // TODO cleanup messages without response from server to avoid memory leak.
+            // todoErr add the validation information beside the message promise
+            std::unordered_map<uint32_t, std::shared_ptr<std::promise<Frame> > > m_messagePromises;
+            TimeoutClockByMeesageCallbackQueue m_timeoutClockByCallback;
+            std::unordered_map<uint32_t, MessageCallback> m_messageCallbacks;
+        };
+    }
+}
+
+#endif // _MESSAGE_MANAGER_H_
diff --git a/kortex_api/include/client/IRouterClient.h b/kortex_api/include/client/IRouterClient.h
new file mode 100644
index 0000000000000000000000000000000000000000..af332956ee69d531b10f63c82a504306131031d1
--- /dev/null
+++ b/kortex_api/include/client/IRouterClient.h
@@ -0,0 +1,55 @@
+#ifndef _I_ROUTER_CLIENT_H_
+#define _I_ROUTER_CLIENT_H_
+
+
+#include <string>
+#include <future>
+#include <functional>
+#include <exception>
+
+#include "messages/Frame.pb.h"
+
+#include "ITransportClient.h"
+#include "common/KError.h"
+
+using namespace std;
+
+namespace Kinova
+{
+namespace Api
+{
+    typedef std::function<void (const Kinova::Api::Frame&)> MessageCallback;
+
+    typedef struct
+    {
+        bool andForget;
+        uint32_t delay_ms;
+        uint32_t timeout_ms;
+    
+    } RouterClientSendOptions;
+
+    class IRouterClient
+    {
+    public:
+        virtual ~IRouterClient() {}
+
+        virtual void reset() = 0;
+        virtual void registerBridgingCallback(std::function<void (Frame &)> bridgingCallback) = 0;
+        virtual void registerNotificationCallback( uint32_t serviceId, function<Error (Frame&)> ) = 0;
+        virtual void registerErrorCallback( function<void(KError)> callback ) = 0;
+        virtual void registerHitCallback(std::function<void (FrameTypes)> hitSessionCallback) = 0;
+
+        virtual future<Frame> send(const std::string& txPayload, uint32_t serviceVersion, uint32_t funcId, uint32_t deviceId, const RouterClientSendOptions& options ) = 0;
+        virtual Error sendWithCallback(const std::string& txPayload, uint32_t serviceVersion, uint32_t funcId, uint32_t deviceId, MessageCallback callback) = 0;
+        virtual Error sendMsgFrame(const Frame& msgFrame) = 0;
+
+        virtual uint16_t getConnectionId() = 0;
+        virtual void SetActivationStatus(bool isActive) = 0;
+
+        virtual ITransportClient* getTransport() = 0;
+    };
+
+} // namespace Api
+} // namespace Kinova
+
+#endif // _I_ROUTER_CLIENT_H_
diff --git a/kortex_api/include/client/ITransportClient.h b/kortex_api/include/client/ITransportClient.h
new file mode 100644
index 0000000000000000000000000000000000000000..94b28dbd7b89e98d04925880e24030a1c01bc36d
--- /dev/null
+++ b/kortex_api/include/client/ITransportClient.h
@@ -0,0 +1,61 @@
+#ifndef _I_TRANSPORT_CLIENT_H_
+#define _I_TRANSPORT_CLIENT_H_
+
+
+#include <string>
+#include <functional>
+#include <exception>
+
+#include <cmath>
+
+using namespace std;
+
+namespace Kinova
+{
+namespace Api
+{
+    // enums
+    enum TransportReadyStateEnum 
+    {
+        CONNECTING = 0,
+        OPEN = 1,
+        CLOSING = 2,
+        CLOSED = 3,
+        UNINITIALIZED = 4,
+        RECONNECTING = 5,
+    };
+
+    // interface
+    class ITransportClient
+    {
+    public:
+        TransportReadyStateEnum readyState;
+
+        virtual ~ITransportClient() {}
+
+        virtual bool connect(std::string host, uint32_t port) = 0;
+        virtual void disconnect() = 0;
+
+        virtual void send(const char* txBuffer, uint32_t txSize) = 0;
+        virtual void onMessage(std::function<void (const char*, uint32_t)> callback) = 0;
+
+        // virtual void onClose(ConnectionClose eventClose)> callback) = 0;
+        // virtual void onError(ConnectionError error)> callback) = 0;
+
+        // virtual bool isClosed() = 0;
+        // virtual bool isClosing() = 0;
+        // virtual bool isConnecting() = 0;
+        // virtual bool isOpen() = 0;
+        // virtual bool isUninitialized() = 0;
+
+        virtual char* getTxBuffer(uint32_t const& allocation_size) = 0;
+        virtual size_t getMaxTxBufferSize() = 0;
+
+        virtual void getHostAddress(std::string &host, uint32_t &port) = 0;
+    };
+
+
+} // namespace Api
+} // namespace Kinova
+
+#endif // _I_TRANSPORT_CLIENT_H_
diff --git a/kortex_api/include/client/NotificationHandler.h b/kortex_api/include/client/NotificationHandler.h
new file mode 100644
index 0000000000000000000000000000000000000000..c74e2fc772331ccc51790cfa74716526cd10c956
--- /dev/null
+++ b/kortex_api/include/client/NotificationHandler.h
@@ -0,0 +1,96 @@
+#ifndef _NOTIFICATION_HANDLER_H_
+#define _NOTIFICATION_HANDLER_H_
+
+
+#include <memory>
+#include <map>
+#include <vector>
+#include <functional>
+#include <future>
+
+#include "common/KBasicException.h"
+#include "common/KDetailedException.h"
+
+#include "messages/Frame.pb.h"
+
+#include "ITransportClient.h"
+#include "IRouterClient.h"
+
+namespace Kinova
+{
+namespace Api
+{
+
+    struct AbstractCallbackFunction
+    {
+        AbstractCallbackFunction() = default;
+        virtual ~AbstractCallbackFunction() = default;
+
+        virtual Error call(Frame& msgFrameNotif) = 0;
+    };
+
+    template <class DataType>
+    struct CallbackFunction : public AbstractCallbackFunction
+    {
+        static constexpr bool isOk = std::is_base_of<::google::protobuf::Message, DataType>::value;
+        static_assert(isOk, "DataType must inherit from ::google::protobuf::Message");
+
+        std::function< void (DataType) > m_callbackFct;
+
+        CallbackFunction(std::function< void(DataType) > callback) : AbstractCallbackFunction() { m_callbackFct = callback; }
+        virtual ~CallbackFunction() override {}
+
+        virtual Error call(Frame& msgFrameNotif) override
+        {
+            Error error;
+            error.set_error_code(ErrorCodes::ERROR_NONE);
+
+            DataType decodedMsgNotif;
+            if( !decodedMsgNotif.ParseFromString(msgFrameNotif.payload()) )
+            {
+                HeaderInfo headerInfo( msgFrameNotif.header() );
+
+                error.set_error_code(ERROR_PROTOCOL_CLIENT);
+                error.set_error_sub_code(PAYLOAD_DECODING_ERR);
+                error.set_error_sub_string(string("The data payload could not be deserialized : notification for serviceId=") + to_string(headerInfo.m_serviceInfo.serviceId) + " \n");
+            }
+            else
+            {
+                // todo ???  thread(m_callbackFct, move(decodedMsgNotif)).detach();
+                thread(m_callbackFct, decodedMsgNotif).detach();
+            }
+
+            return error;
+        }
+    };
+
+    // todoErr add the validation information beside the callback
+    typedef std::unordered_map< uint32_t, std::unique_ptr<AbstractCallbackFunction>> CallbackMap;
+
+    class NotificationHandler
+    {
+        CallbackMap     m_callbackMap;
+        std::mutex      m_mutex;
+
+    public:
+        NotificationHandler();
+        ~NotificationHandler();
+
+        template <class DataType>
+        void addCallback( uint32_t idKey, std::function<void(DataType)> callback )
+        {
+            std::lock_guard<std::mutex> w_scoped(m_mutex);
+            std::unique_ptr<AbstractCallbackFunction> fct{new CallbackFunction<DataType>(callback)};
+            m_callbackMap[idKey] = std::move(fct);
+        }
+
+        void clearIdKeyCallbacks( uint32_t idKey );
+        void clearAll();
+
+        Error call(Frame& msgFrameNotif);
+    };
+
+}
+}
+
+#endif // _NOTIFICATION_HANDLER_H_
diff --git a/kortex_api/include/client/RouterClient.h b/kortex_api/include/client/RouterClient.h
new file mode 100644
index 0000000000000000000000000000000000000000..bcad4d3dca9c1a9c5bd1482c4361efb7d768ea1a
--- /dev/null
+++ b/kortex_api/include/client/RouterClient.h
@@ -0,0 +1,73 @@
+#ifndef _ROUTER_CLIENT_H_
+#define _ROUTER_CLIENT_H_
+
+
+#include <string>
+#include <future>
+#include <functional>
+#include <exception>
+
+#include "messages/Frame.pb.h"
+
+#include "ITransportClient.h"
+#include "IRouterClient.h"
+
+#include "FrameHandler.h"
+
+
+using namespace std;
+
+namespace Kinova
+{
+namespace Api
+{
+
+    typedef map< uint32_t, function<Error (Frame&)> > NotificationServices;
+
+    class RouterClient : public IRouterClient
+    {
+	private:
+        ITransportClient* const m_transport;
+    
+        NotificationServices        m_notificationServices;
+        function<void(KError)>      m_errorCallback;
+        function<void(FrameTypes)>  m_hitSessionCallback;
+        function<void(Frame&)>      m_bridgingCallback;
+
+        FrameHandler            m_frameHandler;
+        uint16_t                m_msgId;
+        uint16_t                m_sessionId;
+
+        //A flag indicating if the instance can be used.
+        bool                    m_isActive;
+
+        std::mutex              m_send_mutex;
+
+    public:
+        RouterClient(ITransportClient* transport, function<void (KError)> errorCallback);
+        virtual ~RouterClient();
+
+        virtual void reset() override;
+        virtual void registerBridgingCallback(std::function<void (Frame &)> bridgingCallback) override;
+        virtual void registerNotificationCallback( uint32_t serviceId, function<Error (Frame&)> ) override;
+        virtual void registerErrorCallback( function<void(KError)> callback ) override;
+        virtual void registerHitCallback(std::function<void (FrameTypes)> hitSessionCallback) override;
+
+        virtual future<Frame> send(const std::string& txPayload, uint32_t serviceVersion, uint32_t funcId, uint32_t deviceId, const RouterClientSendOptions& options ) override;
+        virtual Error sendWithCallback(const std::string& txPayload, uint32_t serviceVersion, uint32_t funcId, uint32_t deviceId, MessageCallback callback) override;
+        virtual Error sendMsgFrame(const Frame& msgFrame) override;
+
+        virtual uint16_t getConnectionId() override;
+        virtual void SetActivationStatus(bool isActive) override;
+
+        virtual ITransportClient* getTransport() override {return m_transport;}
+
+    private:
+        uint16_t generateNewMsgId();
+        void frameHandler(const void *rxBuffer, uint32_t rxSize);
+    };
+
+} // namespace Api
+} // namespace Kinova
+
+#endif // _ROUTER_CLIENT_H_
diff --git a/kortex_api/include/client/SessionManager.h b/kortex_api/include/client/SessionManager.h
new file mode 100644
index 0000000000000000000000000000000000000000..1e20abee20a1cd6cacd52559d1398922d26622f6
--- /dev/null
+++ b/kortex_api/include/client/SessionManager.h
@@ -0,0 +1,48 @@
+#ifndef _SESSION_MANAGER_H_
+#define _SESSION_MANAGER_H_
+
+#include <iostream>
+#include <list>
+#include <future>
+#include <memory>
+#include <functional>
+
+#include "IRouterClient.h"
+#include "messages/Frame.pb.h"
+#include "messages/Session.pb.h"
+#include "client_stubs/SessionClientRpc.h"
+
+namespace Kinova
+{
+namespace Api
+{
+    class SessionManager : public Session::SessionClient
+    {
+    public:
+        SessionManager() = delete;
+        explicit SessionManager(IRouterClient* router, std::function<void()> connectionTimeoutCallback = nullptr);
+        virtual ~SessionManager();
+
+        void CreateSession(const Session::CreateSessionInfo& info);
+        void CloseSession();
+        Session::ConnectionList GetConnections();
+
+    private:
+        void Hit(FrameTypes hitType);
+        void ThreadSessionValidation();
+    
+        std::function<void()>           m_connectionTimeoutCallback;
+        
+        std::thread                     m_thread;
+        std::atomic<bool>               m_hasBeenSent { false };
+        std::atomic<bool>               m_hasBeenReceived { false };
+        std::atomic<bool>               m_threadRunning { false };
+        Session::CreateSessionInfo      m_sessionInfo;
+
+        void checkTransport();
+    };
+
+}
+}
+
+#endif // _MESSAGE_MANAGER_H_
diff --git a/kortex_api/include/client/TransportClientTcp.h b/kortex_api/include/client/TransportClientTcp.h
new file mode 100644
index 0000000000000000000000000000000000000000..f5a6e93b746db00e9bb53e752bf550cfc124e9a6
--- /dev/null
+++ b/kortex_api/include/client/TransportClientTcp.h
@@ -0,0 +1,139 @@
+/* ***************************************************************************
+ * Kinova inc.
+ *
+ * Copyright (c) 2006-2018 Kinova Incorporated. All rights reserved.
+ ****************************************************************************/
+
+#ifndef __TRANSPORT_CLIENT_TCP_H__
+#define __TRANSPORT_CLIENT_TCP_H__
+
+#if defined(_OS_WINDOWS)
+// ---- win ----
+#include <stdio.h>
+#include <winsock2.h>
+#elif defined(_OS_UNIX)
+// --- linux ---
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <netdb.h>
+#include <sys/select.h>
+#include <sys/fcntl.h>
+
+#include <iostream>
+#include <unistd.h>
+#include <ctime>
+#include <stdio.h>
+#include <unistd.h>
+#include <cerrno>
+#include <cstdio>
+#include <cstring>
+#include <cstdlib>
+#else
+#pragma message("WARNING: Unknown OS Type!")
+#endif
+
+#include <atomic>
+#include <thread>
+#include <mutex>
+
+#include <string>
+#include <functional>
+#include <exception>
+
+#include <iostream>
+#include <chrono>
+
+#include "ITransportClient.h"
+#include "common/KinovaTcpUtilities.h"
+#include "common/WindowsNetworking.h"
+
+namespace Kinova
+{
+namespace Api
+{
+    class TransportClientTcp : public ITransportClient
+    {
+    private:
+        const uint32_t kApiPort					= 10000;
+        // Configuration        m_config;
+        bool                    m_isInitialized;
+        struct sockaddr_in      m_socketAddr{};
+        socklen_t               m_socketAddrSize{};
+        int32_t                 m_socketFd{};
+        #if defined(_OS_WINDOWS)
+        WSADATA                 m_wsa{};
+        #endif
+
+        bool                    m_isUsingRcvThread;
+        std::atomic<bool>       m_isRunning { true };
+        std::mutex              m_sendMutex;
+
+        // ---- non-blocking ----
+        fd_set          m_original_rx{};
+        fd_set          m_readfds{};
+
+        int             numfd{};
+        struct hostent  *m_host{};
+        struct timeval  m_tv{};
+        // ----------------------
+
+        // 65535 - 20 (ip header) - 20 (tcp header) = 65495 bytes
+        static constexpr uint32_t kMaxTxBufferSize = 65495;
+        static constexpr uint32_t kMaxRxBufferSize = 65495;
+        static constexpr uint32_t kMaxBufferSize = 16777216;
+
+        bool                 m_bIsReceiving { false };
+        uint32_t             m_nTotalBytesRead {0};
+        uint32_t             m_nTotalBytesToRead {0};
+        uint8_t*             m_tx_buffer;
+        uint8_t*             m_rx_buffer;
+
+        uint32_t             m_current_buffer_size_rx = { kMaxRxBufferSize };
+        uint32_t             m_current_buffer_size_tx = { kMaxTxBufferSize };
+
+
+        KinovaTcpUtilities m_utilities_object;
+
+        std::function<void (const char*, uint32_t) > m_onMessageCallback;
+
+
+    public:
+        TransportReadyStateEnum readyState;
+        std::thread             m_receiveThread;
+
+        explicit TransportClientTcp(bool isUsingRcvThread = true);
+        ~TransportClientTcp() override;
+
+        bool connect(std::string host = "127.0.0.1", uint32_t port = 10000) override;
+        void disconnect() override;
+
+        void send(const char* txBuffer, uint32_t txSize) override;
+        void onMessage(std::function<void (const char*, uint32_t)> callback) override;
+
+        char* getTxBuffer(uint32_t const& allocation_size) override;
+        size_t getMaxTxBufferSize() override { return kMaxBufferSize; }
+
+        int processReceive(long rcvTimeout_usec);
+        int processReceive(struct timeval rcvTimeout_tv);
+
+        virtual void getHostAddress(std::string &host, uint32_t &port) override {
+            host = mHostAddress;
+            port = mHostPort;
+        };
+
+    private:
+
+        std::string mHostAddress;
+        uint32_t mHostPort;
+
+        void receiveThread(std::atomic<bool> &program_is_running);
+        
+        int callReceiveFrom();
+    };
+
+} // namespace Api
+} // namespace Kinova
+
+#endif // __TRANSPORT_CLIENT_H__
diff --git a/kortex_api/include/client/TransportClientUdp.h b/kortex_api/include/client/TransportClientUdp.h
new file mode 100644
index 0000000000000000000000000000000000000000..787697798a25ad5455ff3f4ab8df6321d793128a
--- /dev/null
+++ b/kortex_api/include/client/TransportClientUdp.h
@@ -0,0 +1,148 @@
+/* ***************************************************************************
+ * Kinova inc.
+ * Project :
+ *
+ * Copyright (c) 2006-2018 Kinova Incorporated. All rights reserved.
+ ****************************************************************************/
+
+#ifndef __TRANSPORT_CLIENT_UDP_H__
+#define __TRANSPORT_CLIENT_UDP_H__
+
+#if defined(_OS_WINDOWS)
+// ---- win ----
+#include <stdio.h>
+#include <winsock2.h>
+#elif defined(_OS_UNIX)
+// --- linux ---
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <netdb.h>      // host struct
+#include <sys/select.h> // use select() for multiplexing
+#include <sys/fcntl.h>  // for non-blocking
+
+#include <iostream>
+#include <unistd.h>
+#include <ctime>
+#include <stdio.h>
+#include <unistd.h>
+#include <cerrno>
+#include <cstdio>
+#include <cstring>
+#include <cstdlib>
+#else
+#warning Unknown OS type!
+#endif
+
+#include <atomic>
+#include <thread>
+#include <mutex>
+
+#include <string>
+#include <functional>
+#include <exception>
+
+#include <iostream>
+#include <chrono>
+
+#include "ITransportClient.h"
+
+#if defined(_OS_WINDOWS) // todogr
+typedef int32_t socklen_t;
+#endif
+
+namespace Kinova
+{
+namespace Api
+{
+    const uint32_t kApiPort					= 10000;
+
+    class TransportClientUdp : public ITransportClient
+    {
+        // Configuration        m_config;
+        bool                   	m_isInitialized;
+        struct sockaddr_in      m_socketAddr;
+        socklen_t               m_socketAddrSize;
+        int32_t                 m_socketFd;
+        #if defined(_OS_WINDOWS)
+        WSADATA                 m_wsa;
+        #endif
+
+        bool                    m_isUsingRcvThread;
+        std::atomic<bool>       m_isRunning { true };
+        std::mutex              m_sendMutex;
+
+        // ---- non-blocking ----
+        fd_set          m_original_rx;
+        fd_set          m_readfds;
+
+        int             numfd;
+        struct hostent  *m_host;
+        struct timeval  m_tv;
+        // ----------------------
+
+        // 65535 - 20 (ip header) - 8 (udp header) = 65507 bytes
+        static constexpr uint32_t kMaxTxBufferSize = 65507;
+        static constexpr uint32_t kMaxRxBufferSize = 65507;
+
+        char m_txBuffer[kMaxTxBufferSize];
+        char m_rxBuffer[kMaxRxBufferSize];
+
+        std::function<void (const char*, uint32_t) > m_onMessageCallback;
+
+        // int32_t m_countTx;
+        // int32_t m_countRx;
+        // ChronoClock m_start;
+        // ChronoClock m_elapsed;
+
+    public:
+        TransportReadyStateEnum readyState;
+        std::thread             m_receiveThread;
+
+        TransportClientUdp(bool isUsingRcvThread = true);
+        virtual ~TransportClientUdp();
+
+        virtual bool connect(std::string host = "127.0.0.1", uint32_t port = Kinova::Api::kApiPort) override;
+        virtual void disconnect() override;
+
+        virtual void send(const char* txBuffer, uint32_t txSize) override;
+        virtual void onMessage(std::function<void (const char*, uint32_t)> callback) override;
+
+        // virtual void onClose(ConnectionClose eventClose)> callback) = 0;
+        // virtual void onError(ConnectionError error)> callback) = 0;
+
+        // virtual bool isClosed() = 0;
+        // virtual bool isClosing() = 0;
+        // virtual bool isConnecting() = 0;
+        // virtual bool isOpen() = 0;
+        // virtual bool isUninitialized() = 0;
+
+        virtual char* getTxBuffer(uint32_t const& allocation_size) override { return m_txBuffer; }
+        virtual size_t getMaxTxBufferSize() override { return kMaxTxBufferSize; }
+
+        // double getTimeComm();
+    
+        int processReceive(long rcvTimeout_usec);
+        int processReceive(struct timeval rcvTimeout_tv);
+
+        virtual void getHostAddress(std::string &host, uint32_t &port) override {
+            host = mHostAddress;
+            port = mHostPort;
+        };
+
+    private:
+
+        std::string mHostAddress;
+        uint32_t mHostPort;
+
+        void receiveThread(std::atomic<bool> &program_is_running);
+        
+        // return value: <0 means error (-errorCode); =0 means timeout nothing received; >0 means nbr of handles ready to recvFrom
+        int callReceiveFrom();
+    };
+
+} // namespace Api
+} // namespace Kinova
+
+#endif // __TRANSPORT_CLIENT_H__
diff --git a/kortex_api/include/client/version.h b/kortex_api/include/client/version.h
new file mode 100644
index 0000000000000000000000000000000000000000..ce478452dfcc33137e645bf18787e5b4cbda04f5
--- /dev/null
+++ b/kortex_api/include/client/version.h
@@ -0,0 +1,19 @@
+
+#ifndef VERSION_H
+#define VERSION_H
+
+#define NEO_PART_NUMBER_STR      ""
+
+#define VER_MAJOR                1
+#define VER_MINOR                1
+#define VER_FEATURE              6
+#define VER_BUILD_NUMBER         0
+
+#define VER_COMPANYNAME_STR      "Kinova Robotics"
+#define VER_INTERNALNAME_STR     "Kortex Cpp Client API"
+#define VER_LEGALCOPYRIGHT_STR   "Copyright 2018 Kinova"
+#define VER_LEGALTRADEMARKS1_STR "All Rights Reserved"
+
+#define VER_COMPANYDOMAIN_STR    "www.kinovarobotics.com/"
+
+#endif // VERSION_H
\ No newline at end of file
diff --git a/kortex_api/include/client_stubs/ActuatorConfigClientRpc.h b/kortex_api/include/client_stubs/ActuatorConfigClientRpc.h
new file mode 100644
index 0000000000000000000000000000000000000000..0916f2610db58734ba86ea55763f536defc51fd6
--- /dev/null
+++ b/kortex_api/include/client_stubs/ActuatorConfigClientRpc.h
@@ -0,0 +1,223 @@
+#ifndef __ACTUATORCONFIGCLIENT_H__
+#define __ACTUATORCONFIGCLIENT_H__
+
+#include <string>
+#include <future>
+#include <functional>
+#include <exception>
+
+#include "messages/Frame.pb.h"
+#include "messages/ActuatorConfig.pb.h"
+
+#include "common/Frame.h"
+#include "client/IRouterClient.h"
+#include "client/NotificationHandler.h"
+
+#if __cplusplus >= 201402L
+#define DEPRECATED [[ deprecated ]]
+#define DEPRECATED_MSG(msg) [[ deprecated(msg) ]]
+#elif defined(__GNUC__)
+#define DEPRECATED __attribute__ ((deprecated))
+#define DEPRECATED_MSG(msg) __attribute__ ((deprecated(msg)))
+#elif defined(_MSC_VER)
+#define DEPRECATED __declspec(deprecated)
+#define DEPRECATED_MSG(msg) __declspec(deprecated(msg))
+#else
+#define DEPRECATED 
+#define DEPRECATED_MSG 
+#endif
+namespace Kinova
+{
+namespace Api
+{
+	namespace ActuatorConfig
+	{
+		// todogr move somewhere else
+		const std::string   none = "";
+		
+		enum FunctionUids
+		{
+			eUidGetAxisOffsets = 0xa0001,
+			eUidSetAxisOffsets = 0xa0002,
+			eUidReadTorqueCalibration = 0xa0003,
+			eUidWriteTorqueCalibration = 0xa0004,
+			eUidSetTorqueOffset = 0xa0005,
+			eUidGetControlMode = 0xa0006,
+			eUidSetControlMode = 0xa0007,
+			eUidGetActivatedControlLoop = 0xa0008,
+			eUidSetActivatedControlLoop = 0xa0009,
+			eUidGetVectorDriveParameters = 0xa000a,
+			eUidSetVectorDriveParameters = 0xa000b,
+			eUidGetEncoderDerivativeParameters = 0xa000c,
+			eUidSetEncoderDerivativeParameters = 0xa000d,
+			eUidGetControlLoopParameters = 0xa000e,
+			eUidSetControlLoopParameters = 0xa000f,
+			eUidStartFrequencyResponse = 0xa0010,
+			eUidStopFrequencyResponse = 0xa0011,
+			eUidStartStepResponse = 0xa0012,
+			eUidStopStepResponse = 0xa0013,
+			eUidStartRampResponse = 0xa0014,
+			eUidStopRampResponse = 0xa0015,
+			eUidSelectCustomData = 0xa0016,
+			eUidGetSelectedCustomData = 0xa0017,
+			eUidSetCommandMode = 0xa0018,
+			eUidClearFaults = 0xa0019,
+			eUidSetServoing = 0xa001a,
+			eUidMoveToPosition = 0xa001b,
+			eUidGetCommandMode = 0xa001c,
+			eUidGetServoing = 0xa001d,
+			eUidGetTorqueOffset = 0xa001e,
+			eUidSetCoggingFeedforwardMode = 0xa001f,
+			eUidGetCoggingFeedforwardMode = 0xa0020,
+		};
+		
+		class ActuatorConfigClient
+		{
+			static const uint32_t m_serviceVersion = 1;
+			static const uint32_t m_serviceId = eIdActuatorConfig;
+			NotificationHandler m_notificationHandler;
+
+		protected:
+			IRouterClient* const m_clientRouter;
+
+		public:
+			ActuatorConfigClient(IRouterClient* clientRouter);
+			static uint32_t getUniqueFctId(uint16_t fctId);
+
+			AxisOffsets GetAxisOffsets(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetAxisOffsets_callback(std::function< void (const Error&, const AxisOffsets&) > callback, uint32_t deviceId = 0);
+			std::future<AxisOffsets> GetAxisOffsets_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetAxisOffsets(const AxisPosition& axisposition, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetAxisOffsets_callback(const AxisPosition& axisposition, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetAxisOffsets_async(const AxisPosition& axisposition, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			TorqueCalibration ReadTorqueCalibration(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ReadTorqueCalibration_callback(std::function< void (const Error&, const TorqueCalibration&) > callback, uint32_t deviceId = 0);
+			std::future<TorqueCalibration> ReadTorqueCalibration_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void WriteTorqueCalibration(const TorqueCalibration& torquecalibration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void WriteTorqueCalibration_callback(const TorqueCalibration& torquecalibration, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> WriteTorqueCalibration_async(const TorqueCalibration& torquecalibration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetTorqueOffset(const TorqueOffset& torqueoffset, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetTorqueOffset_callback(const TorqueOffset& torqueoffset, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetTorqueOffset_async(const TorqueOffset& torqueoffset, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			ControlModeInformation GetControlMode(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetControlMode_callback(std::function< void (const Error&, const ControlModeInformation&) > callback, uint32_t deviceId = 0);
+			std::future<ControlModeInformation> GetControlMode_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetControlMode(const ControlModeInformation& controlmodeinformation, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetControlMode_callback(const ControlModeInformation& controlmodeinformation, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetControlMode_async(const ControlModeInformation& controlmodeinformation, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			ControlLoop GetActivatedControlLoop(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetActivatedControlLoop_callback(std::function< void (const Error&, const ControlLoop&) > callback, uint32_t deviceId = 0);
+			std::future<ControlLoop> GetActivatedControlLoop_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetActivatedControlLoop(const ControlLoop& controlloop, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetActivatedControlLoop_callback(const ControlLoop& controlloop, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetActivatedControlLoop_async(const ControlLoop& controlloop, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			VectorDriveParameters GetVectorDriveParameters(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetVectorDriveParameters_callback(std::function< void (const Error&, const VectorDriveParameters&) > callback, uint32_t deviceId = 0);
+			std::future<VectorDriveParameters> GetVectorDriveParameters_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetVectorDriveParameters(const VectorDriveParameters& vectordriveparameters, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetVectorDriveParameters_callback(const VectorDriveParameters& vectordriveparameters, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetVectorDriveParameters_async(const VectorDriveParameters& vectordriveparameters, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			EncoderDerivativeParameters GetEncoderDerivativeParameters(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetEncoderDerivativeParameters_callback(std::function< void (const Error&, const EncoderDerivativeParameters&) > callback, uint32_t deviceId = 0);
+			std::future<EncoderDerivativeParameters> GetEncoderDerivativeParameters_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetEncoderDerivativeParameters(const EncoderDerivativeParameters& encoderderivativeparameters, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetEncoderDerivativeParameters_callback(const EncoderDerivativeParameters& encoderderivativeparameters, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetEncoderDerivativeParameters_async(const EncoderDerivativeParameters& encoderderivativeparameters, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			ControlLoopParameters GetControlLoopParameters(const LoopSelection& loopselection, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetControlLoopParameters_callback(const LoopSelection& loopselection, std::function< void (const Error&, const ControlLoopParameters&) > callback, uint32_t deviceId = 0);
+			std::future<ControlLoopParameters> GetControlLoopParameters_async(const LoopSelection& loopselection, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetControlLoopParameters(const ControlLoopParameters& controlloopparameters, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetControlLoopParameters_callback(const ControlLoopParameters& controlloopparameters, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetControlLoopParameters_async(const ControlLoopParameters& controlloopparameters, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void StartFrequencyResponse(const FrequencyResponse& frequencyresponse, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void StartFrequencyResponse_callback(const FrequencyResponse& frequencyresponse, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> StartFrequencyResponse_async(const FrequencyResponse& frequencyresponse, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void StopFrequencyResponse(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void StopFrequencyResponse_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> StopFrequencyResponse_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void StartStepResponse(const StepResponse& stepresponse, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void StartStepResponse_callback(const StepResponse& stepresponse, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> StartStepResponse_async(const StepResponse& stepresponse, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void StopStepResponse(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void StopStepResponse_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> StopStepResponse_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void StartRampResponse(const RampResponse& rampresponse, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void StartRampResponse_callback(const RampResponse& rampresponse, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> StartRampResponse_async(const RampResponse& rampresponse, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void StopRampResponse(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void StopRampResponse_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> StopRampResponse_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SelectCustomData(const CustomDataSelection& customdataselection, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SelectCustomData_callback(const CustomDataSelection& customdataselection, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SelectCustomData_async(const CustomDataSelection& customdataselection, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			CustomDataSelection GetSelectedCustomData(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetSelectedCustomData_callback(std::function< void (const Error&, const CustomDataSelection&) > callback, uint32_t deviceId = 0);
+			std::future<CustomDataSelection> GetSelectedCustomData_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetCommandMode(const CommandModeInformation& commandmodeinformation, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetCommandMode_callback(const CommandModeInformation& commandmodeinformation, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetCommandMode_async(const CommandModeInformation& commandmodeinformation, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void ClearFaults(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ClearFaults_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> ClearFaults_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetServoing(const Servoing& servoing, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetServoing_callback(const Servoing& servoing, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetServoing_async(const Servoing& servoing, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void MoveToPosition(const PositionCommand& positioncommand, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void MoveToPosition_callback(const PositionCommand& positioncommand, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> MoveToPosition_async(const PositionCommand& positioncommand, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			CommandModeInformation GetCommandMode(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetCommandMode_callback(std::function< void (const Error&, const CommandModeInformation&) > callback, uint32_t deviceId = 0);
+			std::future<CommandModeInformation> GetCommandMode_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Servoing GetServoing(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetServoing_callback(std::function< void (const Error&, const Servoing&) > callback, uint32_t deviceId = 0);
+			std::future<Servoing> GetServoing_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			TorqueOffset GetTorqueOffset(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetTorqueOffset_callback(std::function< void (const Error&, const TorqueOffset&) > callback, uint32_t deviceId = 0);
+			std::future<TorqueOffset> GetTorqueOffset_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetCoggingFeedforwardMode(const CoggingFeedforwardModeInformation& coggingfeedforwardmodeinformation, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetCoggingFeedforwardMode_callback(const CoggingFeedforwardModeInformation& coggingfeedforwardmodeinformation, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetCoggingFeedforwardMode_async(const CoggingFeedforwardModeInformation& coggingfeedforwardmodeinformation, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			CoggingFeedforwardModeInformation GetCoggingFeedforwardMode(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetCoggingFeedforwardMode_callback(std::function< void (const Error&, const CoggingFeedforwardModeInformation&) > callback, uint32_t deviceId = 0);
+			std::future<CoggingFeedforwardModeInformation> GetCoggingFeedforwardMode_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+
+		private:
+			void messageHeaderValidation(const Frame& msgFrame){ /* todogr ... */ }
+		};
+	}
+}
+}
+
+#endif
\ No newline at end of file
diff --git a/kortex_api/include/client_stubs/ActuatorCyclicClientRpc.h b/kortex_api/include/client_stubs/ActuatorCyclicClientRpc.h
new file mode 100644
index 0000000000000000000000000000000000000000..3cda2374903c9ddb99bf64a3aa31e29df0bb6c35
--- /dev/null
+++ b/kortex_api/include/client_stubs/ActuatorCyclicClientRpc.h
@@ -0,0 +1,83 @@
+#ifndef __ACTUATORCYCLICCLIENT_H__
+#define __ACTUATORCYCLICCLIENT_H__
+
+#include <string>
+#include <future>
+#include <functional>
+#include <exception>
+
+#include "messages/Frame.pb.h"
+#include "messages/ActuatorCyclic.pb.h"
+
+#include "common/Frame.h"
+#include "client/IRouterClient.h"
+#include "client/NotificationHandler.h"
+
+#if __cplusplus >= 201402L
+#define DEPRECATED [[ deprecated ]]
+#define DEPRECATED_MSG(msg) [[ deprecated(msg) ]]
+#elif defined(__GNUC__)
+#define DEPRECATED __attribute__ ((deprecated))
+#define DEPRECATED_MSG(msg) __attribute__ ((deprecated(msg)))
+#elif defined(_MSC_VER)
+#define DEPRECATED __declspec(deprecated)
+#define DEPRECATED_MSG(msg) __declspec(deprecated(msg))
+#else
+#define DEPRECATED 
+#define DEPRECATED_MSG 
+#endif
+namespace Kinova
+{
+namespace Api
+{
+	namespace ActuatorCyclic
+	{
+		// todogr move somewhere else
+		const std::string   none = "";
+		
+		enum FunctionUids
+		{
+			eUidRefresh = 0xb0001,
+			eUidRefreshCommand = 0xb0002,
+			eUidRefreshFeedback = 0xb0003,
+			eUidRefreshCustomData = 0xb0004,
+		};
+		
+		class ActuatorCyclicClient
+		{
+			static const uint32_t m_serviceVersion = 1;
+			static const uint32_t m_serviceId = eIdActuatorCyclic;
+			NotificationHandler m_notificationHandler;
+
+		protected:
+			IRouterClient* const m_clientRouter;
+
+		public:
+			ActuatorCyclicClient(IRouterClient* clientRouter);
+			static uint32_t getUniqueFctId(uint16_t fctId);
+
+			Feedback Refresh(const Command& command, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void Refresh_callback(const Command& command, std::function< void (const Error&, const Feedback&) > callback, uint32_t deviceId = 0);
+			std::future<Feedback> Refresh_async(const Command& command, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void RefreshCommand(const Command& command, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void RefreshCommand_callback(const Command& command, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> RefreshCommand_async(const Command& command, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Feedback RefreshFeedback(const MessageId& messageid, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void RefreshFeedback_callback(const MessageId& messageid, std::function< void (const Error&, const Feedback&) > callback, uint32_t deviceId = 0);
+			std::future<Feedback> RefreshFeedback_async(const MessageId& messageid, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			CustomData RefreshCustomData(const MessageId& messageid, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void RefreshCustomData_callback(const MessageId& messageid, std::function< void (const Error&, const CustomData&) > callback, uint32_t deviceId = 0);
+			std::future<CustomData> RefreshCustomData_async(const MessageId& messageid, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+
+		private:
+			void messageHeaderValidation(const Frame& msgFrame){ /* todogr ... */ }
+		};
+	}
+}
+}
+
+#endif
\ No newline at end of file
diff --git a/kortex_api/include/client_stubs/BaseClientRpc.h b/kortex_api/include/client_stubs/BaseClientRpc.h
new file mode 100644
index 0000000000000000000000000000000000000000..c4bd0fb27c83f4eae252dba7dba68713864fd223
--- /dev/null
+++ b/kortex_api/include/client_stubs/BaseClientRpc.h
@@ -0,0 +1,770 @@
+#ifndef __BASECLIENT_H__
+#define __BASECLIENT_H__
+
+#include <string>
+#include <future>
+#include <functional>
+#include <exception>
+
+#include "messages/Frame.pb.h"
+#include "messages/Base.pb.h"
+
+#include "common/Frame.h"
+#include "client/IRouterClient.h"
+#include "client/NotificationHandler.h"
+
+#if __cplusplus >= 201402L
+#define DEPRECATED [[ deprecated ]]
+#define DEPRECATED_MSG(msg) [[ deprecated(msg) ]]
+#elif defined(__GNUC__)
+#define DEPRECATED __attribute__ ((deprecated))
+#define DEPRECATED_MSG(msg) __attribute__ ((deprecated(msg)))
+#elif defined(_MSC_VER)
+#define DEPRECATED __declspec(deprecated)
+#define DEPRECATED_MSG(msg) __declspec(deprecated(msg))
+#else
+#define DEPRECATED 
+#define DEPRECATED_MSG 
+#endif
+namespace Kinova
+{
+namespace Api
+{
+	namespace Base
+	{
+		// todogr move somewhere else
+		const std::string   none = "";
+		
+		enum FunctionUids
+		{
+			eUidCreateUserProfile = 0x20001,
+			eUidUpdateUserProfile = 0x20002,
+			eUidReadUserProfile = 0x20003,
+			eUidDeleteUserProfile = 0x20004,
+			eUidReadAllUserProfiles = 0x20005,
+			eUidReadAllUsers = 0x20006,
+			eUidChangePassword = 0x20007,
+			eUidCreateSequence = 0x20008,
+			eUidUpdateSequence = 0x20009,
+			eUidReadSequence = 0x2000a,
+			eUidDeleteSequence = 0x2000b,
+			eUidReadAllSequences = 0x2000c,
+			eUidPlaySequence = 0x2000f,
+			eUidPlayAdvancedSequence = 0x20010,
+			eUidStopSequence = 0x20011,
+			eUidPauseSequence = 0x20012,
+			eUidResumeSequence = 0x20013,
+			eUidCreateProtectionZone = 0x20014,
+			eUidUpdateProtectionZone = 0x20015,
+			eUidReadProtectionZone = 0x20016,
+			eUidDeleteProtectionZone = 0x20017,
+			eUidReadAllProtectionZones = 0x20018,
+			eUidCreateMapping = 0x2001a,
+			eUidReadMapping = 0x2001b,
+			eUidUpdateMapping = 0x2001c,
+			eUidDeleteMapping = 0x2001d,
+			eUidReadAllMappings = 0x2001e,
+			eUidCreateMap = 0x20024,
+			eUidReadMap = 0x20025,
+			eUidUpdateMap = 0x20026,
+			eUidDeleteMap = 0x20027,
+			eUidReadAllMaps = 0x20028,
+			eUidActivateMap = 0x20029,
+			eUidCreateAction = 0x2002a,
+			eUidReadAction = 0x2002b,
+			eUidReadAllActions = 0x2002c,
+			eUidDeleteAction = 0x2002d,
+			eUidUpdateAction = 0x2002e,
+			eUidExecuteActionFromReference = 0x2002f,
+			eUidExecuteAction = 0x20030,
+			eUidPauseAction = 0x20031,
+			eUidStopAction = 0x20032,
+			eUidResumeAction = 0x20033,
+			eUidGetIPv4Configuration = 0x2003b,
+			eUidSetIPv4Configuration = 0x2003c,
+			eUidSetCommunicationInterfaceEnable = 0x2003d,
+			eUidIsCommunicationInterfaceEnable = 0x2003e,
+			eUidGetAvailableWifi = 0x2003f,
+			eUidGetWifiInformation = 0x20040,
+			eUidAddWifiConfiguration = 0x20041,
+			eUidDeleteWifiConfiguration = 0x20042,
+			eUidGetAllConfiguredWifis = 0x20043,
+			eUidConnectWifi = 0x20044,
+			eUidDisconnectWifi = 0x20045,
+			eUidGetConnectedWifiInformation = 0x20046,
+			eUidUnsubscribe = 0x20061,
+			eUidConfigurationChangeTopic = 0x20062,
+			eUidMappingInfoTopic = 0x20063,
+			eUidOperatingModeTopic = 0x20065,
+			eUidSequenceInfoTopic = 0x20066,
+			eUidProtectionZoneTopic = 0x20067,
+			eUidUserTopic = 0x20068,
+			eUidControllerTopic = 0x20069,
+			eUidActionTopic = 0x2006a,
+			eUidRobotEventTopic = 0x2006b,
+			eUidPlayCartesianTrajectory = 0x2006d,
+			eUidPlayCartesianTrajectoryPosition = 0x2006e,
+			eUidPlayCartesianTrajectoryOrientation = 0x2006f,
+			eUidStop = 0x20070,
+			eUidGetMeasuredCartesianPose = 0x20073,
+			eUidSendWrenchCommand = 0x20076,
+			eUidSendWrenchJoystickCommand = 0x20077,
+			eUidSendTwistJoystickCommand = 0x20078,
+			eUidSendTwistCommand = 0x20079,
+			eUidPlayJointTrajectory = 0x2007c,
+			eUidPlaySelectedJointTrajectory = 0x2007d,
+			eUidGetMeasuredJointAngles = 0x2007e,
+			eUidSendJointSpeedsCommand = 0x20084,
+			eUidSendSelectedJointSpeedCommand = 0x20085,
+			eUidSendGripperCommand = 0x20088,
+			eUidGetMeasuredGripperMovement = 0x20089,
+			eUidSetAdmittance = 0x2008b,
+			eUidSetOperatingMode = 0x2008d,
+			eUidApplyEmergencyStop = 0x20091,
+			eUidClearFaults = 0x20092,
+			eUidGetOperatingMode = 0x20097,
+			eUidSetServoingMode = 0x20098,
+			eUidGetServoingMode = 0x20099,
+			eUidServoingModeTopic = 0x2009a,
+			eUidRestoreFactorySettings = 0x200a0,
+			eUidReboot = 0x200a2,
+			eUidFactoryTopic = 0x200a4,
+			eUidGetAllConnectedControllers = 0x200a6,
+			eUidGetControllerState = 0x200a7,
+			eUidGetActuatorCount = 0x200ab,
+			eUidStartWifiScan = 0x200ac,
+			eUidGetConfiguredWifi = 0x200ad,
+			eUidNetworkTopic = 0x200ae,
+			eUidGetArmState = 0x200af,
+			eUidArmStateTopic = 0x200b0,
+			eUidGetIPv4Information = 0x200b1,
+			eUidSetWifiCountryCode = 0x200b2,
+			eUidGetWifiCountryCode = 0x200b3,
+			eUidSetCapSenseConfig = 0x200b4,
+			eUidGetCapSenseConfig = 0x200b5,
+			eUidGetAllJointsTorqueHardLimitation = 0x200b8,
+			eUidGetWrenchHardLimitation = 0x200ba,
+			eUidSendJointSpeedsJoystickCommand = 0x200bb,
+			eUidSendSelectedJointSpeedJoystickCommand = 0x200bc,
+			eUidEnableBridge = 0x200c1,
+			eUidDisableBridge = 0x200c2,
+			eUidGetBridgeList = 0x200c3,
+			eUidGetBridgeConfig = 0x200c4,
+			eUidPlayPreComputedJointTrajectory = 0x200c5,
+			eUidGetProductConfiguration = 0x200c6,
+			eUidUpdateEndEffectorTypeConfiguration = 0x200c9,
+			eUidRestoreFactoryProductConfiguration = 0x200ce,
+			eUidGetTrajectoryErrorReport = 0x200cf,
+			eUidGetAllJointsTorqueSoftLimitation = 0x200d1,
+			eUidGetWrenchSoftLimitation = 0x200d3,
+			eUidSetControllerConfigurationMode = 0x200d4,
+			eUidGetControllerConfigurationMode = 0x200d5,
+			eUidStartTeaching = 0x200d6,
+			eUidStopTeaching = 0x200d7,
+			eUidAddSequenceTasks = 0x200d8,
+			eUidUpdateSequenceTask = 0x200d9,
+			eUidSwapSequenceTasks = 0x200da,
+			eUidReadSequenceTask = 0x200db,
+			eUidReadAllSequenceTasks = 0x200dc,
+			eUidDeleteSequenceTask = 0x2000d,
+			eUidDeleteAllSequenceTasks = 0x2000e,
+			eUidTakeSnapshot = 0x200df,
+			eUidGetFirmwareBundleVersions = 0x200e0,
+			eUidExecuteWaypointTrajectory = 0x200e2,
+			eUidMoveSequenceTask = 0x200e3,
+			eUidDuplicateMapping = 0x200e4,
+			eUidDuplicateMap = 0x200e5,
+			eUidSetControllerConfiguration = 0x200e6,
+			eUidGetControllerConfiguration = 0x200e7,
+			eUidGetAllControllerConfigurations = 0x200e8,
+			eUidComputeForwardKinematics = 0x200e9,
+			eUidComputeInverseKinematics = 0x200ea,
+			eUidValidateWaypointList = 0x200eb,
+			eUidSetWifiEnableState = 0x200ec,
+			eUidGetWifiEnableState = 0x200ed,
+			eUidSetBluetoothEnableState = 0x200ee,
+			eUidGetBluetoothEnableState = 0x200ef,
+		};
+		
+		class BaseClient
+		{
+			static const uint32_t m_serviceVersion = 1;
+			static const uint32_t m_serviceId = eIdBase;
+			NotificationHandler m_notificationHandler;
+
+		protected:
+			IRouterClient* const m_clientRouter;
+
+		public:
+			BaseClient(IRouterClient* clientRouter);
+			static uint32_t getUniqueFctId(uint16_t fctId);
+
+			Kinova::Api::Common::UserProfileHandle CreateUserProfile(const FullUserProfile& fulluserprofile, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void CreateUserProfile_callback(const FullUserProfile& fulluserprofile, std::function< void (const Error&, const Kinova::Api::Common::UserProfileHandle&) > callback, uint32_t deviceId = 0);
+			std::future<Kinova::Api::Common::UserProfileHandle> CreateUserProfile_async(const FullUserProfile& fulluserprofile, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void UpdateUserProfile(const UserProfile& userprofile, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void UpdateUserProfile_callback(const UserProfile& userprofile, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> UpdateUserProfile_async(const UserProfile& userprofile, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			UserProfile ReadUserProfile(const Kinova::Api::Common::UserProfileHandle& userprofilehandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ReadUserProfile_callback(const Kinova::Api::Common::UserProfileHandle& userprofilehandle, std::function< void (const Error&, const UserProfile&) > callback, uint32_t deviceId = 0);
+			std::future<UserProfile> ReadUserProfile_async(const Kinova::Api::Common::UserProfileHandle& userprofilehandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void DeleteUserProfile(const Kinova::Api::Common::UserProfileHandle& userprofilehandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void DeleteUserProfile_callback(const Kinova::Api::Common::UserProfileHandle& userprofilehandle, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> DeleteUserProfile_async(const Kinova::Api::Common::UserProfileHandle& userprofilehandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			UserProfileList ReadAllUserProfiles(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ReadAllUserProfiles_callback(std::function< void (const Error&, const UserProfileList&) > callback, uint32_t deviceId = 0);
+			std::future<UserProfileList> ReadAllUserProfiles_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			UserList ReadAllUsers(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ReadAllUsers_callback(std::function< void (const Error&, const UserList&) > callback, uint32_t deviceId = 0);
+			std::future<UserList> ReadAllUsers_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void ChangePassword(const PasswordChange& passwordchange, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ChangePassword_callback(const PasswordChange& passwordchange, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> ChangePassword_async(const PasswordChange& passwordchange, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			SequenceHandle CreateSequence(const Sequence& sequence, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void CreateSequence_callback(const Sequence& sequence, std::function< void (const Error&, const SequenceHandle&) > callback, uint32_t deviceId = 0);
+			std::future<SequenceHandle> CreateSequence_async(const Sequence& sequence, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void UpdateSequence(const Sequence& sequence, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void UpdateSequence_callback(const Sequence& sequence, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> UpdateSequence_async(const Sequence& sequence, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Sequence ReadSequence(const SequenceHandle& sequencehandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ReadSequence_callback(const SequenceHandle& sequencehandle, std::function< void (const Error&, const Sequence&) > callback, uint32_t deviceId = 0);
+			std::future<Sequence> ReadSequence_async(const SequenceHandle& sequencehandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void DeleteSequence(const SequenceHandle& sequencehandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void DeleteSequence_callback(const SequenceHandle& sequencehandle, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> DeleteSequence_async(const SequenceHandle& sequencehandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			SequenceList ReadAllSequences(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ReadAllSequences_callback(std::function< void (const Error&, const SequenceList&) > callback, uint32_t deviceId = 0);
+			std::future<SequenceList> ReadAllSequences_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void PlaySequence(const SequenceHandle& sequencehandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void PlaySequence_callback(const SequenceHandle& sequencehandle, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> PlaySequence_async(const SequenceHandle& sequencehandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void PlayAdvancedSequence(const AdvancedSequenceHandle& advancedsequencehandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void PlayAdvancedSequence_callback(const AdvancedSequenceHandle& advancedsequencehandle, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> PlayAdvancedSequence_async(const AdvancedSequenceHandle& advancedsequencehandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void StopSequence(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void StopSequence_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> StopSequence_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void PauseSequence(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void PauseSequence_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> PauseSequence_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void ResumeSequence(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ResumeSequence_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> ResumeSequence_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			ProtectionZoneHandle CreateProtectionZone(const ProtectionZone& protectionzone, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void CreateProtectionZone_callback(const ProtectionZone& protectionzone, std::function< void (const Error&, const ProtectionZoneHandle&) > callback, uint32_t deviceId = 0);
+			std::future<ProtectionZoneHandle> CreateProtectionZone_async(const ProtectionZone& protectionzone, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void UpdateProtectionZone(const ProtectionZone& protectionzone, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void UpdateProtectionZone_callback(const ProtectionZone& protectionzone, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> UpdateProtectionZone_async(const ProtectionZone& protectionzone, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			ProtectionZone ReadProtectionZone(const ProtectionZoneHandle& protectionzonehandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ReadProtectionZone_callback(const ProtectionZoneHandle& protectionzonehandle, std::function< void (const Error&, const ProtectionZone&) > callback, uint32_t deviceId = 0);
+			std::future<ProtectionZone> ReadProtectionZone_async(const ProtectionZoneHandle& protectionzonehandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void DeleteProtectionZone(const ProtectionZoneHandle& protectionzonehandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void DeleteProtectionZone_callback(const ProtectionZoneHandle& protectionzonehandle, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> DeleteProtectionZone_async(const ProtectionZoneHandle& protectionzonehandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			ProtectionZoneList ReadAllProtectionZones(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ReadAllProtectionZones_callback(std::function< void (const Error&, const ProtectionZoneList&) > callback, uint32_t deviceId = 0);
+			std::future<ProtectionZoneList> ReadAllProtectionZones_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			MappingHandle CreateMapping(const Mapping& mapping, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void CreateMapping_callback(const Mapping& mapping, std::function< void (const Error&, const MappingHandle&) > callback, uint32_t deviceId = 0);
+			std::future<MappingHandle> CreateMapping_async(const Mapping& mapping, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Mapping ReadMapping(const MappingHandle& mappinghandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ReadMapping_callback(const MappingHandle& mappinghandle, std::function< void (const Error&, const Mapping&) > callback, uint32_t deviceId = 0);
+			std::future<Mapping> ReadMapping_async(const MappingHandle& mappinghandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void UpdateMapping(const Mapping& mapping, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void UpdateMapping_callback(const Mapping& mapping, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> UpdateMapping_async(const Mapping& mapping, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void DeleteMapping(const MappingHandle& mappinghandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void DeleteMapping_callback(const MappingHandle& mappinghandle, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> DeleteMapping_async(const MappingHandle& mappinghandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			MappingList ReadAllMappings(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ReadAllMappings_callback(std::function< void (const Error&, const MappingList&) > callback, uint32_t deviceId = 0);
+			std::future<MappingList> ReadAllMappings_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			MapHandle CreateMap(const Map& map, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void CreateMap_callback(const Map& map, std::function< void (const Error&, const MapHandle&) > callback, uint32_t deviceId = 0);
+			std::future<MapHandle> CreateMap_async(const Map& map, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Map ReadMap(const MapHandle& maphandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ReadMap_callback(const MapHandle& maphandle, std::function< void (const Error&, const Map&) > callback, uint32_t deviceId = 0);
+			std::future<Map> ReadMap_async(const MapHandle& maphandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void UpdateMap(const Map& map, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void UpdateMap_callback(const Map& map, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> UpdateMap_async(const Map& map, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void DeleteMap(const MapHandle& maphandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void DeleteMap_callback(const MapHandle& maphandle, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> DeleteMap_async(const MapHandle& maphandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			MapList ReadAllMaps(const MappingHandle& mappinghandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ReadAllMaps_callback(const MappingHandle& mappinghandle, std::function< void (const Error&, const MapList&) > callback, uint32_t deviceId = 0);
+			std::future<MapList> ReadAllMaps_async(const MappingHandle& mappinghandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void ActivateMap(const ActivateMapHandle& activatemaphandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ActivateMap_callback(const ActivateMapHandle& activatemaphandle, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> ActivateMap_async(const ActivateMapHandle& activatemaphandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			ActionHandle CreateAction(const Action& action, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void CreateAction_callback(const Action& action, std::function< void (const Error&, const ActionHandle&) > callback, uint32_t deviceId = 0);
+			std::future<ActionHandle> CreateAction_async(const Action& action, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Action ReadAction(const ActionHandle& actionhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ReadAction_callback(const ActionHandle& actionhandle, std::function< void (const Error&, const Action&) > callback, uint32_t deviceId = 0);
+			std::future<Action> ReadAction_async(const ActionHandle& actionhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			ActionList ReadAllActions(const RequestedActionType& requestedactiontype, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ReadAllActions_callback(const RequestedActionType& requestedactiontype, std::function< void (const Error&, const ActionList&) > callback, uint32_t deviceId = 0);
+			std::future<ActionList> ReadAllActions_async(const RequestedActionType& requestedactiontype, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void DeleteAction(const ActionHandle& actionhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void DeleteAction_callback(const ActionHandle& actionhandle, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> DeleteAction_async(const ActionHandle& actionhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void UpdateAction(const Action& action, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void UpdateAction_callback(const Action& action, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> UpdateAction_async(const Action& action, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void ExecuteActionFromReference(const ActionHandle& actionhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ExecuteActionFromReference_callback(const ActionHandle& actionhandle, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> ExecuteActionFromReference_async(const ActionHandle& actionhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void ExecuteAction(const Action& action, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ExecuteAction_callback(const Action& action, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> ExecuteAction_async(const Action& action, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void PauseAction(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void PauseAction_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> PauseAction_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void StopAction(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void StopAction_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> StopAction_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void ResumeAction(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ResumeAction_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> ResumeAction_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			IPv4Configuration GetIPv4Configuration(const NetworkHandle& networkhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetIPv4Configuration_callback(const NetworkHandle& networkhandle, std::function< void (const Error&, const IPv4Configuration&) > callback, uint32_t deviceId = 0);
+			std::future<IPv4Configuration> GetIPv4Configuration_async(const NetworkHandle& networkhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetIPv4Configuration(const FullIPv4Configuration& fullipv4configuration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetIPv4Configuration_callback(const FullIPv4Configuration& fullipv4configuration, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetIPv4Configuration_async(const FullIPv4Configuration& fullipv4configuration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetCommunicationInterfaceEnable(const CommunicationInterfaceConfiguration& communicationinterfaceconfiguration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetCommunicationInterfaceEnable_callback(const CommunicationInterfaceConfiguration& communicationinterfaceconfiguration, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetCommunicationInterfaceEnable_async(const CommunicationInterfaceConfiguration& communicationinterfaceconfiguration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			CommunicationInterfaceConfiguration IsCommunicationInterfaceEnable(const NetworkHandle& networkhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void IsCommunicationInterfaceEnable_callback(const NetworkHandle& networkhandle, std::function< void (const Error&, const CommunicationInterfaceConfiguration&) > callback, uint32_t deviceId = 0);
+			std::future<CommunicationInterfaceConfiguration> IsCommunicationInterfaceEnable_async(const NetworkHandle& networkhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			WifiInformationList GetAvailableWifi(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetAvailableWifi_callback(std::function< void (const Error&, const WifiInformationList&) > callback, uint32_t deviceId = 0);
+			std::future<WifiInformationList> GetAvailableWifi_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			WifiInformation GetWifiInformation(const Ssid& ssid, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetWifiInformation_callback(const Ssid& ssid, std::function< void (const Error&, const WifiInformation&) > callback, uint32_t deviceId = 0);
+			std::future<WifiInformation> GetWifiInformation_async(const Ssid& ssid, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void AddWifiConfiguration(const WifiConfiguration& wificonfiguration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void AddWifiConfiguration_callback(const WifiConfiguration& wificonfiguration, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> AddWifiConfiguration_async(const WifiConfiguration& wificonfiguration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void DeleteWifiConfiguration(const Ssid& ssid, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void DeleteWifiConfiguration_callback(const Ssid& ssid, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> DeleteWifiConfiguration_async(const Ssid& ssid, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			WifiConfigurationList GetAllConfiguredWifis(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetAllConfiguredWifis_callback(std::function< void (const Error&, const WifiConfigurationList&) > callback, uint32_t deviceId = 0);
+			std::future<WifiConfigurationList> GetAllConfiguredWifis_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void ConnectWifi(const Ssid& ssid, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ConnectWifi_callback(const Ssid& ssid, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> ConnectWifi_async(const Ssid& ssid, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void DisconnectWifi(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void DisconnectWifi_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> DisconnectWifi_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			WifiInformation GetConnectedWifiInformation(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetConnectedWifiInformation_callback(std::function< void (const Error&, const WifiInformation&) > callback, uint32_t deviceId = 0);
+			std::future<WifiInformation> GetConnectedWifiInformation_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void Unsubscribe(const Kinova::Api::Common::NotificationHandle& notificationhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Kinova::Api::Common::NotificationHandle OnNotificationConfigurationChangeTopic(std::function< void (ConfigurationChangeNotification) > callback, const Kinova::Api::Common::NotificationOptions& notificationoptions, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Kinova::Api::Common::NotificationHandle OnNotificationMappingInfoTopic(std::function< void (MappingInfoNotification) > callback, const Kinova::Api::Common::NotificationOptions& notificationoptions, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Kinova::Api::Common::NotificationHandle OnNotificationOperatingModeTopic(std::function< void (OperatingModeNotification) > callback, const Kinova::Api::Common::NotificationOptions& notificationoptions, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Kinova::Api::Common::NotificationHandle OnNotificationSequenceInfoTopic(std::function< void (SequenceInfoNotification) > callback, const Kinova::Api::Common::NotificationOptions& notificationoptions, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Kinova::Api::Common::NotificationHandle OnNotificationProtectionZoneTopic(std::function< void (ProtectionZoneNotification) > callback, const Kinova::Api::Common::NotificationOptions& notificationoptions, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Kinova::Api::Common::NotificationHandle OnNotificationUserTopic(std::function< void (UserNotification) > callback, const Kinova::Api::Common::NotificationOptions& notificationoptions, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Kinova::Api::Common::NotificationHandle OnNotificationControllerTopic(std::function< void (ControllerNotification) > callback, const Kinova::Api::Common::NotificationOptions& notificationoptions, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Kinova::Api::Common::NotificationHandle OnNotificationActionTopic(std::function< void (ActionNotification) > callback, const Kinova::Api::Common::NotificationOptions& notificationoptions, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Kinova::Api::Common::NotificationHandle OnNotificationRobotEventTopic(std::function< void (RobotEventNotification) > callback, const Kinova::Api::Common::NotificationOptions& notificationoptions, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			DEPRECATED void PlayCartesianTrajectory(const ConstrainedPose& constrainedpose, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			DEPRECATED void PlayCartesianTrajectory_callback(const ConstrainedPose& constrainedpose, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			DEPRECATED std::future<void> PlayCartesianTrajectory_async(const ConstrainedPose& constrainedpose, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			DEPRECATED void PlayCartesianTrajectoryPosition(const ConstrainedPosition& constrainedposition, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			DEPRECATED void PlayCartesianTrajectoryPosition_callback(const ConstrainedPosition& constrainedposition, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			DEPRECATED std::future<void> PlayCartesianTrajectoryPosition_async(const ConstrainedPosition& constrainedposition, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			DEPRECATED void PlayCartesianTrajectoryOrientation(const ConstrainedOrientation& constrainedorientation, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			DEPRECATED void PlayCartesianTrajectoryOrientation_callback(const ConstrainedOrientation& constrainedorientation, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			DEPRECATED std::future<void> PlayCartesianTrajectoryOrientation_async(const ConstrainedOrientation& constrainedorientation, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void Stop(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void Stop_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> Stop_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Pose GetMeasuredCartesianPose(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetMeasuredCartesianPose_callback(std::function< void (const Error&, const Pose&) > callback, uint32_t deviceId = 0);
+			std::future<Pose> GetMeasuredCartesianPose_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SendWrenchCommand(const WrenchCommand& wrenchcommand, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SendWrenchCommand_callback(const WrenchCommand& wrenchcommand, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SendWrenchCommand_async(const WrenchCommand& wrenchcommand, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SendWrenchJoystickCommand(const WrenchCommand& wrenchcommand, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SendWrenchJoystickCommand_callback(const WrenchCommand& wrenchcommand, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SendWrenchJoystickCommand_async(const WrenchCommand& wrenchcommand, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SendTwistJoystickCommand(const TwistCommand& twistcommand, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SendTwistJoystickCommand_callback(const TwistCommand& twistcommand, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SendTwistJoystickCommand_async(const TwistCommand& twistcommand, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SendTwistCommand(const TwistCommand& twistcommand, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SendTwistCommand_callback(const TwistCommand& twistcommand, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SendTwistCommand_async(const TwistCommand& twistcommand, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			DEPRECATED void PlayJointTrajectory(const ConstrainedJointAngles& constrainedjointangles, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			DEPRECATED void PlayJointTrajectory_callback(const ConstrainedJointAngles& constrainedjointangles, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			DEPRECATED std::future<void> PlayJointTrajectory_async(const ConstrainedJointAngles& constrainedjointangles, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			DEPRECATED void PlaySelectedJointTrajectory(const ConstrainedJointAngle& constrainedjointangle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			DEPRECATED void PlaySelectedJointTrajectory_callback(const ConstrainedJointAngle& constrainedjointangle, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			DEPRECATED std::future<void> PlaySelectedJointTrajectory_async(const ConstrainedJointAngle& constrainedjointangle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			JointAngles GetMeasuredJointAngles(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetMeasuredJointAngles_callback(std::function< void (const Error&, const JointAngles&) > callback, uint32_t deviceId = 0);
+			std::future<JointAngles> GetMeasuredJointAngles_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SendJointSpeedsCommand(const JointSpeeds& jointspeeds, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SendJointSpeedsCommand_callback(const JointSpeeds& jointspeeds, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SendJointSpeedsCommand_async(const JointSpeeds& jointspeeds, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SendSelectedJointSpeedCommand(const JointSpeed& jointspeed, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SendSelectedJointSpeedCommand_callback(const JointSpeed& jointspeed, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SendSelectedJointSpeedCommand_async(const JointSpeed& jointspeed, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SendGripperCommand(const GripperCommand& grippercommand, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SendGripperCommand_callback(const GripperCommand& grippercommand, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SendGripperCommand_async(const GripperCommand& grippercommand, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Gripper GetMeasuredGripperMovement(const GripperRequest& gripperrequest, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetMeasuredGripperMovement_callback(const GripperRequest& gripperrequest, std::function< void (const Error&, const Gripper&) > callback, uint32_t deviceId = 0);
+			std::future<Gripper> GetMeasuredGripperMovement_async(const GripperRequest& gripperrequest, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetAdmittance(const Admittance& admittance, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetAdmittance_callback(const Admittance& admittance, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetAdmittance_async(const Admittance& admittance, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetOperatingMode(const OperatingModeInformation& operatingmodeinformation, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetOperatingMode_callback(const OperatingModeInformation& operatingmodeinformation, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetOperatingMode_async(const OperatingModeInformation& operatingmodeinformation, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void ApplyEmergencyStop(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ApplyEmergencyStop_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> ApplyEmergencyStop_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void ClearFaults(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ClearFaults_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> ClearFaults_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			OperatingModeInformation GetOperatingMode(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetOperatingMode_callback(std::function< void (const Error&, const OperatingModeInformation&) > callback, uint32_t deviceId = 0);
+			std::future<OperatingModeInformation> GetOperatingMode_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetServoingMode(const ServoingModeInformation& servoingmodeinformation, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetServoingMode_callback(const ServoingModeInformation& servoingmodeinformation, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetServoingMode_async(const ServoingModeInformation& servoingmodeinformation, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			ServoingModeInformation GetServoingMode(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetServoingMode_callback(std::function< void (const Error&, const ServoingModeInformation&) > callback, uint32_t deviceId = 0);
+			std::future<ServoingModeInformation> GetServoingMode_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Kinova::Api::Common::NotificationHandle OnNotificationServoingModeTopic(std::function< void (ServoingModeNotification) > callback, const Kinova::Api::Common::NotificationOptions& notificationoptions, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void RestoreFactorySettings(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void RestoreFactorySettings_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> RestoreFactorySettings_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void Reboot(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void Reboot_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> Reboot_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Kinova::Api::Common::NotificationHandle OnNotificationFactoryTopic(std::function< void (FactoryNotification) > callback, const Kinova::Api::Common::NotificationOptions& notificationoptions, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			ControllerList GetAllConnectedControllers(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetAllConnectedControllers_callback(std::function< void (const Error&, const ControllerList&) > callback, uint32_t deviceId = 0);
+			std::future<ControllerList> GetAllConnectedControllers_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			ControllerState GetControllerState(const ControllerHandle& controllerhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetControllerState_callback(const ControllerHandle& controllerhandle, std::function< void (const Error&, const ControllerState&) > callback, uint32_t deviceId = 0);
+			std::future<ControllerState> GetControllerState_async(const ControllerHandle& controllerhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			ActuatorInformation GetActuatorCount(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetActuatorCount_callback(std::function< void (const Error&, const ActuatorInformation&) > callback, uint32_t deviceId = 0);
+			std::future<ActuatorInformation> GetActuatorCount_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void StartWifiScan(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void StartWifiScan_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> StartWifiScan_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			WifiConfiguration GetConfiguredWifi(const Ssid& ssid, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetConfiguredWifi_callback(const Ssid& ssid, std::function< void (const Error&, const WifiConfiguration&) > callback, uint32_t deviceId = 0);
+			std::future<WifiConfiguration> GetConfiguredWifi_async(const Ssid& ssid, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Kinova::Api::Common::NotificationHandle OnNotificationNetworkTopic(std::function< void (NetworkNotification) > callback, const Kinova::Api::Common::NotificationOptions& notificationoptions, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			ArmStateInformation GetArmState(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetArmState_callback(std::function< void (const Error&, const ArmStateInformation&) > callback, uint32_t deviceId = 0);
+			std::future<ArmStateInformation> GetArmState_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Kinova::Api::Common::NotificationHandle OnNotificationArmStateTopic(std::function< void (ArmStateNotification) > callback, const Kinova::Api::Common::NotificationOptions& notificationoptions, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			IPv4Information GetIPv4Information(const NetworkHandle& networkhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetIPv4Information_callback(const NetworkHandle& networkhandle, std::function< void (const Error&, const IPv4Information&) > callback, uint32_t deviceId = 0);
+			std::future<IPv4Information> GetIPv4Information_async(const NetworkHandle& networkhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetWifiCountryCode(const Kinova::Api::Common::CountryCode& countrycode, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetWifiCountryCode_callback(const Kinova::Api::Common::CountryCode& countrycode, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetWifiCountryCode_async(const Kinova::Api::Common::CountryCode& countrycode, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Kinova::Api::Common::CountryCode GetWifiCountryCode(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetWifiCountryCode_callback(std::function< void (const Error&, const Kinova::Api::Common::CountryCode&) > callback, uint32_t deviceId = 0);
+			std::future<Kinova::Api::Common::CountryCode> GetWifiCountryCode_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetCapSenseConfig(const CapSenseConfig& capsenseconfig, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetCapSenseConfig_callback(const CapSenseConfig& capsenseconfig, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetCapSenseConfig_async(const CapSenseConfig& capsenseconfig, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			CapSenseConfig GetCapSenseConfig(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetCapSenseConfig_callback(std::function< void (const Error&, const CapSenseConfig&) > callback, uint32_t deviceId = 0);
+			std::future<CapSenseConfig> GetCapSenseConfig_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			DEPRECATED JointsLimitationsList GetAllJointsTorqueHardLimitation(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			DEPRECATED void GetAllJointsTorqueHardLimitation_callback(std::function< void (const Error&, const JointsLimitationsList&) > callback, uint32_t deviceId = 0);
+			DEPRECATED std::future<JointsLimitationsList> GetAllJointsTorqueHardLimitation_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			DEPRECATED WrenchLimitation GetWrenchHardLimitation(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			DEPRECATED void GetWrenchHardLimitation_callback(std::function< void (const Error&, const WrenchLimitation&) > callback, uint32_t deviceId = 0);
+			DEPRECATED std::future<WrenchLimitation> GetWrenchHardLimitation_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SendJointSpeedsJoystickCommand(const JointSpeeds& jointspeeds, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SendJointSpeedsJoystickCommand_callback(const JointSpeeds& jointspeeds, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SendJointSpeedsJoystickCommand_async(const JointSpeeds& jointspeeds, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SendSelectedJointSpeedJoystickCommand(const JointSpeed& jointspeed, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SendSelectedJointSpeedJoystickCommand_callback(const JointSpeed& jointspeed, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SendSelectedJointSpeedJoystickCommand_async(const JointSpeed& jointspeed, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			BridgeResult EnableBridge(const BridgeConfig& bridgeconfig, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void EnableBridge_callback(const BridgeConfig& bridgeconfig, std::function< void (const Error&, const BridgeResult&) > callback, uint32_t deviceId = 0);
+			std::future<BridgeResult> EnableBridge_async(const BridgeConfig& bridgeconfig, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			BridgeResult DisableBridge(const BridgeIdentifier& bridgeidentifier, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void DisableBridge_callback(const BridgeIdentifier& bridgeidentifier, std::function< void (const Error&, const BridgeResult&) > callback, uint32_t deviceId = 0);
+			std::future<BridgeResult> DisableBridge_async(const BridgeIdentifier& bridgeidentifier, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			BridgeList GetBridgeList(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetBridgeList_callback(std::function< void (const Error&, const BridgeList&) > callback, uint32_t deviceId = 0);
+			std::future<BridgeList> GetBridgeList_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			BridgeConfig GetBridgeConfig(const BridgeIdentifier& bridgeidentifier, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetBridgeConfig_callback(const BridgeIdentifier& bridgeidentifier, std::function< void (const Error&, const BridgeConfig&) > callback, uint32_t deviceId = 0);
+			std::future<BridgeConfig> GetBridgeConfig_async(const BridgeIdentifier& bridgeidentifier, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void PlayPreComputedJointTrajectory(const PreComputedJointTrajectory& precomputedjointtrajectory, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void PlayPreComputedJointTrajectory_callback(const PreComputedJointTrajectory& precomputedjointtrajectory, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> PlayPreComputedJointTrajectory_async(const PreComputedJointTrajectory& precomputedjointtrajectory, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Kinova::Api::ProductConfiguration::CompleteProductConfiguration GetProductConfiguration(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetProductConfiguration_callback(std::function< void (const Error&, const Kinova::Api::ProductConfiguration::CompleteProductConfiguration&) > callback, uint32_t deviceId = 0);
+			std::future<Kinova::Api::ProductConfiguration::CompleteProductConfiguration> GetProductConfiguration_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void UpdateEndEffectorTypeConfiguration(const Kinova::Api::ProductConfiguration::ProductConfigurationEndEffectorType& productconfigurationendeffectortype, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void UpdateEndEffectorTypeConfiguration_callback(const Kinova::Api::ProductConfiguration::ProductConfigurationEndEffectorType& productconfigurationendeffectortype, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> UpdateEndEffectorTypeConfiguration_async(const Kinova::Api::ProductConfiguration::ProductConfigurationEndEffectorType& productconfigurationendeffectortype, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void RestoreFactoryProductConfiguration(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void RestoreFactoryProductConfiguration_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> RestoreFactoryProductConfiguration_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			TrajectoryErrorReport GetTrajectoryErrorReport(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetTrajectoryErrorReport_callback(std::function< void (const Error&, const TrajectoryErrorReport&) > callback, uint32_t deviceId = 0);
+			std::future<TrajectoryErrorReport> GetTrajectoryErrorReport_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			DEPRECATED JointsLimitationsList GetAllJointsTorqueSoftLimitation(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			DEPRECATED void GetAllJointsTorqueSoftLimitation_callback(std::function< void (const Error&, const JointsLimitationsList&) > callback, uint32_t deviceId = 0);
+			DEPRECATED std::future<JointsLimitationsList> GetAllJointsTorqueSoftLimitation_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			DEPRECATED WrenchLimitation GetWrenchSoftLimitation(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			DEPRECATED void GetWrenchSoftLimitation_callback(std::function< void (const Error&, const WrenchLimitation&) > callback, uint32_t deviceId = 0);
+			DEPRECATED std::future<WrenchLimitation> GetWrenchSoftLimitation_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetControllerConfigurationMode(const ControllerConfigurationMode& controllerconfigurationmode, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetControllerConfigurationMode_callback(const ControllerConfigurationMode& controllerconfigurationmode, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetControllerConfigurationMode_async(const ControllerConfigurationMode& controllerconfigurationmode, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			ControllerConfigurationMode GetControllerConfigurationMode(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetControllerConfigurationMode_callback(std::function< void (const Error&, const ControllerConfigurationMode&) > callback, uint32_t deviceId = 0);
+			std::future<ControllerConfigurationMode> GetControllerConfigurationMode_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void StartTeaching(const SequenceTaskHandle& sequencetaskhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void StartTeaching_callback(const SequenceTaskHandle& sequencetaskhandle, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> StartTeaching_async(const SequenceTaskHandle& sequencetaskhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void StopTeaching(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void StopTeaching_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> StopTeaching_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			SequenceTasksRange AddSequenceTasks(const SequenceTasksConfiguration& sequencetasksconfiguration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void AddSequenceTasks_callback(const SequenceTasksConfiguration& sequencetasksconfiguration, std::function< void (const Error&, const SequenceTasksRange&) > callback, uint32_t deviceId = 0);
+			std::future<SequenceTasksRange> AddSequenceTasks_async(const SequenceTasksConfiguration& sequencetasksconfiguration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void UpdateSequenceTask(const SequenceTaskConfiguration& sequencetaskconfiguration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void UpdateSequenceTask_callback(const SequenceTaskConfiguration& sequencetaskconfiguration, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> UpdateSequenceTask_async(const SequenceTaskConfiguration& sequencetaskconfiguration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SwapSequenceTasks(const SequenceTasksPair& sequencetaskspair, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SwapSequenceTasks_callback(const SequenceTasksPair& sequencetaskspair, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SwapSequenceTasks_async(const SequenceTasksPair& sequencetaskspair, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			SequenceTask ReadSequenceTask(const SequenceTaskHandle& sequencetaskhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ReadSequenceTask_callback(const SequenceTaskHandle& sequencetaskhandle, std::function< void (const Error&, const SequenceTask&) > callback, uint32_t deviceId = 0);
+			std::future<SequenceTask> ReadSequenceTask_async(const SequenceTaskHandle& sequencetaskhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			SequenceTasks ReadAllSequenceTasks(const SequenceHandle& sequencehandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ReadAllSequenceTasks_callback(const SequenceHandle& sequencehandle, std::function< void (const Error&, const SequenceTasks&) > callback, uint32_t deviceId = 0);
+			std::future<SequenceTasks> ReadAllSequenceTasks_async(const SequenceHandle& sequencehandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void DeleteSequenceTask(const SequenceTaskHandle& sequencetaskhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void DeleteSequenceTask_callback(const SequenceTaskHandle& sequencetaskhandle, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> DeleteSequenceTask_async(const SequenceTaskHandle& sequencetaskhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void DeleteAllSequenceTasks(const SequenceHandle& sequencehandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void DeleteAllSequenceTasks_callback(const SequenceHandle& sequencehandle, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> DeleteAllSequenceTasks_async(const SequenceHandle& sequencehandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void TakeSnapshot(const Snapshot& snapshot, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void TakeSnapshot_callback(const Snapshot& snapshot, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> TakeSnapshot_async(const Snapshot& snapshot, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			FirmwareBundleVersions GetFirmwareBundleVersions(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetFirmwareBundleVersions_callback(std::function< void (const Error&, const FirmwareBundleVersions&) > callback, uint32_t deviceId = 0);
+			std::future<FirmwareBundleVersions> GetFirmwareBundleVersions_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void ExecuteWaypointTrajectory(const WaypointList& waypointlist, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ExecuteWaypointTrajectory_callback(const WaypointList& waypointlist, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> ExecuteWaypointTrajectory_async(const WaypointList& waypointlist, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void MoveSequenceTask(const SequenceTasksPair& sequencetaskspair, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void MoveSequenceTask_callback(const SequenceTasksPair& sequencetaskspair, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> MoveSequenceTask_async(const SequenceTasksPair& sequencetaskspair, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			MappingHandle DuplicateMapping(const MappingHandle& mappinghandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void DuplicateMapping_callback(const MappingHandle& mappinghandle, std::function< void (const Error&, const MappingHandle&) > callback, uint32_t deviceId = 0);
+			std::future<MappingHandle> DuplicateMapping_async(const MappingHandle& mappinghandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			MapHandle DuplicateMap(const MapHandle& maphandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void DuplicateMap_callback(const MapHandle& maphandle, std::function< void (const Error&, const MapHandle&) > callback, uint32_t deviceId = 0);
+			std::future<MapHandle> DuplicateMap_async(const MapHandle& maphandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetControllerConfiguration(const ControllerConfiguration& controllerconfiguration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetControllerConfiguration_callback(const ControllerConfiguration& controllerconfiguration, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetControllerConfiguration_async(const ControllerConfiguration& controllerconfiguration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			ControllerConfiguration GetControllerConfiguration(const ControllerHandle& controllerhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetControllerConfiguration_callback(const ControllerHandle& controllerhandle, std::function< void (const Error&, const ControllerConfiguration&) > callback, uint32_t deviceId = 0);
+			std::future<ControllerConfiguration> GetControllerConfiguration_async(const ControllerHandle& controllerhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			ControllerConfigurationList GetAllControllerConfigurations(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetAllControllerConfigurations_callback(std::function< void (const Error&, const ControllerConfigurationList&) > callback, uint32_t deviceId = 0);
+			std::future<ControllerConfigurationList> GetAllControllerConfigurations_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Pose ComputeForwardKinematics(const JointAngles& jointangles, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ComputeForwardKinematics_callback(const JointAngles& jointangles, std::function< void (const Error&, const Pose&) > callback, uint32_t deviceId = 0);
+			std::future<Pose> ComputeForwardKinematics_async(const JointAngles& jointangles, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			JointAngles ComputeInverseKinematics(const IKData& ikdata, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ComputeInverseKinematics_callback(const IKData& ikdata, std::function< void (const Error&, const JointAngles&) > callback, uint32_t deviceId = 0);
+			std::future<JointAngles> ComputeInverseKinematics_async(const IKData& ikdata, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			WaypointValidationReport ValidateWaypointList(const WaypointList& waypointlist, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ValidateWaypointList_callback(const WaypointList& waypointlist, std::function< void (const Error&, const WaypointValidationReport&) > callback, uint32_t deviceId = 0);
+			std::future<WaypointValidationReport> ValidateWaypointList_async(const WaypointList& waypointlist, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetWifiEnableState(const WifiEnableState& wifienablestate, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetWifiEnableState_callback(const WifiEnableState& wifienablestate, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetWifiEnableState_async(const WifiEnableState& wifienablestate, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			WifiEnableState GetWifiEnableState(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetWifiEnableState_callback(std::function< void (const Error&, const WifiEnableState&) > callback, uint32_t deviceId = 0);
+			std::future<WifiEnableState> GetWifiEnableState_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetBluetoothEnableState(const BluetoothEnableState& bluetoothenablestate, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetBluetoothEnableState_callback(const BluetoothEnableState& bluetoothenablestate, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetBluetoothEnableState_async(const BluetoothEnableState& bluetoothenablestate, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			BluetoothEnableState GetBluetoothEnableState(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetBluetoothEnableState_callback(std::function< void (const Error&, const BluetoothEnableState&) > callback, uint32_t deviceId = 0);
+			std::future<BluetoothEnableState> GetBluetoothEnableState_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+
+		private:
+			void messageHeaderValidation(const Frame& msgFrame){ /* todogr ... */ }
+		};
+	}
+}
+}
+
+#endif
\ No newline at end of file
diff --git a/kortex_api/include/client_stubs/BaseCyclicClientRpc.h b/kortex_api/include/client_stubs/BaseCyclicClientRpc.h
new file mode 100644
index 0000000000000000000000000000000000000000..1d05fbf6246450ea7b830c12538290640a1f5ce1
--- /dev/null
+++ b/kortex_api/include/client_stubs/BaseCyclicClientRpc.h
@@ -0,0 +1,83 @@
+#ifndef __BASECYCLICCLIENT_H__
+#define __BASECYCLICCLIENT_H__
+
+#include <string>
+#include <future>
+#include <functional>
+#include <exception>
+
+#include "messages/Frame.pb.h"
+#include "messages/BaseCyclic.pb.h"
+
+#include "common/Frame.h"
+#include "client/IRouterClient.h"
+#include "client/NotificationHandler.h"
+
+#if __cplusplus >= 201402L
+#define DEPRECATED [[ deprecated ]]
+#define DEPRECATED_MSG(msg) [[ deprecated(msg) ]]
+#elif defined(__GNUC__)
+#define DEPRECATED __attribute__ ((deprecated))
+#define DEPRECATED_MSG(msg) __attribute__ ((deprecated(msg)))
+#elif defined(_MSC_VER)
+#define DEPRECATED __declspec(deprecated)
+#define DEPRECATED_MSG(msg) __declspec(deprecated(msg))
+#else
+#define DEPRECATED 
+#define DEPRECATED_MSG 
+#endif
+namespace Kinova
+{
+namespace Api
+{
+	namespace BaseCyclic
+	{
+		// todogr move somewhere else
+		const std::string   none = "";
+		
+		enum FunctionUids
+		{
+			eUidRefresh = 0x30001,
+			eUidRefreshCommand = 0x30002,
+			eUidRefreshFeedback = 0x30003,
+			eUidRefreshCustomData = 0x30004,
+		};
+		
+		class BaseCyclicClient
+		{
+			static const uint32_t m_serviceVersion = 1;
+			static const uint32_t m_serviceId = eIdBaseCyclic;
+			NotificationHandler m_notificationHandler;
+
+		protected:
+			IRouterClient* const m_clientRouter;
+
+		public:
+			BaseCyclicClient(IRouterClient* clientRouter);
+			static uint32_t getUniqueFctId(uint16_t fctId);
+
+			Feedback Refresh(const Command& command, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void Refresh_callback(const Command& command, std::function< void (const Error&, const Feedback&) > callback, uint32_t deviceId = 0);
+			std::future<Feedback> Refresh_async(const Command& command, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void RefreshCommand(const Command& command, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void RefreshCommand_callback(const Command& command, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> RefreshCommand_async(const Command& command, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Feedback RefreshFeedback(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void RefreshFeedback_callback(std::function< void (const Error&, const Feedback&) > callback, uint32_t deviceId = 0);
+			std::future<Feedback> RefreshFeedback_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			CustomData RefreshCustomData(const CustomData& customdata, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void RefreshCustomData_callback(const CustomData& customdata, std::function< void (const Error&, const CustomData&) > callback, uint32_t deviceId = 0);
+			std::future<CustomData> RefreshCustomData_async(const CustomData& customdata, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+
+		private:
+			void messageHeaderValidation(const Frame& msgFrame){ /* todogr ... */ }
+		};
+	}
+}
+}
+
+#endif
\ No newline at end of file
diff --git a/kortex_api/include/client_stubs/ControlConfigClientRpc.h b/kortex_api/include/client_stubs/ControlConfigClientRpc.h
new file mode 100644
index 0000000000000000000000000000000000000000..c028e3039707b553cce2ba90a9ec5188dfc7ec0f
--- /dev/null
+++ b/kortex_api/include/client_stubs/ControlConfigClientRpc.h
@@ -0,0 +1,207 @@
+#ifndef __CONTROLCONFIGCLIENT_H__
+#define __CONTROLCONFIGCLIENT_H__
+
+#include <string>
+#include <future>
+#include <functional>
+#include <exception>
+
+#include "messages/Frame.pb.h"
+#include "messages/ControlConfig.pb.h"
+
+#include "common/Frame.h"
+#include "client/IRouterClient.h"
+#include "client/NotificationHandler.h"
+
+#if __cplusplus >= 201402L
+#define DEPRECATED [[ deprecated ]]
+#define DEPRECATED_MSG(msg) [[ deprecated(msg) ]]
+#elif defined(__GNUC__)
+#define DEPRECATED __attribute__ ((deprecated))
+#define DEPRECATED_MSG(msg) __attribute__ ((deprecated(msg)))
+#elif defined(_MSC_VER)
+#define DEPRECATED __declspec(deprecated)
+#define DEPRECATED_MSG(msg) __declspec(deprecated(msg))
+#else
+#define DEPRECATED 
+#define DEPRECATED_MSG 
+#endif
+namespace Kinova
+{
+namespace Api
+{
+	namespace ControlConfig
+	{
+		// todogr move somewhere else
+		const std::string   none = "";
+		
+		enum FunctionUids
+		{
+			eUidSetGravityVector = 0x100001,
+			eUidGetGravityVector = 0x100002,
+			eUidSetPayloadInformation = 0x100003,
+			eUidGetPayloadInformation = 0x100004,
+			eUidSetToolConfiguration = 0x100005,
+			eUidGetToolConfiguration = 0x100006,
+			eUidControlConfigurationTopic = 0x100007,
+			eUidUnsubscribe = 0x100008,
+			eUidSetCartesianReferenceFrame = 0x100009,
+			eUidGetCartesianReferenceFrame = 0x10000a,
+			eUidGetControlMode = 0x10000d,
+			eUidSetJointSpeedSoftLimits = 0x10000e,
+			eUidSetTwistLinearSoftLimit = 0x10000f,
+			eUidSetTwistAngularSoftLimit = 0x100010,
+			eUidSetJointAccelerationSoftLimits = 0x100011,
+			eUidGetKinematicHardLimits = 0x100012,
+			eUidGetKinematicSoftLimits = 0x100013,
+			eUidGetAllKinematicSoftLimits = 0x100014,
+			eUidSetDesiredLinearTwist = 0x100015,
+			eUidSetDesiredAngularTwist = 0x100016,
+			eUidSetDesiredJointSpeeds = 0x100017,
+			eUidGetDesiredSpeeds = 0x100018,
+			eUidResetGravityVector = 0x100019,
+			eUidResetPayloadInformation = 0x10001a,
+			eUidResetToolConfiguration = 0x10001b,
+			eUidResetJointSpeedSoftLimits = 0x10001c,
+			eUidResetTwistLinearSoftLimit = 0x10001d,
+			eUidResetTwistAngularSoftLimit = 0x10001e,
+			eUidResetJointAccelerationSoftLimits = 0x10001f,
+			eUidControlModeTopic = 0x100020,
+		};
+		
+		class ControlConfigClient
+		{
+			static const uint32_t m_serviceVersion = 1;
+			static const uint32_t m_serviceId = eIdControlConfig;
+			NotificationHandler m_notificationHandler;
+
+		protected:
+			IRouterClient* const m_clientRouter;
+
+		public:
+			ControlConfigClient(IRouterClient* clientRouter);
+			static uint32_t getUniqueFctId(uint16_t fctId);
+
+			void SetGravityVector(const GravityVector& gravityvector, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetGravityVector_callback(const GravityVector& gravityvector, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetGravityVector_async(const GravityVector& gravityvector, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			GravityVector GetGravityVector(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetGravityVector_callback(std::function< void (const Error&, const GravityVector&) > callback, uint32_t deviceId = 0);
+			std::future<GravityVector> GetGravityVector_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetPayloadInformation(const PayloadInformation& payloadinformation, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetPayloadInformation_callback(const PayloadInformation& payloadinformation, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetPayloadInformation_async(const PayloadInformation& payloadinformation, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			PayloadInformation GetPayloadInformation(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetPayloadInformation_callback(std::function< void (const Error&, const PayloadInformation&) > callback, uint32_t deviceId = 0);
+			std::future<PayloadInformation> GetPayloadInformation_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetToolConfiguration(const ToolConfiguration& toolconfiguration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetToolConfiguration_callback(const ToolConfiguration& toolconfiguration, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetToolConfiguration_async(const ToolConfiguration& toolconfiguration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			ToolConfiguration GetToolConfiguration(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetToolConfiguration_callback(std::function< void (const Error&, const ToolConfiguration&) > callback, uint32_t deviceId = 0);
+			std::future<ToolConfiguration> GetToolConfiguration_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Kinova::Api::Common::NotificationHandle OnNotificationControlConfigurationTopic(std::function< void (ControlConfigurationNotification) > callback, const Kinova::Api::Common::NotificationOptions& notificationoptions, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void Unsubscribe(const Kinova::Api::Common::NotificationHandle& notificationhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetCartesianReferenceFrame(const CartesianReferenceFrameInfo& cartesianreferenceframeinfo, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetCartesianReferenceFrame_callback(const CartesianReferenceFrameInfo& cartesianreferenceframeinfo, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetCartesianReferenceFrame_async(const CartesianReferenceFrameInfo& cartesianreferenceframeinfo, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			CartesianReferenceFrameInfo GetCartesianReferenceFrame(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetCartesianReferenceFrame_callback(std::function< void (const Error&, const CartesianReferenceFrameInfo&) > callback, uint32_t deviceId = 0);
+			std::future<CartesianReferenceFrameInfo> GetCartesianReferenceFrame_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			ControlModeInformation GetControlMode(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetControlMode_callback(std::function< void (const Error&, const ControlModeInformation&) > callback, uint32_t deviceId = 0);
+			std::future<ControlModeInformation> GetControlMode_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetJointSpeedSoftLimits(const JointSpeedSoftLimits& jointspeedsoftlimits, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetJointSpeedSoftLimits_callback(const JointSpeedSoftLimits& jointspeedsoftlimits, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetJointSpeedSoftLimits_async(const JointSpeedSoftLimits& jointspeedsoftlimits, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetTwistLinearSoftLimit(const TwistLinearSoftLimit& twistlinearsoftlimit, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetTwistLinearSoftLimit_callback(const TwistLinearSoftLimit& twistlinearsoftlimit, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetTwistLinearSoftLimit_async(const TwistLinearSoftLimit& twistlinearsoftlimit, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetTwistAngularSoftLimit(const TwistAngularSoftLimit& twistangularsoftlimit, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetTwistAngularSoftLimit_callback(const TwistAngularSoftLimit& twistangularsoftlimit, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetTwistAngularSoftLimit_async(const TwistAngularSoftLimit& twistangularsoftlimit, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetJointAccelerationSoftLimits(const JointAccelerationSoftLimits& jointaccelerationsoftlimits, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetJointAccelerationSoftLimits_callback(const JointAccelerationSoftLimits& jointaccelerationsoftlimits, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetJointAccelerationSoftLimits_async(const JointAccelerationSoftLimits& jointaccelerationsoftlimits, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			KinematicLimits GetKinematicHardLimits(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetKinematicHardLimits_callback(std::function< void (const Error&, const KinematicLimits&) > callback, uint32_t deviceId = 0);
+			std::future<KinematicLimits> GetKinematicHardLimits_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			KinematicLimits GetKinematicSoftLimits(const ControlModeInformation& controlmodeinformation, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetKinematicSoftLimits_callback(const ControlModeInformation& controlmodeinformation, std::function< void (const Error&, const KinematicLimits&) > callback, uint32_t deviceId = 0);
+			std::future<KinematicLimits> GetKinematicSoftLimits_async(const ControlModeInformation& controlmodeinformation, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			KinematicLimitsList GetAllKinematicSoftLimits(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetAllKinematicSoftLimits_callback(std::function< void (const Error&, const KinematicLimitsList&) > callback, uint32_t deviceId = 0);
+			std::future<KinematicLimitsList> GetAllKinematicSoftLimits_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetDesiredLinearTwist(const LinearTwist& lineartwist, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetDesiredLinearTwist_callback(const LinearTwist& lineartwist, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetDesiredLinearTwist_async(const LinearTwist& lineartwist, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetDesiredAngularTwist(const AngularTwist& angulartwist, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetDesiredAngularTwist_callback(const AngularTwist& angulartwist, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetDesiredAngularTwist_async(const AngularTwist& angulartwist, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetDesiredJointSpeeds(const JointSpeeds& jointspeeds, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetDesiredJointSpeeds_callback(const JointSpeeds& jointspeeds, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetDesiredJointSpeeds_async(const JointSpeeds& jointspeeds, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			DesiredSpeeds GetDesiredSpeeds(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetDesiredSpeeds_callback(std::function< void (const Error&, const DesiredSpeeds&) > callback, uint32_t deviceId = 0);
+			std::future<DesiredSpeeds> GetDesiredSpeeds_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			GravityVector ResetGravityVector(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ResetGravityVector_callback(std::function< void (const Error&, const GravityVector&) > callback, uint32_t deviceId = 0);
+			std::future<GravityVector> ResetGravityVector_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			PayloadInformation ResetPayloadInformation(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ResetPayloadInformation_callback(std::function< void (const Error&, const PayloadInformation&) > callback, uint32_t deviceId = 0);
+			std::future<PayloadInformation> ResetPayloadInformation_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			ToolConfiguration ResetToolConfiguration(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ResetToolConfiguration_callback(std::function< void (const Error&, const ToolConfiguration&) > callback, uint32_t deviceId = 0);
+			std::future<ToolConfiguration> ResetToolConfiguration_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			JointSpeedSoftLimits ResetJointSpeedSoftLimits(const ControlModeInformation& controlmodeinformation, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ResetJointSpeedSoftLimits_callback(const ControlModeInformation& controlmodeinformation, std::function< void (const Error&, const JointSpeedSoftLimits&) > callback, uint32_t deviceId = 0);
+			std::future<JointSpeedSoftLimits> ResetJointSpeedSoftLimits_async(const ControlModeInformation& controlmodeinformation, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			TwistLinearSoftLimit ResetTwistLinearSoftLimit(const ControlModeInformation& controlmodeinformation, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ResetTwistLinearSoftLimit_callback(const ControlModeInformation& controlmodeinformation, std::function< void (const Error&, const TwistLinearSoftLimit&) > callback, uint32_t deviceId = 0);
+			std::future<TwistLinearSoftLimit> ResetTwistLinearSoftLimit_async(const ControlModeInformation& controlmodeinformation, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			TwistAngularSoftLimit ResetTwistAngularSoftLimit(const ControlModeInformation& controlmodeinformation, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ResetTwistAngularSoftLimit_callback(const ControlModeInformation& controlmodeinformation, std::function< void (const Error&, const TwistAngularSoftLimit&) > callback, uint32_t deviceId = 0);
+			std::future<TwistAngularSoftLimit> ResetTwistAngularSoftLimit_async(const ControlModeInformation& controlmodeinformation, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			JointAccelerationSoftLimits ResetJointAccelerationSoftLimits(const ControlModeInformation& controlmodeinformation, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ResetJointAccelerationSoftLimits_callback(const ControlModeInformation& controlmodeinformation, std::function< void (const Error&, const JointAccelerationSoftLimits&) > callback, uint32_t deviceId = 0);
+			std::future<JointAccelerationSoftLimits> ResetJointAccelerationSoftLimits_async(const ControlModeInformation& controlmodeinformation, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Kinova::Api::Common::NotificationHandle OnNotificationControlModeTopic(std::function< void (ControlModeNotification) > callback, const Kinova::Api::Common::NotificationOptions& notificationoptions, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+
+		private:
+			void messageHeaderValidation(const Frame& msgFrame){ /* todogr ... */ }
+		};
+	}
+}
+}
+
+#endif
\ No newline at end of file
diff --git a/kortex_api/include/client_stubs/DeviceConfigClientRpc.h b/kortex_api/include/client_stubs/DeviceConfigClientRpc.h
new file mode 100644
index 0000000000000000000000000000000000000000..fc5a31761792385b91f4123924dc0d8d9b6c6a38
--- /dev/null
+++ b/kortex_api/include/client_stubs/DeviceConfigClientRpc.h
@@ -0,0 +1,230 @@
+#ifndef __DEVICECONFIGCLIENT_H__
+#define __DEVICECONFIGCLIENT_H__
+
+#include <string>
+#include <future>
+#include <functional>
+#include <exception>
+#include "messages/Frame.pb.h"
+#include "messages/DeviceConfig.pb.h"
+
+#include "common/Frame.h"
+#include "client/IRouterClient.h"
+#include "client/NotificationHandler.h"
+
+#if __cplusplus >= 201402L
+#define DEPRECATED [[ deprecated ]]
+#define DEPRECATED_MSG(msg) [[ deprecated(msg) ]]
+#elif defined(__GNUC__)
+#define DEPRECATED __attribute__ ((deprecated))
+#define DEPRECATED_MSG(msg) __attribute__ ((deprecated(msg)))
+#elif defined(_MSC_VER)
+#define DEPRECATED __declspec(deprecated)
+#define DEPRECATED_MSG(msg) __declspec(deprecated(msg))
+#else
+#define DEPRECATED 
+#define DEPRECATED_MSG 
+#endif
+namespace Kinova
+{
+namespace Api
+{
+	namespace DeviceConfig
+	{
+		// todogr move somewhere else
+		const std::string   none = "";
+		
+		enum FunctionUids
+		{
+			eUidGetRunMode = 0x90001,
+			eUidSetRunMode = 0x90002,
+			eUidGetDeviceType = 0x90003,
+			eUidGetFirmwareVersion = 0x90004,
+			eUidGetBootloaderVersion = 0x90005,
+			eUidGetModelNumber = 0x90006,
+			eUidGetPartNumber = 0x90007,
+			eUidGetSerialNumber = 0x90008,
+			eUidGetMACAddress = 0x90009,
+			eUidGetIPv4Settings = 0x9000a,
+			eUidSetIPv4Settings = 0x9000b,
+			eUidGetPartNumberRevision = 0x9000c,
+			eUidRebootRequest = 0x9000e,
+			eUidSetSafetyEnable = 0x9000f,
+			eUidSetSafetyErrorThreshold = 0x90010,
+			eUidSetSafetyWarningThreshold = 0x90011,
+			eUidSetSafetyConfiguration = 0x90012,
+			eUidGetSafetyConfiguration = 0x90013,
+			eUidGetSafetyInformation = 0x90014,
+			eUidGetSafetyEnable = 0x90015,
+			eUidGetSafetyStatus = 0x90016,
+			eUidClearAllSafetyStatus = 0x90017,
+			eUidClearSafetyStatus = 0x90018,
+			eUidGetAllSafetyConfiguration = 0x90019,
+			eUidGetAllSafetyInformation = 0x9001a,
+			eUidResetSafetyDefaults = 0x9001b,
+			eUidSafetyTopic = 0x9001c,
+			eUidExecuteCalibration = 0x90022,
+			eUidGetCalibrationResult = 0x90023,
+			eUidStopCalibration = 0x90024,
+			eUidSetCapSenseConfig = 0x90025,
+			eUidGetCapSenseConfig = 0x90026,
+			eUidReadCapSenseRegister = 0x90027,
+			eUidWriteCapSenseRegister = 0x90028,
+		};
+		
+		class DeviceConfigClient
+		{
+			static const uint32_t m_serviceVersion = 1;
+			static const uint32_t m_serviceId = eIdDeviceConfig;
+			NotificationHandler m_notificationHandler;
+
+		protected:
+			IRouterClient* const m_clientRouter;
+
+		public:
+			DeviceConfigClient(IRouterClient* clientRouter);
+			static uint32_t getUniqueFctId(uint16_t fctId);
+
+			RunMode GetRunMode(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetRunMode_callback(std::function< void (const Error&, const RunMode&) > callback, uint32_t deviceId = 0);
+			std::future<RunMode> GetRunMode_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetRunMode(const RunMode& runmode, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetRunMode_callback(const RunMode& runmode, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetRunMode_async(const RunMode& runmode, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			DeviceType GetDeviceType(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetDeviceType_callback(std::function< void (const Error&, const DeviceType&) > callback, uint32_t deviceId = 0);
+			std::future<DeviceType> GetDeviceType_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			FirmwareVersion GetFirmwareVersion(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetFirmwareVersion_callback(std::function< void (const Error&, const FirmwareVersion&) > callback, uint32_t deviceId = 0);
+			std::future<FirmwareVersion> GetFirmwareVersion_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			BootloaderVersion GetBootloaderVersion(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetBootloaderVersion_callback(std::function< void (const Error&, const BootloaderVersion&) > callback, uint32_t deviceId = 0);
+			std::future<BootloaderVersion> GetBootloaderVersion_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			ModelNumber GetModelNumber(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetModelNumber_callback(std::function< void (const Error&, const ModelNumber&) > callback, uint32_t deviceId = 0);
+			std::future<ModelNumber> GetModelNumber_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			PartNumber GetPartNumber(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetPartNumber_callback(std::function< void (const Error&, const PartNumber&) > callback, uint32_t deviceId = 0);
+			std::future<PartNumber> GetPartNumber_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			SerialNumber GetSerialNumber(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetSerialNumber_callback(std::function< void (const Error&, const SerialNumber&) > callback, uint32_t deviceId = 0);
+			std::future<SerialNumber> GetSerialNumber_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			MACAddress GetMACAddress(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetMACAddress_callback(std::function< void (const Error&, const MACAddress&) > callback, uint32_t deviceId = 0);
+			std::future<MACAddress> GetMACAddress_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			IPv4Settings GetIPv4Settings(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetIPv4Settings_callback(std::function< void (const Error&, const IPv4Settings&) > callback, uint32_t deviceId = 0);
+			std::future<IPv4Settings> GetIPv4Settings_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetIPv4Settings(const IPv4Settings& ipv4settings, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetIPv4Settings_callback(const IPv4Settings& ipv4settings, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetIPv4Settings_async(const IPv4Settings& ipv4settings, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			PartNumberRevision GetPartNumberRevision(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetPartNumberRevision_callback(std::function< void (const Error&, const PartNumberRevision&) > callback, uint32_t deviceId = 0);
+			std::future<PartNumberRevision> GetPartNumberRevision_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void RebootRequest(const RebootRqst& rebootrqst, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void RebootRequest_callback(const RebootRqst& rebootrqst, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> RebootRequest_async(const RebootRqst& rebootrqst, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetSafetyEnable(const SafetyEnable& safetyenable, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetSafetyEnable_callback(const SafetyEnable& safetyenable, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetSafetyEnable_async(const SafetyEnable& safetyenable, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetSafetyErrorThreshold(const SafetyThreshold& safetythreshold, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetSafetyErrorThreshold_callback(const SafetyThreshold& safetythreshold, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetSafetyErrorThreshold_async(const SafetyThreshold& safetythreshold, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetSafetyWarningThreshold(const SafetyThreshold& safetythreshold, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetSafetyWarningThreshold_callback(const SafetyThreshold& safetythreshold, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetSafetyWarningThreshold_async(const SafetyThreshold& safetythreshold, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetSafetyConfiguration(const SafetyConfiguration& safetyconfiguration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetSafetyConfiguration_callback(const SafetyConfiguration& safetyconfiguration, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetSafetyConfiguration_async(const SafetyConfiguration& safetyconfiguration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			SafetyConfiguration GetSafetyConfiguration(const Kinova::Api::Common::SafetyHandle& safetyhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetSafetyConfiguration_callback(const Kinova::Api::Common::SafetyHandle& safetyhandle, std::function< void (const Error&, const SafetyConfiguration&) > callback, uint32_t deviceId = 0);
+			std::future<SafetyConfiguration> GetSafetyConfiguration_async(const Kinova::Api::Common::SafetyHandle& safetyhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			SafetyInformation GetSafetyInformation(const Kinova::Api::Common::SafetyHandle& safetyhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetSafetyInformation_callback(const Kinova::Api::Common::SafetyHandle& safetyhandle, std::function< void (const Error&, const SafetyInformation&) > callback, uint32_t deviceId = 0);
+			std::future<SafetyInformation> GetSafetyInformation_async(const Kinova::Api::Common::SafetyHandle& safetyhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			SafetyEnable GetSafetyEnable(const Kinova::Api::Common::SafetyHandle& safetyhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetSafetyEnable_callback(const Kinova::Api::Common::SafetyHandle& safetyhandle, std::function< void (const Error&, const SafetyEnable&) > callback, uint32_t deviceId = 0);
+			std::future<SafetyEnable> GetSafetyEnable_async(const Kinova::Api::Common::SafetyHandle& safetyhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			SafetyStatus GetSafetyStatus(const Kinova::Api::Common::SafetyHandle& safetyhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetSafetyStatus_callback(const Kinova::Api::Common::SafetyHandle& safetyhandle, std::function< void (const Error&, const SafetyStatus&) > callback, uint32_t deviceId = 0);
+			std::future<SafetyStatus> GetSafetyStatus_async(const Kinova::Api::Common::SafetyHandle& safetyhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void ClearAllSafetyStatus(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ClearAllSafetyStatus_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> ClearAllSafetyStatus_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void ClearSafetyStatus(const Kinova::Api::Common::SafetyHandle& safetyhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ClearSafetyStatus_callback(const Kinova::Api::Common::SafetyHandle& safetyhandle, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> ClearSafetyStatus_async(const Kinova::Api::Common::SafetyHandle& safetyhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			SafetyConfigurationList GetAllSafetyConfiguration(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetAllSafetyConfiguration_callback(std::function< void (const Error&, const SafetyConfigurationList&) > callback, uint32_t deviceId = 0);
+			std::future<SafetyConfigurationList> GetAllSafetyConfiguration_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			SafetyInformationList GetAllSafetyInformation(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetAllSafetyInformation_callback(std::function< void (const Error&, const SafetyInformationList&) > callback, uint32_t deviceId = 0);
+			std::future<SafetyInformationList> GetAllSafetyInformation_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void ResetSafetyDefaults(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ResetSafetyDefaults_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> ResetSafetyDefaults_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Kinova::Api::Common::NotificationHandle OnNotificationSafetyTopic(std::function< void (Kinova::Api::Common::SafetyNotification) > callback, const Kinova::Api::Common::NotificationOptions& notificationoptions, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void ExecuteCalibration(const Calibration& calibration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ExecuteCalibration_callback(const Calibration& calibration, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> ExecuteCalibration_async(const Calibration& calibration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			CalibrationResult GetCalibrationResult(const CalibrationElement& calibrationelement, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetCalibrationResult_callback(const CalibrationElement& calibrationelement, std::function< void (const Error&, const CalibrationResult&) > callback, uint32_t deviceId = 0);
+			std::future<CalibrationResult> GetCalibrationResult_async(const CalibrationElement& calibrationelement, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			CalibrationResult StopCalibration(const Calibration& calibration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void StopCalibration_callback(const Calibration& calibration, std::function< void (const Error&, const CalibrationResult&) > callback, uint32_t deviceId = 0);
+			std::future<CalibrationResult> StopCalibration_async(const Calibration& calibration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetCapSenseConfig(const CapSenseConfig& capsenseconfig, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetCapSenseConfig_callback(const CapSenseConfig& capsenseconfig, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetCapSenseConfig_async(const CapSenseConfig& capsenseconfig, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			CapSenseConfig GetCapSenseConfig(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetCapSenseConfig_callback(std::function< void (const Error&, const CapSenseConfig&) > callback, uint32_t deviceId = 0);
+			std::future<CapSenseConfig> GetCapSenseConfig_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			CapSenseRegister ReadCapSenseRegister(const CapSenseRegister& capsenseregister, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ReadCapSenseRegister_callback(const CapSenseRegister& capsenseregister, std::function< void (const Error&, const CapSenseRegister&) > callback, uint32_t deviceId = 0);
+			std::future<CapSenseRegister> ReadCapSenseRegister_async(const CapSenseRegister& capsenseregister, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void WriteCapSenseRegister(const CapSenseRegister& capsenseregister, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void WriteCapSenseRegister_callback(const CapSenseRegister& capsenseregister, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> WriteCapSenseRegister_async(const CapSenseRegister& capsenseregister, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+
+		private:
+			void messageHeaderValidation(const Frame& msgFrame){ /* todogr ... */ }
+		};
+	}
+}
+}
+
+#endif
\ No newline at end of file
diff --git a/kortex_api/include/client_stubs/DeviceManagerClientRpc.h b/kortex_api/include/client_stubs/DeviceManagerClientRpc.h
new file mode 100644
index 0000000000000000000000000000000000000000..bf45bef57496ce877eadb5e3cebd8ce401b4f4b7
--- /dev/null
+++ b/kortex_api/include/client_stubs/DeviceManagerClientRpc.h
@@ -0,0 +1,68 @@
+#ifndef __DEVICEMANAGERCLIENT_H__
+#define __DEVICEMANAGERCLIENT_H__
+
+#include <string>
+#include <future>
+#include <functional>
+#include <exception>
+
+#include "messages/Frame.pb.h"
+#include "messages/DeviceManager.pb.h"
+
+#include "common/Frame.h"
+#include "client/IRouterClient.h"
+#include "client/NotificationHandler.h"
+
+#if __cplusplus >= 201402L
+#define DEPRECATED [[ deprecated ]]
+#define DEPRECATED_MSG(msg) [[ deprecated(msg) ]]
+#elif defined(__GNUC__)
+#define DEPRECATED __attribute__ ((deprecated))
+#define DEPRECATED_MSG(msg) __attribute__ ((deprecated(msg)))
+#elif defined(_MSC_VER)
+#define DEPRECATED __declspec(deprecated)
+#define DEPRECATED_MSG(msg) __declspec(deprecated(msg))
+#else
+#define DEPRECATED 
+#define DEPRECATED_MSG 
+#endif
+namespace Kinova
+{
+namespace Api
+{
+	namespace DeviceManager
+	{
+		// todogr move somewhere else
+		const std::string   none = "";
+		
+		enum FunctionUids
+		{
+			eUidReadAllDevices = 0x170001,
+		};
+		
+		class DeviceManagerClient
+		{
+			static const uint32_t m_serviceVersion = 1;
+			static const uint32_t m_serviceId = eIdDeviceManager;
+			NotificationHandler m_notificationHandler;
+
+		protected:
+			IRouterClient* const m_clientRouter;
+
+		public:
+			DeviceManagerClient(IRouterClient* clientRouter);
+			static uint32_t getUniqueFctId(uint16_t fctId);
+
+			DeviceHandles ReadAllDevices(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ReadAllDevices_callback(std::function< void (const Error&, const DeviceHandles&) > callback, uint32_t deviceId = 0);
+			std::future<DeviceHandles> ReadAllDevices_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+
+		private:
+			void messageHeaderValidation(const Frame& msgFrame){ /* todogr ... */ }
+		};
+	}
+}
+}
+
+#endif
\ No newline at end of file
diff --git a/kortex_api/include/client_stubs/GripperCyclicClientRpc.h b/kortex_api/include/client_stubs/GripperCyclicClientRpc.h
new file mode 100644
index 0000000000000000000000000000000000000000..0c680f2044b8df519eb307b8e99cea0bf959b424
--- /dev/null
+++ b/kortex_api/include/client_stubs/GripperCyclicClientRpc.h
@@ -0,0 +1,83 @@
+#ifndef __GRIPPERCYCLICCLIENT_H__
+#define __GRIPPERCYCLICCLIENT_H__
+
+#include <string>
+#include <future>
+#include <functional>
+#include <exception>
+
+#include "messages/Frame.pb.h"
+#include "messages/GripperCyclic.pb.h"
+
+#include "common/Frame.h"
+#include "client/IRouterClient.h"
+#include "client/NotificationHandler.h"
+
+#if __cplusplus >= 201402L
+#define DEPRECATED [[ deprecated ]]
+#define DEPRECATED_MSG(msg) [[ deprecated(msg) ]]
+#elif defined(__GNUC__)
+#define DEPRECATED __attribute__ ((deprecated))
+#define DEPRECATED_MSG(msg) __attribute__ ((deprecated(msg)))
+#elif defined(_MSC_VER)
+#define DEPRECATED __declspec(deprecated)
+#define DEPRECATED_MSG(msg) __declspec(deprecated(msg))
+#else
+#define DEPRECATED 
+#define DEPRECATED_MSG 
+#endif
+namespace Kinova
+{
+namespace Api
+{
+	namespace GripperCyclic
+	{
+		// todogr move somewhere else
+		const std::string   none = "";
+		
+		enum FunctionUids
+		{
+			eUidRefresh = 0x110001,
+			eUidRefreshCommand = 0x110002,
+			eUidRefreshFeedback = 0x110003,
+			eUidRefreshCustomData = 0x110004,
+		};
+		
+		class GripperCyclicClient
+		{
+			static const uint32_t m_serviceVersion = 1;
+			static const uint32_t m_serviceId = eIdGripperCyclic;
+			NotificationHandler m_notificationHandler;
+
+		protected:
+			IRouterClient* const m_clientRouter;
+
+		public:
+			GripperCyclicClient(IRouterClient* clientRouter);
+			static uint32_t getUniqueFctId(uint16_t fctId);
+
+			Feedback Refresh(const Command& command, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void Refresh_callback(const Command& command, std::function< void (const Error&, const Feedback&) > callback, uint32_t deviceId = 0);
+			std::future<Feedback> Refresh_async(const Command& command, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void RefreshCommand(const Command& command, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void RefreshCommand_callback(const Command& command, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> RefreshCommand_async(const Command& command, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Feedback RefreshFeedback(const MessageId& messageid, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void RefreshFeedback_callback(const MessageId& messageid, std::function< void (const Error&, const Feedback&) > callback, uint32_t deviceId = 0);
+			std::future<Feedback> RefreshFeedback_async(const MessageId& messageid, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			CustomData RefreshCustomData(const MessageId& messageid, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void RefreshCustomData_callback(const MessageId& messageid, std::function< void (const Error&, const CustomData&) > callback, uint32_t deviceId = 0);
+			std::future<CustomData> RefreshCustomData_async(const MessageId& messageid, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+
+		private:
+			void messageHeaderValidation(const Frame& msgFrame){ /* todogr ... */ }
+		};
+	}
+}
+}
+
+#endif
\ No newline at end of file
diff --git a/kortex_api/include/client_stubs/InterconnectConfigClientRpc.h b/kortex_api/include/client_stubs/InterconnectConfigClientRpc.h
new file mode 100644
index 0000000000000000000000000000000000000000..4547172fd7912047e2d9b869a12e4252613a818c
--- /dev/null
+++ b/kortex_api/include/client_stubs/InterconnectConfigClientRpc.h
@@ -0,0 +1,133 @@
+#ifndef __INTERCONNECTCONFIGCLIENT_H__
+#define __INTERCONNECTCONFIGCLIENT_H__
+
+#include <string>
+#include <future>
+#include <functional>
+#include <exception>
+
+#include "messages/Frame.pb.h"
+#include "messages/InterconnectConfig.pb.h"
+
+#include "common/Frame.h"
+#include "client/IRouterClient.h"
+#include "client/NotificationHandler.h"
+
+#if __cplusplus >= 201402L
+#define DEPRECATED [[ deprecated ]]
+#define DEPRECATED_MSG(msg) [[ deprecated(msg) ]]
+#elif defined(__GNUC__)
+#define DEPRECATED __attribute__ ((deprecated))
+#define DEPRECATED_MSG(msg) __attribute__ ((deprecated(msg)))
+#elif defined(_MSC_VER)
+#define DEPRECATED __declspec(deprecated)
+#define DEPRECATED_MSG(msg) __declspec(deprecated(msg))
+#else
+#define DEPRECATED 
+#define DEPRECATED_MSG 
+#endif
+namespace Kinova
+{
+namespace Api
+{
+	namespace InterconnectConfig
+	{
+		// todogr move somewhere else
+		const std::string   none = "";
+		
+		enum FunctionUids
+		{
+			eUidGetUARTConfiguration = 0xe0001,
+			eUidSetUARTConfiguration = 0xe0002,
+			eUidGetEthernetConfiguration = 0xe0003,
+			eUidSetEthernetConfiguration = 0xe0004,
+			eUidGetGPIOConfiguration = 0xe0005,
+			eUidSetGPIOConfiguration = 0xe0006,
+			eUidGetGPIOState = 0xe0007,
+			eUidSetGPIOState = 0xe0008,
+			eUidGetI2CConfiguration = 0xe0009,
+			eUidSetI2CConfiguration = 0xe000a,
+			eUidI2CRead = 0xe000b,
+			eUidI2CReadRegister = 0xe000c,
+			eUidI2CWrite = 0xe000d,
+			eUidI2CWriteRegister = 0xe000e,
+		};
+		
+		class InterconnectConfigClient
+		{
+			static const uint32_t m_serviceVersion = 1;
+			static const uint32_t m_serviceId = eIdInterconnectConfig;
+			NotificationHandler m_notificationHandler;
+
+		protected:
+			IRouterClient* const m_clientRouter;
+
+		public:
+			InterconnectConfigClient(IRouterClient* clientRouter);
+			static uint32_t getUniqueFctId(uint16_t fctId);
+
+			Kinova::Api::Common::UARTConfiguration GetUARTConfiguration(const Kinova::Api::Common::UARTDeviceIdentification& uartdeviceidentification, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetUARTConfiguration_callback(const Kinova::Api::Common::UARTDeviceIdentification& uartdeviceidentification, std::function< void (const Error&, const Kinova::Api::Common::UARTConfiguration&) > callback, uint32_t deviceId = 0);
+			std::future<Kinova::Api::Common::UARTConfiguration> GetUARTConfiguration_async(const Kinova::Api::Common::UARTDeviceIdentification& uartdeviceidentification, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetUARTConfiguration(const Kinova::Api::Common::UARTConfiguration& uartconfiguration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetUARTConfiguration_callback(const Kinova::Api::Common::UARTConfiguration& uartconfiguration, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetUARTConfiguration_async(const Kinova::Api::Common::UARTConfiguration& uartconfiguration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			EthernetConfiguration GetEthernetConfiguration(const EthernetDeviceIdentification& ethernetdeviceidentification, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetEthernetConfiguration_callback(const EthernetDeviceIdentification& ethernetdeviceidentification, std::function< void (const Error&, const EthernetConfiguration&) > callback, uint32_t deviceId = 0);
+			std::future<EthernetConfiguration> GetEthernetConfiguration_async(const EthernetDeviceIdentification& ethernetdeviceidentification, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetEthernetConfiguration(const EthernetConfiguration& ethernetconfiguration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetEthernetConfiguration_callback(const EthernetConfiguration& ethernetconfiguration, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetEthernetConfiguration_async(const EthernetConfiguration& ethernetconfiguration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			GPIOConfiguration GetGPIOConfiguration(const GPIOIdentification& gpioidentification, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetGPIOConfiguration_callback(const GPIOIdentification& gpioidentification, std::function< void (const Error&, const GPIOConfiguration&) > callback, uint32_t deviceId = 0);
+			std::future<GPIOConfiguration> GetGPIOConfiguration_async(const GPIOIdentification& gpioidentification, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetGPIOConfiguration(const GPIOConfiguration& gpioconfiguration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetGPIOConfiguration_callback(const GPIOConfiguration& gpioconfiguration, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetGPIOConfiguration_async(const GPIOConfiguration& gpioconfiguration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			GPIOState GetGPIOState(const GPIOIdentification& gpioidentification, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetGPIOState_callback(const GPIOIdentification& gpioidentification, std::function< void (const Error&, const GPIOState&) > callback, uint32_t deviceId = 0);
+			std::future<GPIOState> GetGPIOState_async(const GPIOIdentification& gpioidentification, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetGPIOState(const GPIOState& gpiostate, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetGPIOState_callback(const GPIOState& gpiostate, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetGPIOState_async(const GPIOState& gpiostate, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			I2CConfiguration GetI2CConfiguration(const I2CDeviceIdentification& i2cdeviceidentification, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetI2CConfiguration_callback(const I2CDeviceIdentification& i2cdeviceidentification, std::function< void (const Error&, const I2CConfiguration&) > callback, uint32_t deviceId = 0);
+			std::future<I2CConfiguration> GetI2CConfiguration_async(const I2CDeviceIdentification& i2cdeviceidentification, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetI2CConfiguration(const I2CConfiguration& i2cconfiguration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetI2CConfiguration_callback(const I2CConfiguration& i2cconfiguration, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetI2CConfiguration_async(const I2CConfiguration& i2cconfiguration, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			I2CData I2CRead(const I2CReadParameter& i2creadparameter, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void I2CRead_callback(const I2CReadParameter& i2creadparameter, std::function< void (const Error&, const I2CData&) > callback, uint32_t deviceId = 0);
+			std::future<I2CData> I2CRead_async(const I2CReadParameter& i2creadparameter, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			I2CData I2CReadRegister(const I2CReadRegisterParameter& i2creadregisterparameter, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void I2CReadRegister_callback(const I2CReadRegisterParameter& i2creadregisterparameter, std::function< void (const Error&, const I2CData&) > callback, uint32_t deviceId = 0);
+			std::future<I2CData> I2CReadRegister_async(const I2CReadRegisterParameter& i2creadregisterparameter, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void I2CWrite(const I2CWriteParameter& i2cwriteparameter, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void I2CWrite_callback(const I2CWriteParameter& i2cwriteparameter, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> I2CWrite_async(const I2CWriteParameter& i2cwriteparameter, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void I2CWriteRegister(const I2CWriteRegisterParameter& i2cwriteregisterparameter, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void I2CWriteRegister_callback(const I2CWriteRegisterParameter& i2cwriteregisterparameter, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> I2CWriteRegister_async(const I2CWriteRegisterParameter& i2cwriteregisterparameter, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+
+		private:
+			void messageHeaderValidation(const Frame& msgFrame){ /* todogr ... */ }
+		};
+	}
+}
+}
+
+#endif
\ No newline at end of file
diff --git a/kortex_api/include/client_stubs/InterconnectCyclicClientRpc.h b/kortex_api/include/client_stubs/InterconnectCyclicClientRpc.h
new file mode 100644
index 0000000000000000000000000000000000000000..efd21070dca3f840680b09ebd94040f2d5809c98
--- /dev/null
+++ b/kortex_api/include/client_stubs/InterconnectCyclicClientRpc.h
@@ -0,0 +1,83 @@
+#ifndef __INTERCONNECTCYCLICCLIENT_H__
+#define __INTERCONNECTCYCLICCLIENT_H__
+
+#include <string>
+#include <future>
+#include <functional>
+#include <exception>
+
+#include "messages/Frame.pb.h"
+#include "messages/InterconnectCyclic.pb.h"
+
+#include "common/Frame.h"
+#include "client/IRouterClient.h"
+#include "client/NotificationHandler.h"
+
+#if __cplusplus >= 201402L
+#define DEPRECATED [[ deprecated ]]
+#define DEPRECATED_MSG(msg) [[ deprecated(msg) ]]
+#elif defined(__GNUC__)
+#define DEPRECATED __attribute__ ((deprecated))
+#define DEPRECATED_MSG(msg) __attribute__ ((deprecated(msg)))
+#elif defined(_MSC_VER)
+#define DEPRECATED __declspec(deprecated)
+#define DEPRECATED_MSG(msg) __declspec(deprecated(msg))
+#else
+#define DEPRECATED 
+#define DEPRECATED_MSG 
+#endif
+namespace Kinova
+{
+namespace Api
+{
+	namespace InterconnectCyclic
+	{
+		// todogr move somewhere else
+		const std::string   none = "";
+		
+		enum FunctionUids
+		{
+			eUidRefresh = 0xf0001,
+			eUidRefreshCommand = 0xf0002,
+			eUidRefreshFeedback = 0xf0003,
+			eUidRefreshCustomData = 0xf0004,
+		};
+		
+		class InterconnectCyclicClient
+		{
+			static const uint32_t m_serviceVersion = 1;
+			static const uint32_t m_serviceId = eIdInterconnectCyclic;
+			NotificationHandler m_notificationHandler;
+
+		protected:
+			IRouterClient* const m_clientRouter;
+
+		public:
+			InterconnectCyclicClient(IRouterClient* clientRouter);
+			static uint32_t getUniqueFctId(uint16_t fctId);
+
+			Feedback Refresh(const Command& command, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void Refresh_callback(const Command& command, std::function< void (const Error&, const Feedback&) > callback, uint32_t deviceId = 0);
+			std::future<Feedback> Refresh_async(const Command& command, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void RefreshCommand(const Command& command, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void RefreshCommand_callback(const Command& command, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> RefreshCommand_async(const Command& command, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Feedback RefreshFeedback(const MessageId& messageid, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void RefreshFeedback_callback(const MessageId& messageid, std::function< void (const Error&, const Feedback&) > callback, uint32_t deviceId = 0);
+			std::future<Feedback> RefreshFeedback_async(const MessageId& messageid, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			CustomData RefreshCustomData(const MessageId& messageid, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void RefreshCustomData_callback(const MessageId& messageid, std::function< void (const Error&, const CustomData&) > callback, uint32_t deviceId = 0);
+			std::future<CustomData> RefreshCustomData_async(const MessageId& messageid, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+
+		private:
+			void messageHeaderValidation(const Frame& msgFrame){ /* todogr ... */ }
+		};
+	}
+}
+}
+
+#endif
\ No newline at end of file
diff --git a/kortex_api/include/client_stubs/SessionClientRpc.h b/kortex_api/include/client_stubs/SessionClientRpc.h
new file mode 100644
index 0000000000000000000000000000000000000000..a95290f3270d52b5fa891153f7ad3f3d77378de0
--- /dev/null
+++ b/kortex_api/include/client_stubs/SessionClientRpc.h
@@ -0,0 +1,83 @@
+#ifndef __SESSIONCLIENT_H__
+#define __SESSIONCLIENT_H__
+
+#include <string>
+#include <future>
+#include <functional>
+#include <exception>
+
+#include "messages/Frame.pb.h"
+#include "messages/Session.pb.h"
+
+#include "common/Frame.h"
+#include "client/IRouterClient.h"
+#include "client/NotificationHandler.h"
+
+#if __cplusplus >= 201402L
+#define DEPRECATED [[ deprecated ]]
+#define DEPRECATED_MSG(msg) [[ deprecated(msg) ]]
+#elif defined(__GNUC__)
+#define DEPRECATED __attribute__ ((deprecated))
+#define DEPRECATED_MSG(msg) __attribute__ ((deprecated(msg)))
+#elif defined(_MSC_VER)
+#define DEPRECATED __declspec(deprecated)
+#define DEPRECATED_MSG(msg) __declspec(deprecated(msg))
+#else
+#define DEPRECATED 
+#define DEPRECATED_MSG 
+#endif
+namespace Kinova
+{
+namespace Api
+{
+	namespace Session
+	{
+		// todogr move somewhere else
+		const std::string   none = "";
+		
+		enum FunctionUids
+		{
+			eUidCreateSession = 0x10001,
+			eUidCloseSession = 0x10002,
+			eUidKeepAlive = 0x10003,
+			eUidGetConnections = 0x10004,
+		};
+		
+		class SessionClient
+		{
+			static const uint32_t m_serviceVersion = 1;
+			static const uint32_t m_serviceId = eIdSession;
+			NotificationHandler m_notificationHandler;
+
+		protected:
+			IRouterClient* const m_clientRouter;
+
+		public:
+			SessionClient(IRouterClient* clientRouter);
+			static uint32_t getUniqueFctId(uint16_t fctId);
+
+			void CreateSession(const CreateSessionInfo& createsessioninfo, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void CreateSession_callback(const CreateSessionInfo& createsessioninfo, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> CreateSession_async(const CreateSessionInfo& createsessioninfo, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void CloseSession(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void CloseSession_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> CloseSession_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void KeepAlive(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void KeepAlive_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> KeepAlive_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			ConnectionList GetConnections(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetConnections_callback(std::function< void (const Error&, const ConnectionList&) > callback, uint32_t deviceId = 0);
+			std::future<ConnectionList> GetConnections_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+
+		private:
+			void messageHeaderValidation(const Frame& msgFrame){ /* todogr ... */ }
+		};
+	}
+}
+}
+
+#endif
\ No newline at end of file
diff --git a/kortex_api/include/client_stubs/TestClientRpc.h b/kortex_api/include/client_stubs/TestClientRpc.h
new file mode 100644
index 0000000000000000000000000000000000000000..396585c240f628d7ffda479d528d578066ffa056
--- /dev/null
+++ b/kortex_api/include/client_stubs/TestClientRpc.h
@@ -0,0 +1,165 @@
+#ifndef __TESTCLIENT_H__
+#define __TESTCLIENT_H__
+
+#include <string>
+#include <future>
+#include <functional>
+#include <exception>
+
+#include "messages/Frame.pb.h"
+#include "messages/Test.pb.h"
+
+#include "common/Frame.h"
+#include "client/IRouterClient.h"
+#include "client/NotificationHandler.h"
+
+#if __cplusplus >= 201402L
+#define DEPRECATED [[ deprecated ]]
+#define DEPRECATED_MSG(msg) [[ deprecated(msg) ]]
+#elif defined(__GNUC__)
+#define DEPRECATED __attribute__ ((deprecated))
+#define DEPRECATED_MSG(msg) __attribute__ ((deprecated(msg)))
+#elif defined(_MSC_VER)
+#define DEPRECATED __declspec(deprecated)
+#define DEPRECATED_MSG(msg) __declspec(deprecated(msg))
+#else
+#define DEPRECATED 
+#define DEPRECATED_MSG 
+#endif
+namespace Kinova
+{
+namespace Api
+{
+	namespace Test
+	{
+		// todogr move somewhere else
+		const std::string   none = "";
+		
+		enum FunctionUids
+		{
+			eUidSetMockValidationStruct = 0xff00001,
+			eUidTestParamAndReturn = 0xff00002,
+			eUidTestParamOnly = 0xff00003,
+			eUidTestReturnOnly = 0xff00004,
+			eUidTestTimeout = 0xff00005,
+			eUidTestNotif = 0xff00006,
+			eUidTestNotifUnsubscribe = 0xff00007,
+			eUidTestAsync = 0xff00008,
+			eUidTestConcurrence = 0xff00009,
+			eUidTestTriggerNotif = 0xff0000a,
+			eUidTestNotImplemented = 0xff0000b,
+			eUidServerError = 0xff0000c,
+			eUidUnsubscribe = 0xff0001e,
+			eUidSomethingChangeTopic = 0xff0001f,
+			eUidTriggerSomethingChangeTopic = 0xff00020,
+			eUidWait = 0xff00021,
+			eUidThrow = 0xff00022,
+			eUidDisconnect = 0xff00023,
+			eUidForget = 0xff00024,
+			eUidNotImplemented = 0xff00025,
+			eUidDeprecated = 0xff00027,
+			eUidDeprecatedWithMessage = 0xff00028,
+		};
+		
+		class TestClient
+		{
+			static const uint32_t m_serviceVersion = 1;
+			static const uint32_t m_serviceId = eIdTest;
+			NotificationHandler m_notificationHandler;
+
+		protected:
+			IRouterClient* const m_clientRouter;
+
+		public:
+			TestClient(IRouterClient* clientRouter);
+			static uint32_t getUniqueFctId(uint16_t fctId);
+
+			void SetMockValidationStruct(const validateStruct& validatestruct, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetMockValidationStruct_callback(const validateStruct& validatestruct, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetMockValidationStruct_async(const validateStruct& validatestruct, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			RcvStruct TestParamAndReturn(const SendStruct& sendstruct, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void TestParamAndReturn_callback(const SendStruct& sendstruct, std::function< void (const Error&, const RcvStruct&) > callback, uint32_t deviceId = 0);
+			std::future<RcvStruct> TestParamAndReturn_async(const SendStruct& sendstruct, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void TestParamOnly(const SendStruct& sendstruct, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void TestParamOnly_callback(const SendStruct& sendstruct, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> TestParamOnly_async(const SendStruct& sendstruct, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			RcvStruct TestReturnOnly(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void TestReturnOnly_callback(std::function< void (const Error&, const RcvStruct&) > callback, uint32_t deviceId = 0);
+			std::future<RcvStruct> TestReturnOnly_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void TestTimeout(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void TestTimeout_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> TestTimeout_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Kinova::Api::Common::NotificationHandle OnNotificationTestNotif(std::function< void (TestNotification) > callback, const NotifOption& notifoption, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void TestNotifUnsubscribe(const Kinova::Api::Common::NotificationHandle& notificationhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void TestAsync(const timeToResponse& timetoresponse, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void TestAsync_callback(const timeToResponse& timetoresponse, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> TestAsync_async(const timeToResponse& timetoresponse, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void TestConcurrence(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void TestConcurrence_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> TestConcurrence_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void TestTriggerNotif(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void TestTriggerNotif_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> TestTriggerNotif_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void TestNotImplemented(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void TestNotImplemented_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> TestNotImplemented_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			TestError ServerError(const TestError& testerror, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void ServerError_callback(const TestError& testerror, std::function< void (const Error&, const TestError&) > callback, uint32_t deviceId = 0);
+			std::future<TestError> ServerError_async(const TestError& testerror, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void Unsubscribe(const Kinova::Api::Common::NotificationHandle& notificationhandle, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Kinova::Api::Common::NotificationHandle OnNotificationSomethingChangeTopic(std::function< void (SomethingChanged) > callback, const Kinova::Api::Common::NotificationOptions& notificationoptions, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void TriggerSomethingChangeTopic(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void TriggerSomethingChangeTopic_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> TriggerSomethingChangeTopic_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void Wait(const Delay& delay, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void Wait_callback(const Delay& delay, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> Wait_async(const Delay& delay, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void Throw(const Kinova::Api::Error& error, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void Throw_callback(const Kinova::Api::Error& error, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> Throw_async(const Kinova::Api::Error& error, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void Disconnect(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void Disconnect_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> Disconnect_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void Forget(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void Forget_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> Forget_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void NotImplemented(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void NotImplemented_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> NotImplemented_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			DEPRECATED void Deprecated(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			DEPRECATED void Deprecated_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			DEPRECATED std::future<void> Deprecated_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			DEPRECATED_MSG("Purposely deprecated for test") void DeprecatedWithMessage(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			DEPRECATED_MSG("Purposely deprecated for test") void DeprecatedWithMessage_callback(std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			DEPRECATED_MSG("Purposely deprecated for test") std::future<void> DeprecatedWithMessage_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+
+		private:
+			void messageHeaderValidation(const Frame& msgFrame){ /* todogr ... */ }
+		};
+	}
+}
+}
+
+#endif
\ No newline at end of file
diff --git a/kortex_api/include/client_stubs/VisionConfigClientRpc.h b/kortex_api/include/client_stubs/VisionConfigClientRpc.h
new file mode 100644
index 0000000000000000000000000000000000000000..a95158f569c4f9e2679c7272afc61412e7892433
--- /dev/null
+++ b/kortex_api/include/client_stubs/VisionConfigClientRpc.h
@@ -0,0 +1,121 @@
+#ifndef __VISIONCONFIGCLIENT_H__
+#define __VISIONCONFIGCLIENT_H__
+
+#include <string>
+#include <future>
+#include <functional>
+#include <exception>
+
+#include "messages/Frame.pb.h"
+#include "messages/VisionConfig.pb.h"
+
+#include "common/Frame.h"
+#include "client/IRouterClient.h"
+#include "client/NotificationHandler.h"
+
+#if __cplusplus >= 201402L
+#define DEPRECATED [[ deprecated ]]
+#define DEPRECATED_MSG(msg) [[ deprecated(msg) ]]
+#elif defined(__GNUC__)
+#define DEPRECATED __attribute__ ((deprecated))
+#define DEPRECATED_MSG(msg) __attribute__ ((deprecated(msg)))
+#elif defined(_MSC_VER)
+#define DEPRECATED __declspec(deprecated)
+#define DEPRECATED_MSG(msg) __declspec(deprecated(msg))
+#else
+#define DEPRECATED 
+#define DEPRECATED_MSG 
+#endif
+namespace Kinova
+{
+namespace Api
+{
+	namespace VisionConfig
+	{
+		// todogr move somewhere else
+		const std::string   none = "";
+		
+		enum FunctionUids
+		{
+			eUidSetSensorSettings = 0x50001,
+			eUidGetSensorSettings = 0x50002,
+			eUidGetOptionValue = 0x50003,
+			eUidSetOptionValue = 0x50004,
+			eUidGetOptionInformation = 0x50005,
+			eUidVisionTopic = 0x50006,
+			eUidDoSensorFocusAction = 0x50007,
+			eUidGetIntrinsicParameters = 0x50008,
+			eUidGetIntrinsicParametersProfile = 0x50009,
+			eUidSetIntrinsicParameters = 0x5000a,
+			eUidGetExtrinsicParameters = 0x5000b,
+			eUidSetExtrinsicParameters = 0x5000c,
+		};
+		
+		class VisionConfigClient
+		{
+			static const uint32_t m_serviceVersion = 1;
+			static const uint32_t m_serviceId = eIdVisionConfig;
+			NotificationHandler m_notificationHandler;
+
+		protected:
+			IRouterClient* const m_clientRouter;
+
+		public:
+			VisionConfigClient(IRouterClient* clientRouter);
+			static uint32_t getUniqueFctId(uint16_t fctId);
+
+			void SetSensorSettings(const SensorSettings& sensorsettings, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetSensorSettings_callback(const SensorSettings& sensorsettings, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetSensorSettings_async(const SensorSettings& sensorsettings, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			SensorSettings GetSensorSettings(const SensorIdentifier& sensoridentifier, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetSensorSettings_callback(const SensorIdentifier& sensoridentifier, std::function< void (const Error&, const SensorSettings&) > callback, uint32_t deviceId = 0);
+			std::future<SensorSettings> GetSensorSettings_async(const SensorIdentifier& sensoridentifier, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			OptionValue GetOptionValue(const OptionIdentifier& optionidentifier, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetOptionValue_callback(const OptionIdentifier& optionidentifier, std::function< void (const Error&, const OptionValue&) > callback, uint32_t deviceId = 0);
+			std::future<OptionValue> GetOptionValue_async(const OptionIdentifier& optionidentifier, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetOptionValue(const OptionValue& optionvalue, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetOptionValue_callback(const OptionValue& optionvalue, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetOptionValue_async(const OptionValue& optionvalue, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			OptionInformation GetOptionInformation(const OptionIdentifier& optionidentifier, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetOptionInformation_callback(const OptionIdentifier& optionidentifier, std::function< void (const Error&, const OptionInformation&) > callback, uint32_t deviceId = 0);
+			std::future<OptionInformation> GetOptionInformation_async(const OptionIdentifier& optionidentifier, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			Kinova::Api::Common::NotificationHandle OnNotificationVisionTopic(std::function< void (VisionNotification) > callback, const Kinova::Api::Common::NotificationOptions& notificationoptions, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void DoSensorFocusAction(const SensorFocusAction& sensorfocusaction, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void DoSensorFocusAction_callback(const SensorFocusAction& sensorfocusaction, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> DoSensorFocusAction_async(const SensorFocusAction& sensorfocusaction, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			IntrinsicParameters GetIntrinsicParameters(const SensorIdentifier& sensoridentifier, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetIntrinsicParameters_callback(const SensorIdentifier& sensoridentifier, std::function< void (const Error&, const IntrinsicParameters&) > callback, uint32_t deviceId = 0);
+			std::future<IntrinsicParameters> GetIntrinsicParameters_async(const SensorIdentifier& sensoridentifier, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			IntrinsicParameters GetIntrinsicParametersProfile(const IntrinsicProfileIdentifier& intrinsicprofileidentifier, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetIntrinsicParametersProfile_callback(const IntrinsicProfileIdentifier& intrinsicprofileidentifier, std::function< void (const Error&, const IntrinsicParameters&) > callback, uint32_t deviceId = 0);
+			std::future<IntrinsicParameters> GetIntrinsicParametersProfile_async(const IntrinsicProfileIdentifier& intrinsicprofileidentifier, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetIntrinsicParameters(const IntrinsicParameters& intrinsicparameters, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetIntrinsicParameters_callback(const IntrinsicParameters& intrinsicparameters, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetIntrinsicParameters_async(const IntrinsicParameters& intrinsicparameters, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			ExtrinsicParameters GetExtrinsicParameters(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void GetExtrinsicParameters_callback(std::function< void (const Error&, const ExtrinsicParameters&) > callback, uint32_t deviceId = 0);
+			std::future<ExtrinsicParameters> GetExtrinsicParameters_async(uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+			void SetExtrinsicParameters(const ExtrinsicParameters& extrinsicparameters, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+			void SetExtrinsicParameters_callback(const ExtrinsicParameters& extrinsicparameters, std::function< void (const Error&) > callback, uint32_t deviceId = 0);
+			std::future<void> SetExtrinsicParameters_async(const ExtrinsicParameters& extrinsicparameters, uint32_t deviceId = 0, const RouterClientSendOptions& options = {false, 0, 3000});
+
+
+		private:
+			void messageHeaderValidation(const Frame& msgFrame){ /* todogr ... */ }
+		};
+	}
+}
+}
+
+#endif
\ No newline at end of file
diff --git a/kortex_api/include/common/Frame.h b/kortex_api/include/common/Frame.h
new file mode 100644
index 0000000000000000000000000000000000000000..9d21289d43aa125dbebe38817fab6dae132b3ece
--- /dev/null
+++ b/kortex_api/include/common/Frame.h
@@ -0,0 +1,71 @@
+#ifndef __FRAME_H__
+#define __FRAME_H__
+
+#include "messages/Frame.pb.h"
+
+#define ACTUATORCONFIG_CLIENT_PROTO_AVAILABLE
+#define ACTUATORCYCLIC_CLIENT_PROTO_AVAILABLE
+#define BASE_CLIENT_PROTO_AVAILABLE
+#define BASECYCLIC_CLIENT_PROTO_AVAILABLE
+#define COMMON_CLIENT_PROTO_AVAILABLE
+#define CONTROLCONFIG_CLIENT_PROTO_AVAILABLE
+#define DEVICECONFIG_CLIENT_PROTO_AVAILABLE
+#define DEVICEMANAGER_CLIENT_PROTO_AVAILABLE
+#define ERRORS_CLIENT_PROTO_AVAILABLE
+#define FRAME_CLIENT_PROTO_AVAILABLE
+#define GRIPPERCONFIG_CLIENT_PROTO_AVAILABLE
+#define GRIPPERCYCLIC_CLIENT_PROTO_AVAILABLE
+#define GRIPPERCYCLICMESSAGE_CLIENT_PROTO_AVAILABLE
+#define INTERCONNECTCONFIG_CLIENT_PROTO_AVAILABLE
+#define INTERCONNECTCYCLIC_CLIENT_PROTO_AVAILABLE
+#define INTERCONNECTCYCLICMESSAGE_CLIENT_PROTO_AVAILABLE
+#define PRODUCTCONFIGURATION_CLIENT_PROTO_AVAILABLE
+#define SESSION_CLIENT_PROTO_AVAILABLE
+#define TEST_CLIENT_PROTO_AVAILABLE
+#define VISIONCONFIG_CLIENT_PROTO_AVAILABLE
+
+#define ACTUATORCONFIG_SERVER_PROTO_AVAILABLE
+#define ACTUATORCYCLIC_SERVER_PROTO_AVAILABLE
+#define BASE_SERVER_PROTO_AVAILABLE
+#define BASECYCLIC_SERVER_PROTO_AVAILABLE
+#define COMMON_SERVER_PROTO_AVAILABLE
+#define CONTROLCONFIG_SERVER_PROTO_AVAILABLE
+#define DEVICECONFIG_SERVER_PROTO_AVAILABLE
+#define DEVICEMANAGER_SERVER_PROTO_AVAILABLE
+#define ERRORS_SERVER_PROTO_AVAILABLE
+#define FRAME_SERVER_PROTO_AVAILABLE
+#define GRIPPERCONFIG_SERVER_PROTO_AVAILABLE
+#define GRIPPERCYCLIC_SERVER_PROTO_AVAILABLE
+#define GRIPPERCYCLICMESSAGE_SERVER_PROTO_AVAILABLE
+#define INTERCONNECTCONFIG_SERVER_PROTO_AVAILABLE
+#define INTERCONNECTCYCLIC_SERVER_PROTO_AVAILABLE
+#define INTERCONNECTCYCLICMESSAGE_SERVER_PROTO_AVAILABLE
+#define PRODUCTCONFIGURATION_SERVER_PROTO_AVAILABLE
+#define SESSION_SERVER_PROTO_AVAILABLE
+#define TEST_SERVER_PROTO_AVAILABLE
+#define VISIONCONFIG_SERVER_PROTO_AVAILABLE
+
+namespace Kinova
+{
+namespace Api
+{
+	enum ServiceIds
+	{
+		eIdActuatorConfig = 10,
+		eIdActuatorCyclic = 11,
+		eIdBase = 2,
+		eIdBaseCyclic = 3,
+		eIdControlConfig = 16,
+		eIdDeviceConfig = 9,
+		eIdDeviceManager = 23,
+		eIdGripperCyclic = 17,
+		eIdInterconnectConfig = 14,
+		eIdInterconnectCyclic = 15,
+		eIdSession = 1,
+		eIdTest = 4080,
+		eIdVisionConfig = 5,
+	};
+}
+}
+
+#endif
\ No newline at end of file
diff --git a/kortex_api/include/common/HeaderInfo.h b/kortex_api/include/common/HeaderInfo.h
new file mode 100644
index 0000000000000000000000000000000000000000..4f95793a3f0e2ac166536b4c24f9c1c4d9788036
--- /dev/null
+++ b/kortex_api/include/common/HeaderInfo.h
@@ -0,0 +1,81 @@
+#ifndef KINOVAUTILAPI_H
+#define KINOVAUTILAPI_H
+
+#include "messages/Frame.pb.h"
+
+namespace Kinova
+{
+namespace Api
+{
+
+    typedef union
+    {
+        uint32_t frame_info;
+        struct
+        {
+            uint32_t errorSubCode: 12;
+            uint32_t errorCode: 4;
+            uint32_t deviceId: 8;
+
+            uint32_t frameType: 4;
+            uint32_t headerVersion : 4;
+        };
+    } FrameInfo;
+
+    typedef union
+    {
+        uint32_t message_info;
+        struct
+        {
+            uint32_t messageId: 16;
+            uint32_t sessionId: 16;
+        };
+    } MessageInfo;
+    
+    typedef union
+    {
+        uint32_t service_info;
+        struct
+        {
+            uint32_t functionId: 16;
+            uint32_t serviceId: 12;
+            uint32_t serviceVersion: 4;
+        };
+        
+        struct
+        {
+            uint32_t functionUid: 28;
+        };
+    } ServiceInfo;
+    
+    typedef union
+    {
+        uint32_t payload_info;
+        struct
+        {
+            uint32_t payloadLength: 24;
+            uint32_t reserved: 8;
+        };
+    } PayloadInfo;
+    
+    class HeaderInfo
+    {
+    public:
+        HeaderInfo();
+        HeaderInfo(const Header& headerProto);
+
+        Header createHeader();
+
+        void fillHeader(Header* pHeader);
+
+        FrameInfo        m_frameInfo;
+        MessageInfo      m_messageInfo;
+        ServiceInfo      m_serviceInfo;
+        PayloadInfo      m_payloadInfo;
+    };
+
+
+} // namespace Api
+} // namespace Kinova
+
+#endif
diff --git a/kortex_api/include/common/KBasicException.h b/kortex_api/include/common/KBasicException.h
new file mode 100644
index 0000000000000000000000000000000000000000..3fc3b2a8d2a14fc1302de45200ef5b07a1c44c2d
--- /dev/null
+++ b/kortex_api/include/common/KBasicException.h
@@ -0,0 +1,29 @@
+#ifndef KINOVAEXCEPTION_H
+#define KINOVAEXCEPTION_H
+
+#include <string>
+#include <sstream>
+#include <exception>
+
+namespace Kinova
+{
+namespace Api
+{
+
+    class KBasicException : public std::runtime_error
+    {
+    public:
+        KBasicException(const std::string& msgStr);
+        KBasicException(const KBasicException &other);
+
+        virtual const char* what() const throw() override;
+        virtual std::string toString();
+    };
+
+    // todogr add a new kinova exception: KProgException
+    typedef KBasicException KProgException;
+
+} // namespace Api
+} // namespace Kinova
+
+#endif
diff --git a/kortex_api/include/common/KDetailedException.h b/kortex_api/include/common/KDetailedException.h
new file mode 100644
index 0000000000000000000000000000000000000000..096ac711299747d7aefde15dc9e77a15251afd33
--- /dev/null
+++ b/kortex_api/include/common/KDetailedException.h
@@ -0,0 +1,39 @@
+#ifndef KINOVASERVEREXCEPTION_H
+#define KINOVASERVEREXCEPTION_H
+
+#include <string>
+#include <sstream>
+
+#include "KBasicException.h"
+
+#include <messages/Frame.pb.h>
+#include "KError.h"
+
+#include "HeaderInfo.h"
+
+namespace Kinova
+{
+namespace Api
+{
+    class KDetailedException : public KBasicException
+    {
+    public:
+        KDetailedException(const KError& error);
+        KDetailedException(const KDetailedException &other);
+
+        virtual const char* what() const throw() override;
+        virtual std::string toString() override;
+
+        KError&      getErrorInfo() { return m_error; }
+
+    private:
+        void init(const HeaderInfo& header, const Error& error);
+    
+        KError       m_error;
+        std::string  m_errorStr;
+    };
+
+} // namespace Api
+} // namespace Kinova
+
+#endif
diff --git a/kortex_api/include/common/KError.h b/kortex_api/include/common/KError.h
new file mode 100644
index 0000000000000000000000000000000000000000..636f736bd96619e8b80a4ac7ebab8e6d6625acef
--- /dev/null
+++ b/kortex_api/include/common/KError.h
@@ -0,0 +1,42 @@
+#ifndef KINOVAERROR_H
+#define KINOVAERROR_H
+
+#include <string>
+#include <sstream>
+
+#include "messages/Frame.pb.h"
+
+#include "HeaderInfo.h"
+
+namespace Kinova
+{
+namespace Api
+{
+    class KError
+    {
+    public:
+        KError(Kinova::Api::ErrorCodes errorCode, Kinova::Api::SubErrorCodes errorSubCode, std::string errorDescription);
+        KError(const HeaderInfo& header, Kinova::Api::ErrorCodes errorCode, Kinova::Api::SubErrorCodes errorSubCode, std::string errorDescription);
+        KError(const Error& error);
+        KError(const HeaderInfo& header, const Error& error);
+
+        static Error fillError(Kinova::Api::ErrorCodes errorCode, Kinova::Api::SubErrorCodes errorSubCode, std::string errorDescription);
+
+        std::string toString() const;
+
+        bool            isThereHeaderInfo();
+        HeaderInfo      getHeader();
+        Error           getError();
+
+        KError& operator =(const KError& other) = default;
+
+    private:
+        bool            m_isThereHeaderInfo;
+        HeaderInfo      m_header;
+        Error           m_error;
+    };
+
+} // namespace Api
+} // namespace Kinova
+
+#endif
diff --git a/kortex_api/include/common/KinovaTcpUtilities.h b/kortex_api/include/common/KinovaTcpUtilities.h
new file mode 100644
index 0000000000000000000000000000000000000000..570706c2e8ded22a257feeee35e50b07f603b0dd
--- /dev/null
+++ b/kortex_api/include/common/KinovaTcpUtilities.h
@@ -0,0 +1,23 @@
+#ifndef CPPAPI_KINOVATCPUTILITIES_H
+#define CPPAPI_KINOVATCPUTILITIES_H
+
+#include <string>
+
+class KinovaTcpUtilities {
+
+public:
+    KinovaTcpUtilities();
+    ~KinovaTcpUtilities();
+
+    uint32_t ParseBufferHeader(uint8_t* buff);
+    void PrependHeader(uint8_t *in_buf, uint32_t payload_length);
+    void PrintBuffer(uint8_t* in_buf, uint32_t len);
+    char* ResizeBuffer(char *buf, size_t data_size_to_copy, size_t new_size, uint32_t& buffer_size);
+    uint8_t* ResizeBuffer(uint8_t *buf, size_t data_size_to_copy, size_t new_size, uint32_t& buffer_size);
+
+    const std::string KINOVA_MAGIC_STRING = { "\07xEtRoK\07" };
+    const size_t KINOVA_HEADER_SIZE { (KINOVA_MAGIC_STRING.length() + sizeof(uint32_t) )};
+};
+
+
+#endif //CPPAPI_KINOVATCPUTILITIES_H
diff --git a/kortex_api/include/common/TransportBridgeDummy.h b/kortex_api/include/common/TransportBridgeDummy.h
new file mode 100644
index 0000000000000000000000000000000000000000..b1b2c7e5fafbd3009322938d9e32355f815652de
--- /dev/null
+++ b/kortex_api/include/common/TransportBridgeDummy.h
@@ -0,0 +1,127 @@
+/* ***************************************************************************
+ * Kinova inc.
+ * Project : 
+ *
+ * Copyright (c) 2006-2018 Kinova Incorporated. All rights reserved.
+ ****************************************************************************/
+
+#ifndef _TRANSPORT_BRIDGE_DUMMY_H_
+#define _TRANSPORT_BRIDGE_DUMMY_H_
+
+#include <string>
+#include <functional>
+
+#include "client/ITransportClient.h"
+#include "ITransportServer.h"
+
+namespace Kinova
+{
+    using namespace Api;
+    
+    namespace Helper
+    {
+        class TransportBridgeDummy
+        {
+            class TransportBridgeClientDummy : public ITransportClient
+            {
+                TransportBridgeDummy *m_transportBridgeDummy;
+            
+            public:
+                TransportBridgeClientDummy(TransportBridgeDummy *transportBridgeDummy)
+                {
+                    m_transportBridgeDummy = transportBridgeDummy;
+                }
+                
+                virtual ~TransportBridgeClientDummy();
+                
+                virtual bool connect(std::string host = "127.0.0.1", uint32_t port = kApiPort) override { return true; }
+                
+                virtual void disconnect() override {}
+                
+                virtual void send(const char *txBuffer, uint32_t txSize) override
+                {
+                    m_transportBridgeDummy->m_onMessageCallbackServer(m_transportBridgeDummy->m_connectionHandle, (uint8_t *) txBuffer, (int) txSize);
+                }
+                
+                virtual void onMessage(std::function<void(const char *, uint32_t)> callbackClient) override
+                {
+                    m_transportBridgeDummy->m_onMessageCallbackClient = callbackClient;
+                }
+                
+                virtual char *getTxBuffer() override { return m_transportBridgeDummy->m_bufferClientToServer; }
+                
+                virtual size_t getMaxTxBufferSize() override { return m_transportBridgeDummy->m_maxBufferSizeClientToServer; }
+            };
+            
+            class TransportBridgeServerDummy : public ITransportServer
+            {
+                TransportBridgeDummy *m_transportBridgeDummy;
+            
+            public:
+                TransportBridgeServerDummy(TransportBridgeDummy *transportBridgeDummy)
+                {
+                    m_transportBridgeDummy = transportBridgeDummy;
+                }
+                
+                virtual ~TransportBridgeServerDummy() override {}
+                
+                virtual void Process() override {}
+                
+                
+                virtual bool Send(const ClientConnectionHandle &connectionHandle, char *TXBuffer, int txLen) override
+                {
+                    m_transportBridgeDummy->m_onMessageCallbackClient((const char *) TXBuffer, (uint32_t) txLen);
+                }
+                
+                virtual void OnMessage(std::function<void(const ClientConnectionHandle &, uint8_t *, int)> callbackServer) override
+                {
+                    m_transportBridgeDummy->m_onMessageCallbackServer = callbackServer;
+                }
+                
+                virtual char *GetTxBuffer(size_t *pTxLen) override
+                {
+                    *pTxLen = m_transportBridgeDummy->m_maxBufferSizeServerToClient;
+                    
+                    return m_transportBridgeDummy->m_bufferServerToClient;
+                }
+            };
+            
+            ITransportServer *m_server;
+            ITransportClient *m_client;
+        
+        public:
+            static constexpr uint32_t kMaxBufferSizeServerToClient = 65507;
+            static constexpr uint32_t kMaxBufferSizeClientToServer = 65507;
+            
+            const uint32_t m_maxBufferSizeServerToClient = kMaxBufferSizeServerToClient;
+            const uint32_t m_maxBufferSizeClientToServer = kMaxBufferSizeClientToServer;
+            
+            char m_bufferServerToClient[kMaxBufferSizeServerToClient];
+            char m_bufferClientToServer[kMaxBufferSizeClientToServer];
+            
+            std::function<void(const char *, uint32_t)> m_onMessageCallbackClient;
+            std::function<void(const ClientConnectionHandle &, uint8_t *, int)> m_onMessageCallbackServer;
+            
+            struct ClientConnectionHandle m_connectionHandle;
+            
+            TransportBridgeDummy()
+            {
+                m_connectionHandle.clientId = 1;
+                auto m_server = new TransportBridgeServerDummy(this);
+                auto m_client = new TransportBridgeClientDummy(this);
+            }
+            
+            virtual ~TransportBridgeDummy()
+            {
+                delete m_server;
+                delete m_client;
+            }
+            
+            ITransportServer *getServerTransport() { return m_server; }
+            
+            ITransportClient *getClientTransport() { return m_client; }
+        };
+        
+    }
+}
+#endif
diff --git a/kortex_api/include/common/WindowsNetworking.h b/kortex_api/include/common/WindowsNetworking.h
new file mode 100644
index 0000000000000000000000000000000000000000..e92127def3152129df249b92b58bbf6db98db668
--- /dev/null
+++ b/kortex_api/include/common/WindowsNetworking.h
@@ -0,0 +1,21 @@
+#ifndef WINDOWS_NETWORKING_H
+#define WINDOWS_NETWORKING_H
+
+#ifdef _WIN32
+#define _OS_WINDOWS
+
+// Include Windows networking headers before standard C++ headers
+#include <winsock2.h>
+#include <ws2tcpip.h>
+#include <windows.h>
+
+// Define missing types that are used in TransportClientTcp.h
+typedef int socklen_t;
+
+// Ensure proper Windows networking initialization
+#pragma comment(lib, "ws2_32.lib")
+#pragma comment(lib, "iphlpapi.lib")
+
+#endif // _WIN32
+
+#endif // WINDOWS_NETWORKING_H
diff --git a/kortex_api/include/common/version.h b/kortex_api/include/common/version.h
new file mode 100644
index 0000000000000000000000000000000000000000..545a8ec902004e333d5eed66f5ac8e976470064f
--- /dev/null
+++ b/kortex_api/include/common/version.h
@@ -0,0 +1,10 @@
+#ifndef VERSION_H
+#define VERSION_H
+
+#define PROJECT_NAME "KortexApiCpp"
+#define PROJECT_VER  "2.7.0"
+#define PROJECT_VER_MAJOR "2"
+#define PROJECT_VER_MINOR "7"
+#define PTOJECT_VER_PATCH "0"
+
+#endif //VERSION_H
diff --git a/kortex_api/include/google/protobuf/any.h b/kortex_api/include/google/protobuf/any.h
new file mode 100644
index 0000000000000000000000000000000000000000..c2c27ec33381a2948df0a09679e3962b71137b4d
--- /dev/null
+++ b/kortex_api/include/google/protobuf/any.h
@@ -0,0 +1,107 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_ANY_H__
+#define GOOGLE_PROTOBUF_ANY_H__
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/arenastring.h>
+
+namespace google {
+namespace protobuf {
+namespace internal {
+
+// Helper class used to implement google::protobuf::Any.
+class LIBPROTOBUF_EXPORT AnyMetadata {
+  typedef ArenaStringPtr UrlType;
+  typedef ArenaStringPtr ValueType;
+ public:
+  // AnyMetadata does not take ownership of "type_url" and "value".
+  AnyMetadata(UrlType* type_url, ValueType* value);
+
+  // Packs a message using the default type URL prefix: "type.googleapis.com".
+  // The resulted type URL will be "type.googleapis.com/<message_full_name>".
+  void PackFrom(const Message& message);
+  // Packs a message using the given type URL prefix. The type URL will be
+  // constructed by concatenating the message type's full name to the prefix
+  // with an optional "/" separator if the prefix doesn't already end up "/".
+  // For example, both PackFrom(message, "type.googleapis.com") and
+  // PackFrom(message, "type.googleapis.com/") yield the same result type
+  // URL: "type.googleapis.com/<message_full_name>".
+  void PackFrom(const Message& message, const string& type_url_prefix);
+
+  // Unpacks the payload into the given message. Returns false if the message's
+  // type doesn't match the type specified in the type URL (i.e., the full
+  // name after the last "/" of the type URL doesn't match the message's actual
+  // full name) or parsing the payload has failed.
+  bool UnpackTo(Message* message) const;
+
+  // Checks whether the type specified in the type URL matches the given type.
+  // A type is consdiered matching if its full name matches the full name after
+  // the last "/" in the type URL.
+  template<typename T>
+  bool Is() const {
+    return InternalIs(T::default_instance().GetDescriptor());
+  }
+
+ private:
+  bool InternalIs(const Descriptor* message) const;
+
+  UrlType* type_url_;
+  ValueType* value_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(AnyMetadata);
+};
+
+extern const char kAnyFullTypeName[];          // "google.protobuf.Any".
+extern const char kTypeGoogleApisComPrefix[];  // "type.googleapis.com/".
+extern const char kTypeGoogleProdComPrefix[];  // "type.googleprod.com/".
+
+// Get the proto type name from Any::type_url value. For example, passing
+// "type.googleapis.com/rpc.QueryOrigin" will return "rpc.QueryOrigin" in
+// *full_type_name. Returns false if the type_url does not have a "/"
+// in the type url separating the full type name.
+bool ParseAnyTypeUrl(const string& type_url, string* full_type_name);
+
+// See if message is of type google.protobuf.Any, if so, return the descriptors
+// for "type_url" and "value" fields.
+bool GetAnyFieldDescriptors(const Message& message,
+                            const FieldDescriptor** type_url_field,
+                            const FieldDescriptor** value_field);
+
+}  // namespace internal
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_ANY_H__
diff --git a/kortex_api/include/google/protobuf/any.pb.h b/kortex_api/include/google/protobuf/any.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..32847239bef1bcbdab108ce1d21b6c9e13dbe303
--- /dev/null
+++ b/kortex_api/include/google/protobuf/any.pb.h
@@ -0,0 +1,323 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: google/protobuf/any.proto
+
+#ifndef PROTOBUF_google_2fprotobuf_2fany_2eproto__INCLUDED
+#define PROTOBUF_google_2fprotobuf_2fany_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 3005000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 3005001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+#include <google/protobuf/any.h>
+// @@protoc_insertion_point(includes)
+
+namespace protobuf_google_2fprotobuf_2fany_2eproto {
+// Internal implementation detail -- do not use these members.
+struct LIBPROTOBUF_EXPORT TableStruct {
+  static const ::google::protobuf::internal::ParseTableField entries[];
+  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
+  static const ::google::protobuf::internal::ParseTable schema[1];
+  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
+  static const ::google::protobuf::internal::SerializationTable serialization_table[];
+  static const ::google::protobuf::uint32 offsets[];
+};
+void LIBPROTOBUF_EXPORT AddDescriptors();
+void LIBPROTOBUF_EXPORT InitDefaultsAnyImpl();
+void LIBPROTOBUF_EXPORT InitDefaultsAny();
+inline void LIBPROTOBUF_EXPORT InitDefaults() {
+  InitDefaultsAny();
+}
+}  // namespace protobuf_google_2fprotobuf_2fany_2eproto
+namespace google {
+namespace protobuf {
+class Any;
+class AnyDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern AnyDefaultTypeInternal _Any_default_instance_;
+}  // namespace protobuf
+}  // namespace google
+namespace google {
+namespace protobuf {
+
+// ===================================================================
+
+class LIBPROTOBUF_EXPORT Any : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Any) */ {
+ public:
+  Any();
+  virtual ~Any();
+
+  Any(const Any& from);
+
+  inline Any& operator=(const Any& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Any(Any&& from) noexcept
+    : Any() {
+    *this = ::std::move(from);
+  }
+
+  inline Any& operator=(Any&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Any& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Any* internal_default_instance() {
+    return reinterpret_cast<const Any*>(
+               &_Any_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    0;
+
+  // implements Any -----------------------------------------------
+
+  void PackFrom(const ::google::protobuf::Message& message);
+  void PackFrom(const ::google::protobuf::Message& message,
+                const ::std::string& type_url_prefix);
+  bool UnpackTo(::google::protobuf::Message* message) const;
+  template<typename T> bool Is() const {
+    return _any_metadata_.Is<T>();
+  }
+
+  void Swap(Any* other);
+  friend void swap(Any& a, Any& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Any* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Any* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Any& from);
+  void MergeFrom(const Any& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Any* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // string type_url = 1;
+  void clear_type_url();
+  static const int kTypeUrlFieldNumber = 1;
+  const ::std::string& type_url() const;
+  void set_type_url(const ::std::string& value);
+  #if LANG_CXX11
+  void set_type_url(::std::string&& value);
+  #endif
+  void set_type_url(const char* value);
+  void set_type_url(const char* value, size_t size);
+  ::std::string* mutable_type_url();
+  ::std::string* release_type_url();
+  void set_allocated_type_url(::std::string* type_url);
+
+  // bytes value = 2;
+  void clear_value();
+  static const int kValueFieldNumber = 2;
+  const ::std::string& value() const;
+  void set_value(const ::std::string& value);
+  #if LANG_CXX11
+  void set_value(::std::string&& value);
+  #endif
+  void set_value(const char* value);
+  void set_value(const void* value, size_t size);
+  ::std::string* mutable_value();
+  ::std::string* release_value();
+  void set_allocated_value(::std::string* value);
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.Any)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::internal::ArenaStringPtr type_url_;
+  ::google::protobuf::internal::ArenaStringPtr value_;
+  mutable int _cached_size_;
+  ::google::protobuf::internal::AnyMetadata _any_metadata_;
+  friend struct ::protobuf_google_2fprotobuf_2fany_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2fany_2eproto::InitDefaultsAnyImpl();
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// Any
+
+// string type_url = 1;
+inline void Any::clear_type_url() {
+  type_url_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& Any::type_url() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Any.type_url)
+  return type_url_.GetNoArena();
+}
+inline void Any::set_type_url(const ::std::string& value) {
+  
+  type_url_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:google.protobuf.Any.type_url)
+}
+#if LANG_CXX11
+inline void Any::set_type_url(::std::string&& value) {
+  
+  type_url_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.Any.type_url)
+}
+#endif
+inline void Any::set_type_url(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  type_url_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:google.protobuf.Any.type_url)
+}
+inline void Any::set_type_url(const char* value, size_t size) {
+  
+  type_url_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.Any.type_url)
+}
+inline ::std::string* Any::mutable_type_url() {
+  
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Any.type_url)
+  return type_url_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* Any::release_type_url() {
+  // @@protoc_insertion_point(field_release:google.protobuf.Any.type_url)
+  
+  return type_url_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void Any::set_allocated_type_url(::std::string* type_url) {
+  if (type_url != NULL) {
+    
+  } else {
+    
+  }
+  type_url_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), type_url);
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Any.type_url)
+}
+
+// bytes value = 2;
+inline void Any::clear_value() {
+  value_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& Any::value() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Any.value)
+  return value_.GetNoArena();
+}
+inline void Any::set_value(const ::std::string& value) {
+  
+  value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:google.protobuf.Any.value)
+}
+#if LANG_CXX11
+inline void Any::set_value(::std::string&& value) {
+  
+  value_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.Any.value)
+}
+#endif
+inline void Any::set_value(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:google.protobuf.Any.value)
+}
+inline void Any::set_value(const void* value, size_t size) {
+  
+  value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.Any.value)
+}
+inline ::std::string* Any::mutable_value() {
+  
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Any.value)
+  return value_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* Any::release_value() {
+  // @@protoc_insertion_point(field_release:google.protobuf.Any.value)
+  
+  return value_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void Any::set_allocated_value(::std::string* value) {
+  if (value != NULL) {
+    
+  } else {
+    
+  }
+  value_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Any.value)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace protobuf
+}  // namespace google
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_google_2fprotobuf_2fany_2eproto__INCLUDED
diff --git a/kortex_api/include/google/protobuf/api.pb.h b/kortex_api/include/google/protobuf/api.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..96ff3f159b07c4d6c4e041abe5206392e33fd45c
--- /dev/null
+++ b/kortex_api/include/google/protobuf/api.pb.h
@@ -0,0 +1,1165 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: google/protobuf/api.proto
+
+#ifndef PROTOBUF_google_2fprotobuf_2fapi_2eproto__INCLUDED
+#define PROTOBUF_google_2fprotobuf_2fapi_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 3005000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 3005001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+#include <google/protobuf/source_context.pb.h>
+#include <google/protobuf/type.pb.h>
+// @@protoc_insertion_point(includes)
+
+namespace protobuf_google_2fprotobuf_2fapi_2eproto {
+// Internal implementation detail -- do not use these members.
+struct LIBPROTOBUF_EXPORT TableStruct {
+  static const ::google::protobuf::internal::ParseTableField entries[];
+  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
+  static const ::google::protobuf::internal::ParseTable schema[3];
+  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
+  static const ::google::protobuf::internal::SerializationTable serialization_table[];
+  static const ::google::protobuf::uint32 offsets[];
+};
+void LIBPROTOBUF_EXPORT AddDescriptors();
+void LIBPROTOBUF_EXPORT InitDefaultsApiImpl();
+void LIBPROTOBUF_EXPORT InitDefaultsApi();
+void LIBPROTOBUF_EXPORT InitDefaultsMethodImpl();
+void LIBPROTOBUF_EXPORT InitDefaultsMethod();
+void LIBPROTOBUF_EXPORT InitDefaultsMixinImpl();
+void LIBPROTOBUF_EXPORT InitDefaultsMixin();
+inline void LIBPROTOBUF_EXPORT InitDefaults() {
+  InitDefaultsApi();
+  InitDefaultsMethod();
+  InitDefaultsMixin();
+}
+}  // namespace protobuf_google_2fprotobuf_2fapi_2eproto
+namespace google {
+namespace protobuf {
+class Api;
+class ApiDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern ApiDefaultTypeInternal _Api_default_instance_;
+class Method;
+class MethodDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern MethodDefaultTypeInternal _Method_default_instance_;
+class Mixin;
+class MixinDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern MixinDefaultTypeInternal _Mixin_default_instance_;
+}  // namespace protobuf
+}  // namespace google
+namespace google {
+namespace protobuf {
+
+// ===================================================================
+
+class LIBPROTOBUF_EXPORT Api : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Api) */ {
+ public:
+  Api();
+  virtual ~Api();
+
+  Api(const Api& from);
+
+  inline Api& operator=(const Api& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Api(Api&& from) noexcept
+    : Api() {
+    *this = ::std::move(from);
+  }
+
+  inline Api& operator=(Api&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Api& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Api* internal_default_instance() {
+    return reinterpret_cast<const Api*>(
+               &_Api_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    0;
+
+  void Swap(Api* other);
+  friend void swap(Api& a, Api& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Api* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Api* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Api& from);
+  void MergeFrom(const Api& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Api* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .google.protobuf.Method methods = 2;
+  int methods_size() const;
+  void clear_methods();
+  static const int kMethodsFieldNumber = 2;
+  const ::google::protobuf::Method& methods(int index) const;
+  ::google::protobuf::Method* mutable_methods(int index);
+  ::google::protobuf::Method* add_methods();
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::Method >*
+      mutable_methods();
+  const ::google::protobuf::RepeatedPtrField< ::google::protobuf::Method >&
+      methods() const;
+
+  // repeated .google.protobuf.Option options = 3;
+  int options_size() const;
+  void clear_options();
+  static const int kOptionsFieldNumber = 3;
+  const ::google::protobuf::Option& options(int index) const;
+  ::google::protobuf::Option* mutable_options(int index);
+  ::google::protobuf::Option* add_options();
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::Option >*
+      mutable_options();
+  const ::google::protobuf::RepeatedPtrField< ::google::protobuf::Option >&
+      options() const;
+
+  // repeated .google.protobuf.Mixin mixins = 6;
+  int mixins_size() const;
+  void clear_mixins();
+  static const int kMixinsFieldNumber = 6;
+  const ::google::protobuf::Mixin& mixins(int index) const;
+  ::google::protobuf::Mixin* mutable_mixins(int index);
+  ::google::protobuf::Mixin* add_mixins();
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::Mixin >*
+      mutable_mixins();
+  const ::google::protobuf::RepeatedPtrField< ::google::protobuf::Mixin >&
+      mixins() const;
+
+  // string name = 1;
+  void clear_name();
+  static const int kNameFieldNumber = 1;
+  const ::std::string& name() const;
+  void set_name(const ::std::string& value);
+  #if LANG_CXX11
+  void set_name(::std::string&& value);
+  #endif
+  void set_name(const char* value);
+  void set_name(const char* value, size_t size);
+  ::std::string* mutable_name();
+  ::std::string* release_name();
+  void set_allocated_name(::std::string* name);
+
+  // string version = 4;
+  void clear_version();
+  static const int kVersionFieldNumber = 4;
+  const ::std::string& version() const;
+  void set_version(const ::std::string& value);
+  #if LANG_CXX11
+  void set_version(::std::string&& value);
+  #endif
+  void set_version(const char* value);
+  void set_version(const char* value, size_t size);
+  ::std::string* mutable_version();
+  ::std::string* release_version();
+  void set_allocated_version(::std::string* version);
+
+  // .google.protobuf.SourceContext source_context = 5;
+  bool has_source_context() const;
+  void clear_source_context();
+  static const int kSourceContextFieldNumber = 5;
+  const ::google::protobuf::SourceContext& source_context() const;
+  ::google::protobuf::SourceContext* release_source_context();
+  ::google::protobuf::SourceContext* mutable_source_context();
+  void set_allocated_source_context(::google::protobuf::SourceContext* source_context);
+
+  // .google.protobuf.Syntax syntax = 7;
+  void clear_syntax();
+  static const int kSyntaxFieldNumber = 7;
+  ::google::protobuf::Syntax syntax() const;
+  void set_syntax(::google::protobuf::Syntax value);
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.Api)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::Method > methods_;
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::Option > options_;
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::Mixin > mixins_;
+  ::google::protobuf::internal::ArenaStringPtr name_;
+  ::google::protobuf::internal::ArenaStringPtr version_;
+  ::google::protobuf::SourceContext* source_context_;
+  int syntax_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_google_2fprotobuf_2fapi_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2fapi_2eproto::InitDefaultsApiImpl();
+};
+// -------------------------------------------------------------------
+
+class LIBPROTOBUF_EXPORT Method : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Method) */ {
+ public:
+  Method();
+  virtual ~Method();
+
+  Method(const Method& from);
+
+  inline Method& operator=(const Method& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Method(Method&& from) noexcept
+    : Method() {
+    *this = ::std::move(from);
+  }
+
+  inline Method& operator=(Method&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Method& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Method* internal_default_instance() {
+    return reinterpret_cast<const Method*>(
+               &_Method_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    1;
+
+  void Swap(Method* other);
+  friend void swap(Method& a, Method& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Method* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Method* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Method& from);
+  void MergeFrom(const Method& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Method* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .google.protobuf.Option options = 6;
+  int options_size() const;
+  void clear_options();
+  static const int kOptionsFieldNumber = 6;
+  const ::google::protobuf::Option& options(int index) const;
+  ::google::protobuf::Option* mutable_options(int index);
+  ::google::protobuf::Option* add_options();
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::Option >*
+      mutable_options();
+  const ::google::protobuf::RepeatedPtrField< ::google::protobuf::Option >&
+      options() const;
+
+  // string name = 1;
+  void clear_name();
+  static const int kNameFieldNumber = 1;
+  const ::std::string& name() const;
+  void set_name(const ::std::string& value);
+  #if LANG_CXX11
+  void set_name(::std::string&& value);
+  #endif
+  void set_name(const char* value);
+  void set_name(const char* value, size_t size);
+  ::std::string* mutable_name();
+  ::std::string* release_name();
+  void set_allocated_name(::std::string* name);
+
+  // string request_type_url = 2;
+  void clear_request_type_url();
+  static const int kRequestTypeUrlFieldNumber = 2;
+  const ::std::string& request_type_url() const;
+  void set_request_type_url(const ::std::string& value);
+  #if LANG_CXX11
+  void set_request_type_url(::std::string&& value);
+  #endif
+  void set_request_type_url(const char* value);
+  void set_request_type_url(const char* value, size_t size);
+  ::std::string* mutable_request_type_url();
+  ::std::string* release_request_type_url();
+  void set_allocated_request_type_url(::std::string* request_type_url);
+
+  // string response_type_url = 4;
+  void clear_response_type_url();
+  static const int kResponseTypeUrlFieldNumber = 4;
+  const ::std::string& response_type_url() const;
+  void set_response_type_url(const ::std::string& value);
+  #if LANG_CXX11
+  void set_response_type_url(::std::string&& value);
+  #endif
+  void set_response_type_url(const char* value);
+  void set_response_type_url(const char* value, size_t size);
+  ::std::string* mutable_response_type_url();
+  ::std::string* release_response_type_url();
+  void set_allocated_response_type_url(::std::string* response_type_url);
+
+  // bool request_streaming = 3;
+  void clear_request_streaming();
+  static const int kRequestStreamingFieldNumber = 3;
+  bool request_streaming() const;
+  void set_request_streaming(bool value);
+
+  // bool response_streaming = 5;
+  void clear_response_streaming();
+  static const int kResponseStreamingFieldNumber = 5;
+  bool response_streaming() const;
+  void set_response_streaming(bool value);
+
+  // .google.protobuf.Syntax syntax = 7;
+  void clear_syntax();
+  static const int kSyntaxFieldNumber = 7;
+  ::google::protobuf::Syntax syntax() const;
+  void set_syntax(::google::protobuf::Syntax value);
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.Method)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::Option > options_;
+  ::google::protobuf::internal::ArenaStringPtr name_;
+  ::google::protobuf::internal::ArenaStringPtr request_type_url_;
+  ::google::protobuf::internal::ArenaStringPtr response_type_url_;
+  bool request_streaming_;
+  bool response_streaming_;
+  int syntax_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_google_2fprotobuf_2fapi_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2fapi_2eproto::InitDefaultsMethodImpl();
+};
+// -------------------------------------------------------------------
+
+class LIBPROTOBUF_EXPORT Mixin : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Mixin) */ {
+ public:
+  Mixin();
+  virtual ~Mixin();
+
+  Mixin(const Mixin& from);
+
+  inline Mixin& operator=(const Mixin& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Mixin(Mixin&& from) noexcept
+    : Mixin() {
+    *this = ::std::move(from);
+  }
+
+  inline Mixin& operator=(Mixin&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Mixin& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Mixin* internal_default_instance() {
+    return reinterpret_cast<const Mixin*>(
+               &_Mixin_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    2;
+
+  void Swap(Mixin* other);
+  friend void swap(Mixin& a, Mixin& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Mixin* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Mixin* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Mixin& from);
+  void MergeFrom(const Mixin& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Mixin* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // string name = 1;
+  void clear_name();
+  static const int kNameFieldNumber = 1;
+  const ::std::string& name() const;
+  void set_name(const ::std::string& value);
+  #if LANG_CXX11
+  void set_name(::std::string&& value);
+  #endif
+  void set_name(const char* value);
+  void set_name(const char* value, size_t size);
+  ::std::string* mutable_name();
+  ::std::string* release_name();
+  void set_allocated_name(::std::string* name);
+
+  // string root = 2;
+  void clear_root();
+  static const int kRootFieldNumber = 2;
+  const ::std::string& root() const;
+  void set_root(const ::std::string& value);
+  #if LANG_CXX11
+  void set_root(::std::string&& value);
+  #endif
+  void set_root(const char* value);
+  void set_root(const char* value, size_t size);
+  ::std::string* mutable_root();
+  ::std::string* release_root();
+  void set_allocated_root(::std::string* root);
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.Mixin)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::internal::ArenaStringPtr name_;
+  ::google::protobuf::internal::ArenaStringPtr root_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_google_2fprotobuf_2fapi_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2fapi_2eproto::InitDefaultsMixinImpl();
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// Api
+
+// string name = 1;
+inline void Api::clear_name() {
+  name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& Api::name() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Api.name)
+  return name_.GetNoArena();
+}
+inline void Api::set_name(const ::std::string& value) {
+  
+  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:google.protobuf.Api.name)
+}
+#if LANG_CXX11
+inline void Api::set_name(::std::string&& value) {
+  
+  name_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.Api.name)
+}
+#endif
+inline void Api::set_name(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:google.protobuf.Api.name)
+}
+inline void Api::set_name(const char* value, size_t size) {
+  
+  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.Api.name)
+}
+inline ::std::string* Api::mutable_name() {
+  
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Api.name)
+  return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* Api::release_name() {
+  // @@protoc_insertion_point(field_release:google.protobuf.Api.name)
+  
+  return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void Api::set_allocated_name(::std::string* name) {
+  if (name != NULL) {
+    
+  } else {
+    
+  }
+  name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Api.name)
+}
+
+// repeated .google.protobuf.Method methods = 2;
+inline int Api::methods_size() const {
+  return methods_.size();
+}
+inline void Api::clear_methods() {
+  methods_.Clear();
+}
+inline const ::google::protobuf::Method& Api::methods(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Api.methods)
+  return methods_.Get(index);
+}
+inline ::google::protobuf::Method* Api::mutable_methods(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Api.methods)
+  return methods_.Mutable(index);
+}
+inline ::google::protobuf::Method* Api::add_methods() {
+  // @@protoc_insertion_point(field_add:google.protobuf.Api.methods)
+  return methods_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::Method >*
+Api::mutable_methods() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.Api.methods)
+  return &methods_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::Method >&
+Api::methods() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.Api.methods)
+  return methods_;
+}
+
+// repeated .google.protobuf.Option options = 3;
+inline int Api::options_size() const {
+  return options_.size();
+}
+inline const ::google::protobuf::Option& Api::options(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Api.options)
+  return options_.Get(index);
+}
+inline ::google::protobuf::Option* Api::mutable_options(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Api.options)
+  return options_.Mutable(index);
+}
+inline ::google::protobuf::Option* Api::add_options() {
+  // @@protoc_insertion_point(field_add:google.protobuf.Api.options)
+  return options_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::Option >*
+Api::mutable_options() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.Api.options)
+  return &options_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::Option >&
+Api::options() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.Api.options)
+  return options_;
+}
+
+// string version = 4;
+inline void Api::clear_version() {
+  version_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& Api::version() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Api.version)
+  return version_.GetNoArena();
+}
+inline void Api::set_version(const ::std::string& value) {
+  
+  version_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:google.protobuf.Api.version)
+}
+#if LANG_CXX11
+inline void Api::set_version(::std::string&& value) {
+  
+  version_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.Api.version)
+}
+#endif
+inline void Api::set_version(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  version_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:google.protobuf.Api.version)
+}
+inline void Api::set_version(const char* value, size_t size) {
+  
+  version_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.Api.version)
+}
+inline ::std::string* Api::mutable_version() {
+  
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Api.version)
+  return version_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* Api::release_version() {
+  // @@protoc_insertion_point(field_release:google.protobuf.Api.version)
+  
+  return version_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void Api::set_allocated_version(::std::string* version) {
+  if (version != NULL) {
+    
+  } else {
+    
+  }
+  version_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), version);
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Api.version)
+}
+
+// .google.protobuf.SourceContext source_context = 5;
+inline bool Api::has_source_context() const {
+  return this != internal_default_instance() && source_context_ != NULL;
+}
+inline const ::google::protobuf::SourceContext& Api::source_context() const {
+  const ::google::protobuf::SourceContext* p = source_context_;
+  // @@protoc_insertion_point(field_get:google.protobuf.Api.source_context)
+  return p != NULL ? *p : *reinterpret_cast<const ::google::protobuf::SourceContext*>(
+      &::google::protobuf::_SourceContext_default_instance_);
+}
+inline ::google::protobuf::SourceContext* Api::release_source_context() {
+  // @@protoc_insertion_point(field_release:google.protobuf.Api.source_context)
+  
+  ::google::protobuf::SourceContext* temp = source_context_;
+  source_context_ = NULL;
+  return temp;
+}
+inline ::google::protobuf::SourceContext* Api::mutable_source_context() {
+  
+  if (source_context_ == NULL) {
+    source_context_ = new ::google::protobuf::SourceContext;
+  }
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Api.source_context)
+  return source_context_;
+}
+inline void Api::set_allocated_source_context(::google::protobuf::SourceContext* source_context) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(source_context_);
+  }
+  if (source_context) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      source_context = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, source_context, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  source_context_ = source_context;
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Api.source_context)
+}
+
+// repeated .google.protobuf.Mixin mixins = 6;
+inline int Api::mixins_size() const {
+  return mixins_.size();
+}
+inline void Api::clear_mixins() {
+  mixins_.Clear();
+}
+inline const ::google::protobuf::Mixin& Api::mixins(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Api.mixins)
+  return mixins_.Get(index);
+}
+inline ::google::protobuf::Mixin* Api::mutable_mixins(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Api.mixins)
+  return mixins_.Mutable(index);
+}
+inline ::google::protobuf::Mixin* Api::add_mixins() {
+  // @@protoc_insertion_point(field_add:google.protobuf.Api.mixins)
+  return mixins_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::Mixin >*
+Api::mutable_mixins() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.Api.mixins)
+  return &mixins_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::Mixin >&
+Api::mixins() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.Api.mixins)
+  return mixins_;
+}
+
+// .google.protobuf.Syntax syntax = 7;
+inline void Api::clear_syntax() {
+  syntax_ = 0;
+}
+inline ::google::protobuf::Syntax Api::syntax() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Api.syntax)
+  return static_cast< ::google::protobuf::Syntax >(syntax_);
+}
+inline void Api::set_syntax(::google::protobuf::Syntax value) {
+  
+  syntax_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.Api.syntax)
+}
+
+// -------------------------------------------------------------------
+
+// Method
+
+// string name = 1;
+inline void Method::clear_name() {
+  name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& Method::name() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Method.name)
+  return name_.GetNoArena();
+}
+inline void Method::set_name(const ::std::string& value) {
+  
+  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:google.protobuf.Method.name)
+}
+#if LANG_CXX11
+inline void Method::set_name(::std::string&& value) {
+  
+  name_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.Method.name)
+}
+#endif
+inline void Method::set_name(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:google.protobuf.Method.name)
+}
+inline void Method::set_name(const char* value, size_t size) {
+  
+  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.Method.name)
+}
+inline ::std::string* Method::mutable_name() {
+  
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Method.name)
+  return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* Method::release_name() {
+  // @@protoc_insertion_point(field_release:google.protobuf.Method.name)
+  
+  return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void Method::set_allocated_name(::std::string* name) {
+  if (name != NULL) {
+    
+  } else {
+    
+  }
+  name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Method.name)
+}
+
+// string request_type_url = 2;
+inline void Method::clear_request_type_url() {
+  request_type_url_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& Method::request_type_url() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Method.request_type_url)
+  return request_type_url_.GetNoArena();
+}
+inline void Method::set_request_type_url(const ::std::string& value) {
+  
+  request_type_url_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:google.protobuf.Method.request_type_url)
+}
+#if LANG_CXX11
+inline void Method::set_request_type_url(::std::string&& value) {
+  
+  request_type_url_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.Method.request_type_url)
+}
+#endif
+inline void Method::set_request_type_url(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  request_type_url_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:google.protobuf.Method.request_type_url)
+}
+inline void Method::set_request_type_url(const char* value, size_t size) {
+  
+  request_type_url_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.Method.request_type_url)
+}
+inline ::std::string* Method::mutable_request_type_url() {
+  
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Method.request_type_url)
+  return request_type_url_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* Method::release_request_type_url() {
+  // @@protoc_insertion_point(field_release:google.protobuf.Method.request_type_url)
+  
+  return request_type_url_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void Method::set_allocated_request_type_url(::std::string* request_type_url) {
+  if (request_type_url != NULL) {
+    
+  } else {
+    
+  }
+  request_type_url_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), request_type_url);
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Method.request_type_url)
+}
+
+// bool request_streaming = 3;
+inline void Method::clear_request_streaming() {
+  request_streaming_ = false;
+}
+inline bool Method::request_streaming() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Method.request_streaming)
+  return request_streaming_;
+}
+inline void Method::set_request_streaming(bool value) {
+  
+  request_streaming_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.Method.request_streaming)
+}
+
+// string response_type_url = 4;
+inline void Method::clear_response_type_url() {
+  response_type_url_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& Method::response_type_url() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Method.response_type_url)
+  return response_type_url_.GetNoArena();
+}
+inline void Method::set_response_type_url(const ::std::string& value) {
+  
+  response_type_url_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:google.protobuf.Method.response_type_url)
+}
+#if LANG_CXX11
+inline void Method::set_response_type_url(::std::string&& value) {
+  
+  response_type_url_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.Method.response_type_url)
+}
+#endif
+inline void Method::set_response_type_url(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  response_type_url_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:google.protobuf.Method.response_type_url)
+}
+inline void Method::set_response_type_url(const char* value, size_t size) {
+  
+  response_type_url_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.Method.response_type_url)
+}
+inline ::std::string* Method::mutable_response_type_url() {
+  
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Method.response_type_url)
+  return response_type_url_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* Method::release_response_type_url() {
+  // @@protoc_insertion_point(field_release:google.protobuf.Method.response_type_url)
+  
+  return response_type_url_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void Method::set_allocated_response_type_url(::std::string* response_type_url) {
+  if (response_type_url != NULL) {
+    
+  } else {
+    
+  }
+  response_type_url_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), response_type_url);
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Method.response_type_url)
+}
+
+// bool response_streaming = 5;
+inline void Method::clear_response_streaming() {
+  response_streaming_ = false;
+}
+inline bool Method::response_streaming() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Method.response_streaming)
+  return response_streaming_;
+}
+inline void Method::set_response_streaming(bool value) {
+  
+  response_streaming_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.Method.response_streaming)
+}
+
+// repeated .google.protobuf.Option options = 6;
+inline int Method::options_size() const {
+  return options_.size();
+}
+inline const ::google::protobuf::Option& Method::options(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Method.options)
+  return options_.Get(index);
+}
+inline ::google::protobuf::Option* Method::mutable_options(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Method.options)
+  return options_.Mutable(index);
+}
+inline ::google::protobuf::Option* Method::add_options() {
+  // @@protoc_insertion_point(field_add:google.protobuf.Method.options)
+  return options_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::Option >*
+Method::mutable_options() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.Method.options)
+  return &options_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::Option >&
+Method::options() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.Method.options)
+  return options_;
+}
+
+// .google.protobuf.Syntax syntax = 7;
+inline void Method::clear_syntax() {
+  syntax_ = 0;
+}
+inline ::google::protobuf::Syntax Method::syntax() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Method.syntax)
+  return static_cast< ::google::protobuf::Syntax >(syntax_);
+}
+inline void Method::set_syntax(::google::protobuf::Syntax value) {
+  
+  syntax_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.Method.syntax)
+}
+
+// -------------------------------------------------------------------
+
+// Mixin
+
+// string name = 1;
+inline void Mixin::clear_name() {
+  name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& Mixin::name() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Mixin.name)
+  return name_.GetNoArena();
+}
+inline void Mixin::set_name(const ::std::string& value) {
+  
+  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:google.protobuf.Mixin.name)
+}
+#if LANG_CXX11
+inline void Mixin::set_name(::std::string&& value) {
+  
+  name_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.Mixin.name)
+}
+#endif
+inline void Mixin::set_name(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:google.protobuf.Mixin.name)
+}
+inline void Mixin::set_name(const char* value, size_t size) {
+  
+  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.Mixin.name)
+}
+inline ::std::string* Mixin::mutable_name() {
+  
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Mixin.name)
+  return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* Mixin::release_name() {
+  // @@protoc_insertion_point(field_release:google.protobuf.Mixin.name)
+  
+  return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void Mixin::set_allocated_name(::std::string* name) {
+  if (name != NULL) {
+    
+  } else {
+    
+  }
+  name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Mixin.name)
+}
+
+// string root = 2;
+inline void Mixin::clear_root() {
+  root_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& Mixin::root() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Mixin.root)
+  return root_.GetNoArena();
+}
+inline void Mixin::set_root(const ::std::string& value) {
+  
+  root_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:google.protobuf.Mixin.root)
+}
+#if LANG_CXX11
+inline void Mixin::set_root(::std::string&& value) {
+  
+  root_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.Mixin.root)
+}
+#endif
+inline void Mixin::set_root(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  root_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:google.protobuf.Mixin.root)
+}
+inline void Mixin::set_root(const char* value, size_t size) {
+  
+  root_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.Mixin.root)
+}
+inline ::std::string* Mixin::mutable_root() {
+  
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Mixin.root)
+  return root_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* Mixin::release_root() {
+  // @@protoc_insertion_point(field_release:google.protobuf.Mixin.root)
+  
+  return root_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void Mixin::set_allocated_root(::std::string* root) {
+  if (root != NULL) {
+    
+  } else {
+    
+  }
+  root_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), root);
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Mixin.root)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace protobuf
+}  // namespace google
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_google_2fprotobuf_2fapi_2eproto__INCLUDED
diff --git a/kortex_api/include/google/protobuf/arena.h b/kortex_api/include/google/protobuf/arena.h
new file mode 100644
index 0000000000000000000000000000000000000000..32be9a1726304eb918a76c7fa7b947075f2a0ad6
--- /dev/null
+++ b/kortex_api/include/google/protobuf/arena.h
@@ -0,0 +1,934 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// This file defines an Arena allocator for better allocation performance.
+
+#ifndef GOOGLE_PROTOBUF_ARENA_H__
+#define GOOGLE_PROTOBUF_ARENA_H__
+
+#include <limits>
+#ifdef max
+#undef max  // Visual Studio defines this macro
+#endif
+#if LANG_CXX11
+#include <google/protobuf/stubs/type_traits.h>
+#endif
+#if defined(_MSC_VER) && !_HAS_EXCEPTIONS
+// Work around bugs in MSVC <typeinfo> header when _HAS_EXCEPTIONS=0.
+#include <exception>
+#include <typeinfo>
+namespace std {
+using type_info = ::type_info;
+}
+#else
+#include <typeinfo>
+#endif
+
+#include <google/protobuf/arena_impl.h>
+#include <google/protobuf/stubs/port.h>
+
+namespace google {
+namespace protobuf {
+
+class Arena;       // defined below
+class Message;     // message.h
+
+namespace internal {
+struct ArenaStringPtr;  // arenastring.h
+class LazyField;   // lazy_field.h
+
+template<typename Type>
+class GenericTypeHandler; // repeated_field.h
+
+// Templated cleanup methods.
+template<typename T> void arena_destruct_object(void* object) {
+  reinterpret_cast<T*>(object)->~T();
+}
+template<typename T> void arena_delete_object(void* object) {
+  delete reinterpret_cast<T*>(object);
+}
+inline void arena_free(void* object, size_t size) {
+#if defined(__GXX_DELETE_WITH_SIZE__) || defined(__cpp_sized_deallocation)
+  ::operator delete(object, size);
+#else
+  (void)size;
+  ::operator delete(object);
+#endif
+}
+
+}  // namespace internal
+
+// ArenaOptions provides optional additional parameters to arena construction
+// that control its block-allocation behavior.
+struct ArenaOptions {
+  // This defines the size of the first block requested from the system malloc.
+  // Subsequent block sizes will increase in a geometric series up to a maximum.
+  size_t start_block_size;
+
+  // This defines the maximum block size requested from system malloc (unless an
+  // individual arena allocation request occurs with a size larger than this
+  // maximum). Requested block sizes increase up to this value, then remain
+  // here.
+  size_t max_block_size;
+
+  // An initial block of memory for the arena to use, or NULL for none. If
+  // provided, the block must live at least as long as the arena itself. The
+  // creator of the Arena retains ownership of the block after the Arena is
+  // destroyed.
+  char* initial_block;
+
+  // The size of the initial block, if provided.
+  size_t initial_block_size;
+
+  // A function pointer to an alloc method that returns memory blocks of size
+  // requested. By default, it contains a ptr to the malloc function.
+  //
+  // NOTE: block_alloc and dealloc functions are expected to behave like
+  // malloc and free, including Asan poisoning.
+  void* (*block_alloc)(size_t);
+  // A function pointer to a dealloc method that takes ownership of the blocks
+  // from the arena. By default, it contains a ptr to a wrapper function that
+  // calls free.
+  void (*block_dealloc)(void*, size_t);
+  // Hooks for adding external functionality such as user-specific metrics
+  // collection, specific debugging abilities, etc.
+  // Init hook may return a pointer to a cookie to be stored in the arena.
+  // reset and destruction hooks will then be called with the same cookie
+  // pointer. This allows us to save an external object per arena instance and
+  // use it on the other hooks (Note: It is just as legal for init to return
+  // NULL and not use the cookie feature).
+  // on_arena_reset and on_arena_destruction also receive the space used in
+  // the arena just before the reset.
+  void* (*on_arena_init)(Arena* arena);
+  void (*on_arena_reset)(Arena* arena, void* cookie, uint64 space_used);
+  void (*on_arena_destruction)(Arena* arena, void* cookie, uint64 space_used);
+
+  // type_info is promised to be static - its lifetime extends to
+  // match program's lifetime (It is given by typeid operator).
+  // Note: typeid(void) will be passed as allocated_type every time we
+  // intentionally want to avoid monitoring an allocation. (i.e. internal
+  // allocations for managing the arena)
+  void (*on_arena_allocation)(const std::type_info* allocated_type,
+      uint64 alloc_size, void* cookie);
+
+  ArenaOptions()
+      : start_block_size(kDefaultStartBlockSize),
+        max_block_size(kDefaultMaxBlockSize),
+        initial_block(NULL),
+        initial_block_size(0),
+        block_alloc(&::operator new),
+        block_dealloc(&internal::arena_free),
+        on_arena_init(NULL),
+        on_arena_reset(NULL),
+        on_arena_destruction(NULL),
+        on_arena_allocation(NULL) {}
+
+ private:
+  // Constants define default starting block size and max block size for
+  // arena allocator behavior -- see descriptions above.
+  static const size_t kDefaultStartBlockSize = 256;
+  static const size_t kDefaultMaxBlockSize   = 8192;
+};
+
+// Support for non-RTTI environments. (The metrics hooks API uses type
+// information.)
+#ifndef GOOGLE_PROTOBUF_NO_RTTI
+#define RTTI_TYPE_ID(type) (&typeid(type))
+#else
+#define RTTI_TYPE_ID(type) (NULL)
+#endif
+
+// Arena allocator. Arena allocation replaces ordinary (heap-based) allocation
+// with new/delete, and improves performance by aggregating allocations into
+// larger blocks and freeing allocations all at once. Protocol messages are
+// allocated on an arena by using Arena::CreateMessage<T>(Arena*), below, and
+// are automatically freed when the arena is destroyed.
+//
+// This is a thread-safe implementation: multiple threads may allocate from the
+// arena concurrently. Destruction is not thread-safe and the destructing
+// thread must synchronize with users of the arena first.
+//
+// An arena provides two allocation interfaces: CreateMessage<T>, which works
+// for arena-enabled proto2 message types as well as other types that satisfy
+// the appropriate protocol (described below), and Create<T>, which works for
+// any arbitrary type T. CreateMessage<T> is better when the type T supports it,
+// because this interface (i) passes the arena pointer to the created object so
+// that its sub-objects and internal allocations can use the arena too, and (ii)
+// elides the object's destructor call when possible. Create<T> does not place
+// any special requirements on the type T, and will invoke the object's
+// destructor when the arena is destroyed.
+//
+// The arena message allocation protocol, required by CreateMessage<T>, is as
+// follows:
+//
+// - The type T must have (at least) two constructors: a constructor with no
+//   arguments, called when a T is allocated on the heap; and a constructor with
+//   a google::protobuf::Arena* argument, called when a T is allocated on an arena. If the
+//   second constructor is called with a NULL arena pointer, it must be
+//   equivalent to invoking the first (no-argument) constructor.
+//
+// - The type T must have a particular type trait: a nested type
+//   |InternalArenaConstructable_|. This is usually a typedef to |void|. If no
+//   such type trait exists, then the instantiation CreateMessage<T> will fail
+//   to compile.
+//
+// - The type T *may* have the type trait |DestructorSkippable_|. If this type
+//   trait is present in the type, then its destructor will not be called if and
+//   only if it was passed a non-NULL arena pointer. If this type trait is not
+//   present on the type, then its destructor is always called when the
+//   containing arena is destroyed.
+//
+// - One- and two-user-argument forms of CreateMessage<T>() also exist that
+//   forward these constructor arguments to T's constructor: for example,
+//   CreateMessage<T>(Arena*, arg1, arg2) forwards to a constructor T(Arena*,
+//   arg1, arg2).
+//
+// This protocol is implemented by all arena-enabled proto2 message classes as
+// well as RepeatedPtrField.
+//
+// Do NOT subclass Arena. This class will be marked as final when C++11 is
+// enabled.
+class LIBPROTOBUF_EXPORT Arena {
+ public:
+  // Arena constructor taking custom options. See ArenaOptions below for
+  // descriptions of the options available.
+  explicit Arena(const ArenaOptions& options) : impl_(options) {
+    Init(options);
+  }
+
+  // Block overhead.  Use this as a guide for how much to over-allocate the
+  // initial block if you want an allocation of size N to fit inside it.
+  //
+  // WARNING: if you allocate multiple objects, it is difficult to guarantee
+  // that a series of allocations will fit in the initial block, especially if
+  // Arena changes its alignment guarantees in the future!
+  static const size_t kBlockOverhead = internal::ArenaImpl::kHeaderSize;
+
+  // Default constructor with sensible default options, tuned for average
+  // use-cases.
+  Arena() : impl_(ArenaOptions()) { Init(ArenaOptions()); }
+
+  ~Arena() {
+    if (on_arena_reset_ != NULL || on_arena_destruction_ != NULL) {
+      CallDestructorHooks();
+    }
+  }
+
+  void Init(const ArenaOptions& options) {
+    on_arena_allocation_ = options.on_arena_allocation;
+    on_arena_reset_ = options.on_arena_reset;
+    on_arena_destruction_ = options.on_arena_destruction;
+    // Call the initialization hook
+    if (options.on_arena_init != NULL) {
+      hooks_cookie_ = options.on_arena_init(this);
+    } else {
+      hooks_cookie_ = NULL;
+    }
+  }
+
+  // API to create proto2 message objects on the arena. If the arena passed in
+  // is NULL, then a heap allocated object is returned. Type T must be a message
+  // defined in a .proto file with cc_enable_arenas set to true, otherwise a
+  // compilation error will occur.
+  //
+  // RepeatedField and RepeatedPtrField may also be instantiated directly on an
+  // arena with this method.
+  //
+  // This function also accepts any type T that satisfies the arena message
+  // allocation protocol, documented above.
+#if LANG_CXX11
+  template <typename T, typename... Args>
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE static T* CreateMessage(
+      ::google::protobuf::Arena* arena, Args&&... args) {
+    static_assert(
+        InternalHelper<T>::is_arena_constructable::value,
+        "CreateMessage can only construct types that are ArenaConstructable");
+    if (arena == NULL) {
+      return new T(NULL, std::forward<Args>(args)...);
+    } else {
+      return arena->CreateMessageInternal<T>(std::forward<Args>(args)...);
+    }
+  }
+#endif
+  template <typename T> GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  static T* CreateMessage(::google::protobuf::Arena* arena) {
+#if LANG_CXX11
+    static_assert(
+        InternalHelper<T>::is_arena_constructable::value,
+        "CreateMessage can only construct types that are ArenaConstructable");
+#endif
+    if (arena == NULL) {
+      return new T;
+    } else {
+      return arena->CreateMessageInternal<T>();
+    }
+  }
+
+  // One-argument form of CreateMessage. This is useful for constructing objects
+  // that implement the arena message construction protocol described above but
+  // take additional constructor arguments.
+  template <typename T, typename Arg> GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  static T* CreateMessage(::google::protobuf::Arena* arena, const Arg& arg) {
+#if LANG_CXX11
+    static_assert(
+        InternalHelper<T>::is_arena_constructable::value,
+        "CreateMessage can only construct types that are ArenaConstructable");
+#endif
+    if (arena == NULL) {
+      return new T(NULL, arg);
+    } else {
+      return arena->CreateMessageInternal<T>(arg);
+    }
+  }
+
+  // Two-argument form of CreateMessage. This is useful for constructing objects
+  // that implement the arena message construction protocol described above but
+  // take additional constructor arguments.
+  template <typename T, typename Arg1, typename Arg2>
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  static T* CreateMessage(::google::protobuf::Arena* arena,
+                          const Arg1& arg1,
+                          const Arg2& arg2) {
+#if LANG_CXX11
+    static_assert(
+        InternalHelper<T>::is_arena_constructable::value,
+        "CreateMessage can only construct types that are ArenaConstructable");
+#endif
+    if (arena == NULL) {
+      return new T(NULL, arg1, arg2);
+    } else {
+      return arena->CreateMessageInternal<T>(arg1, arg2);
+    }
+  }
+
+  // API to create any objects on the arena. Note that only the object will
+  // be created on the arena; the underlying ptrs (in case of a proto2 message)
+  // will be still heap allocated. Proto messages should usually be allocated
+  // with CreateMessage<T>() instead.
+  //
+  // Note that even if T satisfies the arena message construction protocol
+  // (InternalArenaConstructable_ trait and optional DestructorSkippable_
+  // trait), as described above, this function does not follow the protocol;
+  // instead, it treats T as a black-box type, just as if it did not have these
+  // traits. Specifically, T's constructor arguments will always be only those
+  // passed to Create<T>() -- no additional arena pointer is implicitly added.
+  // Furthermore, the destructor will always be called at arena destruction time
+  // (unless the destructor is trivial). Hence, from T's point of view, it is as
+  // if the object were allocated on the heap (except that the underlying memory
+  // is obtained from the arena).
+#if LANG_CXX11
+  template <typename T, typename... Args>
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  static T* Create(::google::protobuf::Arena* arena, Args&&... args) {
+    if (arena == NULL) {
+      return new T(std::forward<Args>(args)...);
+    } else {
+      return arena->CreateInternal<T>(google::protobuf::internal::has_trivial_destructor<T>::value,
+                                      std::forward<Args>(args)...);
+    }
+  }
+#endif
+  template <typename T> GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  static T* Create(::google::protobuf::Arena* arena) {
+    if (arena == NULL) {
+      return new T();
+    } else {
+      return arena->CreateInternal<T>(google::protobuf::internal::has_trivial_destructor<T>::value);
+    }
+  }
+
+  // Version of the above with one constructor argument for the created object.
+  template <typename T, typename Arg> GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  static T* Create(::google::protobuf::Arena* arena, const Arg& arg) {
+    if (arena == NULL) {
+      return new T(arg);
+    } else {
+      return arena->CreateInternal<T>(google::protobuf::internal::has_trivial_destructor<T>::value,
+                                      arg);
+    }
+  }
+
+  // Version of the above with two constructor arguments for the created object.
+  template <typename T, typename Arg1, typename Arg2>
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  static T* Create(::google::protobuf::Arena* arena, const Arg1& arg1, const Arg2& arg2) {
+    if (arena == NULL) {
+      return new T(arg1, arg2);
+    } else {
+      return arena->CreateInternal<T>(google::protobuf::internal::has_trivial_destructor<T>::value,
+                                      arg1, arg2);
+    }
+  }
+
+  // Version of the above with three constructor arguments for the created
+  // object.
+  template <typename T, typename Arg1, typename Arg2, typename Arg3>
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  static T* Create(::google::protobuf::Arena* arena,
+                   const Arg1& arg1,
+                   const Arg2& arg2,
+                   const Arg3& arg3) {
+    if (arena == NULL) {
+      return new T(arg1, arg2, arg3);
+    } else {
+      return arena->CreateInternal<T>(google::protobuf::internal::has_trivial_destructor<T>::value,
+                                      arg1, arg2, arg3);
+    }
+  }
+
+  // Version of the above with four constructor arguments for the created
+  // object.
+  template <typename T, typename Arg1, typename Arg2, typename Arg3,
+            typename Arg4>
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  static T* Create(::google::protobuf::Arena* arena,
+                   const Arg1& arg1, const Arg2& arg2,
+                   const Arg3& arg3, const Arg4& arg4) {
+    if (arena == NULL) {
+      return new T(arg1, arg2, arg3, arg4);
+    } else {
+      return arena->CreateInternal<T>(google::protobuf::internal::has_trivial_destructor<T>::value,
+                                      arg1, arg2, arg3, arg4);
+    }
+  }
+
+  // Version of the above with five constructor arguments for the created
+  // object.
+  template <typename T, typename Arg1, typename Arg2, typename Arg3,
+            typename Arg4, typename Arg5>
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  static T* Create(::google::protobuf::Arena* arena,
+                   const Arg1& arg1, const Arg2& arg2,
+                   const Arg3& arg3, const Arg4& arg4,
+                   const Arg5& arg5) {
+    if (arena == NULL) {
+      return new T(arg1, arg2, arg3, arg4, arg5);
+    } else {
+      return arena->CreateInternal<T>(google::protobuf::internal::has_trivial_destructor<T>::value,
+                                      arg1, arg2, arg3, arg4, arg5);
+    }
+  }
+
+  // Version of the above with six constructor arguments for the created
+  // object.
+  template <typename T, typename Arg1, typename Arg2, typename Arg3,
+            typename Arg4, typename Arg5, typename Arg6>
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  static T* Create(::google::protobuf::Arena* arena,
+                   const Arg1& arg1, const Arg2& arg2,
+                   const Arg3& arg3, const Arg4& arg4,
+                   const Arg5& arg5, const Arg6& arg6) {
+    if (arena == NULL) {
+      return new T(arg1, arg2, arg3, arg4, arg5, arg6);
+    } else {
+      return arena->CreateInternal<T>(google::protobuf::internal::has_trivial_destructor<T>::value,
+                                      arg1, arg2, arg3, arg4, arg5, arg6);
+    }
+  }
+
+  // Version of the above with seven constructor arguments for the created
+  // object.
+  template <typename T, typename Arg1, typename Arg2, typename Arg3,
+            typename Arg4, typename Arg5, typename Arg6, typename Arg7>
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  static T* Create(::google::protobuf::Arena* arena,
+                   const Arg1& arg1, const Arg2& arg2,
+                   const Arg3& arg3, const Arg4& arg4,
+                   const Arg5& arg5, const Arg6& arg6,
+                   const Arg7& arg7) {
+    if (arena == NULL) {
+      return new T(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
+    } else {
+      return arena->CreateInternal<T>(google::protobuf::internal::has_trivial_destructor<T>::value,
+                                      arg1, arg2, arg3, arg4, arg5, arg6, arg7);
+    }
+  }
+
+  // Version of the above with eight constructor arguments for the created
+  // object.
+  template <typename T, typename Arg1, typename Arg2, typename Arg3,
+            typename Arg4, typename Arg5, typename Arg6, typename Arg7,
+            typename Arg8>
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  static T* Create(::google::protobuf::Arena* arena,
+                   const Arg1& arg1, const Arg2& arg2,
+                   const Arg3& arg3, const Arg4& arg4,
+                   const Arg5& arg5, const Arg6& arg6,
+                   const Arg7& arg7, const Arg8& arg8) {
+    if (arena == NULL) {
+      return new T(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
+    } else {
+      return arena->CreateInternal<T>(
+          google::protobuf::internal::has_trivial_destructor<T>::value,
+          arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
+    }
+  }
+
+  // Create an array of object type T on the arena *without* invoking the
+  // constructor of T. If `arena` is null, then the return value should be freed
+  // with `delete[] x;` (or `::operator delete[](x);`).
+  // To ensure safe uses, this function checks at compile time
+  // (when compiled as C++11) that T is trivially default-constructible and
+  // trivially destructible.
+  template <typename T> GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  static T* CreateArray(::google::protobuf::Arena* arena, size_t num_elements) {
+    GOOGLE_CHECK_LE(num_elements,
+             std::numeric_limits<size_t>::max() / sizeof(T))
+        << "Requested size is too large to fit into size_t.";
+    if (arena == NULL) {
+      return static_cast<T*>(::operator new[](num_elements * sizeof(T)));
+    } else {
+      return arena->CreateInternalRawArray<T>(num_elements);
+    }
+  }
+
+  // Returns the total space allocated by the arena, which is the sum of the
+  // sizes of the underlying blocks. This method is relatively fast; a counter
+  // is kept as blocks are allocated.
+  uint64 SpaceAllocated() const { return impl_.SpaceAllocated(); }
+  // Returns the total space used by the arena. Similar to SpaceAllocated but
+  // does not include free space and block overhead. The total space returned
+  // may not include space used by other threads executing concurrently with
+  // the call to this method.
+  uint64 SpaceUsed() const { return impl_.SpaceUsed(); }
+  // DEPRECATED. Please use SpaceAllocated() and SpaceUsed().
+  //
+  // Combines SpaceAllocated and SpaceUsed. Returns a pair of
+  // <space_allocated, space_used>.
+  std::pair<uint64, uint64> SpaceAllocatedAndUsed() const {
+    return std::make_pair(SpaceAllocated(), SpaceUsed());
+  }
+
+  // Frees all storage allocated by this arena after calling destructors
+  // registered with OwnDestructor() and freeing objects registered with Own().
+  // Any objects allocated on this arena are unusable after this call. It also
+  // returns the total space used by the arena which is the sums of the sizes
+  // of the allocated blocks. This method is not thread-safe.
+  GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE uint64 Reset() {
+    // Call the reset hook
+    if (on_arena_reset_ != NULL) {
+      on_arena_reset_(this, hooks_cookie_, impl_.SpaceAllocated());
+    }
+    return impl_.Reset();
+  }
+
+  // Adds |object| to a list of heap-allocated objects to be freed with |delete|
+  // when the arena is destroyed or reset.
+  template <typename T> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE
+  void Own(T* object) {
+    OwnInternal(object, google::protobuf::internal::is_convertible<T*, ::google::protobuf::Message*>());
+  }
+
+  // Adds |object| to a list of objects whose destructors will be manually
+  // called when the arena is destroyed or reset. This differs from Own() in
+  // that it does not free the underlying memory with |delete|; hence, it is
+  // normally only used for objects that are placement-newed into
+  // arena-allocated memory.
+  template <typename T> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE
+  void OwnDestructor(T* object) {
+    if (object != NULL) {
+      impl_.AddCleanup(object, &internal::arena_destruct_object<T>);
+    }
+  }
+
+  // Adds a custom member function on an object to the list of destructors that
+  // will be manually called when the arena is destroyed or reset. This differs
+  // from OwnDestructor() in that any member function may be specified, not only
+  // the class destructor.
+  GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE void OwnCustomDestructor(
+      void* object, void (*destruct)(void*)) {
+    impl_.AddCleanup(object, destruct);
+  }
+
+  // Retrieves the arena associated with |value| if |value| is an arena-capable
+  // message, or NULL otherwise. This differs from value->GetArena() in that the
+  // latter is a virtual call, while this method is a templated call that
+  // resolves at compile-time.
+  template<typename T> GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  static ::google::protobuf::Arena* GetArena(const T* value) {
+    return GetArenaInternal(value, is_arena_constructable<T>());
+  }
+
+  template <typename T>
+  class InternalHelper {
+    template <typename U>
+    static char DestructorSkippable(const typename U::DestructorSkippable_*);
+    template <typename U>
+    static double DestructorSkippable(...);
+
+    typedef google::protobuf::internal::integral_constant<
+        bool, sizeof(DestructorSkippable<T>(static_cast<const T*>(0))) ==
+                      sizeof(char) ||
+                  google::protobuf::internal::has_trivial_destructor<T>::value>
+        is_destructor_skippable;
+
+    template<typename U>
+    static char ArenaConstructable(
+        const typename U::InternalArenaConstructable_*);
+    template<typename U>
+    static double ArenaConstructable(...);
+
+    typedef google::protobuf::internal::integral_constant<bool, sizeof(ArenaConstructable<T>(
+                                              static_cast<const T*>(0))) ==
+                                              sizeof(char)>
+        is_arena_constructable;
+
+#if LANG_CXX11
+    template <typename... Args>
+    static T* Construct(void* ptr, Args&&... args) {
+      return new (ptr) T(std::forward<Args>(args)...);
+    }
+#else
+    template <typename Arg1>
+    static T* Construct(void* ptr, const Arg1& arg1) {
+      return new (ptr) T(arg1);
+    }
+    template <typename Arg1, typename Arg2>
+    static T* Construct(void* ptr, const Arg1& arg1, const Arg2& arg2) {
+      return new (ptr) T(arg1, arg2);
+    }
+    template <typename Arg1, typename Arg2, typename Arg3>
+    static T* Construct(void* ptr, const Arg1& arg1,
+                        const Arg2& arg2, const Arg3& arg3) {
+      return new (ptr) T(arg1, arg2, arg3);
+    }
+#endif  // LANG_CXX11
+
+    static Arena* GetArena(const T* p) { return p->GetArenaNoVirtual(); }
+
+    friend class Arena;
+  };
+
+  // Helper typetrait that indicates support for arenas in a type T at compile
+  // time. This is public only to allow construction of higher-level templated
+  // utilities. is_arena_constructable<T>::value is true if the message type T
+  // has arena support enabled, and false otherwise.
+  //
+  // This is inside Arena because only Arena has the friend relationships
+  // necessary to see the underlying generated code traits.
+  template <typename T>
+  struct is_arena_constructable : InternalHelper<T>::is_arena_constructable {};
+
+ private:
+  void CallDestructorHooks();
+  void OnArenaAllocation(const std::type_info* allocated_type, size_t n) const;
+  inline void AllocHook(const std::type_info* allocated_type, size_t n) const {
+    if (GOOGLE_PREDICT_FALSE(hooks_cookie_ != NULL)) {
+      OnArenaAllocation(allocated_type, n);
+    }
+  }
+
+  // Allocate and also optionally call on_arena_allocation callback with the
+  // allocated type info when the hooks are in place in ArenaOptions and
+  // the cookie is not null.
+  template<typename T> GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  void* AllocateInternal(bool skip_explicit_ownership) {
+    const size_t n = internal::AlignUpTo8(sizeof(T));
+    AllocHook(RTTI_TYPE_ID(T), n);
+    // Monitor allocation if needed.
+    if (skip_explicit_ownership) {
+      return impl_.AllocateAligned(n);
+    } else {
+      return impl_.AllocateAlignedAndAddCleanup(
+          n, &internal::arena_destruct_object<T>);
+    }
+  }
+
+  // CreateMessage<T> requires that T supports arenas, but this private method
+  // works whether or not T supports arenas. These are not exposed to user code
+  // as it can cause confusing API usages, and end up having double free in
+  // user code. These are used only internally from LazyField and Repeated
+  // fields, since they are designed to work in all mode combinations.
+  template <typename Msg> GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  static Msg* CreateMaybeMessage(Arena* arena, google::protobuf::internal::true_type) {
+    return CreateMessage<Msg>(arena);
+  }
+
+  template <typename T> GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  static T* CreateMaybeMessage(Arena* arena, google::protobuf::internal::false_type) {
+    return Create<T>(arena);
+  }
+
+  template <typename T> GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  static T* CreateMaybeMessage(Arena* arena) {
+    return CreateMaybeMessage<T>(arena, is_arena_constructable<T>());
+  }
+
+  // Just allocate the required size for the given type assuming the
+  // type has a trivial constructor.
+  template<typename T> GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  T* CreateInternalRawArray(size_t num_elements) {
+    GOOGLE_CHECK_LE(num_elements,
+             std::numeric_limits<size_t>::max() / sizeof(T))
+        << "Requested size is too large to fit into size_t.";
+    const size_t n = internal::AlignUpTo8(sizeof(T) * num_elements);
+    // Monitor allocation if needed.
+    AllocHook(RTTI_TYPE_ID(T), n);
+    return static_cast<T*>(impl_.AllocateAligned(n));
+  }
+
+#if LANG_CXX11
+  template <typename T, typename... Args>
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  T* CreateInternal(bool skip_explicit_ownership, Args&&... args) {
+    return new (AllocateInternal<T>(skip_explicit_ownership))
+        T(std::forward<Args>(args)...);
+  }
+#else
+  template <typename T> GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  T* CreateInternal(bool skip_explicit_ownership) {
+    return new (AllocateInternal<T>(skip_explicit_ownership)) T();
+  }
+
+  template <typename T, typename Arg> GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  T* CreateInternal(bool skip_explicit_ownership, const Arg& arg) {
+    return new (AllocateInternal<T>(skip_explicit_ownership)) T(arg);
+  }
+
+  template <typename T, typename Arg1, typename Arg2>
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  T* CreateInternal(bool skip_explicit_ownership,
+                    const Arg1& arg1,
+                    const Arg2& arg2) {
+    return new (AllocateInternal<T>(skip_explicit_ownership)) T(arg1, arg2);
+  }
+
+  template <typename T, typename Arg1, typename Arg2, typename Arg3>
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  T* CreateInternal(bool skip_explicit_ownership,
+                    const Arg1& arg1,
+                    const Arg2& arg2,
+                    const Arg3& arg3) {
+    return new (AllocateInternal<T>(skip_explicit_ownership))
+        T(arg1, arg2, arg3);
+  }
+
+  template <typename T, typename Arg1, typename Arg2, typename Arg3,
+            typename Arg4>
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  T* CreateInternal(bool skip_explicit_ownership,
+                    const Arg1& arg1,
+                    const Arg2& arg2,
+                    const Arg3& arg3,
+                    const Arg4& arg4) {
+    return new (AllocateInternal<T>(skip_explicit_ownership))
+        T(arg1, arg2, arg3, arg4);
+  }
+
+  template <typename T, typename Arg1, typename Arg2, typename Arg3,
+            typename Arg4, typename Arg5>
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  T* CreateInternal(bool skip_explicit_ownership,
+                    const Arg1& arg1,
+                    const Arg2& arg2,
+                    const Arg3& arg3,
+                    const Arg4& arg4,
+                    const Arg5& arg5) {
+    return new (AllocateInternal<T>(skip_explicit_ownership))
+        T(arg1, arg2, arg3, arg4, arg5);
+  }
+
+  template <typename T, typename Arg1, typename Arg2, typename Arg3,
+            typename Arg4, typename Arg5, typename Arg6>
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  T* CreateInternal(bool skip_explicit_ownership,
+                    const Arg1& arg1,
+                    const Arg2& arg2,
+                    const Arg3& arg3,
+                    const Arg4& arg4,
+                    const Arg5& arg5,
+                    const Arg6& arg6) {
+    return new (AllocateInternal<T>(skip_explicit_ownership))
+        T(arg1, arg2, arg3, arg4, arg5, arg6);
+  }
+
+  template <typename T, typename Arg1, typename Arg2, typename Arg3,
+            typename Arg4, typename Arg5, typename Arg6, typename Arg7>
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  T* CreateInternal(bool skip_explicit_ownership,
+                    const Arg1& arg1,
+                    const Arg2& arg2,
+                    const Arg3& arg3,
+                    const Arg4& arg4,
+                    const Arg5& arg5,
+                    const Arg6& arg6,
+                    const Arg7& arg7) {
+    return new (AllocateInternal<T>(skip_explicit_ownership))
+        T(arg1, arg2, arg3, arg4, arg5, arg6, arg7);
+  }
+
+  template <typename T, typename Arg1, typename Arg2, typename Arg3,
+            typename Arg4, typename Arg5, typename Arg6, typename Arg7,
+            typename Arg8>
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  T* CreateInternal(bool skip_explicit_ownership,
+                    const Arg1& arg1,
+                    const Arg2& arg2,
+                    const Arg3& arg3,
+                    const Arg4& arg4,
+                    const Arg5& arg5,
+                    const Arg6& arg6,
+                    const Arg7& arg7,
+                    const Arg8& arg8) {
+    return new (AllocateInternal<T>(skip_explicit_ownership))
+        T(arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
+  }
+#endif
+#if LANG_CXX11
+  template <typename T, typename... Args>
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE T* CreateMessageInternal(
+      Args&&... args) {
+    return InternalHelper<T>::Construct(
+        AllocateInternal<T>(InternalHelper<T>::is_destructor_skippable::value),
+        this, std::forward<Args>(args)...);
+  }
+#endif
+  template <typename T>
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE T* CreateMessageInternal() {
+    return InternalHelper<T>::Construct(
+        AllocateInternal<T>(InternalHelper<T>::is_destructor_skippable::value),
+        this);
+  }
+
+  template <typename T, typename Arg> GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  T* CreateMessageInternal(const Arg& arg) {
+    return InternalHelper<T>::Construct(
+        AllocateInternal<T>(InternalHelper<T>::is_destructor_skippable::value),
+        this, arg);
+  }
+
+  template <typename T, typename Arg1, typename Arg2>
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  T* CreateMessageInternal(const Arg1& arg1, const Arg2& arg2) {
+    return InternalHelper<T>::Construct(
+        AllocateInternal<T>(InternalHelper<T>::is_destructor_skippable::value),
+        this, arg1, arg2);
+  }
+
+  // CreateInArenaStorage is used to implement map field. Without it,
+  // google::protobuf::Map need to call generated message's protected arena constructor,
+  // which needs to declare google::protobuf::Map as friend of generated message.
+  template <typename T>
+  static void CreateInArenaStorage(T* ptr, Arena* arena) {
+    CreateInArenaStorageInternal(ptr, arena,
+                                 typename is_arena_constructable<T>::type());
+    RegisterDestructorInternal(
+        ptr, arena,
+        typename InternalHelper<T>::is_destructor_skippable::type());
+  }
+
+  template <typename T>
+  static void CreateInArenaStorageInternal(
+      T* ptr, Arena* arena, google::protobuf::internal::true_type) {
+    InternalHelper<T>::Construct(ptr, arena);
+  }
+  template <typename T>
+  static void CreateInArenaStorageInternal(
+      T* ptr, Arena* /* arena */, google::protobuf::internal::false_type) {
+    new (ptr) T();
+  }
+
+  template <typename T>
+  static void RegisterDestructorInternal(
+      T* /* ptr */, Arena* /* arena */, google::protobuf::internal::true_type) {}
+  template <typename T>
+  static void RegisterDestructorInternal(
+      T* ptr, Arena* arena, google::protobuf::internal::false_type) {
+    arena->OwnDestructor(ptr);
+  }
+
+  // These implement Own(), which registers an object for deletion (destructor
+  // call and operator delete()). The second parameter has type 'true_type' if T
+  // is a subtype of ::google::protobuf::Message and 'false_type' otherwise. Collapsing
+  // all template instantiations to one for generic Message reduces code size,
+  // using the virtual destructor instead.
+  template<typename T> GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  void OwnInternal(T* object, google::protobuf::internal::true_type) {
+    if (object != NULL) {
+      impl_.AddCleanup(object,
+                       &internal::arena_delete_object< ::google::protobuf::Message>);
+    }
+  }
+  template<typename T> GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  void OwnInternal(T* object, google::protobuf::internal::false_type) {
+    if (object != NULL) {
+      impl_.AddCleanup(object, &internal::arena_delete_object<T>);
+    }
+  }
+
+  // Implementation for GetArena(). Only message objects with
+  // InternalArenaConstructable_ tags can be associated with an arena, and such
+  // objects must implement a GetArenaNoVirtual() method.
+  template <typename T> GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  static ::google::protobuf::Arena* GetArenaInternal(
+      const T* value, google::protobuf::internal::true_type) {
+    return InternalHelper<T>::GetArena(value);
+  }
+
+  template <typename T>
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  static ::google::protobuf::Arena* GetArenaInternal(
+      const T* /* value */, google::protobuf::internal::false_type) {
+    return NULL;
+  }
+
+  // For friends of arena.
+  void* AllocateAligned(size_t n) {
+    AllocHook(NULL, n);
+    return impl_.AllocateAligned(internal::AlignUpTo8(n));
+  }
+
+  internal::ArenaImpl impl_;
+
+  void* (*on_arena_init_)(Arena* arena);
+  void (*on_arena_allocation_)(const std::type_info* allocated_type,
+                               uint64 alloc_size, void* cookie);
+  void (*on_arena_reset_)(Arena* arena, void* cookie, uint64 space_used);
+  void (*on_arena_destruction_)(Arena* arena, void* cookie, uint64 space_used);
+
+  // The arena may save a cookie it receives from the external on_init hook
+  // and then use it when calling the on_reset and on_destruction hooks.
+  void* hooks_cookie_;
+
+  template <typename Type>
+  friend class ::google::protobuf::internal::GenericTypeHandler;
+  friend struct internal::ArenaStringPtr;  // For AllocateAligned.
+  friend class internal::LazyField;    // For CreateMaybeMessage.
+  template <typename Key, typename T>
+  friend class Map;
+};
+
+// Defined above for supporting environments without RTTI.
+#undef RTTI_TYPE_ID
+
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_ARENA_H__
diff --git a/kortex_api/include/google/protobuf/arena_impl.h b/kortex_api/include/google/protobuf/arena_impl.h
new file mode 100644
index 0000000000000000000000000000000000000000..6cc7096bfbe0d5b6c79c1e23048077b65843508c
--- /dev/null
+++ b/kortex_api/include/google/protobuf/arena_impl.h
@@ -0,0 +1,242 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// This file defines an Arena allocator for better allocation performance.
+
+#ifndef GOOGLE_PROTOBUF_ARENA_IMPL_H__
+#define GOOGLE_PROTOBUF_ARENA_IMPL_H__
+
+#include <limits>
+
+#include <google/protobuf/stubs/atomic_sequence_num.h>
+#include <google/protobuf/stubs/atomicops.h>
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/logging.h>
+#include <google/protobuf/stubs/mutex.h>
+#include <google/protobuf/stubs/type_traits.h>
+
+#include <google/protobuf/stubs/port.h>
+
+namespace google {
+
+namespace protobuf {
+namespace internal {
+
+inline size_t AlignUpTo8(size_t n) {
+  // Align n to next multiple of 8 (from Hacker's Delight, Chapter 3.)
+  return (n + 7) & -8;
+}
+
+// This class provides the core Arena memory allocation library. Different
+// implementations only need to implement the public interface below.
+// Arena is not a template type as that would only be useful if all protos
+// in turn would be templates, which will/cannot happen. However separating
+// the memory allocation part from the cruft of the API users expect we can
+// use #ifdef the select the best implementation based on hardware / OS.
+class LIBPROTOBUF_EXPORT ArenaImpl {
+ public:
+  struct Options {
+    size_t start_block_size;
+    size_t max_block_size;
+    char* initial_block;
+    size_t initial_block_size;
+    void* (*block_alloc)(size_t);
+    void (*block_dealloc)(void*, size_t);
+
+    template <typename O>
+    explicit Options(const O& options)
+      : start_block_size(options.start_block_size),
+        max_block_size(options.max_block_size),
+        initial_block(options.initial_block),
+        initial_block_size(options.initial_block_size),
+        block_alloc(options.block_alloc),
+        block_dealloc(options.block_dealloc) {}
+  };
+
+  template <typename O>
+  explicit ArenaImpl(const O& options) : options_(options) {
+    if (options_.initial_block != NULL && options_.initial_block_size > 0) {
+      GOOGLE_CHECK_GE(options_.initial_block_size, sizeof(Block))
+          << ": Initial block size too small for header.";
+      initial_block_ = reinterpret_cast<Block*>(options_.initial_block);
+    } else {
+      initial_block_ = NULL;
+    }
+
+    Init();
+  }
+
+  // Destructor deletes all owned heap allocated objects, and destructs objects
+  // that have non-trivial destructors, except for proto2 message objects whose
+  // destructors can be skipped. Also, frees all blocks except the initial block
+  // if it was passed in.
+  ~ArenaImpl();
+
+  uint64 Reset();
+
+  uint64 SpaceAllocated() const;
+  uint64 SpaceUsed() const;
+
+  void* AllocateAligned(size_t n);
+
+  void* AllocateAlignedAndAddCleanup(size_t n, void (*cleanup)(void*));
+
+  // Add object pointer and cleanup function pointer to the list.
+  void AddCleanup(void* elem, void (*cleanup)(void*));
+
+ private:
+  // Node contains the ptr of the object to be cleaned up and the associated
+  // cleanup function ptr.
+  struct CleanupNode {
+    void* elem;              // Pointer to the object to be cleaned up.
+    void (*cleanup)(void*);  // Function pointer to the destructor or deleter.
+  };
+
+  // Cleanup uses a chunked linked list, to reduce pointer chasing.
+  struct CleanupChunk {
+    static size_t SizeOf(size_t i) {
+      return sizeof(CleanupChunk) + (sizeof(CleanupNode) * (i - 1));
+    }
+    size_t len;            // Number of elements currently present.
+    size_t size;           // Total elements in the list.
+    CleanupChunk* next;    // Next node in the list.
+    CleanupNode nodes[1];  // True length is |size|.
+  };
+
+  struct Block;
+
+  // Tracks per-thread info.  ThreadInfos are kept in a linked list.
+  struct ThreadInfo {
+    void *owner;             // &ThreadCache of this thread;
+    Block* head;             // Head of linked list of blocks.
+    CleanupChunk* cleanup;   // Head of cleanup list.
+    ThreadInfo* next;        // Next ThreadInfo in this linked list.
+  };
+
+  // Blocks are variable length malloc-ed objects.  The following structure
+  // describes the common header for all blocks.
+  struct Block {
+    void* owner;              // &ThreadCache of thread that owns this block.
+    ThreadInfo* thread_info;  // ThreadInfo of thread that owns this block.
+    Block* next;              // Next block in arena (may have different owner)
+    // ((char*) &block) + pos is next available byte. It is always
+    // aligned at a multiple of 8 bytes.
+    size_t pos;
+    size_t size;  // total size of the block.
+    GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+    size_t avail() const { return size - pos; }
+    // data follows
+  };
+
+  struct ThreadCache {
+#if defined(GOOGLE_PROTOBUF_NO_THREADLOCAL)
+    // If we are using the ThreadLocalStorage class to store the ThreadCache,
+    // then the ThreadCache's default constructor has to be responsible for
+    // initializing it.
+    ThreadCache() : last_lifecycle_id_seen(-1), last_block_used_(NULL) {}
+#endif
+
+    // The ThreadCache is considered valid as long as this matches the
+    // lifecycle_id of the arena being used.
+    int64 last_lifecycle_id_seen;
+    Block* last_block_used_;
+  };
+  static google::protobuf::internal::SequenceNumber lifecycle_id_generator_;
+#if defined(GOOGLE_PROTOBUF_NO_THREADLOCAL)
+  // Android ndk does not support GOOGLE_THREAD_LOCAL keyword so we use a custom thread
+  // local storage class we implemented.
+  // iOS also does not support the GOOGLE_THREAD_LOCAL keyword.
+  static ThreadCache& thread_cache();
+#elif defined(PROTOBUF_USE_DLLS)
+  // Thread local variables cannot be exposed through DLL interface but we can
+  // wrap them in static functions.
+  static ThreadCache& thread_cache();
+#else
+  static GOOGLE_THREAD_LOCAL ThreadCache thread_cache_;
+  static ThreadCache& thread_cache() { return thread_cache_; }
+#endif
+
+  void Init();
+
+  // Free all blocks and return the total space used which is the sums of sizes
+  // of the all the allocated blocks.
+  uint64 FreeBlocks();
+
+  void AddCleanupInBlock(Block* b, void* elem, void (*func)(void*));
+  CleanupChunk* ExpandCleanupList(CleanupChunk* cleanup, Block* b);
+  // Delete or Destruct all objects owned by the arena.
+  void CleanupList();
+
+  inline void CacheBlock(Block* block) {
+    thread_cache().last_block_used_ = block;
+    thread_cache().last_lifecycle_id_seen = lifecycle_id_;
+    // TODO(haberman): evaluate whether we would gain efficiency by getting rid
+    // of hint_.  It's the only write we do to ArenaImpl in the allocation path,
+    // which will dirty the cache line.
+    google::protobuf::internal::Release_Store(&hint_, reinterpret_cast<google::protobuf::internal::AtomicWord>(block));
+  }
+
+  google::protobuf::internal::AtomicWord threads_;          // Pointer to a linked list of ThreadInfo.
+  google::protobuf::internal::AtomicWord hint_;             // Fast thread-local block access
+  google::protobuf::internal::AtomicWord space_allocated_;  // Sum of sizes of all allocated blocks.
+
+  Block *initial_block_;     // If non-NULL, points to the block that came from
+                             // user data.
+
+  // Returns a block owned by this thread.
+  Block* GetBlock(size_t n);
+  Block* GetBlockSlow(void* me, Block* my_full_block, size_t n);
+  Block* NewBlock(void* me, Block* my_last_block, size_t min_bytes);
+  void InitBlock(Block* b, void *me, size_t size);
+  static void* AllocFromBlock(Block* b, size_t n);
+  ThreadInfo* NewThreadInfo(Block* b);
+  ThreadInfo* FindThreadInfo(void* me);
+  ThreadInfo* GetThreadInfo(void* me, size_t n);
+
+  int64 lifecycle_id_;  // Unique for each arena. Changes on Reset().
+
+  Options options_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ArenaImpl);
+
+ public:
+  // kHeaderSize is sizeof(Block), aligned up to the nearest multiple of 8 to
+  // protect the invariant that pos is always at a multiple of 8.
+  static const size_t kHeaderSize = (sizeof(Block) + 7) & -8;
+#if LANG_CXX11
+  static_assert(kHeaderSize % 8 == 0, "kHeaderSize must be a multiple of 8.");
+#endif
+};
+
+}  // namespace internal
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_ARENA_IMPL_H__
diff --git a/kortex_api/include/google/protobuf/arenastring.h b/kortex_api/include/google/protobuf/arenastring.h
new file mode 100644
index 0000000000000000000000000000000000000000..c9d045a1592d5e8def54c307ba717e650d46885d
--- /dev/null
+++ b/kortex_api/include/google/protobuf/arenastring.h
@@ -0,0 +1,338 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_ARENASTRING_H__
+#define GOOGLE_PROTOBUF_ARENASTRING_H__
+
+#include <string>
+
+#include <google/protobuf/arena.h>
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/fastmem.h>
+#include <google/protobuf/stubs/logging.h>
+#include <google/protobuf/stubs/port.h>
+
+// This is the implementation of arena string fields written for the open-source
+// release. The ArenaStringPtr struct below is an internal implementation class
+// and *should not be used* by user code. It is used to collect string
+// operations together into one place and abstract away the underlying
+// string-field pointer representation, so that (for example) an alternate
+// implementation that knew more about ::std::string's internals could integrate more
+// closely with the arena allocator.
+
+namespace google {
+namespace protobuf {
+namespace internal {
+
+struct LIBPROTOBUF_EXPORT ArenaStringPtr {
+  inline void Set(const ::std::string* default_value,
+                  const ::std::string& value, ::google::protobuf::Arena* arena) {
+    if (ptr_ == default_value) {
+      CreateInstance(arena, &value);
+    } else {
+      *ptr_ = value;
+    }
+  }
+
+  inline void SetLite(const ::std::string* default_value,
+                      const ::std::string& value,
+                      ::google::protobuf::Arena* arena) {
+    Set(default_value, value, arena);
+  }
+
+  // Basic accessors.
+  inline const ::std::string& Get() const { return *ptr_; }
+
+  inline ::std::string* Mutable(const ::std::string* default_value,
+                           ::google::protobuf::Arena* arena) {
+    if (ptr_ == default_value) {
+      CreateInstance(arena, default_value);
+    }
+    return ptr_;
+  }
+
+  // Release returns a ::std::string* instance that is heap-allocated and is not
+  // Own()'d by any arena. If the field was not set, it returns NULL. The caller
+  // retains ownership. Clears this field back to NULL state. Used to implement
+  // release_<field>() methods on generated classes.
+  inline ::std::string* Release(const ::std::string* default_value,
+                           ::google::protobuf::Arena* arena) {
+    if (ptr_ == default_value) {
+      return NULL;
+    }
+    ::std::string* released = NULL;
+    if (arena != NULL) {
+      // ptr_ is owned by the arena.
+      released = new ::std::string;
+      released->swap(*ptr_);
+    } else {
+      released = ptr_;
+    }
+    ptr_ = const_cast< ::std::string* >(default_value);
+    return released;
+  }
+
+  // UnsafeArenaRelease returns a ::std::string*, but it may be arena-owned (i.e.
+  // have its destructor already registered) if arena != NULL. If the field was
+  // not set, this returns NULL. This method clears this field back to NULL
+  // state. Used to implement unsafe_arena_release_<field>() methods on
+  // generated classes.
+  inline ::std::string* UnsafeArenaRelease(const ::std::string* default_value,
+                                      ::google::protobuf::Arena* /* arena */) {
+    if (ptr_ == default_value) {
+      return NULL;
+    }
+    ::std::string* released = ptr_;
+    ptr_ = const_cast< ::std::string* >(default_value);
+    return released;
+  }
+
+  // Takes a string that is heap-allocated, and takes ownership. The string's
+  // destructor is registered with the arena. Used to implement
+  // set_allocated_<field> in generated classes.
+  inline void SetAllocated(const ::std::string* default_value,
+                           ::std::string* value, ::google::protobuf::Arena* arena) {
+    if (arena == NULL && ptr_ != default_value) {
+      Destroy(default_value, arena);
+    }
+    if (value != NULL) {
+      ptr_ = value;
+      if (arena != NULL) {
+        arena->Own(value);
+      }
+    } else {
+      ptr_ = const_cast< ::std::string* >(default_value);
+    }
+  }
+
+  // Takes a string that has lifetime equal to the arena's lifetime. The arena
+  // must be non-null. It is safe only to pass this method a value returned by
+  // UnsafeArenaRelease() on another field of a message in the same arena. Used
+  // to implement unsafe_arena_set_allocated_<field> in generated classes.
+  inline void UnsafeArenaSetAllocated(const ::std::string* default_value,
+                                      ::std::string* value,
+                                      ::google::protobuf::Arena* /* arena */) {
+    if (value != NULL) {
+      ptr_ = value;
+    } else {
+      ptr_ = const_cast< ::std::string* >(default_value);
+    }
+  }
+
+  // Swaps internal pointers. Arena-safety semantics: this is guarded by the
+  // logic in Swap()/UnsafeArenaSwap() at the message level, so this method is
+  // 'unsafe' if called directly.
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE void Swap(ArenaStringPtr* other) {
+    std::swap(ptr_, other->ptr_);
+  }
+
+  // Frees storage (if not on an arena).
+  inline void Destroy(const ::std::string* default_value,
+                      ::google::protobuf::Arena* arena) {
+    if (arena == NULL && ptr_ != default_value) {
+      delete ptr_;
+    }
+  }
+
+  // Clears content, but keeps allocated string if arena != NULL, to avoid the
+  // overhead of heap operations. After this returns, the content (as seen by
+  // the user) will always be the empty string. Assumes that |default_value|
+  // is an empty string.
+  inline void ClearToEmpty(const ::std::string* default_value,
+                           ::google::protobuf::Arena* /* arena */) {
+    if (ptr_ == default_value) {
+      // Already set to default (which is empty) -- do nothing.
+    } else {
+      ptr_->clear();
+    }
+  }
+
+  // Clears content, but keeps allocated string if arena != NULL, to avoid the
+  // overhead of heap operations. After this returns, the content (as seen by
+  // the user) will always be equal to |default_value|.
+  inline void ClearToDefault(const ::std::string* default_value,
+                             ::google::protobuf::Arena* /* arena */) {
+    if (ptr_ == default_value) {
+      // Already set to default -- do nothing.
+    } else {
+      // Have another allocated string -- rather than throwing this away and
+      // resetting ptr_ to the canonical default string instance, we just reuse
+      // this instance.
+      *ptr_ = *default_value;
+    }
+  }
+
+  // Called from generated code / reflection runtime only. Resets value to point
+  // to a default string pointer, with the semantics that this ArenaStringPtr
+  // does not own the pointed-to memory. Disregards initial value of ptr_ (so
+  // this is the *ONLY* safe method to call after construction or when
+  // reinitializing after becoming the active field in a oneof union).
+  inline void UnsafeSetDefault(const ::std::string* default_value) {
+    // Casting away 'const' is safe here: accessors ensure that ptr_ is only
+    // returned as a const if it is equal to default_value.
+    ptr_ = const_cast< ::std::string* >(default_value);
+  }
+
+  // The 'NoArena' variants of methods below assume arena == NULL and are
+  // optimized to provide very little overhead relative to a raw string pointer
+  // (while still being in-memory compatible with other code that assumes
+  // ArenaStringPtr). Note the invariant that a class instance that has only
+  // ever been mutated by NoArena methods must *only* be in the String state
+  // (i.e., tag bits are not used), *NEVER* ArenaString. This allows all
+  // tagged-pointer manipulations to be avoided.
+  inline void SetNoArena(const ::std::string* default_value,
+                         const ::std::string& value) {
+    if (ptr_ == default_value) {
+      CreateInstanceNoArena(&value);
+    } else {
+      *ptr_ = value;
+    }
+  }
+
+#if LANG_CXX11
+  void SetNoArena(const ::std::string* default_value, ::std::string&& value) {
+    if (IsDefault(default_value)) {
+      ptr_ = new ::std::string(std::move(value));
+    } else {
+      *ptr_ = std::move(value);
+    }
+  }
+#endif
+
+  void AssignWithDefault(const ::std::string* default_value, ArenaStringPtr value);
+
+  inline const ::std::string& GetNoArena() const { return *ptr_; }
+
+  inline ::std::string* MutableNoArena(const ::std::string* default_value) {
+    if (ptr_ == default_value) {
+      CreateInstanceNoArena(default_value);
+    }
+    return ptr_;
+  }
+
+  inline ::std::string* ReleaseNoArena(const ::std::string* default_value) {
+    if (ptr_ == default_value) {
+      return NULL;
+    } else {
+      ::std::string* released = ptr_;
+      ptr_ = const_cast< ::std::string* >(default_value);
+      return released;
+    }
+  }
+
+  inline void SetAllocatedNoArena(const ::std::string* default_value,
+                                  ::std::string* value) {
+    if (ptr_ != default_value) {
+      delete ptr_;
+    }
+    if (value != NULL) {
+      ptr_ = value;
+    } else {
+      ptr_ = const_cast< ::std::string* >(default_value);
+    }
+  }
+
+  inline void DestroyNoArena(const ::std::string* default_value) {
+    if (ptr_ != default_value) {
+      delete ptr_;
+    }
+  }
+
+  inline void ClearToEmptyNoArena(const ::std::string* default_value) {
+    if (ptr_ == default_value) {
+      // Nothing: already equal to default (which is the empty string).
+    } else {
+      ptr_->clear();
+    }
+  }
+
+  inline void ClearToDefaultNoArena(const ::std::string* default_value) {
+    if (ptr_ == default_value) {
+      // Nothing: already set to default.
+    } else {
+      // Reuse existing allocated instance.
+      *ptr_ = *default_value;
+    }
+  }
+
+  // Internal accessor used only at parse time to provide direct access to the
+  // raw pointer from the shared parse routine (in the non-arenas case). The
+  // parse routine does the string allocation in order to save code size in the
+  // generated parsing code.
+  inline ::std::string** UnsafeRawStringPointer() {
+    return &ptr_;
+  }
+
+  inline bool IsDefault(const ::std::string* default_value) const {
+    return ptr_ == default_value;
+  }
+
+ private:
+  ::std::string* ptr_;
+
+  GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE
+  void CreateInstance(::google::protobuf::Arena* arena,
+                      const ::std::string* initial_value) {
+    GOOGLE_DCHECK(initial_value != NULL);
+    ptr_ = new ::std::string(*initial_value);
+    if (arena != NULL) {
+      arena->Own(ptr_);
+    }
+  }
+  GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE
+  void CreateInstanceNoArena(const ::std::string* initial_value) {
+    GOOGLE_DCHECK(initial_value != NULL);
+    ptr_ = new ::std::string(*initial_value);
+  }
+};
+
+}  // namespace internal
+}  // namespace protobuf
+
+
+
+namespace protobuf {
+namespace internal {
+
+inline void ArenaStringPtr::AssignWithDefault(const ::std::string* default_value,
+                                       ArenaStringPtr value) {
+  const ::std::string* me = *UnsafeRawStringPointer();
+  const ::std::string* other = *value.UnsafeRawStringPointer();
+  // If the pointers are the same then do nothing.
+  if (me != other) {
+    SetNoArena(default_value, value.GetNoArena());
+  }
+}
+
+}  // namespace internal
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_ARENASTRING_H__
diff --git a/kortex_api/include/google/protobuf/compiler/code_generator.h b/kortex_api/include/google/protobuf/compiler/code_generator.h
new file mode 100644
index 0000000000000000000000000000000000000000..4b1d90b82548e54932e7118e4861e28e56dcaa95
--- /dev/null
+++ b/kortex_api/include/google/protobuf/compiler/code_generator.h
@@ -0,0 +1,176 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// Defines the abstract interface implemented by each of the language-specific
+// code generators.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_CODE_GENERATOR_H__
+#define GOOGLE_PROTOBUF_COMPILER_CODE_GENERATOR_H__
+
+#include <google/protobuf/stubs/common.h>
+#include <string>
+#include <vector>
+#include <utility>
+
+namespace google {
+namespace protobuf {
+
+namespace io { class ZeroCopyOutputStream; }
+class FileDescriptor;
+
+namespace compiler {
+class AccessInfoMap;
+
+class Version;
+
+// Defined in this file.
+class CodeGenerator;
+class GeneratorContext;
+
+// The abstract interface to a class which generates code implementing a
+// particular proto file in a particular language.  A number of these may
+// be registered with CommandLineInterface to support various languages.
+class LIBPROTOC_EXPORT CodeGenerator {
+ public:
+  inline CodeGenerator() {}
+  virtual ~CodeGenerator();
+
+  // Generates code for the given proto file, generating one or more files in
+  // the given output directory.
+  //
+  // A parameter to be passed to the generator can be specified on the command
+  // line. This is intended to be used to pass generator specific parameters.
+  // It is empty if no parameter was given. ParseGeneratorParameter (below),
+  // can be used to accept multiple parameters within the single parameter
+  // command line flag.
+  //
+  // Returns true if successful.  Otherwise, sets *error to a description of
+  // the problem (e.g. "invalid parameter") and returns false.
+  virtual bool Generate(const FileDescriptor* file,
+                        const string& parameter,
+                        GeneratorContext* generator_context,
+                        string* error) const = 0;
+
+  // Generates code for all given proto files.
+  //
+  // WARNING: The canonical code generator design produces one or two output
+  // files per input .proto file, and we do not wish to encourage alternate
+  // designs.
+  //
+  // A parameter is given as passed on the command line, as in |Generate()|
+  // above.
+  //
+  // Returns true if successful.  Otherwise, sets *error to a description of
+  // the problem (e.g. "invalid parameter") and returns false.
+  virtual bool GenerateAll(const std::vector<const FileDescriptor*>& files,
+                           const string& parameter,
+                           GeneratorContext* generator_context,
+                           string* error) const;
+
+  // This is no longer used, but this class is part of the opensource protobuf
+  // library, so it has to remain to keep vtables the same for the current
+  // version of the library. When protobufs does a api breaking change, the
+  // method can be removed.
+  virtual bool HasGenerateAll() const { return true; }
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CodeGenerator);
+};
+
+// CodeGenerators generate one or more files in a given directory.  This
+// abstract interface represents the directory to which the CodeGenerator is
+// to write and other information about the context in which the Generator
+// runs.
+class LIBPROTOC_EXPORT GeneratorContext {
+ public:
+  inline GeneratorContext() {
+  }
+  virtual ~GeneratorContext();
+
+  // Opens the given file, truncating it if it exists, and returns a
+  // ZeroCopyOutputStream that writes to the file.  The caller takes ownership
+  // of the returned object.  This method never fails (a dummy stream will be
+  // returned instead).
+  //
+  // The filename given should be relative to the root of the source tree.
+  // E.g. the C++ generator, when generating code for "foo/bar.proto", will
+  // generate the files "foo/bar.pb.h" and "foo/bar.pb.cc"; note that
+  // "foo/" is included in these filenames.  The filename is not allowed to
+  // contain "." or ".." components.
+  virtual io::ZeroCopyOutputStream* Open(const string& filename) = 0;
+
+  // Similar to Open() but the output will be appended to the file if exists
+  virtual io::ZeroCopyOutputStream* OpenForAppend(const string& filename);
+
+  // Creates a ZeroCopyOutputStream which will insert code into the given file
+  // at the given insertion point.  See plugin.proto (plugin.pb.h) for more
+  // information on insertion points.  The default implementation
+  // assert-fails -- it exists only for backwards-compatibility.
+  //
+  // WARNING:  This feature is currently EXPERIMENTAL and is subject to change.
+  virtual io::ZeroCopyOutputStream* OpenForInsert(
+      const string& filename, const string& insertion_point);
+
+  // Returns a vector of FileDescriptors for all the files being compiled
+  // in this run.  Useful for languages, such as Go, that treat files
+  // differently when compiled as a set rather than individually.
+  virtual void ListParsedFiles(std::vector<const FileDescriptor*>* output);
+
+  // Retrieves the version number of the protocol compiler associated with
+  // this GeneratorContext.
+  virtual void GetCompilerVersion(Version* version) const;
+
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(GeneratorContext);
+};
+
+// The type GeneratorContext was once called OutputDirectory. This typedef
+// provides backward compatibility.
+typedef GeneratorContext OutputDirectory;
+
+// Several code generators treat the parameter argument as holding a
+// list of options separated by commas.  This helper function parses
+// a set of comma-delimited name/value pairs: e.g.,
+//   "foo=bar,baz,qux=corge"
+// parses to the pairs:
+//   ("foo", "bar"), ("baz", ""), ("qux", "corge")
+void ParseGeneratorParameter(
+    const string&, std::vector<std::pair<string, string> >*);
+
+}  // namespace compiler
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_COMPILER_CODE_GENERATOR_H__
diff --git a/kortex_api/include/google/protobuf/compiler/command_line_interface.h b/kortex_api/include/google/protobuf/compiler/command_line_interface.h
new file mode 100644
index 0000000000000000000000000000000000000000..d5d85f2da3ba480abe607fc46bd9a37a679be8ac
--- /dev/null
+++ b/kortex_api/include/google/protobuf/compiler/command_line_interface.h
@@ -0,0 +1,440 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// Implements the Protocol Compiler front-end such that it may be reused by
+// custom compilers written to support other languages.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_COMMAND_LINE_INTERFACE_H__
+#define GOOGLE_PROTOBUF_COMPILER_COMMAND_LINE_INTERFACE_H__
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/hash.h>
+#include <string>
+#include <vector>
+#include <map>
+#include <set>
+#include <utility>
+
+namespace google {
+namespace protobuf {
+
+class Descriptor;            // descriptor.h
+class DescriptorPool;        // descriptor.h
+class FileDescriptor;        // descriptor.h
+class FileDescriptorSet;     // descriptor.h
+class FileDescriptorProto;   // descriptor.pb.h
+template<typename T> class RepeatedPtrField;  // repeated_field.h
+class SimpleDescriptorDatabase;               // descriptor_database.h
+
+namespace compiler {
+
+class CodeGenerator;     // code_generator.h
+class GeneratorContext;  // code_generator.h
+class DiskSourceTree;    // importer.h
+
+// This class implements the command-line interface to the protocol compiler.
+// It is designed to make it very easy to create a custom protocol compiler
+// supporting the languages of your choice.  For example, if you wanted to
+// create a custom protocol compiler binary which includes both the regular
+// C++ support plus support for your own custom output "Foo", you would
+// write a class "FooGenerator" which implements the CodeGenerator interface,
+// then write a main() procedure like this:
+//
+//   int main(int argc, char* argv[]) {
+//     google::protobuf::compiler::CommandLineInterface cli;
+//
+//     // Support generation of C++ source and headers.
+//     google::protobuf::compiler::cpp::CppGenerator cpp_generator;
+//     cli.RegisterGenerator("--cpp_out", &cpp_generator,
+//       "Generate C++ source and header.");
+//
+//     // Support generation of Foo code.
+//     FooGenerator foo_generator;
+//     cli.RegisterGenerator("--foo_out", &foo_generator,
+//       "Generate Foo file.");
+//
+//     return cli.Run(argc, argv);
+//   }
+//
+// The compiler is invoked with syntax like:
+//   protoc --cpp_out=outdir --foo_out=outdir --proto_path=src src/foo.proto
+//
+// The .proto file to compile can be specified on the command line using either
+// its physical file path, or a virtual path relative to a diretory specified
+// in --proto_path. For example, for src/foo.proto, the following two protoc
+// invocations work the same way:
+//   1. protoc --proto_path=src src/foo.proto (physical file path)
+//   2. protoc --proto_path=src foo.proto (virtual path relative to src)
+//
+// If a file path can be interpreted both as a physical file path and as a
+// relative virtual path, the physical file path takes precendence.
+//
+// For a full description of the command-line syntax, invoke it with --help.
+class LIBPROTOC_EXPORT CommandLineInterface {
+ public:
+  static const char* const kPathSeparator;
+
+  CommandLineInterface();
+  ~CommandLineInterface();
+
+  // Register a code generator for a language.
+  //
+  // Parameters:
+  // * flag_name: The command-line flag used to specify an output file of
+  //   this type.  The name must start with a '-'.  If the name is longer
+  //   than one letter, it must start with two '-'s.
+  // * generator: The CodeGenerator which will be called to generate files
+  //   of this type.
+  // * help_text: Text describing this flag in the --help output.
+  //
+  // Some generators accept extra parameters.  You can specify this parameter
+  // on the command-line by placing it before the output directory, separated
+  // by a colon:
+  //   protoc --foo_out=enable_bar:outdir
+  // The text before the colon is passed to CodeGenerator::Generate() as the
+  // "parameter".
+  void RegisterGenerator(const string& flag_name,
+                         CodeGenerator* generator,
+                         const string& help_text);
+
+  // Register a code generator for a language.
+  // Besides flag_name you can specify another option_flag_name that could be
+  // used to pass extra parameters to the registered code generator.
+  // Suppose you have registered a generator by calling:
+  //   command_line_interface.RegisterGenerator("--foo_out", "--foo_opt", ...)
+  // Then you could invoke the compiler with a command like:
+  //   protoc --foo_out=enable_bar:outdir --foo_opt=enable_baz
+  // This will pass "enable_bar,enable_baz" as the parameter to the generator.
+  void RegisterGenerator(const string& flag_name,
+                         const string& option_flag_name,
+                         CodeGenerator* generator,
+                         const string& help_text);
+
+  // Enables "plugins".  In this mode, if a command-line flag ends with "_out"
+  // but does not match any registered generator, the compiler will attempt to
+  // find a "plugin" to implement the generator.  Plugins are just executables.
+  // They should live somewhere in the PATH.
+  //
+  // The compiler determines the executable name to search for by concatenating
+  // exe_name_prefix with the unrecognized flag name, removing "_out".  So, for
+  // example, if exe_name_prefix is "protoc-" and you pass the flag --foo_out,
+  // the compiler will try to run the program "protoc-foo".
+  //
+  // The plugin program should implement the following usage:
+  //   plugin [--out=OUTDIR] [--parameter=PARAMETER] PROTO_FILES < DESCRIPTORS
+  // --out indicates the output directory (as passed to the --foo_out
+  // parameter); if omitted, the current directory should be used.  --parameter
+  // gives the generator parameter, if any was provided (see below).  The
+  // PROTO_FILES list the .proto files which were given on the compiler
+  // command-line; these are the files for which the plugin is expected to
+  // generate output code.  Finally, DESCRIPTORS is an encoded FileDescriptorSet
+  // (as defined in descriptor.proto).  This is piped to the plugin's stdin.
+  // The set will include descriptors for all the files listed in PROTO_FILES as
+  // well as all files that they import.  The plugin MUST NOT attempt to read
+  // the PROTO_FILES directly -- it must use the FileDescriptorSet.
+  //
+  // The plugin should generate whatever files are necessary, as code generators
+  // normally do.  It should write the names of all files it generates to
+  // stdout.  The names should be relative to the output directory, NOT absolute
+  // names or relative to the current directory.  If any errors occur, error
+  // messages should be written to stderr.  If an error is fatal, the plugin
+  // should exit with a non-zero exit code.
+  //
+  // Plugins can have generator parameters similar to normal built-in
+  // generators. Extra generator parameters can be passed in via a matching
+  // "_opt" parameter. For example:
+  //   protoc --plug_out=enable_bar:outdir --plug_opt=enable_baz
+  // This will pass "enable_bar,enable_baz" as the parameter to the plugin.
+  //
+  void AllowPlugins(const string& exe_name_prefix);
+
+  // Run the Protocol Compiler with the given command-line parameters.
+  // Returns the error code which should be returned by main().
+  //
+  // It may not be safe to call Run() in a multi-threaded environment because
+  // it calls strerror().  I'm not sure why you'd want to do this anyway.
+  int Run(int argc, const char* const argv[]);
+
+  // DEPRECATED. Calling this method has no effect. Protocol compiler now
+  // always try to find the .proto file relative to the current directory
+  // first and if the file is not found, it will then treat the input path
+  // as a virutal path.
+  void SetInputsAreProtoPathRelative(bool /* enable */) {}
+
+  // Provides some text which will be printed when the --version flag is
+  // used.  The version of libprotoc will also be printed on the next line
+  // after this text.
+  void SetVersionInfo(const string& text) {
+    version_info_ = text;
+  }
+
+
+ private:
+  // -----------------------------------------------------------------
+
+  class ErrorPrinter;
+  class GeneratorContextImpl;
+  class MemoryOutputStream;
+  typedef hash_map<string, GeneratorContextImpl*> GeneratorContextMap;
+
+  // Clear state from previous Run().
+  void Clear();
+
+  // Remaps each file in input_files_ so that it is relative to one of the
+  // directories in proto_path_.  Returns false if an error occurred.  This
+  // is only used if inputs_are_proto_path_relative_ is false.
+  bool MakeInputsBeProtoPathRelative(
+    DiskSourceTree* source_tree);
+
+  // Return status for ParseArguments() and InterpretArgument().
+  enum ParseArgumentStatus {
+    PARSE_ARGUMENT_DONE_AND_CONTINUE,
+    PARSE_ARGUMENT_DONE_AND_EXIT,
+    PARSE_ARGUMENT_FAIL
+  };
+
+  // Parse all command-line arguments.
+  ParseArgumentStatus ParseArguments(int argc, const char* const argv[]);
+
+  // Read an argument file and append the file's content to the list of
+  // arguments. Return false if the file cannot be read.
+  bool ExpandArgumentFile(const string& file, std::vector<string>* arguments);
+
+  // Parses a command-line argument into a name/value pair.  Returns
+  // true if the next argument in the argv should be used as the value,
+  // false otherwise.
+  //
+  // Examples:
+  //   "-Isrc/protos" ->
+  //     name = "-I", value = "src/protos"
+  //   "--cpp_out=src/foo.pb2.cc" ->
+  //     name = "--cpp_out", value = "src/foo.pb2.cc"
+  //   "foo.proto" ->
+  //     name = "", value = "foo.proto"
+  bool ParseArgument(const char* arg, string* name, string* value);
+
+  // Interprets arguments parsed with ParseArgument.
+  ParseArgumentStatus InterpretArgument(const string& name,
+                                        const string& value);
+
+  // Print the --help text to stderr.
+  void PrintHelpText();
+
+  // Loads proto_path_ into the provided source_tree.
+  bool InitializeDiskSourceTree(DiskSourceTree* source_tree);
+
+  // Loads descriptor_set_in into the provided database
+  bool PopulateSimpleDescriptorDatabase(SimpleDescriptorDatabase* database);
+
+  // Parses input_files_ into parsed_files
+  bool ParseInputFiles(DescriptorPool* descriptor_pool,
+                       std::vector<const FileDescriptor*>* parsed_files);
+
+  // Generate the given output file from the given input.
+  struct OutputDirective;  // see below
+  bool GenerateOutput(const std::vector<const FileDescriptor*>& parsed_files,
+                      const OutputDirective& output_directive,
+                      GeneratorContext* generator_context);
+  bool GeneratePluginOutput(
+      const std::vector<const FileDescriptor*>& parsed_files,
+      const string& plugin_name, const string& parameter,
+      GeneratorContext* generator_context, string* error);
+
+  // Implements --encode and --decode.
+  bool EncodeOrDecode(const DescriptorPool* pool);
+
+  // Implements the --descriptor_set_out option.
+  bool WriteDescriptorSet(
+      const std::vector<const FileDescriptor*>& parsed_files);
+
+  // Implements the --dependency_out option
+  bool GenerateDependencyManifestFile(
+      const std::vector<const FileDescriptor*>& parsed_files,
+      const GeneratorContextMap& output_directories,
+      DiskSourceTree* source_tree);
+
+  // Get all transitive dependencies of the given file (including the file
+  // itself), adding them to the given list of FileDescriptorProtos.  The
+  // protos will be ordered such that every file is listed before any file that
+  // depends on it, so that you can call DescriptorPool::BuildFile() on them
+  // in order.  Any files in *already_seen will not be added, and each file
+  // added will be inserted into *already_seen.  If include_source_code_info is
+  // true then include the source code information in the FileDescriptorProtos.
+  // If include_json_name is true, populate the json_name field of
+  // FieldDescriptorProto for all fields.
+  static void GetTransitiveDependencies(
+      const FileDescriptor* file,
+      bool include_json_name,
+      bool include_source_code_info,
+      std::set<const FileDescriptor*>* already_seen,
+      RepeatedPtrField<FileDescriptorProto>* output);
+
+  // Implements the --print_free_field_numbers. This function prints free field
+  // numbers into stdout for the message and it's nested message types in
+  // post-order, i.e. nested types first. Printed range are left-right
+  // inclusive, i.e. [a, b].
+  //
+  // Groups:
+  // For historical reasons, groups are considered to share the same
+  // field number space with the parent message, thus it will not print free
+  // field numbers for groups. The field numbers used in the groups are
+  // excluded in the free field numbers of the parent message.
+  //
+  // Extension Ranges:
+  // Extension ranges are considered ocuppied field numbers and they will not be
+  // listed as free numbers in the output.
+  void PrintFreeFieldNumbers(const Descriptor* descriptor);
+
+  // -----------------------------------------------------------------
+
+  // The name of the executable as invoked (i.e. argv[0]).
+  string executable_name_;
+
+  // Version info set with SetVersionInfo().
+  string version_info_;
+
+  // Registered generators.
+  struct GeneratorInfo {
+    string flag_name;
+    string option_flag_name;
+    CodeGenerator* generator;
+    string help_text;
+  };
+  typedef std::map<string, GeneratorInfo> GeneratorMap;
+  GeneratorMap generators_by_flag_name_;
+  GeneratorMap generators_by_option_name_;
+  // A map from generator names to the parameters specified using the option
+  // flag. For example, if the user invokes the compiler with:
+  //   protoc --foo_out=outputdir --foo_opt=enable_bar ...
+  // Then there will be an entry ("--foo_out", "enable_bar") in this map.
+  std::map<string, string> generator_parameters_;
+  // Similar to generator_parameters_, but stores the parameters for plugins.
+  std::map<string, string> plugin_parameters_;
+
+  // See AllowPlugins().  If this is empty, plugins aren't allowed.
+  string plugin_prefix_;
+
+  // Maps specific plugin names to files.  When executing a plugin, this map
+  // is searched first to find the plugin executable.  If not found here, the
+  // PATH (or other OS-specific search strategy) is searched.
+  std::map<string, string> plugins_;
+
+  // Stuff parsed from command line.
+  enum Mode {
+    MODE_COMPILE,  // Normal mode:  parse .proto files and compile them.
+    MODE_ENCODE,   // --encode:  read text from stdin, write binary to stdout.
+    MODE_DECODE,   // --decode:  read binary from stdin, write text to stdout.
+    MODE_PRINT,    // Print mode: print info of the given .proto files and exit.
+  };
+
+  Mode mode_;
+
+  enum PrintMode {
+    PRINT_NONE,               // Not in MODE_PRINT
+    PRINT_FREE_FIELDS,        // --print_free_fields
+  };
+
+  PrintMode print_mode_;
+
+  enum ErrorFormat {
+    ERROR_FORMAT_GCC,   // GCC error output format (default).
+    ERROR_FORMAT_MSVS   // Visual Studio output (--error_format=msvs).
+  };
+
+  ErrorFormat error_format_;
+
+  std::vector<std::pair<string, string> >
+      proto_path_;                   // Search path for proto files.
+  std::vector<string> input_files_;  // Names of the input proto files.
+
+  // Names of proto files which are allowed to be imported. Used by build
+  // systems to enforce depend-on-what-you-import.
+  std::set<string> direct_dependencies_;
+  bool direct_dependencies_explicitly_set_;
+
+  // If there's a violation of depend-on-what-you-import, this string will be
+  // presented to the user. "%s" will be replaced with the violating import.
+  string direct_dependencies_violation_msg_;
+
+  // output_directives_ lists all the files we are supposed to output and what
+  // generator to use for each.
+  struct OutputDirective {
+    string name;                // E.g. "--foo_out"
+    CodeGenerator* generator;   // NULL for plugins
+    string parameter;
+    string output_location;
+  };
+  std::vector<OutputDirective> output_directives_;
+
+  // When using --encode or --decode, this names the type we are encoding or
+  // decoding.  (Empty string indicates --decode_raw.)
+  string codec_type_;
+
+  // If --descriptor_set_in was given, these are filenames containing
+  // parsed FileDescriptorSets to be used for loading protos.  Otherwise, empty.
+  std::vector<string> descriptor_set_in_names_;
+
+  // If --descriptor_set_out was given, this is the filename to which the
+  // FileDescriptorSet should be written.  Otherwise, empty.
+  string descriptor_set_out_name_;
+
+  // If --dependency_out was given, this is the path to the file where the
+  // dependency file will be written. Otherwise, empty.
+  string dependency_out_name_;
+
+  // Path to a file that contains serialized AccessInfo which provides
+  // relative hotness of fields per message. This helps protoc to generate
+  // better code.
+  string profile_path_;
+
+  // True if --include_imports was given, meaning that we should
+  // write all transitive dependencies to the DescriptorSet.  Otherwise, only
+  // the .proto files listed on the command-line are added.
+  bool imports_in_descriptor_set_;
+
+  // True if --include_source_info was given, meaning that we should not strip
+  // SourceCodeInfo from the DescriptorSet.
+  bool source_info_in_descriptor_set_;
+
+  // Was the --disallow_services flag used?
+  bool disallow_services_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CommandLineInterface);
+};
+
+}  // namespace compiler
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_COMPILER_COMMAND_LINE_INTERFACE_H__
diff --git a/kortex_api/include/google/protobuf/compiler/cpp/cpp_generator.h b/kortex_api/include/google/protobuf/compiler/cpp/cpp_generator.h
new file mode 100644
index 0000000000000000000000000000000000000000..3d517cf4a5ba1a9d0a7b52fce1e521fada8b0a1f
--- /dev/null
+++ b/kortex_api/include/google/protobuf/compiler/cpp/cpp_generator.h
@@ -0,0 +1,72 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// Generates C++ code for a given .proto file.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_CPP_GENERATOR_H__
+#define GOOGLE_PROTOBUF_COMPILER_CPP_GENERATOR_H__
+
+#include <string>
+#include <google/protobuf/compiler/code_generator.h>
+
+namespace google {
+namespace protobuf {
+namespace compiler {
+namespace cpp {
+
+// CodeGenerator implementation which generates a C++ source file and
+// header.  If you create your own protocol compiler binary and you want
+// it to support C++ output, you can do so by registering an instance of this
+// CodeGenerator with the CommandLineInterface in your main() function.
+class LIBPROTOC_EXPORT CppGenerator : public CodeGenerator {
+ public:
+  CppGenerator();
+  ~CppGenerator();
+
+  // implements CodeGenerator ----------------------------------------
+  bool Generate(const FileDescriptor* file,
+                const string& parameter,
+                GeneratorContext* generator_context,
+                string* error) const;
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CppGenerator);
+};
+
+}  // namespace cpp
+}  // namespace compiler
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_COMPILER_CPP_GENERATOR_H__
diff --git a/kortex_api/include/google/protobuf/compiler/csharp/csharp_generator.h b/kortex_api/include/google/protobuf/compiler/csharp/csharp_generator.h
new file mode 100644
index 0000000000000000000000000000000000000000..c8b19529139d277b2b7cd34b90b317c63b7d71c3
--- /dev/null
+++ b/kortex_api/include/google/protobuf/compiler/csharp/csharp_generator.h
@@ -0,0 +1,64 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Generates C# code for a given .proto file.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_CSHARP_GENERATOR_H__
+#define GOOGLE_PROTOBUF_COMPILER_CSHARP_GENERATOR_H__
+
+#include <string>
+
+#include <google/protobuf/compiler/code_generator.h>
+
+namespace google {
+namespace protobuf {
+namespace compiler {
+namespace csharp {
+
+// CodeGenerator implementation which generates a C# source file and
+// header.  If you create your own protocol compiler binary and you want
+// it to support C# output, you can do so by registering an instance of this
+// CodeGenerator with the CommandLineInterface in your main() function.
+class LIBPROTOC_EXPORT Generator
+    : public google::protobuf::compiler::CodeGenerator {
+public:
+  virtual bool Generate(
+      const FileDescriptor* file,
+      const string& parameter,
+      GeneratorContext* generator_context,
+      string* error) const;
+};
+
+}  // namespace csharp
+}  // namespace compiler
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_COMPILER_CSHARP_GENERATOR_H__
diff --git a/kortex_api/include/google/protobuf/compiler/csharp/csharp_names.h b/kortex_api/include/google/protobuf/compiler/csharp/csharp_names.h
new file mode 100644
index 0000000000000000000000000000000000000000..21758f2882c74160683f96fa328b40508aa55d35
--- /dev/null
+++ b/kortex_api/include/google/protobuf/compiler/csharp/csharp_names.h
@@ -0,0 +1,104 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// Provides a mechanism for mapping a descriptor to the
+// fully-qualified name of the corresponding C# class.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_CSHARP_NAMES_H__
+#define GOOGLE_PROTOBUF_COMPILER_CSHARP_NAMES_H__
+
+#include <string>
+#include <google/protobuf/stubs/port.h>
+
+namespace google {
+namespace protobuf {
+
+class Descriptor;
+class EnumDescriptor;
+class FileDescriptor;
+class ServiceDescriptor;
+
+namespace compiler {
+namespace csharp {
+
+// Requires:
+//   descriptor != NULL
+//
+// Returns:
+//   The namespace to use for given file descriptor.
+string LIBPROTOC_EXPORT GetFileNamespace(const FileDescriptor* descriptor);
+
+// Requires:
+//   descriptor != NULL
+//
+// Returns:
+//   The fully-qualified C# class name.
+string LIBPROTOC_EXPORT GetClassName(const Descriptor* descriptor);
+
+// Requires:
+//   descriptor != NULL
+//
+// Returns:
+//   The fully-qualified name of the C# class that provides
+//   access to the file descriptor. Proto compiler generates
+//   such class for each .proto file processed.
+string LIBPROTOC_EXPORT GetReflectionClassName(const FileDescriptor* descriptor);
+
+// Generates output file name for given file descriptor. If generate_directories
+// is true, the output file will be put under directory corresponding to file's
+// namespace. base_namespace can be used to strip some of the top level
+// directories. E.g. for file with namespace "Bar.Foo" and base_namespace="Bar",
+// the resulting file will be put under directory "Foo" (and not "Bar/Foo").
+//
+// Requires:
+//   descriptor != NULL
+//   error != NULL
+//
+//  Returns:
+//    The file name to use as output file for given file descriptor. In case
+//    of failure, this function will return empty string and error parameter
+//    will contain the error message.
+string LIBPROTOC_EXPORT GetOutputFile(
+    const google::protobuf::FileDescriptor* descriptor,
+    const string file_extension,
+    const bool generate_directories,
+    const string base_namespace,
+    string* error);
+
+}  // namespace csharp
+}  // namespace compiler
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_COMPILER_CSHARP_NAMES_H__
diff --git a/kortex_api/include/google/protobuf/compiler/importer.h b/kortex_api/include/google/protobuf/compiler/importer.h
new file mode 100644
index 0000000000000000000000000000000000000000..a4ffcf87de32a0fe7d82620988ae86cd597e6c55
--- /dev/null
+++ b/kortex_api/include/google/protobuf/compiler/importer.h
@@ -0,0 +1,327 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// This file is the public interface to the .proto file parser.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_IMPORTER_H__
+#define GOOGLE_PROTOBUF_COMPILER_IMPORTER_H__
+
+#include <string>
+#include <vector>
+#include <set>
+#include <utility>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/descriptor_database.h>
+#include <google/protobuf/compiler/parser.h>
+
+namespace google {
+namespace protobuf {
+
+namespace io { class ZeroCopyInputStream; }
+
+namespace compiler {
+
+// Defined in this file.
+class Importer;
+class MultiFileErrorCollector;
+class SourceTree;
+class DiskSourceTree;
+
+// TODO(kenton):  Move all SourceTree stuff to a separate file?
+
+// An implementation of DescriptorDatabase which loads files from a SourceTree
+// and parses them.
+//
+// Note:  This class is not thread-safe since it maintains a table of source
+//   code locations for error reporting.  However, when a DescriptorPool wraps
+//   a DescriptorDatabase, it uses mutex locking to make sure only one method
+//   of the database is called at a time, even if the DescriptorPool is used
+//   from multiple threads.  Therefore, there is only a problem if you create
+//   multiple DescriptorPools wrapping the same SourceTreeDescriptorDatabase
+//   and use them from multiple threads.
+//
+// Note:  This class does not implement FindFileContainingSymbol() or
+//   FindFileContainingExtension(); these will always return false.
+class LIBPROTOBUF_EXPORT SourceTreeDescriptorDatabase : public DescriptorDatabase {
+ public:
+  SourceTreeDescriptorDatabase(SourceTree* source_tree);
+  ~SourceTreeDescriptorDatabase();
+
+  // Instructs the SourceTreeDescriptorDatabase to report any parse errors
+  // to the given MultiFileErrorCollector.  This should be called before
+  // parsing.  error_collector must remain valid until either this method
+  // is called again or the SourceTreeDescriptorDatabase is destroyed.
+  void RecordErrorsTo(MultiFileErrorCollector* error_collector) {
+    error_collector_ = error_collector;
+  }
+
+  // Gets a DescriptorPool::ErrorCollector which records errors to the
+  // MultiFileErrorCollector specified with RecordErrorsTo().  This collector
+  // has the ability to determine exact line and column numbers of errors
+  // from the information given to it by the DescriptorPool.
+  DescriptorPool::ErrorCollector* GetValidationErrorCollector() {
+    using_validation_error_collector_ = true;
+    return &validation_error_collector_;
+  }
+
+  // implements DescriptorDatabase -----------------------------------
+  bool FindFileByName(const string& filename, FileDescriptorProto* output);
+  bool FindFileContainingSymbol(const string& symbol_name,
+                                FileDescriptorProto* output);
+  bool FindFileContainingExtension(const string& containing_type,
+                                   int field_number,
+                                   FileDescriptorProto* output);
+
+ private:
+  class SingleFileErrorCollector;
+
+  SourceTree* source_tree_;
+  MultiFileErrorCollector* error_collector_;
+
+  class LIBPROTOBUF_EXPORT ValidationErrorCollector : public DescriptorPool::ErrorCollector {
+   public:
+    ValidationErrorCollector(SourceTreeDescriptorDatabase* owner);
+    ~ValidationErrorCollector();
+
+    // implements ErrorCollector ---------------------------------------
+    void AddError(const string& filename,
+                  const string& element_name,
+                  const Message* descriptor,
+                  ErrorLocation location,
+                  const string& message);
+
+    virtual void AddWarning(const string& filename,
+                            const string& element_name,
+                            const Message* descriptor,
+                            ErrorLocation location,
+                            const string& message);
+
+   private:
+    SourceTreeDescriptorDatabase* owner_;
+  };
+  friend class ValidationErrorCollector;
+
+  bool using_validation_error_collector_;
+  SourceLocationTable source_locations_;
+  ValidationErrorCollector validation_error_collector_;
+};
+
+// Simple interface for parsing .proto files.  This wraps the process
+// of opening the file, parsing it with a Parser, recursively parsing all its
+// imports, and then cross-linking the results to produce a FileDescriptor.
+//
+// This is really just a thin wrapper around SourceTreeDescriptorDatabase.
+// You may find that SourceTreeDescriptorDatabase is more flexible.
+//
+// TODO(kenton):  I feel like this class is not well-named.
+class LIBPROTOBUF_EXPORT Importer {
+ public:
+  Importer(SourceTree* source_tree,
+           MultiFileErrorCollector* error_collector);
+  ~Importer();
+
+  // Import the given file and build a FileDescriptor representing it.  If
+  // the file is already in the DescriptorPool, the existing FileDescriptor
+  // will be returned.  The FileDescriptor is property of the DescriptorPool,
+  // and will remain valid until it is destroyed.  If any errors occur, they
+  // will be reported using the error collector and Import() will return NULL.
+  //
+  // A particular Importer object will only report errors for a particular
+  // file once.  All future attempts to import the same file will return NULL
+  // without reporting any errors.  The idea is that you might want to import
+  // a lot of files without seeing the same errors over and over again.  If
+  // you want to see errors for the same files repeatedly, you can use a
+  // separate Importer object to import each one (but use the same
+  // DescriptorPool so that they can be cross-linked).
+  const FileDescriptor* Import(const string& filename);
+
+  // The DescriptorPool in which all imported FileDescriptors and their
+  // contents are stored.
+  inline const DescriptorPool* pool() const {
+    return &pool_;
+  }
+
+  void AddUnusedImportTrackFile(const string& file_name);
+  void ClearUnusedImportTrackFiles();
+
+
+ private:
+  SourceTreeDescriptorDatabase database_;
+  DescriptorPool pool_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Importer);
+};
+
+// If the importer encounters problems while trying to import the proto files,
+// it reports them to a MultiFileErrorCollector.
+class LIBPROTOBUF_EXPORT MultiFileErrorCollector {
+ public:
+  inline MultiFileErrorCollector() {}
+  virtual ~MultiFileErrorCollector();
+
+  // Line and column numbers are zero-based.  A line number of -1 indicates
+  // an error with the entire file (e.g. "not found").
+  virtual void AddError(const string& filename, int line, int column,
+                        const string& message) = 0;
+
+  virtual void AddWarning(const string& filename, int line, int column,
+                          const string& message) {}
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MultiFileErrorCollector);
+};
+
+// Abstract interface which represents a directory tree containing proto files.
+// Used by the default implementation of Importer to resolve import statements
+// Most users will probably want to use the DiskSourceTree implementation,
+// below.
+class LIBPROTOBUF_EXPORT SourceTree {
+ public:
+  inline SourceTree() {}
+  virtual ~SourceTree();
+
+  // Open the given file and return a stream that reads it, or NULL if not
+  // found.  The caller takes ownership of the returned object.  The filename
+  // must be a path relative to the root of the source tree and must not
+  // contain "." or ".." components.
+  virtual io::ZeroCopyInputStream* Open(const string& filename) = 0;
+
+  // If Open() returns NULL, calling this method immediately will return an
+  // description of the error.
+  // Subclasses should implement this method and return a meaningful value for
+  // better error reporting.
+  // TODO(xiaofeng): change this to a pure virtual function.
+  virtual string GetLastErrorMessage();
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(SourceTree);
+};
+
+// An implementation of SourceTree which loads files from locations on disk.
+// Multiple mappings can be set up to map locations in the DiskSourceTree to
+// locations in the physical filesystem.
+class LIBPROTOBUF_EXPORT DiskSourceTree : public SourceTree {
+ public:
+  DiskSourceTree();
+  ~DiskSourceTree();
+
+  // Map a path on disk to a location in the SourceTree.  The path may be
+  // either a file or a directory.  If it is a directory, the entire tree
+  // under it will be mapped to the given virtual location.  To map a directory
+  // to the root of the source tree, pass an empty string for virtual_path.
+  //
+  // If multiple mapped paths apply when opening a file, they will be searched
+  // in order.  For example, if you do:
+  //   MapPath("bar", "foo/bar");
+  //   MapPath("", "baz");
+  // and then you do:
+  //   Open("bar/qux");
+  // the DiskSourceTree will first try to open foo/bar/qux, then baz/bar/qux,
+  // returning the first one that opens successfuly.
+  //
+  // disk_path may be an absolute path or relative to the current directory,
+  // just like a path you'd pass to open().
+  void MapPath(const string& virtual_path, const string& disk_path);
+
+  // Return type for DiskFileToVirtualFile().
+  enum DiskFileToVirtualFileResult {
+    SUCCESS,
+    SHADOWED,
+    CANNOT_OPEN,
+    NO_MAPPING
+  };
+
+  // Given a path to a file on disk, find a virtual path mapping to that
+  // file.  The first mapping created with MapPath() whose disk_path contains
+  // the filename is used.  However, that virtual path may not actually be
+  // usable to open the given file.  Possible return values are:
+  // * SUCCESS: The mapping was found.  *virtual_file is filled in so that
+  //   calling Open(*virtual_file) will open the file named by disk_file.
+  // * SHADOWED: A mapping was found, but using Open() to open this virtual
+  //   path will end up returning some different file.  This is because some
+  //   other mapping with a higher precedence also matches this virtual path
+  //   and maps it to a different file that exists on disk.  *virtual_file
+  //   is filled in as it would be in the SUCCESS case.  *shadowing_disk_file
+  //   is filled in with the disk path of the file which would be opened if
+  //   you were to call Open(*virtual_file).
+  // * CANNOT_OPEN: The mapping was found and was not shadowed, but the
+  //   file specified cannot be opened.  When this value is returned,
+  //   errno will indicate the reason the file cannot be opened.  *virtual_file
+  //   will be set to the virtual path as in the SUCCESS case, even though
+  //   it is not useful.
+  // * NO_MAPPING: Indicates that no mapping was found which contains this
+  //   file.
+  DiskFileToVirtualFileResult
+    DiskFileToVirtualFile(const string& disk_file,
+                          string* virtual_file,
+                          string* shadowing_disk_file);
+
+  // Given a virtual path, find the path to the file on disk.
+  // Return true and update disk_file with the on-disk path if the file exists.
+  // Return false and leave disk_file untouched if the file doesn't exist.
+  bool VirtualFileToDiskFile(const string& virtual_file, string* disk_file);
+
+  // implements SourceTree -------------------------------------------
+  virtual io::ZeroCopyInputStream* Open(const string& filename);
+
+  virtual string GetLastErrorMessage();
+
+ private:
+  struct Mapping {
+    string virtual_path;
+    string disk_path;
+
+    inline Mapping(const string& virtual_path_param,
+                   const string& disk_path_param)
+      : virtual_path(virtual_path_param), disk_path(disk_path_param) {}
+  };
+  std::vector<Mapping> mappings_;
+  string last_error_message_;
+
+  // Like Open(), but returns the on-disk path in disk_file if disk_file is
+  // non-NULL and the file could be successfully opened.
+  io::ZeroCopyInputStream* OpenVirtualFile(const string& virtual_file,
+                                           string* disk_file);
+
+  // Like Open() but given the actual on-disk path.
+  io::ZeroCopyInputStream* OpenDiskFile(const string& filename);
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(DiskSourceTree);
+};
+
+}  // namespace compiler
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_COMPILER_IMPORTER_H__
diff --git a/kortex_api/include/google/protobuf/compiler/java/java_generator.h b/kortex_api/include/google/protobuf/compiler/java/java_generator.h
new file mode 100644
index 0000000000000000000000000000000000000000..47f76be983d1ac1aea1ab187ac7451aa0c7c409f
--- /dev/null
+++ b/kortex_api/include/google/protobuf/compiler/java/java_generator.h
@@ -0,0 +1,72 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// Generates Java code for a given .proto file.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_JAVA_GENERATOR_H__
+#define GOOGLE_PROTOBUF_COMPILER_JAVA_GENERATOR_H__
+
+#include <string>
+#include <google/protobuf/compiler/code_generator.h>
+
+namespace google {
+namespace protobuf {
+namespace compiler {
+namespace java {
+
+// CodeGenerator implementation which generates Java code.  If you create your
+// own protocol compiler binary and you want it to support Java output, you
+// can do so by registering an instance of this CodeGenerator with the
+// CommandLineInterface in your main() function.
+class LIBPROTOC_EXPORT JavaGenerator : public CodeGenerator {
+ public:
+  JavaGenerator();
+  ~JavaGenerator();
+
+  // implements CodeGenerator ----------------------------------------
+  bool Generate(const FileDescriptor* file,
+                const string& parameter,
+                GeneratorContext* context,
+                string* error) const;
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(JavaGenerator);
+};
+
+}  // namespace java
+}  // namespace compiler
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_COMPILER_JAVA_GENERATOR_H__
diff --git a/kortex_api/include/google/protobuf/compiler/java/java_names.h b/kortex_api/include/google/protobuf/compiler/java/java_names.h
new file mode 100644
index 0000000000000000000000000000000000000000..0d6143353a0006ce18c760a57036346e17ca429e
--- /dev/null
+++ b/kortex_api/include/google/protobuf/compiler/java/java_names.h
@@ -0,0 +1,87 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// Provides a mechanism for mapping a descriptor to the
+// fully-qualified name of the corresponding Java class.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_JAVA_NAMES_H__
+#define GOOGLE_PROTOBUF_COMPILER_JAVA_NAMES_H__
+
+#include <string>
+
+namespace google {
+namespace protobuf {
+
+class Descriptor;
+class EnumDescriptor;
+class FileDescriptor;
+class ServiceDescriptor;
+
+namespace compiler {
+namespace java {
+
+// Requires:
+//   descriptor != NULL
+//
+// Returns:
+//   The fully-qualified Java class name.
+string ClassName(const Descriptor* descriptor);
+
+// Requires:
+//   descriptor != NULL
+//
+// Returns:
+//   The fully-qualified Java class name.
+string ClassName(const EnumDescriptor* descriptor);
+
+// Requires:
+//   descriptor != NULL
+//
+// Returns:
+//   The fully-qualified Java class name.
+string ClassName(const FileDescriptor* descriptor);
+
+// Requires:
+//   descriptor != NULL
+//
+// Returns:
+//   The fully-qualified Java class name.
+string ClassName(const ServiceDescriptor* descriptor);
+
+}  // namespace java
+}  // namespace compiler
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_COMPILER_JAVA_NAMES_H__
diff --git a/kortex_api/include/google/protobuf/compiler/javanano/javanano_generator.h b/kortex_api/include/google/protobuf/compiler/javanano/javanano_generator.h
new file mode 100644
index 0000000000000000000000000000000000000000..6f9f7f2a4a01d97cc3b5d0af5c50950065459a44
--- /dev/null
+++ b/kortex_api/include/google/protobuf/compiler/javanano/javanano_generator.h
@@ -0,0 +1,72 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// http://code.google.com/p/protobuf/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// Generates Java nano code for a given .proto file.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_JAVANANO_NANO_GENERATOR_H__
+#define GOOGLE_PROTOBUF_COMPILER_JAVANANO_NANO_GENERATOR_H__
+
+#include <string>
+#include <google/protobuf/compiler/code_generator.h>
+
+namespace google {
+namespace protobuf {
+namespace compiler {
+namespace javanano {
+
+// CodeGenerator implementation which generates Java nano code.  If you create your
+// own protocol compiler binary and you want it to support Java output for the
+// nano runtime, you can do so by registering an instance of this CodeGenerator with
+// the CommandLineInterface in your main() function.
+class LIBPROTOC_EXPORT JavaNanoGenerator : public CodeGenerator {
+ public:
+  JavaNanoGenerator();
+  ~JavaNanoGenerator();
+
+  // implements CodeGenerator ----------------------------------------
+  bool Generate(const FileDescriptor* file,
+                const string& parameter,
+                GeneratorContext* output_directory,
+                string* error) const;
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(JavaNanoGenerator);
+};
+
+}  // namespace javanano
+}  // namespace compiler
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_COMPILER_JAVANANO_NANO_GENERATOR_H__
diff --git a/kortex_api/include/google/protobuf/compiler/js/js_generator.h b/kortex_api/include/google/protobuf/compiler/js/js_generator.h
new file mode 100644
index 0000000000000000000000000000000000000000..3cc60e2283fba5a035da41af826a378e2f99e11a
--- /dev/null
+++ b/kortex_api/include/google/protobuf/compiler/js/js_generator.h
@@ -0,0 +1,333 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Generates JavaScript code for a given .proto file.
+//
+#ifndef GOOGLE_PROTOBUF_COMPILER_JS_GENERATOR_H__
+#define GOOGLE_PROTOBUF_COMPILER_JS_GENERATOR_H__
+
+#include <string>
+#include <set>
+
+#include <google/protobuf/stubs/logging.h>
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/compiler/code_generator.h>
+
+namespace google {
+namespace protobuf {
+
+class Descriptor;
+class EnumDescriptor;
+class FieldDescriptor;
+class OneofDescriptor;
+class FileDescriptor;
+
+namespace io { class Printer; }
+
+namespace compiler {
+namespace js {
+
+struct GeneratorOptions {
+  // Output path.
+  string output_dir;
+  // Namespace prefix.
+  string namespace_prefix;
+  // Enable binary-format support?
+  bool binary;
+  // What style of imports should be used.
+  enum ImportStyle {
+    kImportClosure,   // goog.require()
+    kImportCommonJs,  // require()
+    kImportBrowser,   // no import statements
+    kImportEs6,       // import { member } from ''
+  } import_style;
+
+  GeneratorOptions()
+      : output_dir("."),
+        namespace_prefix(""),
+        binary(false),
+        import_style(kImportClosure),
+        add_require_for_enums(false),
+        testonly(false),
+        library(""),
+        error_on_name_conflict(false),
+        extension(".js"),
+        one_output_file_per_input_file(false),
+        annotate_code(false) {}
+
+  bool ParseFromOptions(
+      const std::vector< std::pair< string, string > >& options,
+      string* error);
+
+  // Returns the file name extension to use for generated code.
+  string GetFileNameExtension() const {
+    return import_style == kImportClosure ? extension : "_pb.js";
+  }
+
+  enum OutputMode {
+    // Create an output file for each input .proto file.
+    kOneOutputFilePerInputFile,
+    // Create an output file for each type.
+    kOneOutputFilePerType,
+    // Put everything in a single file named by the library option.
+    kEverythingInOneFile,
+  };
+
+  // Indicates how to output the generated code based on the provided options.
+  OutputMode output_mode() const;
+
+  // The remaining options are only relevant when we are using kImportClosure.
+
+  // Add a `goog.requires()` call for each enum type used. If not set, a
+  // forward declaration with `goog.forwardDeclare` is produced instead.
+  bool add_require_for_enums;
+  // Set this as a test-only module via `goog.setTestOnly();`.
+  bool testonly;
+  // Create a library with name <name>_lib.js rather than a separate .js file
+  // per type?
+  string library;
+  // Error if there are two types that would generate the same output file?
+  bool error_on_name_conflict;
+  // The extension to use for output file names.
+  string extension;
+  // Create a separate output file for each input file?
+  bool one_output_file_per_input_file;
+  // If true, we should build .meta files that contain annotations for
+  // generated code. See GeneratedCodeInfo in descriptor.proto.
+  bool annotate_code;
+};
+
+// CodeGenerator implementation which generates a JavaScript source file and
+// header.  If you create your own protocol compiler binary and you want it to
+// support JavaScript output, you can do so by registering an instance of this
+// CodeGenerator with the CommandLineInterface in your main() function.
+class LIBPROTOC_EXPORT Generator : public CodeGenerator {
+ public:
+  Generator() {}
+  virtual ~Generator() {}
+
+  virtual bool Generate(const FileDescriptor* file,
+                        const string& parameter,
+                        GeneratorContext* context,
+                        string* error) const {
+    *error = "Unimplemented Generate() method. Call GenerateAll() instead.";
+    return false;
+  }
+
+  virtual bool HasGenerateAll() const { return true; }
+
+  virtual bool GenerateAll(const std::vector<const FileDescriptor*>& files,
+                           const string& parameter,
+                           GeneratorContext* context,
+                           string* error) const;
+
+ private:
+  void GenerateHeader(const GeneratorOptions& options,
+                      io::Printer* printer) const;
+
+  // Generate goog.provides() calls.
+  void FindProvides(const GeneratorOptions& options,
+                    io::Printer* printer,
+                    const std::vector<const FileDescriptor*>& file,
+                    std::set<string>* provided) const;
+  void FindProvidesForFile(const GeneratorOptions& options,
+                           io::Printer* printer,
+                           const FileDescriptor* file,
+                           std::set<string>* provided) const;
+  void FindProvidesForMessage(const GeneratorOptions& options,
+                              io::Printer* printer,
+                              const Descriptor* desc,
+                              std::set<string>* provided) const;
+  void FindProvidesForEnum(const GeneratorOptions& options,
+                           io::Printer* printer,
+                           const EnumDescriptor* enumdesc,
+                           std::set<string>* provided) const;
+  // For extension fields at file scope.
+  void FindProvidesForFields(const GeneratorOptions& options,
+                             io::Printer* printer,
+                             const std::vector<const FieldDescriptor*>& fields,
+                             std::set<string>* provided) const;
+  // Print the goog.provides() found by the methods above.
+  void GenerateProvides(const GeneratorOptions& options,
+                        io::Printer* printer,
+                        std::set<string>* provided) const;
+
+  // Generate goog.setTestOnly() if indicated.
+  void GenerateTestOnly(const GeneratorOptions& options,
+                        io::Printer* printer) const;
+
+  // Generate goog.requires() calls.
+  void GenerateRequiresForLibrary(
+      const GeneratorOptions& options, io::Printer* printer,
+      const std::vector<const FileDescriptor*>& files,
+      std::set<string>* provided) const;
+  void GenerateRequiresForMessage(const GeneratorOptions& options,
+                        io::Printer* printer,
+                        const Descriptor* desc,
+                        std::set<string>* provided) const;
+  // For extension fields at file scope.
+  void GenerateRequiresForExtensions(
+      const GeneratorOptions& options, io::Printer* printer,
+      const std::vector<const FieldDescriptor*>& fields,
+      std::set<string>* provided) const;
+  void GenerateRequiresImpl(const GeneratorOptions& options,
+                            io::Printer* printer, std::set<string>* required,
+                            std::set<string>* forwards,
+                            std::set<string>* provided, bool require_jspb,
+                            bool require_extension, bool require_map) const;
+  void FindRequiresForMessage(const GeneratorOptions& options,
+                              const Descriptor* desc,
+                              std::set<string>* required,
+                              std::set<string>* forwards,
+                              bool* have_message) const;
+  void FindRequiresForField(const GeneratorOptions& options,
+                            const FieldDescriptor* field,
+                            std::set<string>* required,
+                            std::set<string>* forwards) const;
+  void FindRequiresForExtension(const GeneratorOptions& options,
+                                const FieldDescriptor* field,
+                                std::set<string>* required,
+                                std::set<string>* forwards) const;
+
+  void GenerateFile(const GeneratorOptions& options,
+                    io::Printer* printer,
+                    const FileDescriptor* file) const;
+
+  // Generate definitions for all message classes and enums in all files,
+  // processing the files in dependence order.
+  void GenerateFilesInDepOrder(
+      const GeneratorOptions& options, io::Printer* printer,
+      const std::vector<const FileDescriptor*>& file) const;
+  // Helper for above.
+  void GenerateFileAndDeps(const GeneratorOptions& options,
+                           io::Printer* printer,
+                           const FileDescriptor* root,
+                           std::set<const FileDescriptor*>* all_files,
+                           std::set<const FileDescriptor*>* generated) const;
+
+  // Generate definitions for all message classes and enums.
+  void GenerateClassesAndEnums(const GeneratorOptions& options,
+                               io::Printer* printer,
+                               const FileDescriptor* file) const;
+
+  void GenerateFieldValueExpression(io::Printer* printer,
+                                    const char* obj_reference,
+                                    const FieldDescriptor* field,
+                                    bool use_default) const;
+
+  // Generate definition for one class.
+  void GenerateClass(const GeneratorOptions& options,
+                     io::Printer* printer,
+                     const Descriptor* desc) const;
+  void GenerateClassConstructor(const GeneratorOptions& options,
+                                io::Printer* printer,
+                                const Descriptor* desc) const;
+  void GenerateClassFieldInfo(const GeneratorOptions& options,
+                              io::Printer* printer,
+                              const Descriptor* desc) const;
+  void GenerateClassXid(const GeneratorOptions& options,
+                        io::Printer* printer,
+                        const Descriptor* desc) const;
+  void GenerateOneofCaseDefinition(const GeneratorOptions& options,
+                                   io::Printer* printer,
+                                   const OneofDescriptor* oneof) const;
+  void GenerateClassToObject(const GeneratorOptions& options,
+                             io::Printer* printer,
+                             const Descriptor* desc) const;
+  void GenerateClassFieldToObject(const GeneratorOptions& options,
+                                  io::Printer* printer,
+                                  const FieldDescriptor* field) const;
+  void GenerateClassFromObject(const GeneratorOptions& options,
+                               io::Printer* printer,
+                               const Descriptor* desc) const;
+  void GenerateClassFieldFromObject(const GeneratorOptions& options,
+                                    io::Printer* printer,
+                                    const FieldDescriptor* field) const;
+  void GenerateClassClone(const GeneratorOptions& options,
+                          io::Printer* printer,
+                          const Descriptor* desc) const;
+  void GenerateClassRegistration(const GeneratorOptions& options,
+                                 io::Printer* printer,
+                                 const Descriptor* desc) const;
+  void GenerateClassFields(const GeneratorOptions& options,
+                           io::Printer* printer,
+                           const Descriptor* desc) const;
+  void GenerateClassField(const GeneratorOptions& options,
+                          io::Printer* printer,
+                          const FieldDescriptor* desc) const;
+  void GenerateClassExtensionFieldInfo(const GeneratorOptions& options,
+                                       io::Printer* printer,
+                                       const Descriptor* desc) const;
+  void GenerateClassDeserialize(const GeneratorOptions& options,
+                                io::Printer* printer,
+                                const Descriptor* desc) const;
+  void GenerateClassDeserializeBinary(const GeneratorOptions& options,
+                                      io::Printer* printer,
+                                      const Descriptor* desc) const;
+  void GenerateClassDeserializeBinaryField(const GeneratorOptions& options,
+                                           io::Printer* printer,
+                                           const FieldDescriptor* field) const;
+  void GenerateClassSerializeBinary(const GeneratorOptions& options,
+                                    io::Printer* printer,
+                                    const Descriptor* desc) const;
+  void GenerateClassSerializeBinaryField(const GeneratorOptions& options,
+                                         io::Printer* printer,
+                                         const FieldDescriptor* field) const;
+
+  // Generate definition for one enum.
+  void GenerateEnum(const GeneratorOptions& options,
+                    io::Printer* printer,
+                    const EnumDescriptor* enumdesc) const;
+
+  // Generate an extension definition.
+  void GenerateExtension(const GeneratorOptions& options,
+                         io::Printer* printer,
+                         const FieldDescriptor* field) const;
+
+  // Generate addFoo() method for repeated primitive fields.
+  void GenerateRepeatedPrimitiveHelperMethods(const GeneratorOptions& options,
+                                              io::Printer* printer,
+                                              const FieldDescriptor* field,
+                                              bool untyped) const;
+
+  // Generate addFoo() method for repeated message fields.
+  void GenerateRepeatedMessageHelperMethods(const GeneratorOptions& options,
+                                            io::Printer* printer,
+                                            const FieldDescriptor* field) const;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Generator);
+};
+
+}  // namespace js
+}  // namespace compiler
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_COMPILER_JS_GENERATOR_H__
diff --git a/kortex_api/include/google/protobuf/compiler/js/well_known_types_embed.h b/kortex_api/include/google/protobuf/compiler/js/well_known_types_embed.h
new file mode 100644
index 0000000000000000000000000000000000000000..174c665e452c8f99956cc4198342e7ba4576ee8b
--- /dev/null
+++ b/kortex_api/include/google/protobuf/compiler/js/well_known_types_embed.h
@@ -0,0 +1,43 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_JS_WELL_KNOWN_TYPES_EMBED_H__
+#define GOOGLE_PROTOBUF_COMPILER_JS_WELL_KNOWN_TYPES_EMBED_H__
+
+#include <stddef.h>
+
+struct FileToc {
+  const char* name;
+  const char* data;
+};
+
+extern struct FileToc well_known_types_js[];
+
+#endif  // GOOGLE_PROTOBUF_COMPILER_JS_WELL_KNOWN_TYPES_EMBED_H__
diff --git a/kortex_api/include/google/protobuf/compiler/objectivec/objectivec_generator.h b/kortex_api/include/google/protobuf/compiler/objectivec/objectivec_generator.h
new file mode 100644
index 0000000000000000000000000000000000000000..b172331861b2c726f0a973b9807451296704a21d
--- /dev/null
+++ b/kortex_api/include/google/protobuf/compiler/objectivec/objectivec_generator.h
@@ -0,0 +1,72 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Generates ObjectiveC code for a given .proto file.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_OBJECTIVEC_GENERATOR_H__
+#define GOOGLE_PROTOBUF_COMPILER_OBJECTIVEC_GENERATOR_H__
+
+#include <string>
+#include <google/protobuf/compiler/code_generator.h>
+
+namespace google {
+namespace protobuf {
+namespace compiler {
+namespace objectivec {
+
+// CodeGenerator implementation which generates a ObjectiveC source file and
+// header.  If you create your own protocol compiler binary and you want it to
+// support ObjectiveC output, you can do so by registering an instance of this
+// CodeGenerator with the CommandLineInterface in your main() function.
+class LIBPROTOC_EXPORT ObjectiveCGenerator : public CodeGenerator {
+ public:
+  ObjectiveCGenerator();
+  ~ObjectiveCGenerator();
+
+  // implements CodeGenerator ----------------------------------------
+  bool HasGenerateAll() const;
+  bool Generate(const FileDescriptor* file,
+                const string& parameter,
+                GeneratorContext* context,
+                string* error) const;
+  bool GenerateAll(const vector<const FileDescriptor*>& files,
+                   const string& parameter,
+                   GeneratorContext* context,
+                   string* error) const;
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ObjectiveCGenerator);
+};
+
+}  // namespace objectivec
+}  // namespace compiler
+}  // namespace protobuf
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_COMPILER_OBJECTIVEC_GENERATOR_H__
diff --git a/kortex_api/include/google/protobuf/compiler/objectivec/objectivec_helpers.h b/kortex_api/include/google/protobuf/compiler/objectivec/objectivec_helpers.h
new file mode 100644
index 0000000000000000000000000000000000000000..daea7609e592393424a1cdd2982fb854b25bf960
--- /dev/null
+++ b/kortex_api/include/google/protobuf/compiler/objectivec/objectivec_helpers.h
@@ -0,0 +1,291 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Helper functions for generating ObjectiveC code.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_OBJECTIVEC_HELPERS_H__
+#define GOOGLE_PROTOBUF_COMPILER_OBJECTIVEC_HELPERS_H__
+
+#include <string>
+#include <vector>
+
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/descriptor.pb.h>
+
+namespace google {
+namespace protobuf {
+namespace compiler {
+namespace objectivec {
+
+// Generator options (see objectivec_generator.cc for a description of each):
+struct Options {
+  Options();
+  string expected_prefixes_path;
+  string generate_for_named_framework;
+  string named_framework_to_proto_path_mappings_path;
+};
+
+// Escape C++ trigraphs by escaping question marks to "\?".
+string LIBPROTOC_EXPORT EscapeTrigraphs(const string& to_escape);
+
+// Strips ".proto" or ".protodevel" from the end of a filename.
+string LIBPROTOC_EXPORT StripProto(const string& filename);
+
+// Remove white space from either end of a StringPiece.
+void LIBPROTOC_EXPORT StringPieceTrimWhitespace(StringPiece* input);
+
+// Returns true if the name requires a ns_returns_not_retained attribute applied
+// to it.
+bool LIBPROTOC_EXPORT IsRetainedName(const string& name);
+
+// Returns true if the name starts with "init" and will need to have special
+// handling under ARC.
+bool LIBPROTOC_EXPORT IsInitName(const string& name);
+
+// Gets the objc_class_prefix.
+string LIBPROTOC_EXPORT FileClassPrefix(const FileDescriptor* file);
+
+// Gets the path of the file we're going to generate (sans the .pb.h
+// extension).  The path will be dependent on the objectivec package
+// declared in the proto package.
+string LIBPROTOC_EXPORT FilePath(const FileDescriptor* file);
+
+// Just like FilePath(), but without the directory part.
+string LIBPROTOC_EXPORT FilePathBasename(const FileDescriptor* file);
+
+// Gets the name of the root class we'll generate in the file.  This class
+// is not meant for external consumption, but instead contains helpers that
+// the rest of the classes need
+string LIBPROTOC_EXPORT FileClassName(const FileDescriptor* file);
+
+// These return the fully-qualified class name corresponding to the given
+// descriptor.
+string LIBPROTOC_EXPORT ClassName(const Descriptor* descriptor);
+string LIBPROTOC_EXPORT ClassName(const Descriptor* descriptor, string* out_suffix_added);
+string LIBPROTOC_EXPORT EnumName(const EnumDescriptor* descriptor);
+
+// Returns the fully-qualified name of the enum value corresponding to the
+// the descriptor.
+string LIBPROTOC_EXPORT EnumValueName(const EnumValueDescriptor* descriptor);
+
+// Returns the name of the enum value corresponding to the descriptor.
+string LIBPROTOC_EXPORT EnumValueShortName(const EnumValueDescriptor* descriptor);
+
+// Reverse what an enum does.
+string LIBPROTOC_EXPORT UnCamelCaseEnumShortName(const string& name);
+
+// Returns the name to use for the extension (used as the method off the file's
+// Root class).
+string LIBPROTOC_EXPORT ExtensionMethodName(const FieldDescriptor* descriptor);
+
+// Returns the transformed field name.
+string LIBPROTOC_EXPORT FieldName(const FieldDescriptor* field);
+string LIBPROTOC_EXPORT FieldNameCapitalized(const FieldDescriptor* field);
+
+// Returns the transformed oneof name.
+string LIBPROTOC_EXPORT OneofEnumName(const OneofDescriptor* descriptor);
+string LIBPROTOC_EXPORT OneofName(const OneofDescriptor* descriptor);
+string LIBPROTOC_EXPORT OneofNameCapitalized(const OneofDescriptor* descriptor);
+
+inline bool HasFieldPresence(const FileDescriptor* file) {
+  return file->syntax() != FileDescriptor::SYNTAX_PROTO3;
+}
+
+inline bool HasPreservingUnknownEnumSemantics(const FileDescriptor* file) {
+  return file->syntax() == FileDescriptor::SYNTAX_PROTO3;
+}
+
+inline bool IsMapEntryMessage(const Descriptor* descriptor) {
+  return descriptor->options().map_entry();
+}
+
+// Reverse of the above.
+string LIBPROTOC_EXPORT UnCamelCaseFieldName(const string& name, const FieldDescriptor* field);
+
+enum ObjectiveCType {
+  OBJECTIVECTYPE_INT32,
+  OBJECTIVECTYPE_UINT32,
+  OBJECTIVECTYPE_INT64,
+  OBJECTIVECTYPE_UINT64,
+  OBJECTIVECTYPE_FLOAT,
+  OBJECTIVECTYPE_DOUBLE,
+  OBJECTIVECTYPE_BOOLEAN,
+  OBJECTIVECTYPE_STRING,
+  OBJECTIVECTYPE_DATA,
+  OBJECTIVECTYPE_ENUM,
+  OBJECTIVECTYPE_MESSAGE
+};
+
+enum FlagType {
+  FLAGTYPE_DESCRIPTOR_INITIALIZATION,
+  FLAGTYPE_EXTENSION,
+  FLAGTYPE_FIELD
+};
+
+template<class TDescriptor>
+string GetOptionalDeprecatedAttribute(
+    const TDescriptor* descriptor,
+    const FileDescriptor* file = NULL,
+    bool preSpace = true, bool postNewline = false) {
+  bool isDeprecated = descriptor->options().deprecated();
+  // The file is only passed when checking Messages & Enums, so those types
+  // get tagged. At the moment, it doesn't seem to make sense to tag every
+  // field or enum value with when the file is deprecated.
+  if (!isDeprecated && file) {
+    isDeprecated = file->options().deprecated();
+  }
+  if (isDeprecated) {
+    string result = "DEPRECATED_ATTRIBUTE";
+    if (preSpace) {
+      result.insert(0, " ");
+    }
+    if (postNewline) {
+      result.append("\n");
+    }
+    return result;
+  } else {
+    return "";
+  }
+}
+
+string LIBPROTOC_EXPORT GetCapitalizedType(const FieldDescriptor* field);
+
+ObjectiveCType LIBPROTOC_EXPORT GetObjectiveCType(FieldDescriptor::Type field_type);
+
+inline ObjectiveCType GetObjectiveCType(const FieldDescriptor* field) {
+  return GetObjectiveCType(field->type());
+}
+
+bool LIBPROTOC_EXPORT IsPrimitiveType(const FieldDescriptor* field);
+bool LIBPROTOC_EXPORT IsReferenceType(const FieldDescriptor* field);
+
+string LIBPROTOC_EXPORT GPBGenericValueFieldName(const FieldDescriptor* field);
+string LIBPROTOC_EXPORT DefaultValue(const FieldDescriptor* field);
+bool LIBPROTOC_EXPORT HasNonZeroDefaultValue(const FieldDescriptor* field);
+
+string LIBPROTOC_EXPORT BuildFlagsString(const FlagType type, const vector<string>& strings);
+
+// Builds HeaderDoc/appledoc style comments out of the comments in the .proto
+// file.
+string LIBPROTOC_EXPORT BuildCommentsString(const SourceLocation& location,
+                           bool prefer_single_line);
+
+// The name the commonly used by the library when built as a framework.
+// This lines up to the name used in the CocoaPod.
+extern LIBPROTOC_EXPORT const char* const ProtobufLibraryFrameworkName;
+// Returns the CPP symbol name to use as the gate for framework style imports
+// for the given framework name to use.
+string LIBPROTOC_EXPORT ProtobufFrameworkImportSymbol(const string& framework_name);
+
+// Checks if the file is one of the proto's bundled with the library.
+bool LIBPROTOC_EXPORT IsProtobufLibraryBundledProtoFile(const FileDescriptor* file);
+
+// Checks the prefix for the given files and outputs any warnings as needed. If
+// there are flat out errors, then out_error is filled in with the first error
+// and the result is false.
+bool LIBPROTOC_EXPORT ValidateObjCClassPrefixes(const vector<const FileDescriptor*>& files,
+                               const Options& generation_options,
+                               string* out_error);
+
+// Generate decode data needed for ObjC's GPBDecodeTextFormatName() to transform
+// the input into the expected output.
+class LIBPROTOC_EXPORT TextFormatDecodeData {
+ public:
+  TextFormatDecodeData();
+  ~TextFormatDecodeData();
+
+  void AddString(int32 key, const string& input_for_decode,
+                 const string& desired_output);
+  size_t num_entries() const { return entries_.size(); }
+  string Data() const;
+
+  static string DecodeDataForString(const string& input_for_decode,
+                                    const string& desired_output);
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(TextFormatDecodeData);
+
+  typedef std::pair<int32, string> DataEntry;
+  vector<DataEntry> entries_;
+};
+
+// Helper for parsing simple files.
+class LIBPROTOC_EXPORT LineConsumer {
+ public:
+  LineConsumer();
+  virtual ~LineConsumer();
+  virtual bool ConsumeLine(const StringPiece& line, string* out_error) = 0;
+};
+
+bool LIBPROTOC_EXPORT ParseSimpleFile(
+    const string& path, LineConsumer* line_consumer, string* out_error);
+
+
+// Helper class for parsing framework import mappings and generating
+// import statements.
+class LIBPROTOC_EXPORT ImportWriter {
+ public:
+  ImportWriter(const string& generate_for_named_framework,
+               const string& named_framework_to_proto_path_mappings_path);
+  ~ImportWriter();
+
+  void AddFile(const FileDescriptor* file, const string& header_extension);
+  void Print(io::Printer *printer) const;
+
+ private:
+  class ProtoFrameworkCollector : public LineConsumer {
+   public:
+    ProtoFrameworkCollector(std::map<string, string>* inout_proto_file_to_framework_name)
+        : map_(inout_proto_file_to_framework_name) {}
+
+    virtual bool ConsumeLine(const StringPiece& line, string* out_error);
+
+   private:
+    std::map<string, string>* map_;
+  };
+
+  void ParseFrameworkMappings();
+
+  const string generate_for_named_framework_;
+  const string named_framework_to_proto_path_mappings_path_;
+  std::map<string, string> proto_file_to_framework_name_;
+  bool need_to_parse_mapping_file_;
+
+  vector<string> protobuf_framework_imports_;
+  vector<string> protobuf_non_framework_imports_;
+  vector<string> other_framework_imports_;
+  vector<string> other_imports_;
+};
+
+}  // namespace objectivec
+}  // namespace compiler
+}  // namespace protobuf
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_COMPILER_OBJECTIVEC_HELPERS_H__
diff --git a/kortex_api/include/google/protobuf/compiler/parser.h b/kortex_api/include/google/protobuf/compiler/parser.h
new file mode 100644
index 0000000000000000000000000000000000000000..33b4c7009a55669e901727a379f076e5d883a792
--- /dev/null
+++ b/kortex_api/include/google/protobuf/compiler/parser.h
@@ -0,0 +1,575 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// Implements parsing of .proto files to FileDescriptorProtos.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_PARSER_H__
+#define GOOGLE_PROTOBUF_COMPILER_PARSER_H__
+
+#include <map>
+#include <string>
+#include <utility>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/descriptor.pb.h>
+#include <google/protobuf/repeated_field.h>
+#include <google/protobuf/io/tokenizer.h>
+
+namespace google {
+namespace protobuf { class Message; }
+
+namespace protobuf {
+namespace compiler {
+
+// Defined in this file.
+class Parser;
+class SourceLocationTable;
+
+// Implements parsing of protocol definitions (such as .proto files).
+//
+// Note that most users will be more interested in the Importer class.
+// Parser is a lower-level class which simply converts a single .proto file
+// to a FileDescriptorProto.  It does not resolve import directives or perform
+// many other kinds of validation needed to construct a complete
+// FileDescriptor.
+class LIBPROTOBUF_EXPORT Parser {
+ public:
+  Parser();
+  ~Parser();
+
+  // Parse the entire input and construct a FileDescriptorProto representing
+  // it.  Returns true if no errors occurred, false otherwise.
+  bool Parse(io::Tokenizer* input, FileDescriptorProto* file);
+
+  // Optional features:
+
+  // DEPRECATED:  New code should use the SourceCodeInfo embedded in the
+  //   FileDescriptorProto.
+  //
+  // Requests that locations of certain definitions be recorded to the given
+  // SourceLocationTable while parsing.  This can be used to look up exact line
+  // and column numbers for errors reported by DescriptorPool during validation.
+  // Set to NULL (the default) to discard source location information.
+  void RecordSourceLocationsTo(SourceLocationTable* location_table) {
+    source_location_table_ = location_table;
+  }
+
+  // Requests that errors be recorded to the given ErrorCollector while
+  // parsing.  Set to NULL (the default) to discard error messages.
+  void RecordErrorsTo(io::ErrorCollector* error_collector) {
+    error_collector_ = error_collector;
+  }
+
+  // Returns the identifier used in the "syntax = " declaration, if one was
+  // seen during the last call to Parse(), or the empty string otherwise.
+  const string& GetSyntaxIdentifier() { return syntax_identifier_; }
+
+  // If set true, input files will be required to begin with a syntax
+  // identifier.  Otherwise, files may omit this.  If a syntax identifier
+  // is provided, it must be 'syntax = "proto2";' and must appear at the
+  // top of this file regardless of whether or not it was required.
+  void SetRequireSyntaxIdentifier(bool value) {
+    require_syntax_identifier_ = value;
+  }
+
+  // Call SetStopAfterSyntaxIdentifier(true) to tell the parser to stop
+  // parsing as soon as it has seen the syntax identifier, or lack thereof.
+  // This is useful for quickly identifying the syntax of the file without
+  // parsing the whole thing.  If this is enabled, no error will be recorded
+  // if the syntax identifier is something other than "proto2" (since
+  // presumably the caller intends to deal with that), but other kinds of
+  // errors (e.g. parse errors) will still be reported.  When this is enabled,
+  // you may pass a NULL FileDescriptorProto to Parse().
+  void SetStopAfterSyntaxIdentifier(bool value) {
+    stop_after_syntax_identifier_ = value;
+  }
+
+ private:
+  class LocationRecorder;
+
+  // =================================================================
+  // Error recovery helpers
+
+  // Consume the rest of the current statement.  This consumes tokens
+  // until it sees one of:
+  //   ';'  Consumes the token and returns.
+  //   '{'  Consumes the brace then calls SkipRestOfBlock().
+  //   '}'  Returns without consuming.
+  //   EOF  Returns (can't consume).
+  // The Parser often calls SkipStatement() after encountering a syntax
+  // error.  This allows it to go on parsing the following lines, allowing
+  // it to report more than just one error in the file.
+  void SkipStatement();
+
+  // Consume the rest of the current block, including nested blocks,
+  // ending after the closing '}' is encountered and consumed, or at EOF.
+  void SkipRestOfBlock();
+
+  // -----------------------------------------------------------------
+  // Single-token consuming helpers
+  //
+  // These make parsing code more readable.
+
+  // True if the current token is TYPE_END.
+  inline bool AtEnd();
+
+  // True if the next token matches the given text.
+  inline bool LookingAt(const char* text);
+  // True if the next token is of the given type.
+  inline bool LookingAtType(io::Tokenizer::TokenType token_type);
+
+  // If the next token exactly matches the text given, consume it and return
+  // true.  Otherwise, return false without logging an error.
+  bool TryConsume(const char* text);
+
+  // These attempt to read some kind of token from the input.  If successful,
+  // they return true.  Otherwise they return false and add the given error
+  // to the error list.
+
+  // Consume a token with the exact text given.
+  bool Consume(const char* text, const char* error);
+  // Same as above, but automatically generates the error "Expected \"text\".",
+  // where "text" is the expected token text.
+  bool Consume(const char* text);
+  // Consume a token of type IDENTIFIER and store its text in "output".
+  bool ConsumeIdentifier(string* output, const char* error);
+  // Consume an integer and store its value in "output".
+  bool ConsumeInteger(int* output, const char* error);
+  // Consume a signed integer and store its value in "output".
+  bool ConsumeSignedInteger(int* output, const char* error);
+  // Consume a 64-bit integer and store its value in "output".  If the value
+  // is greater than max_value, an error will be reported.
+  bool ConsumeInteger64(uint64 max_value, uint64* output, const char* error);
+  // Consume a number and store its value in "output".  This will accept
+  // tokens of either INTEGER or FLOAT type.
+  bool ConsumeNumber(double* output, const char* error);
+  // Consume a string literal and store its (unescaped) value in "output".
+  bool ConsumeString(string* output, const char* error);
+
+  // Consume a token representing the end of the statement.  Comments between
+  // this token and the next will be harvested for documentation.  The given
+  // LocationRecorder should refer to the declaration that was just parsed;
+  // it will be populated with these comments.
+  //
+  // TODO(kenton):  The LocationRecorder is const because historically locations
+  //   have been passed around by const reference, for no particularly good
+  //   reason.  We should probably go through and change them all to mutable
+  //   pointer to make this more intuitive.
+  bool TryConsumeEndOfDeclaration(
+      const char* text, const LocationRecorder* location);
+  bool TryConsumeEndOfDeclarationFinishScope(
+      const char* text, const LocationRecorder* location);
+
+  bool ConsumeEndOfDeclaration(
+      const char* text, const LocationRecorder* location);
+
+  // -----------------------------------------------------------------
+  // Error logging helpers
+
+  // Invokes error_collector_->AddError(), if error_collector_ is not NULL.
+  void AddError(int line, int column, const string& error);
+
+  // Invokes error_collector_->AddError() with the line and column number
+  // of the current token.
+  void AddError(const string& error);
+
+  // Records a location in the SourceCodeInfo.location table (see
+  // descriptor.proto).  We use RAII to ensure that the start and end locations
+  // are recorded -- the constructor records the start location and the
+  // destructor records the end location.  Since the parser is
+  // recursive-descent, this works out beautifully.
+  class LIBPROTOBUF_EXPORT LocationRecorder {
+   public:
+    // Construct the file's "root" location.
+    LocationRecorder(Parser* parser);
+
+    // Construct a location that represents a declaration nested within the
+    // given parent.  E.g. a field's location is nested within the location
+    // for a message type.  The parent's path will be copied, so you should
+    // call AddPath() only to add the path components leading from the parent
+    // to the child (as opposed to leading from the root to the child).
+    LocationRecorder(const LocationRecorder& parent);
+
+    // Convenience constructors that call AddPath() one or two times.
+    LocationRecorder(const LocationRecorder& parent, int path1);
+    LocationRecorder(const LocationRecorder& parent, int path1, int path2);
+
+    ~LocationRecorder();
+
+    // Add a path component.  See SourceCodeInfo.Location.path in
+    // descriptor.proto.
+    void AddPath(int path_component);
+
+    // By default the location is considered to start at the current token at
+    // the time the LocationRecorder is created.  StartAt() sets the start
+    // location to the given token instead.
+    void StartAt(const io::Tokenizer::Token& token);
+
+    // Start at the same location as some other LocationRecorder.
+    void StartAt(const LocationRecorder& other);
+
+    // By default the location is considered to end at the previous token at
+    // the time the LocationRecorder is destroyed.  EndAt() sets the end
+    // location to the given token instead.
+    void EndAt(const io::Tokenizer::Token& token);
+
+    // Records the start point of this location to the SourceLocationTable that
+    // was passed to RecordSourceLocationsTo(), if any.  SourceLocationTable
+    // is an older way of keeping track of source locations which is still
+    // used in some places.
+    void RecordLegacyLocation(const Message* descriptor,
+        DescriptorPool::ErrorCollector::ErrorLocation location);
+
+    // Attaches leading and trailing comments to the location.  The two strings
+    // will be swapped into place, so after this is called *leading and
+    // *trailing will be empty.
+    //
+    // TODO(kenton):  See comment on TryConsumeEndOfDeclaration(), above, for
+    //   why this is const.
+    void AttachComments(string* leading, string* trailing,
+                        std::vector<string>* detached_comments) const;
+
+   private:
+    // Indexes of parent and current location in the parent
+    // SourceCodeInfo.location repeated field. For top-level elements,
+    // parent_index_ is -1.
+    Parser* parser_;
+    SourceCodeInfo::Location* location_;
+
+    void Init(const LocationRecorder& parent);
+  };
+
+  // =================================================================
+  // Parsers for various language constructs
+
+  // Parses the "syntax = \"proto2\";" line at the top of the file.  Returns
+  // false if it failed to parse or if the syntax identifier was not
+  // recognized.
+  bool ParseSyntaxIdentifier(const LocationRecorder& parent);
+
+  // These methods parse various individual bits of code.  They return
+  // false if they completely fail to parse the construct.  In this case,
+  // it is probably necessary to skip the rest of the statement to recover.
+  // However, if these methods return true, it does NOT mean that there
+  // were no errors; only that there were no *syntax* errors.  For instance,
+  // if a service method is defined using proper syntax but uses a primitive
+  // type as its input or output, ParseMethodField() still returns true
+  // and only reports the error by calling AddError().  In practice, this
+  // makes logic much simpler for the caller.
+
+  // Parse a top-level message, enum, service, etc.
+  bool ParseTopLevelStatement(FileDescriptorProto* file,
+                              const LocationRecorder& root_location);
+
+  // Parse various language high-level language construrcts.
+  bool ParseMessageDefinition(DescriptorProto* message,
+                              const LocationRecorder& message_location,
+                              const FileDescriptorProto* containing_file);
+  bool ParseEnumDefinition(EnumDescriptorProto* enum_type,
+                           const LocationRecorder& enum_location,
+                           const FileDescriptorProto* containing_file);
+  bool ParseServiceDefinition(ServiceDescriptorProto* service,
+                              const LocationRecorder& service_location,
+                              const FileDescriptorProto* containing_file);
+  bool ParsePackage(FileDescriptorProto* file,
+                    const LocationRecorder& root_location,
+                    const FileDescriptorProto* containing_file);
+  bool ParseImport(RepeatedPtrField<string>* dependency,
+                   RepeatedField<int32>* public_dependency,
+                   RepeatedField<int32>* weak_dependency,
+                   const LocationRecorder& root_location,
+                   const FileDescriptorProto* containing_file);
+
+  // These methods parse the contents of a message, enum, or service type and
+  // add them to the given object.  They consume the entire block including
+  // the beginning and ending brace.
+  bool ParseMessageBlock(DescriptorProto* message,
+                         const LocationRecorder& message_location,
+                         const FileDescriptorProto* containing_file);
+  bool ParseEnumBlock(EnumDescriptorProto* enum_type,
+                      const LocationRecorder& enum_location,
+                      const FileDescriptorProto* containing_file);
+  bool ParseServiceBlock(ServiceDescriptorProto* service,
+                         const LocationRecorder& service_location,
+                         const FileDescriptorProto* containing_file);
+
+  // Parse one statement within a message, enum, or service block, including
+  // final semicolon.
+  bool ParseMessageStatement(DescriptorProto* message,
+                             const LocationRecorder& message_location,
+                             const FileDescriptorProto* containing_file);
+  bool ParseEnumStatement(EnumDescriptorProto* message,
+                          const LocationRecorder& enum_location,
+                          const FileDescriptorProto* containing_file);
+  bool ParseServiceStatement(ServiceDescriptorProto* message,
+                             const LocationRecorder& service_location,
+                             const FileDescriptorProto* containing_file);
+
+  // Parse a field of a message.  If the field is a group, its type will be
+  // added to "messages".
+  //
+  // parent_location and location_field_number_for_nested_type are needed when
+  // parsing groups -- we need to generate a nested message type within the
+  // parent and record its location accordingly.  Since the parent could be
+  // either a FileDescriptorProto or a DescriptorProto, we must pass in the
+  // correct field number to use.
+  bool ParseMessageField(FieldDescriptorProto* field,
+                         RepeatedPtrField<DescriptorProto>* messages,
+                         const LocationRecorder& parent_location,
+                         int location_field_number_for_nested_type,
+                         const LocationRecorder& field_location,
+                         const FileDescriptorProto* containing_file);
+
+  // Like ParseMessageField() but expects the label has already been filled in
+  // by the caller.
+  bool ParseMessageFieldNoLabel(FieldDescriptorProto* field,
+                                RepeatedPtrField<DescriptorProto>* messages,
+                                const LocationRecorder& parent_location,
+                                int location_field_number_for_nested_type,
+                                const LocationRecorder& field_location,
+                                const FileDescriptorProto* containing_file);
+
+  // Parse an "extensions" declaration.
+  bool ParseExtensions(DescriptorProto* message,
+                       const LocationRecorder& extensions_location,
+                       const FileDescriptorProto* containing_file);
+
+  // Parse a "reserved" declaration.
+  bool ParseReserved(DescriptorProto* message,
+                     const LocationRecorder& message_location);
+  bool ParseReservedNames(DescriptorProto* message,
+                          const LocationRecorder& parent_location);
+  bool ParseReservedNumbers(DescriptorProto* message,
+                            const LocationRecorder& parent_location);
+  bool ParseReserved(EnumDescriptorProto* message,
+                     const LocationRecorder& message_location);
+  bool ParseReservedNames(EnumDescriptorProto* message,
+                          const LocationRecorder& parent_location);
+  bool ParseReservedNumbers(EnumDescriptorProto* message,
+                            const LocationRecorder& parent_location);
+
+  // Parse an "extend" declaration.  (See also comments for
+  // ParseMessageField().)
+  bool ParseExtend(RepeatedPtrField<FieldDescriptorProto>* extensions,
+                   RepeatedPtrField<DescriptorProto>* messages,
+                   const LocationRecorder& parent_location,
+                   int location_field_number_for_nested_type,
+                   const LocationRecorder& extend_location,
+                   const FileDescriptorProto* containing_file);
+
+  // Parse a "oneof" declaration.  The caller is responsible for setting
+  // oneof_decl->label() since it will have had to parse the label before it
+  // knew it was parsing a oneof.
+  bool ParseOneof(OneofDescriptorProto* oneof_decl,
+                  DescriptorProto* containing_type,
+                  int oneof_index,
+                  const LocationRecorder& oneof_location,
+                  const LocationRecorder& containing_type_location,
+                  const FileDescriptorProto* containing_file);
+
+  // Parse a single enum value within an enum block.
+  bool ParseEnumConstant(EnumValueDescriptorProto* enum_value,
+                         const LocationRecorder& enum_value_location,
+                         const FileDescriptorProto* containing_file);
+
+  // Parse enum constant options, i.e. the list in square brackets at the end
+  // of the enum constant value definition.
+  bool ParseEnumConstantOptions(EnumValueDescriptorProto* value,
+                                const LocationRecorder& enum_value_location,
+                                const FileDescriptorProto* containing_file);
+
+  // Parse a single method within a service definition.
+  bool ParseServiceMethod(MethodDescriptorProto* method,
+                          const LocationRecorder& method_location,
+                          const FileDescriptorProto* containing_file);
+
+
+  // Parse options of a single method or stream.
+  bool ParseMethodOptions(const LocationRecorder& parent_location,
+                          const FileDescriptorProto* containing_file,
+                          const int optionsFieldNumber,
+                          Message* mutable_options);
+
+  // Parse "required", "optional", or "repeated" and fill in "label"
+  // with the value. Returns true if such a label is consumed.
+  bool ParseLabel(FieldDescriptorProto::Label* label,
+                  const FileDescriptorProto* containing_file);
+
+  // Parse a type name and fill in "type" (if it is a primitive) or
+  // "type_name" (if it is not) with the type parsed.
+  bool ParseType(FieldDescriptorProto::Type* type,
+                 string* type_name);
+  // Parse a user-defined type and fill in "type_name" with the name.
+  // If a primitive type is named, it is treated as an error.
+  bool ParseUserDefinedType(string* type_name);
+
+  // Parses field options, i.e. the stuff in square brackets at the end
+  // of a field definition.  Also parses default value.
+  bool ParseFieldOptions(FieldDescriptorProto* field,
+                         const LocationRecorder& field_location,
+                         const FileDescriptorProto* containing_file);
+
+  // Parse the "default" option.  This needs special handling because its
+  // type is the field's type.
+  bool ParseDefaultAssignment(FieldDescriptorProto* field,
+                              const LocationRecorder& field_location,
+                              const FileDescriptorProto* containing_file);
+
+  bool ParseJsonName(FieldDescriptorProto* field,
+                     const LocationRecorder& field_location,
+                     const FileDescriptorProto* containing_file);
+
+  enum OptionStyle {
+    OPTION_ASSIGNMENT,  // just "name = value"
+    OPTION_STATEMENT    // "option name = value;"
+  };
+
+  // Parse a single option name/value pair, e.g. "ctype = CORD".  The name
+  // identifies a field of the given Message, and the value of that field
+  // is set to the parsed value.
+  bool ParseOption(Message* options,
+                   const LocationRecorder& options_location,
+                   const FileDescriptorProto* containing_file,
+                   OptionStyle style);
+
+  // Parses a single part of a multipart option name. A multipart name consists
+  // of names separated by dots. Each name is either an identifier or a series
+  // of identifiers separated by dots and enclosed in parentheses. E.g.,
+  // "foo.(bar.baz).qux".
+  bool ParseOptionNamePart(UninterpretedOption* uninterpreted_option,
+                           const LocationRecorder& part_location,
+                           const FileDescriptorProto* containing_file);
+
+  // Parses a string surrounded by balanced braces.  Strips off the outer
+  // braces and stores the enclosed string in *value.
+  // E.g.,
+  //     { foo }                     *value gets 'foo'
+  //     { foo { bar: box } }        *value gets 'foo { bar: box }'
+  //     {}                          *value gets ''
+  //
+  // REQUIRES: LookingAt("{")
+  // When finished successfully, we are looking at the first token past
+  // the ending brace.
+  bool ParseUninterpretedBlock(string* value);
+
+  struct MapField {
+    // Whether the field is a map field.
+    bool is_map_field;
+    // The types of the key and value if they are primitive types.
+    FieldDescriptorProto::Type key_type;
+    FieldDescriptorProto::Type value_type;
+    // Or the type names string if the types are customized types.
+    string key_type_name;
+    string value_type_name;
+
+    MapField() : is_map_field(false) {}
+  };
+  // Desugar the map syntax to generate a nested map entry message.
+  void GenerateMapEntry(const MapField& map_field, FieldDescriptorProto* field,
+                        RepeatedPtrField<DescriptorProto>* messages);
+
+  // Whether fields without label default to optional fields.
+  bool DefaultToOptionalFields() const {
+    return syntax_identifier_ == "proto3";
+  }
+
+
+  bool ValidateEnum(const EnumDescriptorProto* proto);
+
+  // =================================================================
+
+  io::Tokenizer* input_;
+  io::ErrorCollector* error_collector_;
+  SourceCodeInfo* source_code_info_;
+  SourceLocationTable* source_location_table_;  // legacy
+  bool had_errors_;
+  bool require_syntax_identifier_;
+  bool stop_after_syntax_identifier_;
+  string syntax_identifier_;
+
+  // Leading doc comments for the next declaration.  These are not complete
+  // yet; use ConsumeEndOfDeclaration() to get the complete comments.
+  string upcoming_doc_comments_;
+
+  // Detached comments are not connected to any syntax entities. Elements in
+  // this vector are paragraphs of comments separated by empty lines. The
+  // detached comments will be put into the leading_detached_comments field for
+  // the next element (See SourceCodeInfo.Location in descriptor.proto), when
+  // ConsumeEndOfDeclaration() is called.
+  std::vector<string> upcoming_detached_comments_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Parser);
+};
+
+// A table mapping (descriptor, ErrorLocation) pairs -- as reported by
+// DescriptorPool when validating descriptors -- to line and column numbers
+// within the original source code.
+//
+// This is semi-obsolete:  FileDescriptorProto.source_code_info now contains
+// far more complete information about source locations.  However, as of this
+// writing you still need to use SourceLocationTable when integrating with
+// DescriptorPool.
+class LIBPROTOBUF_EXPORT SourceLocationTable {
+ public:
+  SourceLocationTable();
+  ~SourceLocationTable();
+
+  // Finds the precise location of the given error and fills in *line and
+  // *column with the line and column numbers.  If not found, sets *line to
+  // -1 and *column to 0 (since line = -1 is used to mean "error has no exact
+  // location" in the ErrorCollector interface).  Returns true if found, false
+  // otherwise.
+  bool Find(const Message* descriptor,
+            DescriptorPool::ErrorCollector::ErrorLocation location,
+            int* line, int* column) const;
+
+  // Adds a location to the table.
+  void Add(const Message* descriptor,
+           DescriptorPool::ErrorCollector::ErrorLocation location,
+           int line, int column);
+
+  // Clears the contents of the table.
+  void Clear();
+
+ private:
+  typedef std::map<
+    std::pair<const Message*, DescriptorPool::ErrorCollector::ErrorLocation>,
+    std::pair<int, int> > LocationMap;
+  LocationMap location_map_;
+};
+
+}  // namespace compiler
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_COMPILER_PARSER_H__
diff --git a/kortex_api/include/google/protobuf/compiler/php/php_generator.h b/kortex_api/include/google/protobuf/compiler/php/php_generator.h
new file mode 100644
index 0000000000000000000000000000000000000000..67e70bc7b54464cd5f6774bad3a21bb292bda038
--- /dev/null
+++ b/kortex_api/include/google/protobuf/compiler/php/php_generator.h
@@ -0,0 +1,66 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_PHP_GENERATOR_H__
+#define GOOGLE_PROTOBUF_COMPILER_PHP_GENERATOR_H__
+
+#include <google/protobuf/compiler/code_generator.h>
+#include <google/protobuf/descriptor.h>
+
+#include <string>
+
+namespace google {
+namespace protobuf {
+namespace compiler {
+namespace php {
+
+class LIBPROTOC_EXPORT Generator
+    : public google::protobuf::compiler::CodeGenerator {
+  virtual bool Generate(
+      const FileDescriptor* file,
+      const string& parameter,
+      GeneratorContext* generator_context,
+      string* error) const;
+
+};
+
+// To skip reserved keywords in php, some generated classname are prefixed.
+// Other code generators may need following API to figure out the actual
+// classname.
+std::string GeneratedClassName(const google::protobuf::Descriptor* desc);
+std::string GeneratedClassName(const google::protobuf::EnumDescriptor* desc);
+std::string GeneratedClassName(const google::protobuf::ServiceDescriptor* desc);
+
+}  // namespace php
+}  // namespace compiler
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_COMPILER_PHP_GENERATOR_H__
diff --git a/kortex_api/include/google/protobuf/compiler/plugin.h b/kortex_api/include/google/protobuf/compiler/plugin.h
new file mode 100644
index 0000000000000000000000000000000000000000..d2793a9ff13b2409a1a668fd49fdf467fb47132f
--- /dev/null
+++ b/kortex_api/include/google/protobuf/compiler/plugin.h
@@ -0,0 +1,90 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//
+// Front-end for protoc code generator plugins written in C++.
+//
+// To implement a protoc plugin in C++, simply write an implementation of
+// CodeGenerator, then create a main() function like:
+//   int main(int argc, char* argv[]) {
+//     MyCodeGenerator generator;
+//     return google::protobuf::compiler::PluginMain(argc, argv, &generator);
+//   }
+// You must link your plugin against libprotobuf and libprotoc.
+//
+// The core part of PluginMain is to invoke the given CodeGenerator on a
+// CodeGeneratorRequest to generate a CodeGeneratorResponse. This part is
+// abstracted out and made into function GenerateCode so that it can be reused,
+// for example, to implement a variant of PluginMain that does some
+// preprocessing on the input CodeGeneratorRequest before feeding the request
+// to the given code generator.
+//
+// To get protoc to use the plugin, do one of the following:
+// * Place the plugin binary somewhere in the PATH and give it the name
+//   "protoc-gen-NAME" (replacing "NAME" with the name of your plugin).  If you
+//   then invoke protoc with the parameter --NAME_out=OUT_DIR (again, replace
+//   "NAME" with your plugin's name), protoc will invoke your plugin to generate
+//   the output, which will be placed in OUT_DIR.
+// * Place the plugin binary anywhere, with any name, and pass the --plugin
+//   parameter to protoc to direct it to your plugin like so:
+//     protoc --plugin=protoc-gen-NAME=path/to/mybinary --NAME_out=OUT_DIR
+//   On Windows, make sure to include the .exe suffix:
+//     protoc --plugin=protoc-gen-NAME=path/to/mybinary.exe --NAME_out=OUT_DIR
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_PLUGIN_H__
+#define GOOGLE_PROTOBUF_COMPILER_PLUGIN_H__
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+namespace google {
+namespace protobuf {
+namespace compiler {
+
+class CodeGenerator;    // code_generator.h
+class CodeGeneratorRequest;
+class CodeGeneratorResponse;
+
+// Implements main() for a protoc plugin exposing the given code generator.
+LIBPROTOC_EXPORT int PluginMain(int argc, char* argv[], const CodeGenerator* generator);
+
+// Generates code using the given code generator. Returns true if the code
+// generation is successful. If the code geneartion fails, error_msg may be
+// populated to describe the failure cause.
+bool GenerateCode(const CodeGeneratorRequest& request,
+    const CodeGenerator& generator, CodeGeneratorResponse* response,
+    string* error_msg);
+
+}  // namespace compiler
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_COMPILER_PLUGIN_H__
diff --git a/kortex_api/include/google/protobuf/compiler/plugin.pb.h b/kortex_api/include/google/protobuf/compiler/plugin.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..ef1cfb936f3261223fafdb9b3b0bc078ebecff95
--- /dev/null
+++ b/kortex_api/include/google/protobuf/compiler/plugin.pb.h
@@ -0,0 +1,1361 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: google/protobuf/compiler/plugin.proto
+
+#ifndef PROTOBUF_google_2fprotobuf_2fcompiler_2fplugin_2eproto__INCLUDED
+#define PROTOBUF_google_2fprotobuf_2fcompiler_2fplugin_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 3005000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 3005001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+#include <google/protobuf/descriptor.pb.h>
+// @@protoc_insertion_point(includes)
+#ifdef major
+#undef major
+#endif
+#ifdef minor
+#undef minor
+#endif
+
+namespace protobuf_google_2fprotobuf_2fcompiler_2fplugin_2eproto {
+// Internal implementation detail -- do not use these members.
+struct LIBPROTOC_EXPORT TableStruct {
+  static const ::google::protobuf::internal::ParseTableField entries[];
+  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
+  static const ::google::protobuf::internal::ParseTable schema[4];
+  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
+  static const ::google::protobuf::internal::SerializationTable serialization_table[];
+  static const ::google::protobuf::uint32 offsets[];
+};
+void LIBPROTOC_EXPORT AddDescriptors();
+void LIBPROTOC_EXPORT InitDefaultsVersionImpl();
+void LIBPROTOC_EXPORT InitDefaultsVersion();
+void LIBPROTOC_EXPORT InitDefaultsCodeGeneratorRequestImpl();
+void LIBPROTOC_EXPORT InitDefaultsCodeGeneratorRequest();
+void LIBPROTOC_EXPORT InitDefaultsCodeGeneratorResponse_FileImpl();
+void LIBPROTOC_EXPORT InitDefaultsCodeGeneratorResponse_File();
+void LIBPROTOC_EXPORT InitDefaultsCodeGeneratorResponseImpl();
+void LIBPROTOC_EXPORT InitDefaultsCodeGeneratorResponse();
+inline void LIBPROTOC_EXPORT InitDefaults() {
+  InitDefaultsVersion();
+  InitDefaultsCodeGeneratorRequest();
+  InitDefaultsCodeGeneratorResponse_File();
+  InitDefaultsCodeGeneratorResponse();
+}
+}  // namespace protobuf_google_2fprotobuf_2fcompiler_2fplugin_2eproto
+namespace google {
+namespace protobuf {
+namespace compiler {
+class CodeGeneratorRequest;
+class CodeGeneratorRequestDefaultTypeInternal;
+LIBPROTOC_EXPORT extern CodeGeneratorRequestDefaultTypeInternal _CodeGeneratorRequest_default_instance_;
+class CodeGeneratorResponse;
+class CodeGeneratorResponseDefaultTypeInternal;
+LIBPROTOC_EXPORT extern CodeGeneratorResponseDefaultTypeInternal _CodeGeneratorResponse_default_instance_;
+class CodeGeneratorResponse_File;
+class CodeGeneratorResponse_FileDefaultTypeInternal;
+LIBPROTOC_EXPORT extern CodeGeneratorResponse_FileDefaultTypeInternal _CodeGeneratorResponse_File_default_instance_;
+class Version;
+class VersionDefaultTypeInternal;
+LIBPROTOC_EXPORT extern VersionDefaultTypeInternal _Version_default_instance_;
+}  // namespace compiler
+}  // namespace protobuf
+}  // namespace google
+namespace google {
+namespace protobuf {
+namespace compiler {
+
+// ===================================================================
+
+class LIBPROTOC_EXPORT Version : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.compiler.Version) */ {
+ public:
+  Version();
+  virtual ~Version();
+
+  Version(const Version& from);
+
+  inline Version& operator=(const Version& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Version(Version&& from) noexcept
+    : Version() {
+    *this = ::std::move(from);
+  }
+
+  inline Version& operator=(Version&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields();
+  }
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields();
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Version& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Version* internal_default_instance() {
+    return reinterpret_cast<const Version*>(
+               &_Version_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    0;
+
+  void Swap(Version* other);
+  friend void swap(Version& a, Version& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Version* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Version* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Version& from);
+  void MergeFrom(const Version& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Version* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional string suffix = 4;
+  bool has_suffix() const;
+  void clear_suffix();
+  static const int kSuffixFieldNumber = 4;
+  const ::std::string& suffix() const;
+  void set_suffix(const ::std::string& value);
+  #if LANG_CXX11
+  void set_suffix(::std::string&& value);
+  #endif
+  void set_suffix(const char* value);
+  void set_suffix(const char* value, size_t size);
+  ::std::string* mutable_suffix();
+  ::std::string* release_suffix();
+  void set_allocated_suffix(::std::string* suffix);
+
+  // optional int32 major = 1;
+  bool has_major() const;
+  void clear_major();
+  static const int kMajorFieldNumber = 1;
+  ::google::protobuf::int32 major() const;
+  void set_major(::google::protobuf::int32 value);
+
+  // optional int32 minor = 2;
+  bool has_minor() const;
+  void clear_minor();
+  static const int kMinorFieldNumber = 2;
+  ::google::protobuf::int32 minor() const;
+  void set_minor(::google::protobuf::int32 value);
+
+  // optional int32 patch = 3;
+  bool has_patch() const;
+  void clear_patch();
+  static const int kPatchFieldNumber = 3;
+  ::google::protobuf::int32 patch() const;
+  void set_patch(::google::protobuf::int32 value);
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.compiler.Version)
+ private:
+  void set_has_major();
+  void clear_has_major();
+  void set_has_minor();
+  void clear_has_minor();
+  void set_has_patch();
+  void clear_has_patch();
+  void set_has_suffix();
+  void clear_has_suffix();
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::internal::HasBits<1> _has_bits_;
+  mutable int _cached_size_;
+  ::google::protobuf::internal::ArenaStringPtr suffix_;
+  ::google::protobuf::int32 major_;
+  ::google::protobuf::int32 minor_;
+  ::google::protobuf::int32 patch_;
+  friend struct ::protobuf_google_2fprotobuf_2fcompiler_2fplugin_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2fcompiler_2fplugin_2eproto::InitDefaultsVersionImpl();
+};
+// -------------------------------------------------------------------
+
+class LIBPROTOC_EXPORT CodeGeneratorRequest : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.compiler.CodeGeneratorRequest) */ {
+ public:
+  CodeGeneratorRequest();
+  virtual ~CodeGeneratorRequest();
+
+  CodeGeneratorRequest(const CodeGeneratorRequest& from);
+
+  inline CodeGeneratorRequest& operator=(const CodeGeneratorRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  CodeGeneratorRequest(CodeGeneratorRequest&& from) noexcept
+    : CodeGeneratorRequest() {
+    *this = ::std::move(from);
+  }
+
+  inline CodeGeneratorRequest& operator=(CodeGeneratorRequest&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields();
+  }
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields();
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const CodeGeneratorRequest& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const CodeGeneratorRequest* internal_default_instance() {
+    return reinterpret_cast<const CodeGeneratorRequest*>(
+               &_CodeGeneratorRequest_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    1;
+
+  void Swap(CodeGeneratorRequest* other);
+  friend void swap(CodeGeneratorRequest& a, CodeGeneratorRequest& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline CodeGeneratorRequest* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  CodeGeneratorRequest* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const CodeGeneratorRequest& from);
+  void MergeFrom(const CodeGeneratorRequest& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(CodeGeneratorRequest* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated string file_to_generate = 1;
+  int file_to_generate_size() const;
+  void clear_file_to_generate();
+  static const int kFileToGenerateFieldNumber = 1;
+  const ::std::string& file_to_generate(int index) const;
+  ::std::string* mutable_file_to_generate(int index);
+  void set_file_to_generate(int index, const ::std::string& value);
+  #if LANG_CXX11
+  void set_file_to_generate(int index, ::std::string&& value);
+  #endif
+  void set_file_to_generate(int index, const char* value);
+  void set_file_to_generate(int index, const char* value, size_t size);
+  ::std::string* add_file_to_generate();
+  void add_file_to_generate(const ::std::string& value);
+  #if LANG_CXX11
+  void add_file_to_generate(::std::string&& value);
+  #endif
+  void add_file_to_generate(const char* value);
+  void add_file_to_generate(const char* value, size_t size);
+  const ::google::protobuf::RepeatedPtrField< ::std::string>& file_to_generate() const;
+  ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_file_to_generate();
+
+  // repeated .google.protobuf.FileDescriptorProto proto_file = 15;
+  int proto_file_size() const;
+  void clear_proto_file();
+  static const int kProtoFileFieldNumber = 15;
+  const ::google::protobuf::FileDescriptorProto& proto_file(int index) const;
+  ::google::protobuf::FileDescriptorProto* mutable_proto_file(int index);
+  ::google::protobuf::FileDescriptorProto* add_proto_file();
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::FileDescriptorProto >*
+      mutable_proto_file();
+  const ::google::protobuf::RepeatedPtrField< ::google::protobuf::FileDescriptorProto >&
+      proto_file() const;
+
+  // optional string parameter = 2;
+  bool has_parameter() const;
+  void clear_parameter();
+  static const int kParameterFieldNumber = 2;
+  const ::std::string& parameter() const;
+  void set_parameter(const ::std::string& value);
+  #if LANG_CXX11
+  void set_parameter(::std::string&& value);
+  #endif
+  void set_parameter(const char* value);
+  void set_parameter(const char* value, size_t size);
+  ::std::string* mutable_parameter();
+  ::std::string* release_parameter();
+  void set_allocated_parameter(::std::string* parameter);
+
+  // optional .google.protobuf.compiler.Version compiler_version = 3;
+  bool has_compiler_version() const;
+  void clear_compiler_version();
+  static const int kCompilerVersionFieldNumber = 3;
+  const ::google::protobuf::compiler::Version& compiler_version() const;
+  ::google::protobuf::compiler::Version* release_compiler_version();
+  ::google::protobuf::compiler::Version* mutable_compiler_version();
+  void set_allocated_compiler_version(::google::protobuf::compiler::Version* compiler_version);
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.compiler.CodeGeneratorRequest)
+ private:
+  void set_has_parameter();
+  void clear_has_parameter();
+  void set_has_compiler_version();
+  void clear_has_compiler_version();
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::internal::HasBits<1> _has_bits_;
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::std::string> file_to_generate_;
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::FileDescriptorProto > proto_file_;
+  ::google::protobuf::internal::ArenaStringPtr parameter_;
+  ::google::protobuf::compiler::Version* compiler_version_;
+  friend struct ::protobuf_google_2fprotobuf_2fcompiler_2fplugin_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2fcompiler_2fplugin_2eproto::InitDefaultsCodeGeneratorRequestImpl();
+};
+// -------------------------------------------------------------------
+
+class LIBPROTOC_EXPORT CodeGeneratorResponse_File : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.compiler.CodeGeneratorResponse.File) */ {
+ public:
+  CodeGeneratorResponse_File();
+  virtual ~CodeGeneratorResponse_File();
+
+  CodeGeneratorResponse_File(const CodeGeneratorResponse_File& from);
+
+  inline CodeGeneratorResponse_File& operator=(const CodeGeneratorResponse_File& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  CodeGeneratorResponse_File(CodeGeneratorResponse_File&& from) noexcept
+    : CodeGeneratorResponse_File() {
+    *this = ::std::move(from);
+  }
+
+  inline CodeGeneratorResponse_File& operator=(CodeGeneratorResponse_File&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields();
+  }
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields();
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const CodeGeneratorResponse_File& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const CodeGeneratorResponse_File* internal_default_instance() {
+    return reinterpret_cast<const CodeGeneratorResponse_File*>(
+               &_CodeGeneratorResponse_File_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    2;
+
+  void Swap(CodeGeneratorResponse_File* other);
+  friend void swap(CodeGeneratorResponse_File& a, CodeGeneratorResponse_File& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline CodeGeneratorResponse_File* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  CodeGeneratorResponse_File* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const CodeGeneratorResponse_File& from);
+  void MergeFrom(const CodeGeneratorResponse_File& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(CodeGeneratorResponse_File* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional string name = 1;
+  bool has_name() const;
+  void clear_name();
+  static const int kNameFieldNumber = 1;
+  const ::std::string& name() const;
+  void set_name(const ::std::string& value);
+  #if LANG_CXX11
+  void set_name(::std::string&& value);
+  #endif
+  void set_name(const char* value);
+  void set_name(const char* value, size_t size);
+  ::std::string* mutable_name();
+  ::std::string* release_name();
+  void set_allocated_name(::std::string* name);
+
+  // optional string insertion_point = 2;
+  bool has_insertion_point() const;
+  void clear_insertion_point();
+  static const int kInsertionPointFieldNumber = 2;
+  const ::std::string& insertion_point() const;
+  void set_insertion_point(const ::std::string& value);
+  #if LANG_CXX11
+  void set_insertion_point(::std::string&& value);
+  #endif
+  void set_insertion_point(const char* value);
+  void set_insertion_point(const char* value, size_t size);
+  ::std::string* mutable_insertion_point();
+  ::std::string* release_insertion_point();
+  void set_allocated_insertion_point(::std::string* insertion_point);
+
+  // optional string content = 15;
+  bool has_content() const;
+  void clear_content();
+  static const int kContentFieldNumber = 15;
+  const ::std::string& content() const;
+  void set_content(const ::std::string& value);
+  #if LANG_CXX11
+  void set_content(::std::string&& value);
+  #endif
+  void set_content(const char* value);
+  void set_content(const char* value, size_t size);
+  ::std::string* mutable_content();
+  ::std::string* release_content();
+  void set_allocated_content(::std::string* content);
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.compiler.CodeGeneratorResponse.File)
+ private:
+  void set_has_name();
+  void clear_has_name();
+  void set_has_insertion_point();
+  void clear_has_insertion_point();
+  void set_has_content();
+  void clear_has_content();
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::internal::HasBits<1> _has_bits_;
+  mutable int _cached_size_;
+  ::google::protobuf::internal::ArenaStringPtr name_;
+  ::google::protobuf::internal::ArenaStringPtr insertion_point_;
+  ::google::protobuf::internal::ArenaStringPtr content_;
+  friend struct ::protobuf_google_2fprotobuf_2fcompiler_2fplugin_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2fcompiler_2fplugin_2eproto::InitDefaultsCodeGeneratorResponse_FileImpl();
+};
+// -------------------------------------------------------------------
+
+class LIBPROTOC_EXPORT CodeGeneratorResponse : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.compiler.CodeGeneratorResponse) */ {
+ public:
+  CodeGeneratorResponse();
+  virtual ~CodeGeneratorResponse();
+
+  CodeGeneratorResponse(const CodeGeneratorResponse& from);
+
+  inline CodeGeneratorResponse& operator=(const CodeGeneratorResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  CodeGeneratorResponse(CodeGeneratorResponse&& from) noexcept
+    : CodeGeneratorResponse() {
+    *this = ::std::move(from);
+  }
+
+  inline CodeGeneratorResponse& operator=(CodeGeneratorResponse&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields();
+  }
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields();
+  }
+
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const CodeGeneratorResponse& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const CodeGeneratorResponse* internal_default_instance() {
+    return reinterpret_cast<const CodeGeneratorResponse*>(
+               &_CodeGeneratorResponse_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    3;
+
+  void Swap(CodeGeneratorResponse* other);
+  friend void swap(CodeGeneratorResponse& a, CodeGeneratorResponse& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline CodeGeneratorResponse* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  CodeGeneratorResponse* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const CodeGeneratorResponse& from);
+  void MergeFrom(const CodeGeneratorResponse& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(CodeGeneratorResponse* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  typedef CodeGeneratorResponse_File File;
+
+  // accessors -------------------------------------------------------
+
+  // repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
+  int file_size() const;
+  void clear_file();
+  static const int kFileFieldNumber = 15;
+  const ::google::protobuf::compiler::CodeGeneratorResponse_File& file(int index) const;
+  ::google::protobuf::compiler::CodeGeneratorResponse_File* mutable_file(int index);
+  ::google::protobuf::compiler::CodeGeneratorResponse_File* add_file();
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::compiler::CodeGeneratorResponse_File >*
+      mutable_file();
+  const ::google::protobuf::RepeatedPtrField< ::google::protobuf::compiler::CodeGeneratorResponse_File >&
+      file() const;
+
+  // optional string error = 1;
+  bool has_error() const;
+  void clear_error();
+  static const int kErrorFieldNumber = 1;
+  const ::std::string& error() const;
+  void set_error(const ::std::string& value);
+  #if LANG_CXX11
+  void set_error(::std::string&& value);
+  #endif
+  void set_error(const char* value);
+  void set_error(const char* value, size_t size);
+  ::std::string* mutable_error();
+  ::std::string* release_error();
+  void set_allocated_error(::std::string* error);
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.compiler.CodeGeneratorResponse)
+ private:
+  void set_has_error();
+  void clear_has_error();
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::internal::HasBits<1> _has_bits_;
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::compiler::CodeGeneratorResponse_File > file_;
+  ::google::protobuf::internal::ArenaStringPtr error_;
+  friend struct ::protobuf_google_2fprotobuf_2fcompiler_2fplugin_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2fcompiler_2fplugin_2eproto::InitDefaultsCodeGeneratorResponseImpl();
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// Version
+
+// optional int32 major = 1;
+inline bool Version::has_major() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void Version::set_has_major() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void Version::clear_has_major() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void Version::clear_major() {
+  major_ = 0;
+  clear_has_major();
+}
+inline ::google::protobuf::int32 Version::major() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.compiler.Version.major)
+  return major_;
+}
+inline void Version::set_major(::google::protobuf::int32 value) {
+  set_has_major();
+  major_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.compiler.Version.major)
+}
+
+// optional int32 minor = 2;
+inline bool Version::has_minor() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void Version::set_has_minor() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void Version::clear_has_minor() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void Version::clear_minor() {
+  minor_ = 0;
+  clear_has_minor();
+}
+inline ::google::protobuf::int32 Version::minor() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.compiler.Version.minor)
+  return minor_;
+}
+inline void Version::set_minor(::google::protobuf::int32 value) {
+  set_has_minor();
+  minor_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.compiler.Version.minor)
+}
+
+// optional int32 patch = 3;
+inline bool Version::has_patch() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void Version::set_has_patch() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void Version::clear_has_patch() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void Version::clear_patch() {
+  patch_ = 0;
+  clear_has_patch();
+}
+inline ::google::protobuf::int32 Version::patch() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.compiler.Version.patch)
+  return patch_;
+}
+inline void Version::set_patch(::google::protobuf::int32 value) {
+  set_has_patch();
+  patch_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.compiler.Version.patch)
+}
+
+// optional string suffix = 4;
+inline bool Version::has_suffix() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void Version::set_has_suffix() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void Version::clear_has_suffix() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void Version::clear_suffix() {
+  suffix_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  clear_has_suffix();
+}
+inline const ::std::string& Version::suffix() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.compiler.Version.suffix)
+  return suffix_.GetNoArena();
+}
+inline void Version::set_suffix(const ::std::string& value) {
+  set_has_suffix();
+  suffix_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:google.protobuf.compiler.Version.suffix)
+}
+#if LANG_CXX11
+inline void Version::set_suffix(::std::string&& value) {
+  set_has_suffix();
+  suffix_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.compiler.Version.suffix)
+}
+#endif
+inline void Version::set_suffix(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  set_has_suffix();
+  suffix_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:google.protobuf.compiler.Version.suffix)
+}
+inline void Version::set_suffix(const char* value, size_t size) {
+  set_has_suffix();
+  suffix_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.compiler.Version.suffix)
+}
+inline ::std::string* Version::mutable_suffix() {
+  set_has_suffix();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.compiler.Version.suffix)
+  return suffix_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* Version::release_suffix() {
+  // @@protoc_insertion_point(field_release:google.protobuf.compiler.Version.suffix)
+  clear_has_suffix();
+  return suffix_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void Version::set_allocated_suffix(::std::string* suffix) {
+  if (suffix != NULL) {
+    set_has_suffix();
+  } else {
+    clear_has_suffix();
+  }
+  suffix_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), suffix);
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.compiler.Version.suffix)
+}
+
+// -------------------------------------------------------------------
+
+// CodeGeneratorRequest
+
+// repeated string file_to_generate = 1;
+inline int CodeGeneratorRequest::file_to_generate_size() const {
+  return file_to_generate_.size();
+}
+inline void CodeGeneratorRequest::clear_file_to_generate() {
+  file_to_generate_.Clear();
+}
+inline const ::std::string& CodeGeneratorRequest::file_to_generate(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.compiler.CodeGeneratorRequest.file_to_generate)
+  return file_to_generate_.Get(index);
+}
+inline ::std::string* CodeGeneratorRequest::mutable_file_to_generate(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.compiler.CodeGeneratorRequest.file_to_generate)
+  return file_to_generate_.Mutable(index);
+}
+inline void CodeGeneratorRequest::set_file_to_generate(int index, const ::std::string& value) {
+  // @@protoc_insertion_point(field_set:google.protobuf.compiler.CodeGeneratorRequest.file_to_generate)
+  file_to_generate_.Mutable(index)->assign(value);
+}
+#if LANG_CXX11
+inline void CodeGeneratorRequest::set_file_to_generate(int index, ::std::string&& value) {
+  // @@protoc_insertion_point(field_set:google.protobuf.compiler.CodeGeneratorRequest.file_to_generate)
+  file_to_generate_.Mutable(index)->assign(std::move(value));
+}
+#endif
+inline void CodeGeneratorRequest::set_file_to_generate(int index, const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  file_to_generate_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:google.protobuf.compiler.CodeGeneratorRequest.file_to_generate)
+}
+inline void CodeGeneratorRequest::set_file_to_generate(int index, const char* value, size_t size) {
+  file_to_generate_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.compiler.CodeGeneratorRequest.file_to_generate)
+}
+inline ::std::string* CodeGeneratorRequest::add_file_to_generate() {
+  // @@protoc_insertion_point(field_add_mutable:google.protobuf.compiler.CodeGeneratorRequest.file_to_generate)
+  return file_to_generate_.Add();
+}
+inline void CodeGeneratorRequest::add_file_to_generate(const ::std::string& value) {
+  file_to_generate_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:google.protobuf.compiler.CodeGeneratorRequest.file_to_generate)
+}
+#if LANG_CXX11
+inline void CodeGeneratorRequest::add_file_to_generate(::std::string&& value) {
+  file_to_generate_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:google.protobuf.compiler.CodeGeneratorRequest.file_to_generate)
+}
+#endif
+inline void CodeGeneratorRequest::add_file_to_generate(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  file_to_generate_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:google.protobuf.compiler.CodeGeneratorRequest.file_to_generate)
+}
+inline void CodeGeneratorRequest::add_file_to_generate(const char* value, size_t size) {
+  file_to_generate_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:google.protobuf.compiler.CodeGeneratorRequest.file_to_generate)
+}
+inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
+CodeGeneratorRequest::file_to_generate() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.compiler.CodeGeneratorRequest.file_to_generate)
+  return file_to_generate_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::std::string>*
+CodeGeneratorRequest::mutable_file_to_generate() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.compiler.CodeGeneratorRequest.file_to_generate)
+  return &file_to_generate_;
+}
+
+// optional string parameter = 2;
+inline bool CodeGeneratorRequest::has_parameter() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void CodeGeneratorRequest::set_has_parameter() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void CodeGeneratorRequest::clear_has_parameter() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void CodeGeneratorRequest::clear_parameter() {
+  parameter_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  clear_has_parameter();
+}
+inline const ::std::string& CodeGeneratorRequest::parameter() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.compiler.CodeGeneratorRequest.parameter)
+  return parameter_.GetNoArena();
+}
+inline void CodeGeneratorRequest::set_parameter(const ::std::string& value) {
+  set_has_parameter();
+  parameter_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:google.protobuf.compiler.CodeGeneratorRequest.parameter)
+}
+#if LANG_CXX11
+inline void CodeGeneratorRequest::set_parameter(::std::string&& value) {
+  set_has_parameter();
+  parameter_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.compiler.CodeGeneratorRequest.parameter)
+}
+#endif
+inline void CodeGeneratorRequest::set_parameter(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  set_has_parameter();
+  parameter_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:google.protobuf.compiler.CodeGeneratorRequest.parameter)
+}
+inline void CodeGeneratorRequest::set_parameter(const char* value, size_t size) {
+  set_has_parameter();
+  parameter_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.compiler.CodeGeneratorRequest.parameter)
+}
+inline ::std::string* CodeGeneratorRequest::mutable_parameter() {
+  set_has_parameter();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.compiler.CodeGeneratorRequest.parameter)
+  return parameter_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* CodeGeneratorRequest::release_parameter() {
+  // @@protoc_insertion_point(field_release:google.protobuf.compiler.CodeGeneratorRequest.parameter)
+  clear_has_parameter();
+  return parameter_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void CodeGeneratorRequest::set_allocated_parameter(::std::string* parameter) {
+  if (parameter != NULL) {
+    set_has_parameter();
+  } else {
+    clear_has_parameter();
+  }
+  parameter_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), parameter);
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.compiler.CodeGeneratorRequest.parameter)
+}
+
+// repeated .google.protobuf.FileDescriptorProto proto_file = 15;
+inline int CodeGeneratorRequest::proto_file_size() const {
+  return proto_file_.size();
+}
+inline const ::google::protobuf::FileDescriptorProto& CodeGeneratorRequest::proto_file(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.compiler.CodeGeneratorRequest.proto_file)
+  return proto_file_.Get(index);
+}
+inline ::google::protobuf::FileDescriptorProto* CodeGeneratorRequest::mutable_proto_file(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.compiler.CodeGeneratorRequest.proto_file)
+  return proto_file_.Mutable(index);
+}
+inline ::google::protobuf::FileDescriptorProto* CodeGeneratorRequest::add_proto_file() {
+  // @@protoc_insertion_point(field_add:google.protobuf.compiler.CodeGeneratorRequest.proto_file)
+  return proto_file_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::FileDescriptorProto >*
+CodeGeneratorRequest::mutable_proto_file() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.compiler.CodeGeneratorRequest.proto_file)
+  return &proto_file_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::FileDescriptorProto >&
+CodeGeneratorRequest::proto_file() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.compiler.CodeGeneratorRequest.proto_file)
+  return proto_file_;
+}
+
+// optional .google.protobuf.compiler.Version compiler_version = 3;
+inline bool CodeGeneratorRequest::has_compiler_version() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void CodeGeneratorRequest::set_has_compiler_version() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void CodeGeneratorRequest::clear_has_compiler_version() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void CodeGeneratorRequest::clear_compiler_version() {
+  if (compiler_version_ != NULL) compiler_version_->Clear();
+  clear_has_compiler_version();
+}
+inline const ::google::protobuf::compiler::Version& CodeGeneratorRequest::compiler_version() const {
+  const ::google::protobuf::compiler::Version* p = compiler_version_;
+  // @@protoc_insertion_point(field_get:google.protobuf.compiler.CodeGeneratorRequest.compiler_version)
+  return p != NULL ? *p : *reinterpret_cast<const ::google::protobuf::compiler::Version*>(
+      &::google::protobuf::compiler::_Version_default_instance_);
+}
+inline ::google::protobuf::compiler::Version* CodeGeneratorRequest::release_compiler_version() {
+  // @@protoc_insertion_point(field_release:google.protobuf.compiler.CodeGeneratorRequest.compiler_version)
+  clear_has_compiler_version();
+  ::google::protobuf::compiler::Version* temp = compiler_version_;
+  compiler_version_ = NULL;
+  return temp;
+}
+inline ::google::protobuf::compiler::Version* CodeGeneratorRequest::mutable_compiler_version() {
+  set_has_compiler_version();
+  if (compiler_version_ == NULL) {
+    compiler_version_ = new ::google::protobuf::compiler::Version;
+  }
+  // @@protoc_insertion_point(field_mutable:google.protobuf.compiler.CodeGeneratorRequest.compiler_version)
+  return compiler_version_;
+}
+inline void CodeGeneratorRequest::set_allocated_compiler_version(::google::protobuf::compiler::Version* compiler_version) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete compiler_version_;
+  }
+  if (compiler_version) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      compiler_version = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, compiler_version, submessage_arena);
+    }
+    set_has_compiler_version();
+  } else {
+    clear_has_compiler_version();
+  }
+  compiler_version_ = compiler_version;
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.compiler.CodeGeneratorRequest.compiler_version)
+}
+
+// -------------------------------------------------------------------
+
+// CodeGeneratorResponse_File
+
+// optional string name = 1;
+inline bool CodeGeneratorResponse_File::has_name() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void CodeGeneratorResponse_File::set_has_name() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void CodeGeneratorResponse_File::clear_has_name() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void CodeGeneratorResponse_File::clear_name() {
+  name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  clear_has_name();
+}
+inline const ::std::string& CodeGeneratorResponse_File::name() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.compiler.CodeGeneratorResponse.File.name)
+  return name_.GetNoArena();
+}
+inline void CodeGeneratorResponse_File::set_name(const ::std::string& value) {
+  set_has_name();
+  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:google.protobuf.compiler.CodeGeneratorResponse.File.name)
+}
+#if LANG_CXX11
+inline void CodeGeneratorResponse_File::set_name(::std::string&& value) {
+  set_has_name();
+  name_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.compiler.CodeGeneratorResponse.File.name)
+}
+#endif
+inline void CodeGeneratorResponse_File::set_name(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  set_has_name();
+  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:google.protobuf.compiler.CodeGeneratorResponse.File.name)
+}
+inline void CodeGeneratorResponse_File::set_name(const char* value, size_t size) {
+  set_has_name();
+  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.compiler.CodeGeneratorResponse.File.name)
+}
+inline ::std::string* CodeGeneratorResponse_File::mutable_name() {
+  set_has_name();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.compiler.CodeGeneratorResponse.File.name)
+  return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* CodeGeneratorResponse_File::release_name() {
+  // @@protoc_insertion_point(field_release:google.protobuf.compiler.CodeGeneratorResponse.File.name)
+  clear_has_name();
+  return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void CodeGeneratorResponse_File::set_allocated_name(::std::string* name) {
+  if (name != NULL) {
+    set_has_name();
+  } else {
+    clear_has_name();
+  }
+  name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.compiler.CodeGeneratorResponse.File.name)
+}
+
+// optional string insertion_point = 2;
+inline bool CodeGeneratorResponse_File::has_insertion_point() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void CodeGeneratorResponse_File::set_has_insertion_point() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void CodeGeneratorResponse_File::clear_has_insertion_point() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void CodeGeneratorResponse_File::clear_insertion_point() {
+  insertion_point_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  clear_has_insertion_point();
+}
+inline const ::std::string& CodeGeneratorResponse_File::insertion_point() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.compiler.CodeGeneratorResponse.File.insertion_point)
+  return insertion_point_.GetNoArena();
+}
+inline void CodeGeneratorResponse_File::set_insertion_point(const ::std::string& value) {
+  set_has_insertion_point();
+  insertion_point_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:google.protobuf.compiler.CodeGeneratorResponse.File.insertion_point)
+}
+#if LANG_CXX11
+inline void CodeGeneratorResponse_File::set_insertion_point(::std::string&& value) {
+  set_has_insertion_point();
+  insertion_point_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.compiler.CodeGeneratorResponse.File.insertion_point)
+}
+#endif
+inline void CodeGeneratorResponse_File::set_insertion_point(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  set_has_insertion_point();
+  insertion_point_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:google.protobuf.compiler.CodeGeneratorResponse.File.insertion_point)
+}
+inline void CodeGeneratorResponse_File::set_insertion_point(const char* value, size_t size) {
+  set_has_insertion_point();
+  insertion_point_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.compiler.CodeGeneratorResponse.File.insertion_point)
+}
+inline ::std::string* CodeGeneratorResponse_File::mutable_insertion_point() {
+  set_has_insertion_point();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.compiler.CodeGeneratorResponse.File.insertion_point)
+  return insertion_point_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* CodeGeneratorResponse_File::release_insertion_point() {
+  // @@protoc_insertion_point(field_release:google.protobuf.compiler.CodeGeneratorResponse.File.insertion_point)
+  clear_has_insertion_point();
+  return insertion_point_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void CodeGeneratorResponse_File::set_allocated_insertion_point(::std::string* insertion_point) {
+  if (insertion_point != NULL) {
+    set_has_insertion_point();
+  } else {
+    clear_has_insertion_point();
+  }
+  insertion_point_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), insertion_point);
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.compiler.CodeGeneratorResponse.File.insertion_point)
+}
+
+// optional string content = 15;
+inline bool CodeGeneratorResponse_File::has_content() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void CodeGeneratorResponse_File::set_has_content() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void CodeGeneratorResponse_File::clear_has_content() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void CodeGeneratorResponse_File::clear_content() {
+  content_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  clear_has_content();
+}
+inline const ::std::string& CodeGeneratorResponse_File::content() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.compiler.CodeGeneratorResponse.File.content)
+  return content_.GetNoArena();
+}
+inline void CodeGeneratorResponse_File::set_content(const ::std::string& value) {
+  set_has_content();
+  content_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:google.protobuf.compiler.CodeGeneratorResponse.File.content)
+}
+#if LANG_CXX11
+inline void CodeGeneratorResponse_File::set_content(::std::string&& value) {
+  set_has_content();
+  content_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.compiler.CodeGeneratorResponse.File.content)
+}
+#endif
+inline void CodeGeneratorResponse_File::set_content(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  set_has_content();
+  content_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:google.protobuf.compiler.CodeGeneratorResponse.File.content)
+}
+inline void CodeGeneratorResponse_File::set_content(const char* value, size_t size) {
+  set_has_content();
+  content_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.compiler.CodeGeneratorResponse.File.content)
+}
+inline ::std::string* CodeGeneratorResponse_File::mutable_content() {
+  set_has_content();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.compiler.CodeGeneratorResponse.File.content)
+  return content_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* CodeGeneratorResponse_File::release_content() {
+  // @@protoc_insertion_point(field_release:google.protobuf.compiler.CodeGeneratorResponse.File.content)
+  clear_has_content();
+  return content_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void CodeGeneratorResponse_File::set_allocated_content(::std::string* content) {
+  if (content != NULL) {
+    set_has_content();
+  } else {
+    clear_has_content();
+  }
+  content_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), content);
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.compiler.CodeGeneratorResponse.File.content)
+}
+
+// -------------------------------------------------------------------
+
+// CodeGeneratorResponse
+
+// optional string error = 1;
+inline bool CodeGeneratorResponse::has_error() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void CodeGeneratorResponse::set_has_error() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void CodeGeneratorResponse::clear_has_error() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void CodeGeneratorResponse::clear_error() {
+  error_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  clear_has_error();
+}
+inline const ::std::string& CodeGeneratorResponse::error() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.compiler.CodeGeneratorResponse.error)
+  return error_.GetNoArena();
+}
+inline void CodeGeneratorResponse::set_error(const ::std::string& value) {
+  set_has_error();
+  error_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:google.protobuf.compiler.CodeGeneratorResponse.error)
+}
+#if LANG_CXX11
+inline void CodeGeneratorResponse::set_error(::std::string&& value) {
+  set_has_error();
+  error_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.compiler.CodeGeneratorResponse.error)
+}
+#endif
+inline void CodeGeneratorResponse::set_error(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  set_has_error();
+  error_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:google.protobuf.compiler.CodeGeneratorResponse.error)
+}
+inline void CodeGeneratorResponse::set_error(const char* value, size_t size) {
+  set_has_error();
+  error_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.compiler.CodeGeneratorResponse.error)
+}
+inline ::std::string* CodeGeneratorResponse::mutable_error() {
+  set_has_error();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.compiler.CodeGeneratorResponse.error)
+  return error_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* CodeGeneratorResponse::release_error() {
+  // @@protoc_insertion_point(field_release:google.protobuf.compiler.CodeGeneratorResponse.error)
+  clear_has_error();
+  return error_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void CodeGeneratorResponse::set_allocated_error(::std::string* error) {
+  if (error != NULL) {
+    set_has_error();
+  } else {
+    clear_has_error();
+  }
+  error_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), error);
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.compiler.CodeGeneratorResponse.error)
+}
+
+// repeated .google.protobuf.compiler.CodeGeneratorResponse.File file = 15;
+inline int CodeGeneratorResponse::file_size() const {
+  return file_.size();
+}
+inline void CodeGeneratorResponse::clear_file() {
+  file_.Clear();
+}
+inline const ::google::protobuf::compiler::CodeGeneratorResponse_File& CodeGeneratorResponse::file(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.compiler.CodeGeneratorResponse.file)
+  return file_.Get(index);
+}
+inline ::google::protobuf::compiler::CodeGeneratorResponse_File* CodeGeneratorResponse::mutable_file(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.compiler.CodeGeneratorResponse.file)
+  return file_.Mutable(index);
+}
+inline ::google::protobuf::compiler::CodeGeneratorResponse_File* CodeGeneratorResponse::add_file() {
+  // @@protoc_insertion_point(field_add:google.protobuf.compiler.CodeGeneratorResponse.file)
+  return file_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::compiler::CodeGeneratorResponse_File >*
+CodeGeneratorResponse::mutable_file() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.compiler.CodeGeneratorResponse.file)
+  return &file_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::compiler::CodeGeneratorResponse_File >&
+CodeGeneratorResponse::file() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.compiler.CodeGeneratorResponse.file)
+  return file_;
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace compiler
+}  // namespace protobuf
+}  // namespace google
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_google_2fprotobuf_2fcompiler_2fplugin_2eproto__INCLUDED
diff --git a/kortex_api/include/google/protobuf/compiler/python/python_generator.h b/kortex_api/include/google/protobuf/compiler/python/python_generator.h
new file mode 100644
index 0000000000000000000000000000000000000000..2b5a028b3fef5f011825633b02b1139cd296ae51
--- /dev/null
+++ b/kortex_api/include/google/protobuf/compiler/python/python_generator.h
@@ -0,0 +1,176 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: robinson@google.com (Will Robinson)
+//
+// Generates Python code for a given .proto file.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_PYTHON_GENERATOR_H__
+#define GOOGLE_PROTOBUF_COMPILER_PYTHON_GENERATOR_H__
+
+#include <string>
+
+#include <google/protobuf/compiler/code_generator.h>
+#include <google/protobuf/stubs/mutex.h>
+#include <google/protobuf/stubs/common.h>
+
+namespace google {
+namespace protobuf {
+
+class Descriptor;
+class EnumDescriptor;
+class EnumValueDescriptor;
+class FieldDescriptor;
+class OneofDescriptor;
+class ServiceDescriptor;
+
+namespace io { class Printer; }
+
+namespace compiler {
+namespace python {
+
+// CodeGenerator implementation for generated Python protocol buffer classes.
+// If you create your own protocol compiler binary and you want it to support
+// Python output, you can do so by registering an instance of this
+// CodeGenerator with the CommandLineInterface in your main() function.
+class LIBPROTOC_EXPORT Generator : public CodeGenerator {
+ public:
+  Generator();
+  virtual ~Generator();
+
+  // CodeGenerator methods.
+  virtual bool Generate(const FileDescriptor* file,
+                        const string& parameter,
+                        GeneratorContext* generator_context,
+                        string* error) const;
+
+ private:
+  void PrintImports() const;
+  void PrintFileDescriptor() const;
+  void PrintTopLevelEnums() const;
+  void PrintAllNestedEnumsInFile() const;
+  void PrintNestedEnums(const Descriptor& descriptor) const;
+  void PrintEnum(const EnumDescriptor& enum_descriptor) const;
+
+  void PrintTopLevelExtensions() const;
+
+  void PrintFieldDescriptor(
+      const FieldDescriptor& field, bool is_extension) const;
+  void PrintFieldDescriptorsInDescriptor(
+      const Descriptor& message_descriptor,
+      bool is_extension,
+      const string& list_variable_name,
+      int (Descriptor::*CountFn)() const,
+      const FieldDescriptor* (Descriptor::*GetterFn)(int) const) const;
+  void PrintFieldsInDescriptor(const Descriptor& message_descriptor) const;
+  void PrintExtensionsInDescriptor(const Descriptor& message_descriptor) const;
+  void PrintMessageDescriptors() const;
+  void PrintDescriptor(const Descriptor& message_descriptor) const;
+  void PrintNestedDescriptors(const Descriptor& containing_descriptor) const;
+
+  void PrintMessages() const;
+  void PrintMessage(const Descriptor& message_descriptor, const string& prefix,
+                    std::vector<string>* to_register) const;
+  void PrintNestedMessages(const Descriptor& containing_descriptor,
+                           const string& prefix,
+                           std::vector<string>* to_register) const;
+
+  void FixForeignFieldsInDescriptors() const;
+  void FixForeignFieldsInDescriptor(
+      const Descriptor& descriptor,
+      const Descriptor* containing_descriptor) const;
+  void FixForeignFieldsInField(const Descriptor* containing_type,
+                               const FieldDescriptor& field,
+                               const string& python_dict_name) const;
+  void AddMessageToFileDescriptor(const Descriptor& descriptor) const;
+  void AddEnumToFileDescriptor(const EnumDescriptor& descriptor) const;
+  void AddExtensionToFileDescriptor(const FieldDescriptor& descriptor) const;
+  void AddServiceToFileDescriptor(const ServiceDescriptor& descriptor) const;
+  string FieldReferencingExpression(const Descriptor* containing_type,
+                                    const FieldDescriptor& field,
+                                    const string& python_dict_name) const;
+  template <typename DescriptorT>
+  void FixContainingTypeInDescriptor(
+      const DescriptorT& descriptor,
+      const Descriptor* containing_descriptor) const;
+
+  void FixForeignFieldsInExtensions() const;
+  void FixForeignFieldsInExtension(
+      const FieldDescriptor& extension_field) const;
+  void FixForeignFieldsInNestedExtensions(const Descriptor& descriptor) const;
+
+  void PrintServices() const;
+  void PrintServiceDescriptors() const;
+  void PrintServiceDescriptor(const ServiceDescriptor& descriptor) const;
+  void PrintServiceClass(const ServiceDescriptor& descriptor) const;
+  void PrintServiceStub(const ServiceDescriptor& descriptor) const;
+  void PrintDescriptorKeyAndModuleName(
+      const ServiceDescriptor& descriptor) const;
+
+  void PrintEnumValueDescriptor(const EnumValueDescriptor& descriptor) const;
+  string OptionsValue(const string& class_name,
+                      const string& serialized_options) const;
+  bool GeneratingDescriptorProto() const;
+
+  template <typename DescriptorT>
+  string ModuleLevelDescriptorName(const DescriptorT& descriptor) const;
+  string ModuleLevelMessageName(const Descriptor& descriptor) const;
+  string ModuleLevelServiceDescriptorName(
+      const ServiceDescriptor& descriptor) const;
+
+  template <typename DescriptorT, typename DescriptorProtoT>
+  void PrintSerializedPbInterval(
+      const DescriptorT& descriptor, DescriptorProtoT& proto) const;
+
+  void FixAllDescriptorOptions() const;
+  void FixOptionsForField(const FieldDescriptor& field) const;
+  void FixOptionsForOneof(const OneofDescriptor& oneof) const;
+  void FixOptionsForEnum(const EnumDescriptor& descriptor) const;
+  void FixOptionsForMessage(const Descriptor& descriptor) const;
+
+  void CopyPublicDependenciesAliases(
+      const string& copy_from, const FileDescriptor* file) const;
+
+  // Very coarse-grained lock to ensure that Generate() is reentrant.
+  // Guards file_, printer_ and file_descriptor_serialized_.
+  mutable Mutex mutex_;
+  mutable const FileDescriptor* file_;  // Set in Generate().  Under mutex_.
+  mutable string file_descriptor_serialized_;
+  mutable io::Printer* printer_;  // Set in Generate().  Under mutex_.
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Generator);
+};
+
+}  // namespace python
+}  // namespace compiler
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_COMPILER_PYTHON_GENERATOR_H__
diff --git a/kortex_api/include/google/protobuf/compiler/ruby/ruby_generator.h b/kortex_api/include/google/protobuf/compiler/ruby/ruby_generator.h
new file mode 100644
index 0000000000000000000000000000000000000000..8c1dfa26717296275db5233698aacca0ef312f51
--- /dev/null
+++ b/kortex_api/include/google/protobuf/compiler/ruby/ruby_generator.h
@@ -0,0 +1,64 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Generates Ruby code for a given .proto file.
+
+#ifndef GOOGLE_PROTOBUF_COMPILER_RUBY_GENERATOR_H__
+#define GOOGLE_PROTOBUF_COMPILER_RUBY_GENERATOR_H__
+
+#include <string>
+
+#include <google/protobuf/compiler/code_generator.h>
+
+namespace google {
+namespace protobuf {
+namespace compiler {
+namespace ruby {
+
+// CodeGenerator implementation for generated Ruby protocol buffer classes.
+// If you create your own protocol compiler binary and you want it to support
+// Ruby output, you can do so by registering an instance of this
+// CodeGenerator with the CommandLineInterface in your main() function.
+class LIBPROTOC_EXPORT Generator
+    : public google::protobuf::compiler::CodeGenerator {
+  virtual bool Generate(
+      const FileDescriptor* file,
+      const string& parameter,
+      GeneratorContext* generator_context,
+      string* error) const;
+};
+
+}  // namespace ruby
+}  // namespace compiler
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_COMPILER_RUBY_GENERATOR_H__
+
diff --git a/kortex_api/include/google/protobuf/descriptor.h b/kortex_api/include/google/protobuf/descriptor.h
new file mode 100644
index 0000000000000000000000000000000000000000..5f5159a8ad9e8ccce73dea10778eae0cd597033f
--- /dev/null
+++ b/kortex_api/include/google/protobuf/descriptor.h
@@ -0,0 +1,2137 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// This file contains classes which describe a type of protocol message.
+// You can use a message's descriptor to learn at runtime what fields
+// it contains and what the types of those fields are.  The Message
+// interface also allows you to dynamically access and modify individual
+// fields by passing the FieldDescriptor of the field you are interested
+// in.
+//
+// Most users will not care about descriptors, because they will write
+// code specific to certain protocol types and will simply use the classes
+// generated by the protocol compiler directly.  Advanced users who want
+// to operate on arbitrary types (not known at compile time) may want to
+// read descriptors in order to learn about the contents of a message.
+// A very small number of users will want to construct their own
+// Descriptors, either because they are implementing Message manually or
+// because they are writing something like the protocol compiler.
+//
+// For an example of how you might use descriptors, see the code example
+// at the top of message.h.
+
+#ifndef GOOGLE_PROTOBUF_DESCRIPTOR_H__
+#define GOOGLE_PROTOBUF_DESCRIPTOR_H__
+
+#include <memory>
+#ifndef _SHARED_PTR_H
+#include <google/protobuf/stubs/shared_ptr.h>
+#endif
+#include <set>
+#include <string>
+#include <vector>
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/mutex.h>
+#include <google/protobuf/stubs/once.h>
+
+// TYPE_BOOL is defined in the MacOS's ConditionalMacros.h.
+#ifdef TYPE_BOOL
+#undef TYPE_BOOL
+#endif  // TYPE_BOOL
+
+namespace google {
+namespace protobuf {
+
+// Defined in this file.
+class Descriptor;
+class FieldDescriptor;
+class OneofDescriptor;
+class EnumDescriptor;
+class EnumValueDescriptor;
+class ServiceDescriptor;
+class MethodDescriptor;
+class FileDescriptor;
+class DescriptorDatabase;
+class DescriptorPool;
+
+// Defined in descriptor.proto
+class DescriptorProto;
+class FieldDescriptorProto;
+class OneofDescriptorProto;
+class EnumDescriptorProto;
+class EnumValueDescriptorProto;
+class ServiceDescriptorProto;
+class MethodDescriptorProto;
+class FileDescriptorProto;
+class MessageOptions;
+class FieldOptions;
+class OneofOptions;
+class EnumOptions;
+class EnumValueOptions;
+class ExtensionRangeOptions;
+class ServiceOptions;
+class MethodOptions;
+class FileOptions;
+class UninterpretedOption;
+class SourceCodeInfo;
+
+// Defined in message.h
+class Message;
+
+// Defined in descriptor.cc
+class DescriptorBuilder;
+class FileDescriptorTables;
+struct Symbol;
+
+// Defined in unknown_field_set.h.
+class UnknownField;
+
+// Defined in generated_message_reflection.h.
+namespace internal {
+class GeneratedMessageReflection;
+}  // namespace internal
+
+// Defined in command_line_interface.cc
+namespace compiler {
+class CommandLineInterface;
+}  // namespace compiler
+
+namespace descriptor_unittest {
+class DescriptorTest;
+}  // namespace descriptor_unittest
+
+// Defined in printer.h
+namespace io {
+class Printer;
+}  // namespace io
+
+// NB, all indices are zero-based.
+struct SourceLocation {
+  int start_line;
+  int end_line;
+  int start_column;
+  int end_column;
+
+  // Doc comments found at the source location.
+  // See the comments in SourceCodeInfo.Location (descriptor.proto) for details.
+  string leading_comments;
+  string trailing_comments;
+  std::vector<string> leading_detached_comments;
+};
+
+// Options when generating machine-parsable output from a descriptor with
+// DebugString().
+struct DebugStringOptions {
+  // include original user comments as recorded in SourceLocation entries. N.B.
+  // that this must be |false| by default: several other pieces of code (for
+  // example, the C++ code generation for fields in the proto compiler) rely on
+  // DebugString() output being unobstructed by user comments.
+  bool include_comments;
+  // If true, elide the braced body in the debug string.
+  bool elide_group_body;
+  bool elide_oneof_body;
+
+  DebugStringOptions()
+      : include_comments(false),
+        elide_group_body(false),
+        elide_oneof_body(false) {}
+};
+
+// A class to handle the simplest cases of a lazily linked descriptor
+// for a message type that isn't built at the time of cross linking,
+// which is needed when a pool has lazily_build_dependencies_ set.
+// Must be instantiated as mutable in a descriptor.
+namespace internal {
+class LIBPROTOBUF_EXPORT LazyDescriptor {
+ public:
+  // Init function to be called at init time of a descriptor containing
+  // a LazyDescriptor.
+  void Init() {
+    descriptor_ = NULL;
+    name_ = NULL;
+    once_ = NULL;
+    file_ = NULL;
+  }
+
+  // Sets the value of the descriptor if it is known during the descriptor
+  // building process. Not thread safe, should only be called during the
+  // descriptor build process. Should not be called after SetLazy has been
+  // called.
+  void Set(const Descriptor* descriptor);
+
+  // Sets the information needed to lazily cross link the descriptor at a later
+  // time, SetLazy is not thread safe, should be called only once at descriptor
+  // build time if the symbol wasn't found and building of the file containing
+  // that type is delayed because lazily_build_dependencies_ is set on the pool.
+  // Should not be called after Set() has been called.
+  void SetLazy(const string& name, const FileDescriptor* file);
+
+  // Returns the current value of the descriptor, thread-safe. If SetLazy(...)
+  // has been called, will do a one-time cross link of the type specified,
+  // building the descriptor file that contains the type if necessary.
+  inline const Descriptor* Get() {
+    Once();
+    return descriptor_;
+  }
+
+ private:
+  static void OnceStatic(LazyDescriptor* lazy);
+  void OnceInternal();
+  void Once();
+
+  const Descriptor* descriptor_;
+  const string* name_;
+  GoogleOnceDynamic* once_;
+  const FileDescriptor* file_;
+};
+}  // namespace internal
+
+// Describes a type of protocol message, or a particular group within a
+// message.  To obtain the Descriptor for a given message object, call
+// Message::GetDescriptor().  Generated message classes also have a
+// static method called descriptor() which returns the type's descriptor.
+// Use DescriptorPool to construct your own descriptors.
+class LIBPROTOBUF_EXPORT Descriptor {
+ public:
+  // The name of the message type, not including its scope.
+  const string& name() const;
+
+  // The fully-qualified name of the message type, scope delimited by
+  // periods.  For example, message type "Foo" which is declared in package
+  // "bar" has full name "bar.Foo".  If a type "Baz" is nested within
+  // Foo, Baz's full_name is "bar.Foo.Baz".  To get only the part that
+  // comes after the last '.', use name().
+  const string& full_name() const;
+
+  // Index of this descriptor within the file or containing type's message
+  // type array.
+  int index() const;
+
+  // The .proto file in which this message type was defined.  Never NULL.
+  const FileDescriptor* file() const;
+
+  // If this Descriptor describes a nested type, this returns the type
+  // in which it is nested.  Otherwise, returns NULL.
+  const Descriptor* containing_type() const;
+
+  // Get options for this message type.  These are specified in the .proto file
+  // by placing lines like "option foo = 1234;" in the message definition.
+  // Allowed options are defined by MessageOptions in
+  // google/protobuf/descriptor.proto, and any available extensions of that
+  // message.
+  const MessageOptions& options() const;
+
+  // Write the contents of this Descriptor into the given DescriptorProto.
+  // The target DescriptorProto must be clear before calling this; if it
+  // isn't, the result may be garbage.
+  void CopyTo(DescriptorProto* proto) const;
+
+  // Write the contents of this decriptor in a human-readable form. Output
+  // will be suitable for re-parsing.
+  string DebugString() const;
+
+  // Similar to DebugString(), but additionally takes options (e.g.,
+  // include original user comments in output).
+  string DebugStringWithOptions(const DebugStringOptions& options) const;
+
+  // Returns true if this is a placeholder for an unknown type. This will
+  // only be the case if this descriptor comes from a DescriptorPool
+  // with AllowUnknownDependencies() set.
+  bool is_placeholder() const;
+
+  // Field stuff -----------------------------------------------------
+
+  // The number of fields in this message type.
+  int field_count() const;
+  // Gets a field by index, where 0 <= index < field_count().
+  // These are returned in the order they were defined in the .proto file.
+  const FieldDescriptor* field(int index) const;
+
+  // Looks up a field by declared tag number.  Returns NULL if no such field
+  // exists.
+  const FieldDescriptor* FindFieldByNumber(int number) const;
+  // Looks up a field by name.  Returns NULL if no such field exists.
+  const FieldDescriptor* FindFieldByName(const string& name) const;
+
+  // Looks up a field by lowercased name (as returned by lowercase_name()).
+  // This lookup may be ambiguous if multiple field names differ only by case,
+  // in which case the field returned is chosen arbitrarily from the matches.
+  const FieldDescriptor* FindFieldByLowercaseName(
+      const string& lowercase_name) const;
+
+  // Looks up a field by camel-case name (as returned by camelcase_name()).
+  // This lookup may be ambiguous if multiple field names differ in a way that
+  // leads them to have identical camel-case names, in which case the field
+  // returned is chosen arbitrarily from the matches.
+  const FieldDescriptor* FindFieldByCamelcaseName(
+      const string& camelcase_name) const;
+
+  // The number of oneofs in this message type.
+  int oneof_decl_count() const;
+  // Get a oneof by index, where 0 <= index < oneof_decl_count().
+  // These are returned in the order they were defined in the .proto file.
+  const OneofDescriptor* oneof_decl(int index) const;
+
+  // Looks up a oneof by name.  Returns NULL if no such oneof exists.
+  const OneofDescriptor* FindOneofByName(const string& name) const;
+
+  // Nested type stuff -----------------------------------------------
+
+  // The number of nested types in this message type.
+  int nested_type_count() const;
+  // Gets a nested type by index, where 0 <= index < nested_type_count().
+  // These are returned in the order they were defined in the .proto file.
+  const Descriptor* nested_type(int index) const;
+
+  // Looks up a nested type by name.  Returns NULL if no such nested type
+  // exists.
+  const Descriptor* FindNestedTypeByName(const string& name) const;
+
+  // Enum stuff ------------------------------------------------------
+
+  // The number of enum types in this message type.
+  int enum_type_count() const;
+  // Gets an enum type by index, where 0 <= index < enum_type_count().
+  // These are returned in the order they were defined in the .proto file.
+  const EnumDescriptor* enum_type(int index) const;
+
+  // Looks up an enum type by name.  Returns NULL if no such enum type exists.
+  const EnumDescriptor* FindEnumTypeByName(const string& name) const;
+
+  // Looks up an enum value by name, among all enum types in this message.
+  // Returns NULL if no such value exists.
+  const EnumValueDescriptor* FindEnumValueByName(const string& name) const;
+
+  // Extensions ------------------------------------------------------
+
+  // A range of field numbers which are designated for third-party
+  // extensions.
+  struct ExtensionRange {
+    typedef ExtensionRangeOptions OptionsType;
+
+    int start;  // inclusive
+    int end;    // exclusive
+
+    const ExtensionRangeOptions* options_;
+  };
+
+  // The number of extension ranges in this message type.
+  int extension_range_count() const;
+  // Gets an extension range by index, where 0 <= index <
+  // extension_range_count(). These are returned in the order they were defined
+  // in the .proto file.
+  const ExtensionRange* extension_range(int index) const;
+
+  // Returns true if the number is in one of the extension ranges.
+  bool IsExtensionNumber(int number) const;
+
+  // Returns NULL if no extension range contains the given number.
+  const ExtensionRange* FindExtensionRangeContainingNumber(int number) const;
+
+  // The number of extensions -- extending *other* messages -- that were
+  // defined nested within this message type's scope.
+  int extension_count() const;
+  // Get an extension by index, where 0 <= index < extension_count().
+  // These are returned in the order they were defined in the .proto file.
+  const FieldDescriptor* extension(int index) const;
+
+  // Looks up a named extension (which extends some *other* message type)
+  // defined within this message type's scope.
+  const FieldDescriptor* FindExtensionByName(const string& name) const;
+
+  // Similar to FindFieldByLowercaseName(), but finds extensions defined within
+  // this message type's scope.
+  const FieldDescriptor* FindExtensionByLowercaseName(const string& name) const;
+
+  // Similar to FindFieldByCamelcaseName(), but finds extensions defined within
+  // this message type's scope.
+  const FieldDescriptor* FindExtensionByCamelcaseName(const string& name) const;
+
+  // Reserved fields -------------------------------------------------
+
+  // A range of reserved field numbers.
+  struct ReservedRange {
+    int start;  // inclusive
+    int end;    // exclusive
+  };
+
+  // The number of reserved ranges in this message type.
+  int reserved_range_count() const;
+  // Gets an reserved range by index, where 0 <= index <
+  // reserved_range_count(). These are returned in the order they were defined
+  // in the .proto file.
+  const ReservedRange* reserved_range(int index) const;
+
+  // Returns true if the number is in one of the reserved ranges.
+  bool IsReservedNumber(int number) const;
+
+  // Returns NULL if no reserved range contains the given number.
+  const ReservedRange* FindReservedRangeContainingNumber(int number) const;
+
+  // The number of reserved field names in this message type.
+  int reserved_name_count() const;
+
+  // Gets a reserved name by index, where 0 <= index < reserved_name_count().
+  const string& reserved_name(int index) const;
+
+  // Returns true if the field name is reserved.
+  bool IsReservedName(const string& name) const;
+
+  // Source Location ---------------------------------------------------
+
+  // Updates |*out_location| to the source location of the complete
+  // extent of this message declaration.  Returns false and leaves
+  // |*out_location| unchanged iff location information was not available.
+  bool GetSourceLocation(SourceLocation* out_location) const;
+
+ private:
+  typedef MessageOptions OptionsType;
+
+  // Allows tests to test CopyTo(proto, true).
+  friend class ::google::protobuf::descriptor_unittest::DescriptorTest;
+
+  // Allows access to GetLocationPath for annotations.
+  friend class ::google::protobuf::io::Printer;
+
+  // Fill the json_name field of FieldDescriptorProto.
+  void CopyJsonNameTo(DescriptorProto* proto) const;
+
+  // Internal version of DebugString; controls the level of indenting for
+  // correct depth. Takes |options| to control debug-string options, and
+  // |include_opening_clause| to indicate whether the "message ... " part of the
+  // clause has already been generated (this varies depending on context).
+  void DebugString(int depth, string *contents,
+                   const DebugStringOptions& options,
+                   bool include_opening_clause) const;
+
+  // Walks up the descriptor tree to generate the source location path
+  // to this descriptor from the file root.
+  void GetLocationPath(std::vector<int>* output) const;
+
+  const string* name_;
+  const string* full_name_;
+  const FileDescriptor* file_;
+  const Descriptor* containing_type_;
+  const MessageOptions* options_;
+
+  // These arrays are separated from their sizes to minimize padding on 64-bit.
+  FieldDescriptor* fields_;
+  OneofDescriptor* oneof_decls_;
+  Descriptor* nested_types_;
+  EnumDescriptor* enum_types_;
+  ExtensionRange* extension_ranges_;
+  FieldDescriptor* extensions_;
+  ReservedRange* reserved_ranges_;
+  const string** reserved_names_;
+
+  int field_count_;
+  int oneof_decl_count_;
+  int nested_type_count_;
+  int enum_type_count_;
+  int extension_range_count_;
+  int extension_count_;
+  int reserved_range_count_;
+  int reserved_name_count_;
+
+  // True if this is a placeholder for an unknown type.
+  bool is_placeholder_;
+  // True if this is a placeholder and the type name wasn't fully-qualified.
+  bool is_unqualified_placeholder_;
+
+  // IMPORTANT:  If you add a new field, make sure to search for all instances
+  // of Allocate<Descriptor>() and AllocateArray<Descriptor>() in descriptor.cc
+  // and update them to initialize the field.
+
+  // Must be constructed using DescriptorPool.
+  Descriptor() {}
+  friend class DescriptorBuilder;
+  friend class DescriptorPool;
+  friend class EnumDescriptor;
+  friend class FieldDescriptor;
+  friend class OneofDescriptor;
+  friend class MethodDescriptor;
+  friend class FileDescriptor;
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Descriptor);
+};
+
+
+// Describes a single field of a message.  To get the descriptor for a given
+// field, first get the Descriptor for the message in which it is defined,
+// then call Descriptor::FindFieldByName().  To get a FieldDescriptor for
+// an extension, do one of the following:
+// - Get the Descriptor or FileDescriptor for its containing scope, then
+//   call Descriptor::FindExtensionByName() or
+//   FileDescriptor::FindExtensionByName().
+// - Given a DescriptorPool, call DescriptorPool::FindExtensionByNumber().
+// - Given a Reflection for a message object, call
+//   Reflection::FindKnownExtensionByName() or
+//   Reflection::FindKnownExtensionByNumber().
+// Use DescriptorPool to construct your own descriptors.
+class LIBPROTOBUF_EXPORT FieldDescriptor {
+ public:
+  // Identifies a field type.  0 is reserved for errors.  The order is weird
+  // for historical reasons.  Types 12 and up are new in proto2.
+  enum Type {
+    TYPE_DOUBLE         = 1,   // double, exactly eight bytes on the wire.
+    TYPE_FLOAT          = 2,   // float, exactly four bytes on the wire.
+    TYPE_INT64          = 3,   // int64, varint on the wire.  Negative numbers
+                               // take 10 bytes.  Use TYPE_SINT64 if negative
+                               // values are likely.
+    TYPE_UINT64         = 4,   // uint64, varint on the wire.
+    TYPE_INT32          = 5,   // int32, varint on the wire.  Negative numbers
+                               // take 10 bytes.  Use TYPE_SINT32 if negative
+                               // values are likely.
+    TYPE_FIXED64        = 6,   // uint64, exactly eight bytes on the wire.
+    TYPE_FIXED32        = 7,   // uint32, exactly four bytes on the wire.
+    TYPE_BOOL           = 8,   // bool, varint on the wire.
+    TYPE_STRING         = 9,   // UTF-8 text.
+    TYPE_GROUP          = 10,  // Tag-delimited message.  Deprecated.
+    TYPE_MESSAGE        = 11,  // Length-delimited message.
+
+    TYPE_BYTES          = 12,  // Arbitrary byte array.
+    TYPE_UINT32         = 13,  // uint32, varint on the wire
+    TYPE_ENUM           = 14,  // Enum, varint on the wire
+    TYPE_SFIXED32       = 15,  // int32, exactly four bytes on the wire
+    TYPE_SFIXED64       = 16,  // int64, exactly eight bytes on the wire
+    TYPE_SINT32         = 17,  // int32, ZigZag-encoded varint on the wire
+    TYPE_SINT64         = 18,  // int64, ZigZag-encoded varint on the wire
+
+    MAX_TYPE            = 18,  // Constant useful for defining lookup tables
+                               // indexed by Type.
+  };
+
+  // Specifies the C++ data type used to represent the field.  There is a
+  // fixed mapping from Type to CppType where each Type maps to exactly one
+  // CppType.  0 is reserved for errors.
+  enum CppType {
+    CPPTYPE_INT32       = 1,     // TYPE_INT32, TYPE_SINT32, TYPE_SFIXED32
+    CPPTYPE_INT64       = 2,     // TYPE_INT64, TYPE_SINT64, TYPE_SFIXED64
+    CPPTYPE_UINT32      = 3,     // TYPE_UINT32, TYPE_FIXED32
+    CPPTYPE_UINT64      = 4,     // TYPE_UINT64, TYPE_FIXED64
+    CPPTYPE_DOUBLE      = 5,     // TYPE_DOUBLE
+    CPPTYPE_FLOAT       = 6,     // TYPE_FLOAT
+    CPPTYPE_BOOL        = 7,     // TYPE_BOOL
+    CPPTYPE_ENUM        = 8,     // TYPE_ENUM
+    CPPTYPE_STRING      = 9,     // TYPE_STRING, TYPE_BYTES
+    CPPTYPE_MESSAGE     = 10,    // TYPE_MESSAGE, TYPE_GROUP
+
+    MAX_CPPTYPE         = 10,    // Constant useful for defining lookup tables
+                                 // indexed by CppType.
+  };
+
+  // Identifies whether the field is optional, required, or repeated.  0 is
+  // reserved for errors.
+  enum Label {
+    LABEL_OPTIONAL      = 1,    // optional
+    LABEL_REQUIRED      = 2,    // required
+    LABEL_REPEATED      = 3,    // repeated
+
+    MAX_LABEL           = 3,    // Constant useful for defining lookup tables
+                                // indexed by Label.
+  };
+
+  // Valid field numbers are positive integers up to kMaxNumber.
+  static const int kMaxNumber = (1 << 29) - 1;
+
+  // First field number reserved for the protocol buffer library implementation.
+  // Users may not declare fields that use reserved numbers.
+  static const int kFirstReservedNumber = 19000;
+  // Last field number reserved for the protocol buffer library implementation.
+  // Users may not declare fields that use reserved numbers.
+  static const int kLastReservedNumber  = 19999;
+
+  const string& name() const;        // Name of this field within the message.
+  const string& full_name() const;   // Fully-qualified name of the field.
+  const string& json_name() const;   // JSON name of this field.
+  const FileDescriptor* file() const;// File in which this field was defined.
+  bool is_extension() const;         // Is this an extension field?
+  int number() const;                // Declared tag number.
+
+  // Same as name() except converted to lower-case.  This (and especially the
+  // FindFieldByLowercaseName() method) can be useful when parsing formats
+  // which prefer to use lowercase naming style.  (Although, technically
+  // field names should be lowercased anyway according to the protobuf style
+  // guide, so this only makes a difference when dealing with old .proto files
+  // which do not follow the guide.)
+  const string& lowercase_name() const;
+
+  // Same as name() except converted to camel-case.  In this conversion, any
+  // time an underscore appears in the name, it is removed and the next
+  // letter is capitalized.  Furthermore, the first letter of the name is
+  // lower-cased.  Examples:
+  //   FooBar -> fooBar
+  //   foo_bar -> fooBar
+  //   fooBar -> fooBar
+  // This (and especially the FindFieldByCamelcaseName() method) can be useful
+  // when parsing formats which prefer to use camel-case naming style.
+  const string& camelcase_name() const;
+
+  Type type() const;                  // Declared type of this field.
+  const char* type_name() const;      // Name of the declared type.
+  CppType cpp_type() const;           // C++ type of this field.
+  const char* cpp_type_name() const;  // Name of the C++ type.
+  Label label() const;                // optional/required/repeated
+
+  bool is_required() const;      // shorthand for label() == LABEL_REQUIRED
+  bool is_optional() const;      // shorthand for label() == LABEL_OPTIONAL
+  bool is_repeated() const;      // shorthand for label() == LABEL_REPEATED
+  bool is_packable() const;      // shorthand for is_repeated() &&
+                                 //               IsTypePackable(type())
+  bool is_packed() const;        // shorthand for is_packable() &&
+                                 //               options().packed()
+  bool is_map() const;           // shorthand for type() == TYPE_MESSAGE &&
+                                 // message_type()->options().map_entry()
+
+  // Index of this field within the message's field array, or the file or
+  // extension scope's extensions array.
+  int index() const;
+
+  // Does this field have an explicitly-declared default value?
+  bool has_default_value() const;
+
+  // Whether the user has specified the json_name field option in the .proto
+  // file.
+  bool has_json_name() const;
+
+  // Get the field default value if cpp_type() == CPPTYPE_INT32.  If no
+  // explicit default was defined, the default is 0.
+  int32 default_value_int32() const;
+  // Get the field default value if cpp_type() == CPPTYPE_INT64.  If no
+  // explicit default was defined, the default is 0.
+  int64 default_value_int64() const;
+  // Get the field default value if cpp_type() == CPPTYPE_UINT32.  If no
+  // explicit default was defined, the default is 0.
+  uint32 default_value_uint32() const;
+  // Get the field default value if cpp_type() == CPPTYPE_UINT64.  If no
+  // explicit default was defined, the default is 0.
+  uint64 default_value_uint64() const;
+  // Get the field default value if cpp_type() == CPPTYPE_FLOAT.  If no
+  // explicit default was defined, the default is 0.0.
+  float default_value_float() const;
+  // Get the field default value if cpp_type() == CPPTYPE_DOUBLE.  If no
+  // explicit default was defined, the default is 0.0.
+  double default_value_double() const;
+  // Get the field default value if cpp_type() == CPPTYPE_BOOL.  If no
+  // explicit default was defined, the default is false.
+  bool default_value_bool() const;
+  // Get the field default value if cpp_type() == CPPTYPE_ENUM.  If no
+  // explicit default was defined, the default is the first value defined
+  // in the enum type (all enum types are required to have at least one value).
+  // This never returns NULL.
+  const EnumValueDescriptor* default_value_enum() const;
+  // Get the field default value if cpp_type() == CPPTYPE_STRING.  If no
+  // explicit default was defined, the default is the empty string.
+  const string& default_value_string() const;
+
+  // The Descriptor for the message of which this is a field.  For extensions,
+  // this is the extended type.  Never NULL.
+  const Descriptor* containing_type() const;
+
+  // If the field is a member of a oneof, this is the one, otherwise this is
+  // NULL.
+  const OneofDescriptor* containing_oneof() const;
+
+  // If the field is a member of a oneof, returns the index in that oneof.
+  int index_in_oneof() const;
+
+  // An extension may be declared within the scope of another message.  If this
+  // field is an extension (is_extension() is true), then extension_scope()
+  // returns that message, or NULL if the extension was declared at global
+  // scope.  If this is not an extension, extension_scope() is undefined (may
+  // assert-fail).
+  const Descriptor* extension_scope() const;
+
+  // If type is TYPE_MESSAGE or TYPE_GROUP, returns a descriptor for the
+  // message or the group type.  Otherwise, returns null.
+  const Descriptor* message_type() const;
+  // If type is TYPE_ENUM, returns a descriptor for the enum.  Otherwise,
+  // returns null.
+  const EnumDescriptor* enum_type() const;
+
+  // Get the FieldOptions for this field.  This includes things listed in
+  // square brackets after the field definition.  E.g., the field:
+  //   optional string text = 1 [ctype=CORD];
+  // has the "ctype" option set.  Allowed options are defined by FieldOptions
+  // in google/protobuf/descriptor.proto, and any available extensions of that
+  // message.
+  const FieldOptions& options() const;
+
+  // See Descriptor::CopyTo().
+  void CopyTo(FieldDescriptorProto* proto) const;
+
+  // See Descriptor::DebugString().
+  string DebugString() const;
+
+  // See Descriptor::DebugStringWithOptions().
+  string DebugStringWithOptions(const DebugStringOptions& options) const;
+
+  // Helper method to get the CppType for a particular Type.
+  static CppType TypeToCppType(Type type);
+
+  // Helper method to get the name of a Type.
+  static const char* TypeName(Type type);
+
+  // Helper method to get the name of a CppType.
+  static const char* CppTypeName(CppType cpp_type);
+
+  // Return true iff [packed = true] is valid for fields of this type.
+  static inline bool IsTypePackable(Type field_type);
+
+  // Source Location ---------------------------------------------------
+
+  // Updates |*out_location| to the source location of the complete
+  // extent of this field declaration.  Returns false and leaves
+  // |*out_location| unchanged iff location information was not available.
+  bool GetSourceLocation(SourceLocation* out_location) const;
+
+ private:
+  typedef FieldOptions OptionsType;
+
+  // Allows access to GetLocationPath for annotations.
+  friend class ::google::protobuf::io::Printer;
+
+  // Fill the json_name field of FieldDescriptorProto.
+  void CopyJsonNameTo(FieldDescriptorProto* proto) const;
+
+  // See Descriptor::DebugString().
+  enum PrintLabelFlag { PRINT_LABEL, OMIT_LABEL };
+  void DebugString(int depth, PrintLabelFlag print_label_flag,
+                   string* contents, const DebugStringOptions& options) const;
+
+  // formats the default value appropriately and returns it as a string.
+  // Must have a default value to call this. If quote_string_type is true, then
+  // types of CPPTYPE_STRING whill be surrounded by quotes and CEscaped.
+  string DefaultValueAsString(bool quote_string_type) const;
+
+  // Helper function that returns the field type name for DebugString.
+  string FieldTypeNameDebugString() const;
+
+  // Walks up the descriptor tree to generate the source location path
+  // to this descriptor from the file root.
+  void GetLocationPath(std::vector<int>* output) const;
+
+  // Returns true if this is a map message type.
+  bool is_map_message_type() const;
+
+  const string* name_;
+  const string* full_name_;
+  const string* lowercase_name_;
+  const string* camelcase_name_;
+  // If has_json_name_ is true, it's the value specified by the user.
+  // Otherwise, it has the same value as camelcase_name_.
+  const string* json_name_;
+  const FileDescriptor* file_;
+  GoogleOnceDynamic* type_once_;
+  static void TypeOnceInit(const FieldDescriptor* to_init);
+  void InternalTypeOnceInit() const;
+  mutable Type type_;
+  Label label_;
+  bool has_default_value_;
+  // Whether the user has specified the json_name field option in the .proto
+  // file.
+  bool has_json_name_;
+  bool is_extension_;
+  int number_;
+  int index_in_oneof_;
+  const Descriptor* containing_type_;
+  const OneofDescriptor* containing_oneof_;
+  const Descriptor* extension_scope_;
+  mutable const Descriptor* message_type_;
+  mutable const EnumDescriptor* enum_type_;
+  const FieldOptions* options_;
+  const string* type_name_;
+  const string* default_value_enum_name_;
+  // IMPORTANT:  If you add a new field, make sure to search for all instances
+  // of Allocate<FieldDescriptor>() and AllocateArray<FieldDescriptor>() in
+  // descriptor.cc and update them to initialize the field.
+
+  union {
+    int32  default_value_int32_;
+    int64  default_value_int64_;
+    uint32 default_value_uint32_;
+    uint64 default_value_uint64_;
+    float  default_value_float_;
+    double default_value_double_;
+    bool   default_value_bool_;
+
+    mutable const EnumValueDescriptor* default_value_enum_;
+    const string* default_value_string_;
+  };
+
+  static const CppType kTypeToCppTypeMap[MAX_TYPE + 1];
+
+  static const char * const kTypeToName[MAX_TYPE + 1];
+
+  static const char * const kCppTypeToName[MAX_CPPTYPE + 1];
+
+  static const char * const kLabelToName[MAX_LABEL + 1];
+
+  // Must be constructed using DescriptorPool.
+  FieldDescriptor() {}
+  friend class DescriptorBuilder;
+  friend class FileDescriptor;
+  friend class Descriptor;
+  friend class OneofDescriptor;
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(FieldDescriptor);
+};
+
+
+// Describes a oneof defined in a message type.
+class LIBPROTOBUF_EXPORT OneofDescriptor {
+ public:
+  const string& name() const;       // Name of this oneof.
+  const string& full_name() const;  // Fully-qualified name of the oneof.
+
+  // Index of this oneof within the message's oneof array.
+  int index() const;
+
+  // The .proto file in which this oneof was defined.  Never NULL.
+  const FileDescriptor* file() const;
+  // The Descriptor for the message containing this oneof.
+  const Descriptor* containing_type() const;
+
+  // The number of (non-extension) fields which are members of this oneof.
+  int field_count() const;
+  // Get a member of this oneof, in the order in which they were declared in the
+  // .proto file.  Does not include extensions.
+  const FieldDescriptor* field(int index) const;
+
+  const OneofOptions& options() const;
+
+  // See Descriptor::CopyTo().
+  void CopyTo(OneofDescriptorProto* proto) const;
+
+  // See Descriptor::DebugString().
+  string DebugString() const;
+
+  // See Descriptor::DebugStringWithOptions().
+  string DebugStringWithOptions(const DebugStringOptions& options) const;
+
+  // Source Location ---------------------------------------------------
+
+  // Updates |*out_location| to the source location of the complete
+  // extent of this oneof declaration.  Returns false and leaves
+  // |*out_location| unchanged iff location information was not available.
+  bool GetSourceLocation(SourceLocation* out_location) const;
+
+ private:
+  typedef OneofOptions OptionsType;
+
+  // Allows access to GetLocationPath for annotations.
+  friend class ::google::protobuf::io::Printer;
+
+  // See Descriptor::DebugString().
+  void DebugString(int depth, string* contents,
+                   const DebugStringOptions& options) const;
+
+  // Walks up the descriptor tree to generate the source location path
+  // to this descriptor from the file root.
+  void GetLocationPath(std::vector<int>* output) const;
+
+  const string* name_;
+  const string* full_name_;
+  const Descriptor* containing_type_;
+  bool is_extendable_;
+  int field_count_;
+  const FieldDescriptor** fields_;
+  const OneofOptions* options_;
+
+  // IMPORTANT:  If you add a new field, make sure to search for all instances
+  // of Allocate<OneofDescriptor>() and AllocateArray<OneofDescriptor>()
+  // in descriptor.cc and update them to initialize the field.
+
+  // Must be constructed using DescriptorPool.
+  OneofDescriptor() {}
+  friend class DescriptorBuilder;
+  friend class Descriptor;
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(OneofDescriptor);
+};
+
+// Describes an enum type defined in a .proto file.  To get the EnumDescriptor
+// for a generated enum type, call TypeName_descriptor().  Use DescriptorPool
+// to construct your own descriptors.
+class LIBPROTOBUF_EXPORT EnumDescriptor {
+ public:
+  // The name of this enum type in the containing scope.
+  const string& name() const;
+
+  // The fully-qualified name of the enum type, scope delimited by periods.
+  const string& full_name() const;
+
+  // Index of this enum within the file or containing message's enum array.
+  int index() const;
+
+  // The .proto file in which this enum type was defined.  Never NULL.
+  const FileDescriptor* file() const;
+
+  // The number of values for this EnumDescriptor.  Guaranteed to be greater
+  // than zero.
+  int value_count() const;
+  // Gets a value by index, where 0 <= index < value_count().
+  // These are returned in the order they were defined in the .proto file.
+  const EnumValueDescriptor* value(int index) const;
+
+  // Looks up a value by name.  Returns NULL if no such value exists.
+  const EnumValueDescriptor* FindValueByName(const string& name) const;
+  // Looks up a value by number.  Returns NULL if no such value exists.  If
+  // multiple values have this number, the first one defined is returned.
+  const EnumValueDescriptor* FindValueByNumber(int number) const;
+
+  // If this enum type is nested in a message type, this is that message type.
+  // Otherwise, NULL.
+  const Descriptor* containing_type() const;
+
+  // Get options for this enum type.  These are specified in the .proto file by
+  // placing lines like "option foo = 1234;" in the enum definition.  Allowed
+  // options are defined by EnumOptions in google/protobuf/descriptor.proto,
+  // and any available extensions of that message.
+  const EnumOptions& options() const;
+
+  // See Descriptor::CopyTo().
+  void CopyTo(EnumDescriptorProto* proto) const;
+
+  // See Descriptor::DebugString().
+  string DebugString() const;
+
+  // See Descriptor::DebugStringWithOptions().
+  string DebugStringWithOptions(const DebugStringOptions& options) const;
+
+  // Returns true if this is a placeholder for an unknown enum. This will
+  // only be the case if this descriptor comes from a DescriptorPool
+  // with AllowUnknownDependencies() set.
+  bool is_placeholder() const;
+
+  // Reserved fields -------------------------------------------------
+
+  // A range of reserved field numbers.
+  struct ReservedRange {
+    int start;  // inclusive
+    int end;    // inclusive
+  };
+
+  // The number of reserved ranges in this message type.
+  int reserved_range_count() const;
+  // Gets an reserved range by index, where 0 <= index <
+  // reserved_range_count(). These are returned in the order they were defined
+  // in the .proto file.
+  const EnumDescriptor::ReservedRange* reserved_range(int index) const;
+
+  // Returns true if the number is in one of the reserved ranges.
+  bool IsReservedNumber(int number) const;
+
+  // Returns NULL if no reserved range contains the given number.
+  const EnumDescriptor::ReservedRange*
+      FindReservedRangeContainingNumber(int number) const;
+
+  // The number of reserved field names in this message type.
+  int reserved_name_count() const;
+
+  // Gets a reserved name by index, where 0 <= index < reserved_name_count().
+  const string& reserved_name(int index) const;
+
+  // Returns true if the field name is reserved.
+  bool IsReservedName(const string& name) const;
+
+  // Source Location ---------------------------------------------------
+
+  // Updates |*out_location| to the source location of the complete
+  // extent of this enum declaration.  Returns false and leaves
+  // |*out_location| unchanged iff location information was not available.
+  bool GetSourceLocation(SourceLocation* out_location) const;
+
+ private:
+  typedef EnumOptions OptionsType;
+
+  // Allows access to GetLocationPath for annotations.
+  friend class ::google::protobuf::io::Printer;
+
+  // Looks up a value by number.  If the value does not exist, dynamically
+  // creates a new EnumValueDescriptor for that value, assuming that it was
+  // unknown. If a new descriptor is created, this is done in a thread-safe way,
+  // and future calls will return the same value descriptor pointer.
+  //
+  // This is private but is used by GeneratedMessageReflection (which is
+  // friended below) to return a valid EnumValueDescriptor from GetEnum() when
+  // this feature is enabled.
+  const EnumValueDescriptor*
+      FindValueByNumberCreatingIfUnknown(int number) const;
+
+
+  // See Descriptor::DebugString().
+  void DebugString(int depth, string *contents,
+                   const DebugStringOptions& options) const;
+
+  // Walks up the descriptor tree to generate the source location path
+  // to this descriptor from the file root.
+  void GetLocationPath(std::vector<int>* output) const;
+
+  const string* name_;
+  const string* full_name_;
+  const FileDescriptor* file_;
+  const Descriptor* containing_type_;
+  const EnumOptions* options_;
+
+  // True if this is a placeholder for an unknown type.
+  bool is_placeholder_;
+  // True if this is a placeholder and the type name wasn't fully-qualified.
+  bool is_unqualified_placeholder_;
+
+  int value_count_;
+  EnumValueDescriptor* values_;
+
+  int reserved_range_count_;
+  int reserved_name_count_;
+  EnumDescriptor::ReservedRange* reserved_ranges_;
+  const string** reserved_names_;
+
+  // IMPORTANT:  If you add a new field, make sure to search for all instances
+  // of Allocate<EnumDescriptor>() and AllocateArray<EnumDescriptor>() in
+  // descriptor.cc and update them to initialize the field.
+
+  // Must be constructed using DescriptorPool.
+  EnumDescriptor() {}
+  friend class DescriptorBuilder;
+  friend class Descriptor;
+  friend class FieldDescriptor;
+  friend class EnumValueDescriptor;
+  friend class FileDescriptor;
+  friend class DescriptorPool;
+  friend class internal::GeneratedMessageReflection;
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(EnumDescriptor);
+};
+
+// Describes an individual enum constant of a particular type.  To get the
+// EnumValueDescriptor for a given enum value, first get the EnumDescriptor
+// for its type, then use EnumDescriptor::FindValueByName() or
+// EnumDescriptor::FindValueByNumber().  Use DescriptorPool to construct
+// your own descriptors.
+class LIBPROTOBUF_EXPORT EnumValueDescriptor {
+ public:
+  const string& name() const;  // Name of this enum constant.
+  int index() const;           // Index within the enums's Descriptor.
+  int number() const;          // Numeric value of this enum constant.
+
+  // The full_name of an enum value is a sibling symbol of the enum type.
+  // e.g. the full name of FieldDescriptorProto::TYPE_INT32 is actually
+  // "google.protobuf.FieldDescriptorProto.TYPE_INT32", NOT
+  // "google.protobuf.FieldDescriptorProto.Type.TYPE_INT32".  This is to conform
+  // with C++ scoping rules for enums.
+  const string& full_name() const;
+
+  // The .proto file in which this value was defined.  Never NULL.
+  const FileDescriptor* file() const;
+  // The type of this value.  Never NULL.
+  const EnumDescriptor* type() const;
+
+  // Get options for this enum value.  These are specified in the .proto file
+  // by adding text like "[foo = 1234]" after an enum value definition.
+  // Allowed options are defined by EnumValueOptions in
+  // google/protobuf/descriptor.proto, and any available extensions of that
+  // message.
+  const EnumValueOptions& options() const;
+
+  // See Descriptor::CopyTo().
+  void CopyTo(EnumValueDescriptorProto* proto) const;
+
+  // See Descriptor::DebugString().
+  string DebugString() const;
+
+  // See Descriptor::DebugStringWithOptions().
+  string DebugStringWithOptions(const DebugStringOptions& options) const;
+
+
+  // Source Location ---------------------------------------------------
+
+  // Updates |*out_location| to the source location of the complete
+  // extent of this enum value declaration.  Returns false and leaves
+  // |*out_location| unchanged iff location information was not available.
+  bool GetSourceLocation(SourceLocation* out_location) const;
+
+ private:
+  typedef EnumValueOptions OptionsType;
+
+  // Allows access to GetLocationPath for annotations.
+  friend class ::google::protobuf::io::Printer;
+
+  // See Descriptor::DebugString().
+  void DebugString(int depth, string *contents,
+                   const DebugStringOptions& options) const;
+
+  // Walks up the descriptor tree to generate the source location path
+  // to this descriptor from the file root.
+  void GetLocationPath(std::vector<int>* output) const;
+
+  const string* name_;
+  const string* full_name_;
+  int number_;
+  const EnumDescriptor* type_;
+  const EnumValueOptions* options_;
+  // IMPORTANT:  If you add a new field, make sure to search for all instances
+  // of Allocate<EnumValueDescriptor>() and AllocateArray<EnumValueDescriptor>()
+  // in descriptor.cc and update them to initialize the field.
+
+  // Must be constructed using DescriptorPool.
+  EnumValueDescriptor() {}
+  friend class DescriptorBuilder;
+  friend class EnumDescriptor;
+  friend class DescriptorPool;
+  friend class FileDescriptorTables;
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(EnumValueDescriptor);
+};
+
+// Describes an RPC service.  To get the ServiceDescriptor for a service,
+// call Service::GetDescriptor().  Generated service classes also have a
+// static method called descriptor() which returns the type's
+// ServiceDescriptor.  Use DescriptorPool to construct your own descriptors.
+class LIBPROTOBUF_EXPORT ServiceDescriptor {
+ public:
+  // The name of the service, not including its containing scope.
+  const string& name() const;
+  // The fully-qualified name of the service, scope delimited by periods.
+  const string& full_name() const;
+  // Index of this service within the file's services array.
+  int index() const;
+
+  // The .proto file in which this service was defined.  Never NULL.
+  const FileDescriptor* file() const;
+
+  // Get options for this service type.  These are specified in the .proto file
+  // by placing lines like "option foo = 1234;" in the service definition.
+  // Allowed options are defined by ServiceOptions in
+  // google/protobuf/descriptor.proto, and any available extensions of that
+  // message.
+  const ServiceOptions& options() const;
+
+  // The number of methods this service defines.
+  int method_count() const;
+  // Gets a MethodDescriptor by index, where 0 <= index < method_count().
+  // These are returned in the order they were defined in the .proto file.
+  const MethodDescriptor* method(int index) const;
+
+  // Look up a MethodDescriptor by name.
+  const MethodDescriptor* FindMethodByName(const string& name) const;
+  // See Descriptor::CopyTo().
+  void CopyTo(ServiceDescriptorProto* proto) const;
+
+  // See Descriptor::DebugString().
+  string DebugString() const;
+
+  // See Descriptor::DebugStringWithOptions().
+  string DebugStringWithOptions(const DebugStringOptions& options) const;
+
+
+  // Source Location ---------------------------------------------------
+
+  // Updates |*out_location| to the source location of the complete
+  // extent of this service declaration.  Returns false and leaves
+  // |*out_location| unchanged iff location information was not available.
+  bool GetSourceLocation(SourceLocation* out_location) const;
+
+ private:
+  typedef ServiceOptions OptionsType;
+
+  // Allows access to GetLocationPath for annotations.
+  friend class ::google::protobuf::io::Printer;
+
+  // See Descriptor::DebugString().
+  void DebugString(string *contents, const DebugStringOptions& options) const;
+
+  // Walks up the descriptor tree to generate the source location path
+  // to this descriptor from the file root.
+  void GetLocationPath(std::vector<int>* output) const;
+
+  const string* name_;
+  const string* full_name_;
+  const FileDescriptor* file_;
+  const ServiceOptions* options_;
+  MethodDescriptor* methods_;
+  int method_count_;
+  // IMPORTANT:  If you add a new field, make sure to search for all instances
+  // of Allocate<ServiceDescriptor>() and AllocateArray<ServiceDescriptor>() in
+  // descriptor.cc and update them to initialize the field.
+
+  // Must be constructed using DescriptorPool.
+  ServiceDescriptor() {}
+  friend class DescriptorBuilder;
+  friend class FileDescriptor;
+  friend class MethodDescriptor;
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ServiceDescriptor);
+};
+
+
+// Describes an individual service method.  To obtain a MethodDescriptor given
+// a service, first get its ServiceDescriptor, then call
+// ServiceDescriptor::FindMethodByName().  Use DescriptorPool to construct your
+// own descriptors.
+class LIBPROTOBUF_EXPORT MethodDescriptor {
+ public:
+  // Name of this method, not including containing scope.
+  const string& name() const;
+  // The fully-qualified name of the method, scope delimited by periods.
+  const string& full_name() const;
+  // Index within the service's Descriptor.
+  int index() const;
+
+  // The .proto file in which this method was defined.  Never NULL.
+  const FileDescriptor* file() const;
+  // Gets the service to which this method belongs.  Never NULL.
+  const ServiceDescriptor* service() const;
+
+  // Gets the type of protocol message which this method accepts as input.
+  const Descriptor* input_type() const;
+  // Gets the type of protocol message which this message produces as output.
+  const Descriptor* output_type() const;
+
+  // Gets whether the client streams multiple requests.
+  bool client_streaming() const;
+  // Gets whether the server streams multiple responses.
+  bool server_streaming() const;
+
+  // Get options for this method.  These are specified in the .proto file by
+  // placing lines like "option foo = 1234;" in curly-braces after a method
+  // declaration.  Allowed options are defined by MethodOptions in
+  // google/protobuf/descriptor.proto, and any available extensions of that
+  // message.
+  const MethodOptions& options() const;
+
+  // See Descriptor::CopyTo().
+  void CopyTo(MethodDescriptorProto* proto) const;
+
+  // See Descriptor::DebugString().
+  string DebugString() const;
+
+  // See Descriptor::DebugStringWithOptions().
+  string DebugStringWithOptions(const DebugStringOptions& options) const;
+
+
+  // Source Location ---------------------------------------------------
+
+  // Updates |*out_location| to the source location of the complete
+  // extent of this method declaration.  Returns false and leaves
+  // |*out_location| unchanged iff location information was not available.
+  bool GetSourceLocation(SourceLocation* out_location) const;
+
+ private:
+  typedef MethodOptions OptionsType;
+
+  // Allows access to GetLocationPath for annotations.
+  friend class ::google::protobuf::io::Printer;
+
+  // See Descriptor::DebugString().
+  void DebugString(int depth, string *contents,
+                   const DebugStringOptions& options) const;
+
+  // Walks up the descriptor tree to generate the source location path
+  // to this descriptor from the file root.
+  void GetLocationPath(std::vector<int>* output) const;
+
+  const string* name_;
+  const string* full_name_;
+  const ServiceDescriptor* service_;
+  mutable internal::LazyDescriptor input_type_;
+  mutable internal::LazyDescriptor output_type_;
+  const MethodOptions* options_;
+  bool client_streaming_;
+  bool server_streaming_;
+  // IMPORTANT:  If you add a new field, make sure to search for all instances
+  // of Allocate<MethodDescriptor>() and AllocateArray<MethodDescriptor>() in
+  // descriptor.cc and update them to initialize the field.
+
+  // Must be constructed using DescriptorPool.
+  MethodDescriptor() {}
+  friend class DescriptorBuilder;
+  friend class ServiceDescriptor;
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MethodDescriptor);
+};
+
+
+// Describes a whole .proto file.  To get the FileDescriptor for a compiled-in
+// file, get the descriptor for something defined in that file and call
+// descriptor->file().  Use DescriptorPool to construct your own descriptors.
+class LIBPROTOBUF_EXPORT FileDescriptor {
+ public:
+  // The filename, relative to the source tree.
+  // e.g. "google/protobuf/descriptor.proto"
+  const string& name() const;
+
+  // The package, e.g. "google.protobuf.compiler".
+  const string& package() const;
+
+  // The DescriptorPool in which this FileDescriptor and all its contents were
+  // allocated.  Never NULL.
+  const DescriptorPool* pool() const;
+
+  // The number of files imported by this one.
+  int dependency_count() const;
+  // Gets an imported file by index, where 0 <= index < dependency_count().
+  // These are returned in the order they were defined in the .proto file.
+  const FileDescriptor* dependency(int index) const;
+
+  // The number of files public imported by this one.
+  // The public dependency list is a subset of the dependency list.
+  int public_dependency_count() const;
+  // Gets a public imported file by index, where 0 <= index <
+  // public_dependency_count().
+  // These are returned in the order they were defined in the .proto file.
+  const FileDescriptor* public_dependency(int index) const;
+
+  // The number of files that are imported for weak fields.
+  // The weak dependency list is a subset of the dependency list.
+  int weak_dependency_count() const;
+  // Gets a weak imported file by index, where 0 <= index <
+  // weak_dependency_count().
+  // These are returned in the order they were defined in the .proto file.
+  const FileDescriptor* weak_dependency(int index) const;
+
+  // Number of top-level message types defined in this file.  (This does not
+  // include nested types.)
+  int message_type_count() const;
+  // Gets a top-level message type, where 0 <= index < message_type_count().
+  // These are returned in the order they were defined in the .proto file.
+  const Descriptor* message_type(int index) const;
+
+  // Number of top-level enum types defined in this file.  (This does not
+  // include nested types.)
+  int enum_type_count() const;
+  // Gets a top-level enum type, where 0 <= index < enum_type_count().
+  // These are returned in the order they were defined in the .proto file.
+  const EnumDescriptor* enum_type(int index) const;
+
+  // Number of services defined in this file.
+  int service_count() const;
+  // Gets a service, where 0 <= index < service_count().
+  // These are returned in the order they were defined in the .proto file.
+  const ServiceDescriptor* service(int index) const;
+
+  // Number of extensions defined at file scope.  (This does not include
+  // extensions nested within message types.)
+  int extension_count() const;
+  // Gets an extension's descriptor, where 0 <= index < extension_count().
+  // These are returned in the order they were defined in the .proto file.
+  const FieldDescriptor* extension(int index) const;
+
+  // Get options for this file.  These are specified in the .proto file by
+  // placing lines like "option foo = 1234;" at the top level, outside of any
+  // other definitions.  Allowed options are defined by FileOptions in
+  // google/protobuf/descriptor.proto, and any available extensions of that
+  // message.
+  const FileOptions& options() const;
+
+  // Syntax of this file.
+  enum Syntax {
+    SYNTAX_UNKNOWN = 0,
+    SYNTAX_PROTO2  = 2,
+    SYNTAX_PROTO3  = 3,
+  };
+  Syntax syntax() const;
+  static const char* SyntaxName(Syntax syntax);
+
+  // Find a top-level message type by name.  Returns NULL if not found.
+  const Descriptor* FindMessageTypeByName(const string& name) const;
+  // Find a top-level enum type by name.  Returns NULL if not found.
+  const EnumDescriptor* FindEnumTypeByName(const string& name) const;
+  // Find an enum value defined in any top-level enum by name.  Returns NULL if
+  // not found.
+  const EnumValueDescriptor* FindEnumValueByName(const string& name) const;
+  // Find a service definition by name.  Returns NULL if not found.
+  const ServiceDescriptor* FindServiceByName(const string& name) const;
+  // Find a top-level extension definition by name.  Returns NULL if not found.
+  const FieldDescriptor* FindExtensionByName(const string& name) const;
+  // Similar to FindExtensionByName(), but searches by lowercased-name.  See
+  // Descriptor::FindFieldByLowercaseName().
+  const FieldDescriptor* FindExtensionByLowercaseName(const string& name) const;
+  // Similar to FindExtensionByName(), but searches by camelcased-name.  See
+  // Descriptor::FindFieldByCamelcaseName().
+  const FieldDescriptor* FindExtensionByCamelcaseName(const string& name) const;
+
+  // See Descriptor::CopyTo().
+  // Notes:
+  // - This method does NOT copy source code information since it is relatively
+  //   large and rarely needed.  See CopySourceCodeInfoTo() below.
+  void CopyTo(FileDescriptorProto* proto) const;
+  // Write the source code information of this FileDescriptor into the given
+  // FileDescriptorProto.  See CopyTo() above.
+  void CopySourceCodeInfoTo(FileDescriptorProto* proto) const;
+  // Fill the json_name field of FieldDescriptorProto for all fields. Can only
+  // be called after CopyTo().
+  void CopyJsonNameTo(FileDescriptorProto* proto) const;
+
+  // See Descriptor::DebugString().
+  string DebugString() const;
+
+  // See Descriptor::DebugStringWithOptions().
+  string DebugStringWithOptions(const DebugStringOptions& options) const;
+
+  // Returns true if this is a placeholder for an unknown file. This will
+  // only be the case if this descriptor comes from a DescriptorPool
+  // with AllowUnknownDependencies() set.
+  bool is_placeholder() const;
+
+  // Updates |*out_location| to the source location of the complete extent of
+  // this file declaration (namely, the empty path).
+  bool GetSourceLocation(SourceLocation* out_location) const;
+
+  // Updates |*out_location| to the source location of the complete
+  // extent of the declaration or declaration-part denoted by |path|.
+  // Returns false and leaves |*out_location| unchanged iff location
+  // information was not available.  (See SourceCodeInfo for
+  // description of path encoding.)
+  bool GetSourceLocation(const std::vector<int>& path,
+                         SourceLocation* out_location) const;
+
+ private:
+  typedef FileOptions OptionsType;
+
+  const string* name_;
+  const string* package_;
+  const DescriptorPool* pool_;
+  GoogleOnceDynamic* dependencies_once_;
+  static void DependenciesOnceInit(const FileDescriptor* to_init);
+  void InternalDependenciesOnceInit() const;
+
+  // These are arranged to minimze padding on 64-bit.
+  int dependency_count_;
+  int public_dependency_count_;
+  int weak_dependency_count_;
+  int message_type_count_;
+  int enum_type_count_;
+  int service_count_;
+  int extension_count_;
+  Syntax syntax_;
+  bool is_placeholder_;
+
+  // Indicates the FileDescriptor is completed building. Used to verify
+  // that type accessor functions that can possibly build a dependent file
+  // aren't called during the process of building the file.
+  bool finished_building_;
+
+  mutable const FileDescriptor** dependencies_;
+  const string** dependencies_names_;
+  int* public_dependencies_;
+  int* weak_dependencies_;
+  Descriptor* message_types_;
+  EnumDescriptor* enum_types_;
+  ServiceDescriptor* services_;
+  FieldDescriptor* extensions_;
+  const FileOptions* options_;
+
+  const FileDescriptorTables* tables_;
+  const SourceCodeInfo* source_code_info_;
+
+  // IMPORTANT:  If you add a new field, make sure to search for all instances
+  // of Allocate<FileDescriptor>() and AllocateArray<FileDescriptor>() in
+  // descriptor.cc and update them to initialize the field.
+
+  FileDescriptor() {}
+  friend class DescriptorBuilder;
+  friend class DescriptorPool;
+  friend class Descriptor;
+  friend class FieldDescriptor;
+  friend class internal::LazyDescriptor;
+  friend class OneofDescriptor;
+  friend class EnumDescriptor;
+  friend class EnumValueDescriptor;
+  friend class MethodDescriptor;
+  friend class ServiceDescriptor;
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(FileDescriptor);
+};
+
+
+// ===================================================================
+
+// Used to construct descriptors.
+//
+// Normally you won't want to build your own descriptors.  Message classes
+// constructed by the protocol compiler will provide them for you.  However,
+// if you are implementing Message on your own, or if you are writing a
+// program which can operate on totally arbitrary types and needs to load
+// them from some sort of database, you might need to.
+//
+// Since Descriptors are composed of a whole lot of cross-linked bits of
+// data that would be a pain to put together manually, the
+// DescriptorPool class is provided to make the process easier.  It can
+// take a FileDescriptorProto (defined in descriptor.proto), validate it,
+// and convert it to a set of nicely cross-linked Descriptors.
+//
+// DescriptorPool also helps with memory management.  Descriptors are
+// composed of many objects containing static data and pointers to each
+// other.  In all likelihood, when it comes time to delete this data,
+// you'll want to delete it all at once.  In fact, it is not uncommon to
+// have a whole pool of descriptors all cross-linked with each other which
+// you wish to delete all at once.  This class represents such a pool, and
+// handles the memory management for you.
+//
+// You can also search for descriptors within a DescriptorPool by name, and
+// extensions by number.
+class LIBPROTOBUF_EXPORT DescriptorPool {
+ public:
+  // Create a normal, empty DescriptorPool.
+  DescriptorPool();
+
+  // Constructs a DescriptorPool that, when it can't find something among the
+  // descriptors already in the pool, looks for it in the given
+  // DescriptorDatabase.
+  // Notes:
+  // - If a DescriptorPool is constructed this way, its BuildFile*() methods
+  //   must not be called (they will assert-fail).  The only way to populate
+  //   the pool with descriptors is to call the Find*By*() methods.
+  // - The Find*By*() methods may block the calling thread if the
+  //   DescriptorDatabase blocks.  This in turn means that parsing messages
+  //   may block if they need to look up extensions.
+  // - The Find*By*() methods will use mutexes for thread-safety, thus making
+  //   them slower even when they don't have to fall back to the database.
+  //   In fact, even the Find*By*() methods of descriptor objects owned by
+  //   this pool will be slower, since they will have to obtain locks too.
+  // - An ErrorCollector may optionally be given to collect validation errors
+  //   in files loaded from the database.  If not given, errors will be printed
+  //   to GOOGLE_LOG(ERROR).  Remember that files are built on-demand, so this
+  //   ErrorCollector may be called from any thread that calls one of the
+  //   Find*By*() methods.
+  // - The DescriptorDatabase must not be mutated during the lifetime of
+  //   the DescriptorPool. Even if the client takes care to avoid data races,
+  //   changes to the content of the DescriptorDatabase may not be reflected
+  //   in subsequent lookups in the DescriptorPool.
+  class ErrorCollector;
+  explicit DescriptorPool(DescriptorDatabase* fallback_database,
+                          ErrorCollector* error_collector = NULL);
+
+  ~DescriptorPool();
+
+  // Get a pointer to the generated pool.  Generated protocol message classes
+  // which are compiled into the binary will allocate their descriptors in
+  // this pool.  Do not add your own descriptors to this pool.
+  static const DescriptorPool* generated_pool();
+
+
+  // Find a FileDescriptor in the pool by file name.  Returns NULL if not
+  // found.
+  const FileDescriptor* FindFileByName(const string& name) const;
+
+  // Find the FileDescriptor in the pool which defines the given symbol.
+  // If any of the Find*ByName() methods below would succeed, then this is
+  // equivalent to calling that method and calling the result's file() method.
+  // Otherwise this returns NULL.
+  const FileDescriptor* FindFileContainingSymbol(
+      const string& symbol_name) const;
+
+  // Looking up descriptors ------------------------------------------
+  // These find descriptors by fully-qualified name.  These will find both
+  // top-level descriptors and nested descriptors.  They return NULL if not
+  // found.
+
+  const Descriptor* FindMessageTypeByName(const string& name) const;
+  const FieldDescriptor* FindFieldByName(const string& name) const;
+  const FieldDescriptor* FindExtensionByName(const string& name) const;
+  const OneofDescriptor* FindOneofByName(const string& name) const;
+  const EnumDescriptor* FindEnumTypeByName(const string& name) const;
+  const EnumValueDescriptor* FindEnumValueByName(const string& name) const;
+  const ServiceDescriptor* FindServiceByName(const string& name) const;
+  const MethodDescriptor* FindMethodByName(const string& name) const;
+
+  // Finds an extension of the given type by number.  The extendee must be
+  // a member of this DescriptorPool or one of its underlays.
+  const FieldDescriptor* FindExtensionByNumber(const Descriptor* extendee,
+                                               int number) const;
+
+  // Finds extensions of extendee. The extensions will be appended to
+  // out in an undefined order. Only extensions defined directly in
+  // this DescriptorPool or one of its underlays are guaranteed to be
+  // found: extensions defined in the fallback database might not be found
+  // depending on the database implementation.
+  void FindAllExtensions(const Descriptor* extendee,
+                         std::vector<const FieldDescriptor*>* out) const;
+
+  // Building descriptors --------------------------------------------
+
+  // When converting a FileDescriptorProto to a FileDescriptor, various
+  // errors might be detected in the input.  The caller may handle these
+  // programmatically by implementing an ErrorCollector.
+  class LIBPROTOBUF_EXPORT ErrorCollector {
+   public:
+    inline ErrorCollector() {}
+    virtual ~ErrorCollector();
+
+    // These constants specify what exact part of the construct is broken.
+    // This is useful e.g. for mapping the error back to an exact location
+    // in a .proto file.
+    enum ErrorLocation {
+      NAME,              // the symbol name, or the package name for files
+      NUMBER,            // field or extension range number
+      TYPE,              // field type
+      EXTENDEE,          // field extendee
+      DEFAULT_VALUE,     // field default value
+      INPUT_TYPE,        // method input type
+      OUTPUT_TYPE,       // method output type
+      OPTION_NAME,       // name in assignment
+      OPTION_VALUE,      // value in option assignment
+      OTHER              // some other problem
+    };
+
+    // Reports an error in the FileDescriptorProto. Use this function if the
+    // problem occurred should interrupt building the FileDescriptorProto.
+    virtual void AddError(
+      const string& filename,      // File name in which the error occurred.
+      const string& element_name,  // Full name of the erroneous element.
+      const Message* descriptor,   // Descriptor of the erroneous element.
+      ErrorLocation location,      // One of the location constants, above.
+      const string& message        // Human-readable error message.
+      ) = 0;
+
+    // Reports a warning in the FileDescriptorProto. Use this function if the
+    // problem occurred should NOT interrupt building the FileDescriptorProto.
+    virtual void AddWarning(
+      const string& /*filename*/,      // File name in which the error occurred.
+      const string& /*element_name*/,  // Full name of the erroneous element.
+      const Message* /*descriptor*/,   // Descriptor of the erroneous element.
+      ErrorLocation /*location*/,      // One of the location constants, above.
+      const string& /*message*/        // Human-readable error message.
+      ) {}
+
+   private:
+    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ErrorCollector);
+  };
+
+  // Convert the FileDescriptorProto to real descriptors and place them in
+  // this DescriptorPool.  All dependencies of the file must already be in
+  // the pool.  Returns the resulting FileDescriptor, or NULL if there were
+  // problems with the input (e.g. the message was invalid, or dependencies
+  // were missing).  Details about the errors are written to GOOGLE_LOG(ERROR).
+  const FileDescriptor* BuildFile(const FileDescriptorProto& proto);
+
+  // Same as BuildFile() except errors are sent to the given ErrorCollector.
+  const FileDescriptor* BuildFileCollectingErrors(
+    const FileDescriptorProto& proto,
+    ErrorCollector* error_collector);
+
+  // By default, it is an error if a FileDescriptorProto contains references
+  // to types or other files that are not found in the DescriptorPool (or its
+  // backing DescriptorDatabase, if any).  If you call
+  // AllowUnknownDependencies(), however, then unknown types and files
+  // will be replaced by placeholder descriptors (which can be identified by
+  // the is_placeholder() method).  This can allow you to
+  // perform some useful operations with a .proto file even if you do not
+  // have access to other .proto files on which it depends.  However, some
+  // heuristics must be used to fill in the gaps in information, and these
+  // can lead to descriptors which are inaccurate.  For example, the
+  // DescriptorPool may be forced to guess whether an unknown type is a message
+  // or an enum, as well as what package it resides in.  Furthermore,
+  // placeholder types will not be discoverable via FindMessageTypeByName()
+  // and similar methods, which could confuse some descriptor-based algorithms.
+  // Generally, the results of this option should be handled with extreme care.
+  void AllowUnknownDependencies() { allow_unknown_ = true; }
+
+  // By default, weak imports are allowed to be missing, in which case we will
+  // use a placeholder for the dependency and convert the field to be an Empty
+  // message field. If you call EnforceWeakDependencies(true), however, the
+  // DescriptorPool will report a import not found error.
+  void EnforceWeakDependencies(bool enforce) { enforce_weak_ = enforce; }
+
+  // Internal stuff --------------------------------------------------
+  // These methods MUST NOT be called from outside the proto2 library.
+  // These methods may contain hidden pitfalls and may be removed in a
+  // future library version.
+
+  // Create a DescriptorPool which is overlaid on top of some other pool.
+  // If you search for a descriptor in the overlay and it is not found, the
+  // underlay will be searched as a backup.  If the underlay has its own
+  // underlay, that will be searched next, and so on.  This also means that
+  // files built in the overlay will be cross-linked with the underlay's
+  // descriptors if necessary.  The underlay remains property of the caller;
+  // it must remain valid for the lifetime of the newly-constructed pool.
+  //
+  // Example:  Say you want to parse a .proto file at runtime in order to use
+  // its type with a DynamicMessage.  Say this .proto file has dependencies,
+  // but you know that all the dependencies will be things that are already
+  // compiled into the binary.  For ease of use, you'd like to load the types
+  // right out of generated_pool() rather than have to parse redundant copies
+  // of all these .protos and runtime.  But, you don't want to add the parsed
+  // types directly into generated_pool(): this is not allowed, and would be
+  // bad design anyway.  So, instead, you could use generated_pool() as an
+  // underlay for a new DescriptorPool in which you add only the new file.
+  //
+  // WARNING:  Use of underlays can lead to many subtle gotchas.  Instead,
+  //   try to formulate what you want to do in terms of DescriptorDatabases.
+  explicit DescriptorPool(const DescriptorPool* underlay);
+
+  // Called by generated classes at init time to add their descriptors to
+  // generated_pool.  Do NOT call this in your own code!  filename must be a
+  // permanent string (e.g. a string literal).
+  static void InternalAddGeneratedFile(
+      const void* encoded_file_descriptor, int size);
+
+  // Disallow [enforce_utf8 = false] in .proto files.
+  void DisallowEnforceUtf8() { disallow_enforce_utf8_ = true; }
+
+
+  // For internal use only:  Gets a non-const pointer to the generated pool.
+  // This is called at static-initialization time only, so thread-safety is
+  // not a concern.  If both an underlay and a fallback database are present,
+  // the underlay takes precedence.
+  static DescriptorPool* internal_generated_pool();
+
+  // For internal use only:  Changes the behavior of BuildFile() such that it
+  // allows the file to make reference to message types declared in other files
+  // which it did not officially declare as dependencies.
+  void InternalDontEnforceDependencies();
+
+  // For internal use only: Enables lazy building of dependencies of a file.
+  // Delay the building of dependencies of a file descriptor until absolutely
+  // necessary, like when message_type() is called on a field that is defined
+  // in that dependency's file. This will cause functional issues if a proto
+  // or one of it's dependencies has errors. Should only be enabled for the
+  // generated_pool_ (because no descriptor build errors are guaranteed by
+  // the compilation generation process), testing, or if a lack of descriptor
+  // build errors can be guaranteed for a pool.
+  void InternalSetLazilyBuildDependencies() {
+    lazily_build_dependencies_ = true;
+    // This needs to be set when lazily building dependencies, as it breaks
+    // dependency checking.
+    InternalDontEnforceDependencies();
+  }
+
+  // For internal use only.
+  void internal_set_underlay(const DescriptorPool* underlay) {
+    underlay_ = underlay;
+  }
+
+  // For internal (unit test) use only:  Returns true if a FileDescriptor has
+  // been constructed for the given file, false otherwise.  Useful for testing
+  // lazy descriptor initialization behavior.
+  bool InternalIsFileLoaded(const string& filename) const;
+
+
+  // Add a file to unused_import_track_files_. DescriptorBuilder will log
+  // warnings for those files if there is any unused import.
+  void AddUnusedImportTrackFile(const string& file_name);
+  void ClearUnusedImportTrackFiles();
+
+ private:
+  friend class Descriptor;
+  friend class internal::LazyDescriptor;
+  friend class FieldDescriptor;
+  friend class EnumDescriptor;
+  friend class ServiceDescriptor;
+  friend class MethodDescriptor;
+  friend class FileDescriptor;
+  friend class StreamDescriptor;
+  friend class DescriptorBuilder;
+  friend class FileDescriptorTables;
+
+  // Return true if the given name is a sub-symbol of any non-package
+  // descriptor that already exists in the descriptor pool.  (The full
+  // definition of such types is already known.)
+  bool IsSubSymbolOfBuiltType(const string& name) const;
+
+  // Tries to find something in the fallback database and link in the
+  // corresponding proto file.  Returns true if successful, in which case
+  // the caller should search for the thing again.  These are declared
+  // const because they are called by (semantically) const methods.
+  bool TryFindFileInFallbackDatabase(const string& name) const;
+  bool TryFindSymbolInFallbackDatabase(const string& name) const;
+  bool TryFindExtensionInFallbackDatabase(const Descriptor* containing_type,
+                                          int field_number) const;
+
+  // Like BuildFile() but called internally when the file has been loaded from
+  // fallback_database_.  Declared const because it is called by (semantically)
+  // const methods.
+  const FileDescriptor* BuildFileFromDatabase(
+    const FileDescriptorProto& proto) const;
+
+  // Helper for when lazily_build_dependencies_ is set, can look up a symbol
+  // after the file's descriptor is built, and can build the file where that
+  // symbol is defined if necessary. Will create a placeholder if the type
+  // doesn't exist in the fallback database, or the file doesn't build
+  // successfully.
+  Symbol CrossLinkOnDemandHelper(const string& name, bool expecting_enum) const;
+
+  // Create a placeholder FileDescriptor of the specified name
+  FileDescriptor* NewPlaceholderFile(const string& name) const;
+  FileDescriptor* NewPlaceholderFileWithMutexHeld(const string& name) const;
+
+  enum PlaceholderType {
+    PLACEHOLDER_MESSAGE,
+    PLACEHOLDER_ENUM,
+    PLACEHOLDER_EXTENDABLE_MESSAGE
+  };
+  // Create a placeholder Descriptor of the specified name
+  Symbol NewPlaceholder(const string& name,
+                        PlaceholderType placeholder_type) const;
+  Symbol NewPlaceholderWithMutexHeld(const string& name,
+                                     PlaceholderType placeholder_type) const;
+
+  // If fallback_database_ is NULL, this is NULL.  Otherwise, this is a mutex
+  // which must be locked while accessing tables_.
+  Mutex* mutex_;
+
+  // See constructor.
+  DescriptorDatabase* fallback_database_;
+  ErrorCollector* default_error_collector_;
+  const DescriptorPool* underlay_;
+
+  // This class contains a lot of hash maps with complicated types that
+  // we'd like to keep out of the header.
+  class Tables;
+  google::protobuf::scoped_ptr<Tables> tables_;
+
+  bool enforce_dependencies_;
+  bool lazily_build_dependencies_;
+  bool allow_unknown_;
+  bool enforce_weak_;
+  bool disallow_enforce_utf8_;
+  std::set<string> unused_import_track_files_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(DescriptorPool);
+};
+
+
+// inline methods ====================================================
+
+// These macros makes this repetitive code more readable.
+#define PROTOBUF_DEFINE_ACCESSOR(CLASS, FIELD, TYPE) \
+  inline TYPE CLASS::FIELD() const { return FIELD##_; }
+
+// Strings fields are stored as pointers but returned as const references.
+#define PROTOBUF_DEFINE_STRING_ACCESSOR(CLASS, FIELD) \
+  inline const string& CLASS::FIELD() const { return *FIELD##_; }
+
+// Arrays take an index parameter, obviously.
+#define PROTOBUF_DEFINE_ARRAY_ACCESSOR(CLASS, FIELD, TYPE) \
+  inline TYPE CLASS::FIELD(int index) const { return FIELD##s_ + index; }
+
+#define PROTOBUF_DEFINE_OPTIONS_ACCESSOR(CLASS, TYPE) \
+  inline const TYPE& CLASS::options() const { return *options_; }
+
+PROTOBUF_DEFINE_STRING_ACCESSOR(Descriptor, name)
+PROTOBUF_DEFINE_STRING_ACCESSOR(Descriptor, full_name)
+PROTOBUF_DEFINE_ACCESSOR(Descriptor, file, const FileDescriptor*)
+PROTOBUF_DEFINE_ACCESSOR(Descriptor, containing_type, const Descriptor*)
+
+PROTOBUF_DEFINE_ACCESSOR(Descriptor, field_count, int)
+PROTOBUF_DEFINE_ACCESSOR(Descriptor, oneof_decl_count, int)
+PROTOBUF_DEFINE_ACCESSOR(Descriptor, nested_type_count, int)
+PROTOBUF_DEFINE_ACCESSOR(Descriptor, enum_type_count, int)
+
+PROTOBUF_DEFINE_ARRAY_ACCESSOR(Descriptor, field, const FieldDescriptor*)
+PROTOBUF_DEFINE_ARRAY_ACCESSOR(Descriptor, oneof_decl, const OneofDescriptor*)
+PROTOBUF_DEFINE_ARRAY_ACCESSOR(Descriptor, nested_type, const Descriptor*)
+PROTOBUF_DEFINE_ARRAY_ACCESSOR(Descriptor, enum_type, const EnumDescriptor*)
+
+PROTOBUF_DEFINE_ACCESSOR(Descriptor, extension_range_count, int)
+PROTOBUF_DEFINE_ACCESSOR(Descriptor, extension_count, int)
+PROTOBUF_DEFINE_ARRAY_ACCESSOR(Descriptor, extension_range,
+                               const Descriptor::ExtensionRange*)
+PROTOBUF_DEFINE_ARRAY_ACCESSOR(Descriptor, extension,
+                               const FieldDescriptor*)
+
+PROTOBUF_DEFINE_ACCESSOR(Descriptor, reserved_range_count, int)
+PROTOBUF_DEFINE_ARRAY_ACCESSOR(Descriptor, reserved_range,
+                               const Descriptor::ReservedRange*)
+PROTOBUF_DEFINE_ACCESSOR(Descriptor, reserved_name_count, int)
+
+PROTOBUF_DEFINE_OPTIONS_ACCESSOR(Descriptor, MessageOptions)
+PROTOBUF_DEFINE_ACCESSOR(Descriptor, is_placeholder, bool)
+
+PROTOBUF_DEFINE_STRING_ACCESSOR(FieldDescriptor, name)
+PROTOBUF_DEFINE_STRING_ACCESSOR(FieldDescriptor, full_name)
+PROTOBUF_DEFINE_STRING_ACCESSOR(FieldDescriptor, json_name)
+PROTOBUF_DEFINE_STRING_ACCESSOR(FieldDescriptor, lowercase_name)
+PROTOBUF_DEFINE_STRING_ACCESSOR(FieldDescriptor, camelcase_name)
+PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, file, const FileDescriptor*)
+PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, number, int)
+PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, is_extension, bool)
+PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, label, FieldDescriptor::Label)
+PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, containing_type, const Descriptor*)
+PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, containing_oneof,
+                         const OneofDescriptor*)
+PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, index_in_oneof, int)
+PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, extension_scope, const Descriptor*)
+PROTOBUF_DEFINE_OPTIONS_ACCESSOR(FieldDescriptor, FieldOptions)
+PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, has_default_value, bool)
+PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, has_json_name, bool)
+PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_int32 , int32 )
+PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_int64 , int64 )
+PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_uint32, uint32)
+PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_uint64, uint64)
+PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_float , float )
+PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_double, double)
+PROTOBUF_DEFINE_ACCESSOR(FieldDescriptor, default_value_bool  , bool  )
+PROTOBUF_DEFINE_STRING_ACCESSOR(FieldDescriptor, default_value_string)
+
+PROTOBUF_DEFINE_STRING_ACCESSOR(OneofDescriptor, name)
+PROTOBUF_DEFINE_STRING_ACCESSOR(OneofDescriptor, full_name)
+PROTOBUF_DEFINE_ACCESSOR(OneofDescriptor, containing_type, const Descriptor*)
+PROTOBUF_DEFINE_ACCESSOR(OneofDescriptor, field_count, int)
+PROTOBUF_DEFINE_OPTIONS_ACCESSOR(OneofDescriptor, OneofOptions)
+
+PROTOBUF_DEFINE_STRING_ACCESSOR(EnumDescriptor, name)
+PROTOBUF_DEFINE_STRING_ACCESSOR(EnumDescriptor, full_name)
+PROTOBUF_DEFINE_ACCESSOR(EnumDescriptor, file, const FileDescriptor*)
+PROTOBUF_DEFINE_ACCESSOR(EnumDescriptor, containing_type, const Descriptor*)
+PROTOBUF_DEFINE_ACCESSOR(EnumDescriptor, value_count, int)
+PROTOBUF_DEFINE_ARRAY_ACCESSOR(EnumDescriptor, value,
+                               const EnumValueDescriptor*)
+PROTOBUF_DEFINE_OPTIONS_ACCESSOR(EnumDescriptor, EnumOptions)
+PROTOBUF_DEFINE_ACCESSOR(EnumDescriptor, is_placeholder, bool)
+PROTOBUF_DEFINE_ACCESSOR(EnumDescriptor, reserved_range_count, int)
+PROTOBUF_DEFINE_ARRAY_ACCESSOR(EnumDescriptor, reserved_range,
+                               const EnumDescriptor::ReservedRange*)
+PROTOBUF_DEFINE_ACCESSOR(EnumDescriptor, reserved_name_count, int)
+
+PROTOBUF_DEFINE_STRING_ACCESSOR(EnumValueDescriptor, name)
+PROTOBUF_DEFINE_STRING_ACCESSOR(EnumValueDescriptor, full_name)
+PROTOBUF_DEFINE_ACCESSOR(EnumValueDescriptor, number, int)
+PROTOBUF_DEFINE_ACCESSOR(EnumValueDescriptor, type, const EnumDescriptor*)
+PROTOBUF_DEFINE_OPTIONS_ACCESSOR(EnumValueDescriptor, EnumValueOptions)
+
+PROTOBUF_DEFINE_STRING_ACCESSOR(ServiceDescriptor, name)
+PROTOBUF_DEFINE_STRING_ACCESSOR(ServiceDescriptor, full_name)
+PROTOBUF_DEFINE_ACCESSOR(ServiceDescriptor, file, const FileDescriptor*)
+PROTOBUF_DEFINE_ACCESSOR(ServiceDescriptor, method_count, int)
+PROTOBUF_DEFINE_ARRAY_ACCESSOR(ServiceDescriptor, method,
+                               const MethodDescriptor*)
+PROTOBUF_DEFINE_OPTIONS_ACCESSOR(ServiceDescriptor, ServiceOptions)
+
+PROTOBUF_DEFINE_STRING_ACCESSOR(MethodDescriptor, name)
+PROTOBUF_DEFINE_STRING_ACCESSOR(MethodDescriptor, full_name)
+PROTOBUF_DEFINE_ACCESSOR(MethodDescriptor, service, const ServiceDescriptor*)
+PROTOBUF_DEFINE_OPTIONS_ACCESSOR(MethodDescriptor, MethodOptions)
+PROTOBUF_DEFINE_ACCESSOR(MethodDescriptor, client_streaming, bool)
+PROTOBUF_DEFINE_ACCESSOR(MethodDescriptor, server_streaming, bool)
+
+PROTOBUF_DEFINE_STRING_ACCESSOR(FileDescriptor, name)
+PROTOBUF_DEFINE_STRING_ACCESSOR(FileDescriptor, package)
+PROTOBUF_DEFINE_ACCESSOR(FileDescriptor, pool, const DescriptorPool*)
+PROTOBUF_DEFINE_ACCESSOR(FileDescriptor, dependency_count, int)
+PROTOBUF_DEFINE_ACCESSOR(FileDescriptor, public_dependency_count, int)
+PROTOBUF_DEFINE_ACCESSOR(FileDescriptor, weak_dependency_count, int)
+PROTOBUF_DEFINE_ACCESSOR(FileDescriptor, message_type_count, int)
+PROTOBUF_DEFINE_ACCESSOR(FileDescriptor, enum_type_count, int)
+PROTOBUF_DEFINE_ACCESSOR(FileDescriptor, service_count, int)
+PROTOBUF_DEFINE_ACCESSOR(FileDescriptor, extension_count, int)
+PROTOBUF_DEFINE_OPTIONS_ACCESSOR(FileDescriptor, FileOptions)
+PROTOBUF_DEFINE_ACCESSOR(FileDescriptor, is_placeholder, bool)
+
+PROTOBUF_DEFINE_ARRAY_ACCESSOR(FileDescriptor, message_type, const Descriptor*)
+PROTOBUF_DEFINE_ARRAY_ACCESSOR(FileDescriptor, enum_type, const EnumDescriptor*)
+PROTOBUF_DEFINE_ARRAY_ACCESSOR(FileDescriptor, service,
+                               const ServiceDescriptor*)
+PROTOBUF_DEFINE_ARRAY_ACCESSOR(FileDescriptor, extension,
+                               const FieldDescriptor*)
+
+#undef PROTOBUF_DEFINE_ACCESSOR
+#undef PROTOBUF_DEFINE_STRING_ACCESSOR
+#undef PROTOBUF_DEFINE_ARRAY_ACCESSOR
+
+// A few accessors differ from the macros...
+
+inline bool Descriptor::IsExtensionNumber(int number) const {
+  return FindExtensionRangeContainingNumber(number) != NULL;
+}
+
+inline bool Descriptor::IsReservedNumber(int number) const {
+  return FindReservedRangeContainingNumber(number) != NULL;
+}
+
+inline bool Descriptor::IsReservedName(const string& name) const {
+  for (int i = 0; i < reserved_name_count(); i++) {
+    if (name == reserved_name(i)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// Can't use PROTOBUF_DEFINE_ARRAY_ACCESSOR because reserved_names_ is actually
+// an array of pointers rather than the usual array of objects.
+inline const string& Descriptor::reserved_name(int index) const {
+  return *reserved_names_[index];
+}
+
+inline bool EnumDescriptor::IsReservedNumber(int number) const {
+  return FindReservedRangeContainingNumber(number) != NULL;
+}
+
+inline bool EnumDescriptor::IsReservedName(const string& name) const {
+  for (int i = 0; i < reserved_name_count(); i++) {
+    if (name == reserved_name(i)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// Can't use PROTOBUF_DEFINE_ARRAY_ACCESSOR because reserved_names_ is actually
+// an array of pointers rather than the usual array of objects.
+inline const string& EnumDescriptor::reserved_name(int index) const {
+  return *reserved_names_[index];
+}
+
+inline FieldDescriptor::Type FieldDescriptor::type() const {
+  if (type_once_) {
+    type_once_->Init(&FieldDescriptor::TypeOnceInit, this);
+  }
+  return type_;
+}
+
+inline bool FieldDescriptor::is_required() const {
+  return label() == LABEL_REQUIRED;
+}
+
+inline bool FieldDescriptor::is_optional() const {
+  return label() == LABEL_OPTIONAL;
+}
+
+inline bool FieldDescriptor::is_repeated() const {
+  return label() == LABEL_REPEATED;
+}
+
+inline bool FieldDescriptor::is_packable() const {
+  return is_repeated() && IsTypePackable(type());
+}
+
+inline bool FieldDescriptor::is_map() const {
+  return type() == TYPE_MESSAGE && is_map_message_type();
+}
+
+// To save space, index() is computed by looking at the descriptor's position
+// in the parent's array of children.
+inline int FieldDescriptor::index() const {
+  if (!is_extension_) {
+    return static_cast<int>(this - containing_type()->fields_);
+  } else if (extension_scope_ != NULL) {
+    return static_cast<int>(this - extension_scope_->extensions_);
+  } else {
+    return static_cast<int>(this - file_->extensions_);
+  }
+}
+
+inline int Descriptor::index() const {
+  if (containing_type_ == NULL) {
+    return static_cast<int>(this - file_->message_types_);
+  } else {
+    return static_cast<int>(this - containing_type_->nested_types_);
+  }
+}
+
+inline const FileDescriptor* OneofDescriptor::file() const {
+  return containing_type()->file();
+}
+
+inline int OneofDescriptor::index() const {
+  return static_cast<int>(this - containing_type_->oneof_decls_);
+}
+
+inline int EnumDescriptor::index() const {
+  if (containing_type_ == NULL) {
+    return static_cast<int>(this - file_->enum_types_);
+  } else {
+    return static_cast<int>(this - containing_type_->enum_types_);
+  }
+}
+
+inline const FileDescriptor* EnumValueDescriptor::file() const {
+  return type()->file();
+}
+
+inline int EnumValueDescriptor::index() const {
+  return static_cast<int>(this - type_->values_);
+}
+
+inline int ServiceDescriptor::index() const {
+  return static_cast<int>(this - file_->services_);
+}
+
+inline const FileDescriptor* MethodDescriptor::file() const {
+  return service()->file();
+}
+
+inline int MethodDescriptor::index() const {
+  return static_cast<int>(this - service_->methods_);
+}
+
+inline const char* FieldDescriptor::type_name() const {
+  return kTypeToName[type()];
+}
+
+inline FieldDescriptor::CppType FieldDescriptor::cpp_type() const {
+  return kTypeToCppTypeMap[type()];
+}
+
+inline const char* FieldDescriptor::cpp_type_name() const {
+  return kCppTypeToName[kTypeToCppTypeMap[type()]];
+}
+
+inline FieldDescriptor::CppType FieldDescriptor::TypeToCppType(Type type) {
+  return kTypeToCppTypeMap[type];
+}
+
+inline const char* FieldDescriptor::TypeName(Type type) {
+  return kTypeToName[type];
+}
+
+inline const char* FieldDescriptor::CppTypeName(CppType cpp_type) {
+  return kCppTypeToName[cpp_type];
+}
+
+inline bool FieldDescriptor::IsTypePackable(Type field_type) {
+  return (field_type != FieldDescriptor::TYPE_STRING &&
+          field_type != FieldDescriptor::TYPE_GROUP &&
+          field_type != FieldDescriptor::TYPE_MESSAGE &&
+          field_type != FieldDescriptor::TYPE_BYTES);
+}
+
+inline const FileDescriptor* FileDescriptor::public_dependency(
+    int index) const {
+  return dependency(public_dependencies_[index]);
+}
+
+inline const FileDescriptor* FileDescriptor::weak_dependency(
+    int index) const {
+  return dependency(weak_dependencies_[index]);
+}
+
+inline FileDescriptor::Syntax FileDescriptor::syntax() const {
+  return syntax_;
+}
+
+// Can't use PROTOBUF_DEFINE_ARRAY_ACCESSOR because fields_ is actually an array
+// of pointers rather than the usual array of objects.
+inline const FieldDescriptor* OneofDescriptor::field(int index) const {
+  return fields_[index];
+}
+
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_DESCRIPTOR_H__
diff --git a/kortex_api/include/google/protobuf/descriptor.pb.h b/kortex_api/include/google/protobuf/descriptor.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..4ed5cac94447bcb687e94ce9ecd5466fc42f31c0
--- /dev/null
+++ b/kortex_api/include/google/protobuf/descriptor.pb.h
@@ -0,0 +1,11497 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: google/protobuf/descriptor.proto
+
+#ifndef PROTOBUF_google_2fprotobuf_2fdescriptor_2eproto__INCLUDED
+#define PROTOBUF_google_2fprotobuf_2fdescriptor_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 3005000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 3005001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+// @@protoc_insertion_point(includes)
+
+namespace protobuf_google_2fprotobuf_2fdescriptor_2eproto {
+// Internal implementation detail -- do not use these members.
+struct LIBPROTOBUF_EXPORT TableStruct {
+  static const ::google::protobuf::internal::ParseTableField entries[];
+  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
+  static const ::google::protobuf::internal::ParseTable schema[27];
+  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
+  static const ::google::protobuf::internal::SerializationTable serialization_table[];
+  static const ::google::protobuf::uint32 offsets[];
+};
+void LIBPROTOBUF_EXPORT AddDescriptors();
+void LIBPROTOBUF_EXPORT InitDefaultsFileDescriptorSetImpl();
+void LIBPROTOBUF_EXPORT InitDefaultsFileDescriptorSet();
+void LIBPROTOBUF_EXPORT InitDefaultsFileDescriptorProtoImpl();
+void LIBPROTOBUF_EXPORT InitDefaultsFileDescriptorProto();
+void LIBPROTOBUF_EXPORT InitDefaultsDescriptorProto_ExtensionRangeImpl();
+void LIBPROTOBUF_EXPORT InitDefaultsDescriptorProto_ExtensionRange();
+void LIBPROTOBUF_EXPORT InitDefaultsDescriptorProto_ReservedRangeImpl();
+void LIBPROTOBUF_EXPORT InitDefaultsDescriptorProto_ReservedRange();
+void LIBPROTOBUF_EXPORT InitDefaultsDescriptorProtoImpl();
+void LIBPROTOBUF_EXPORT InitDefaultsDescriptorProto();
+void LIBPROTOBUF_EXPORT InitDefaultsExtensionRangeOptionsImpl();
+void LIBPROTOBUF_EXPORT InitDefaultsExtensionRangeOptions();
+void LIBPROTOBUF_EXPORT InitDefaultsFieldDescriptorProtoImpl();
+void LIBPROTOBUF_EXPORT InitDefaultsFieldDescriptorProto();
+void LIBPROTOBUF_EXPORT InitDefaultsOneofDescriptorProtoImpl();
+void LIBPROTOBUF_EXPORT InitDefaultsOneofDescriptorProto();
+void LIBPROTOBUF_EXPORT InitDefaultsEnumDescriptorProto_EnumReservedRangeImpl();
+void LIBPROTOBUF_EXPORT InitDefaultsEnumDescriptorProto_EnumReservedRange();
+void LIBPROTOBUF_EXPORT InitDefaultsEnumDescriptorProtoImpl();
+void LIBPROTOBUF_EXPORT InitDefaultsEnumDescriptorProto();
+void LIBPROTOBUF_EXPORT InitDefaultsEnumValueDescriptorProtoImpl();
+void LIBPROTOBUF_EXPORT InitDefaultsEnumValueDescriptorProto();
+void LIBPROTOBUF_EXPORT InitDefaultsServiceDescriptorProtoImpl();
+void LIBPROTOBUF_EXPORT InitDefaultsServiceDescriptorProto();
+void LIBPROTOBUF_EXPORT InitDefaultsMethodDescriptorProtoImpl();
+void LIBPROTOBUF_EXPORT InitDefaultsMethodDescriptorProto();
+void LIBPROTOBUF_EXPORT InitDefaultsFileOptionsImpl();
+void LIBPROTOBUF_EXPORT InitDefaultsFileOptions();
+void LIBPROTOBUF_EXPORT InitDefaultsMessageOptionsImpl();
+void LIBPROTOBUF_EXPORT InitDefaultsMessageOptions();
+void LIBPROTOBUF_EXPORT InitDefaultsFieldOptionsImpl();
+void LIBPROTOBUF_EXPORT InitDefaultsFieldOptions();
+void LIBPROTOBUF_EXPORT InitDefaultsOneofOptionsImpl();
+void LIBPROTOBUF_EXPORT InitDefaultsOneofOptions();
+void LIBPROTOBUF_EXPORT InitDefaultsEnumOptionsImpl();
+void LIBPROTOBUF_EXPORT InitDefaultsEnumOptions();
+void LIBPROTOBUF_EXPORT InitDefaultsEnumValueOptionsImpl();
+void LIBPROTOBUF_EXPORT InitDefaultsEnumValueOptions();
+void LIBPROTOBUF_EXPORT InitDefaultsServiceOptionsImpl();
+void LIBPROTOBUF_EXPORT InitDefaultsServiceOptions();
+void LIBPROTOBUF_EXPORT InitDefaultsMethodOptionsImpl();
+void LIBPROTOBUF_EXPORT InitDefaultsMethodOptions();
+void LIBPROTOBUF_EXPORT InitDefaultsUninterpretedOption_NamePartImpl();
+void LIBPROTOBUF_EXPORT InitDefaultsUninterpretedOption_NamePart();
+void LIBPROTOBUF_EXPORT InitDefaultsUninterpretedOptionImpl();
+void LIBPROTOBUF_EXPORT InitDefaultsUninterpretedOption();
+void LIBPROTOBUF_EXPORT InitDefaultsSourceCodeInfo_LocationImpl();
+void LIBPROTOBUF_EXPORT InitDefaultsSourceCodeInfo_Location();
+void LIBPROTOBUF_EXPORT InitDefaultsSourceCodeInfoImpl();
+void LIBPROTOBUF_EXPORT InitDefaultsSourceCodeInfo();
+void LIBPROTOBUF_EXPORT InitDefaultsGeneratedCodeInfo_AnnotationImpl();
+void LIBPROTOBUF_EXPORT InitDefaultsGeneratedCodeInfo_Annotation();
+void LIBPROTOBUF_EXPORT InitDefaultsGeneratedCodeInfoImpl();
+void LIBPROTOBUF_EXPORT InitDefaultsGeneratedCodeInfo();
+inline void LIBPROTOBUF_EXPORT InitDefaults() {
+  InitDefaultsFileDescriptorSet();
+  InitDefaultsFileDescriptorProto();
+  InitDefaultsDescriptorProto_ExtensionRange();
+  InitDefaultsDescriptorProto_ReservedRange();
+  InitDefaultsDescriptorProto();
+  InitDefaultsExtensionRangeOptions();
+  InitDefaultsFieldDescriptorProto();
+  InitDefaultsOneofDescriptorProto();
+  InitDefaultsEnumDescriptorProto_EnumReservedRange();
+  InitDefaultsEnumDescriptorProto();
+  InitDefaultsEnumValueDescriptorProto();
+  InitDefaultsServiceDescriptorProto();
+  InitDefaultsMethodDescriptorProto();
+  InitDefaultsFileOptions();
+  InitDefaultsMessageOptions();
+  InitDefaultsFieldOptions();
+  InitDefaultsOneofOptions();
+  InitDefaultsEnumOptions();
+  InitDefaultsEnumValueOptions();
+  InitDefaultsServiceOptions();
+  InitDefaultsMethodOptions();
+  InitDefaultsUninterpretedOption_NamePart();
+  InitDefaultsUninterpretedOption();
+  InitDefaultsSourceCodeInfo_Location();
+  InitDefaultsSourceCodeInfo();
+  InitDefaultsGeneratedCodeInfo_Annotation();
+  InitDefaultsGeneratedCodeInfo();
+}
+}  // namespace protobuf_google_2fprotobuf_2fdescriptor_2eproto
+namespace google {
+namespace protobuf {
+class DescriptorProto;
+class DescriptorProtoDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern DescriptorProtoDefaultTypeInternal _DescriptorProto_default_instance_;
+class DescriptorProto_ExtensionRange;
+class DescriptorProto_ExtensionRangeDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern DescriptorProto_ExtensionRangeDefaultTypeInternal _DescriptorProto_ExtensionRange_default_instance_;
+class DescriptorProto_ReservedRange;
+class DescriptorProto_ReservedRangeDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern DescriptorProto_ReservedRangeDefaultTypeInternal _DescriptorProto_ReservedRange_default_instance_;
+class EnumDescriptorProto;
+class EnumDescriptorProtoDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern EnumDescriptorProtoDefaultTypeInternal _EnumDescriptorProto_default_instance_;
+class EnumDescriptorProto_EnumReservedRange;
+class EnumDescriptorProto_EnumReservedRangeDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern EnumDescriptorProto_EnumReservedRangeDefaultTypeInternal _EnumDescriptorProto_EnumReservedRange_default_instance_;
+class EnumOptions;
+class EnumOptionsDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern EnumOptionsDefaultTypeInternal _EnumOptions_default_instance_;
+class EnumValueDescriptorProto;
+class EnumValueDescriptorProtoDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern EnumValueDescriptorProtoDefaultTypeInternal _EnumValueDescriptorProto_default_instance_;
+class EnumValueOptions;
+class EnumValueOptionsDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern EnumValueOptionsDefaultTypeInternal _EnumValueOptions_default_instance_;
+class ExtensionRangeOptions;
+class ExtensionRangeOptionsDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern ExtensionRangeOptionsDefaultTypeInternal _ExtensionRangeOptions_default_instance_;
+class FieldDescriptorProto;
+class FieldDescriptorProtoDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern FieldDescriptorProtoDefaultTypeInternal _FieldDescriptorProto_default_instance_;
+class FieldOptions;
+class FieldOptionsDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern FieldOptionsDefaultTypeInternal _FieldOptions_default_instance_;
+class FileDescriptorProto;
+class FileDescriptorProtoDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern FileDescriptorProtoDefaultTypeInternal _FileDescriptorProto_default_instance_;
+class FileDescriptorSet;
+class FileDescriptorSetDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern FileDescriptorSetDefaultTypeInternal _FileDescriptorSet_default_instance_;
+class FileOptions;
+class FileOptionsDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern FileOptionsDefaultTypeInternal _FileOptions_default_instance_;
+class GeneratedCodeInfo;
+class GeneratedCodeInfoDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern GeneratedCodeInfoDefaultTypeInternal _GeneratedCodeInfo_default_instance_;
+class GeneratedCodeInfo_Annotation;
+class GeneratedCodeInfo_AnnotationDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern GeneratedCodeInfo_AnnotationDefaultTypeInternal _GeneratedCodeInfo_Annotation_default_instance_;
+class MessageOptions;
+class MessageOptionsDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern MessageOptionsDefaultTypeInternal _MessageOptions_default_instance_;
+class MethodDescriptorProto;
+class MethodDescriptorProtoDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern MethodDescriptorProtoDefaultTypeInternal _MethodDescriptorProto_default_instance_;
+class MethodOptions;
+class MethodOptionsDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern MethodOptionsDefaultTypeInternal _MethodOptions_default_instance_;
+class OneofDescriptorProto;
+class OneofDescriptorProtoDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern OneofDescriptorProtoDefaultTypeInternal _OneofDescriptorProto_default_instance_;
+class OneofOptions;
+class OneofOptionsDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern OneofOptionsDefaultTypeInternal _OneofOptions_default_instance_;
+class ServiceDescriptorProto;
+class ServiceDescriptorProtoDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern ServiceDescriptorProtoDefaultTypeInternal _ServiceDescriptorProto_default_instance_;
+class ServiceOptions;
+class ServiceOptionsDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern ServiceOptionsDefaultTypeInternal _ServiceOptions_default_instance_;
+class SourceCodeInfo;
+class SourceCodeInfoDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern SourceCodeInfoDefaultTypeInternal _SourceCodeInfo_default_instance_;
+class SourceCodeInfo_Location;
+class SourceCodeInfo_LocationDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern SourceCodeInfo_LocationDefaultTypeInternal _SourceCodeInfo_Location_default_instance_;
+class UninterpretedOption;
+class UninterpretedOptionDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern UninterpretedOptionDefaultTypeInternal _UninterpretedOption_default_instance_;
+class UninterpretedOption_NamePart;
+class UninterpretedOption_NamePartDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern UninterpretedOption_NamePartDefaultTypeInternal _UninterpretedOption_NamePart_default_instance_;
+}  // namespace protobuf
+}  // namespace google
+namespace google {
+namespace protobuf {
+
+enum FieldDescriptorProto_Type {
+  FieldDescriptorProto_Type_TYPE_DOUBLE = 1,
+  FieldDescriptorProto_Type_TYPE_FLOAT = 2,
+  FieldDescriptorProto_Type_TYPE_INT64 = 3,
+  FieldDescriptorProto_Type_TYPE_UINT64 = 4,
+  FieldDescriptorProto_Type_TYPE_INT32 = 5,
+  FieldDescriptorProto_Type_TYPE_FIXED64 = 6,
+  FieldDescriptorProto_Type_TYPE_FIXED32 = 7,
+  FieldDescriptorProto_Type_TYPE_BOOL = 8,
+  FieldDescriptorProto_Type_TYPE_STRING = 9,
+  FieldDescriptorProto_Type_TYPE_GROUP = 10,
+  FieldDescriptorProto_Type_TYPE_MESSAGE = 11,
+  FieldDescriptorProto_Type_TYPE_BYTES = 12,
+  FieldDescriptorProto_Type_TYPE_UINT32 = 13,
+  FieldDescriptorProto_Type_TYPE_ENUM = 14,
+  FieldDescriptorProto_Type_TYPE_SFIXED32 = 15,
+  FieldDescriptorProto_Type_TYPE_SFIXED64 = 16,
+  FieldDescriptorProto_Type_TYPE_SINT32 = 17,
+  FieldDescriptorProto_Type_TYPE_SINT64 = 18
+};
+LIBPROTOBUF_EXPORT bool FieldDescriptorProto_Type_IsValid(int value);
+const FieldDescriptorProto_Type FieldDescriptorProto_Type_Type_MIN = FieldDescriptorProto_Type_TYPE_DOUBLE;
+const FieldDescriptorProto_Type FieldDescriptorProto_Type_Type_MAX = FieldDescriptorProto_Type_TYPE_SINT64;
+const int FieldDescriptorProto_Type_Type_ARRAYSIZE = FieldDescriptorProto_Type_Type_MAX + 1;
+
+LIBPROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor* FieldDescriptorProto_Type_descriptor();
+inline const ::std::string& FieldDescriptorProto_Type_Name(FieldDescriptorProto_Type value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    FieldDescriptorProto_Type_descriptor(), value);
+}
+inline bool FieldDescriptorProto_Type_Parse(
+    const ::std::string& name, FieldDescriptorProto_Type* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<FieldDescriptorProto_Type>(
+    FieldDescriptorProto_Type_descriptor(), name, value);
+}
+enum FieldDescriptorProto_Label {
+  FieldDescriptorProto_Label_LABEL_OPTIONAL = 1,
+  FieldDescriptorProto_Label_LABEL_REQUIRED = 2,
+  FieldDescriptorProto_Label_LABEL_REPEATED = 3
+};
+LIBPROTOBUF_EXPORT bool FieldDescriptorProto_Label_IsValid(int value);
+const FieldDescriptorProto_Label FieldDescriptorProto_Label_Label_MIN = FieldDescriptorProto_Label_LABEL_OPTIONAL;
+const FieldDescriptorProto_Label FieldDescriptorProto_Label_Label_MAX = FieldDescriptorProto_Label_LABEL_REPEATED;
+const int FieldDescriptorProto_Label_Label_ARRAYSIZE = FieldDescriptorProto_Label_Label_MAX + 1;
+
+LIBPROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor* FieldDescriptorProto_Label_descriptor();
+inline const ::std::string& FieldDescriptorProto_Label_Name(FieldDescriptorProto_Label value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    FieldDescriptorProto_Label_descriptor(), value);
+}
+inline bool FieldDescriptorProto_Label_Parse(
+    const ::std::string& name, FieldDescriptorProto_Label* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<FieldDescriptorProto_Label>(
+    FieldDescriptorProto_Label_descriptor(), name, value);
+}
+enum FileOptions_OptimizeMode {
+  FileOptions_OptimizeMode_SPEED = 1,
+  FileOptions_OptimizeMode_CODE_SIZE = 2,
+  FileOptions_OptimizeMode_LITE_RUNTIME = 3
+};
+LIBPROTOBUF_EXPORT bool FileOptions_OptimizeMode_IsValid(int value);
+const FileOptions_OptimizeMode FileOptions_OptimizeMode_OptimizeMode_MIN = FileOptions_OptimizeMode_SPEED;
+const FileOptions_OptimizeMode FileOptions_OptimizeMode_OptimizeMode_MAX = FileOptions_OptimizeMode_LITE_RUNTIME;
+const int FileOptions_OptimizeMode_OptimizeMode_ARRAYSIZE = FileOptions_OptimizeMode_OptimizeMode_MAX + 1;
+
+LIBPROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor* FileOptions_OptimizeMode_descriptor();
+inline const ::std::string& FileOptions_OptimizeMode_Name(FileOptions_OptimizeMode value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    FileOptions_OptimizeMode_descriptor(), value);
+}
+inline bool FileOptions_OptimizeMode_Parse(
+    const ::std::string& name, FileOptions_OptimizeMode* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<FileOptions_OptimizeMode>(
+    FileOptions_OptimizeMode_descriptor(), name, value);
+}
+enum FieldOptions_CType {
+  FieldOptions_CType_STRING = 0,
+  FieldOptions_CType_CORD = 1,
+  FieldOptions_CType_STRING_PIECE = 2
+};
+LIBPROTOBUF_EXPORT bool FieldOptions_CType_IsValid(int value);
+const FieldOptions_CType FieldOptions_CType_CType_MIN = FieldOptions_CType_STRING;
+const FieldOptions_CType FieldOptions_CType_CType_MAX = FieldOptions_CType_STRING_PIECE;
+const int FieldOptions_CType_CType_ARRAYSIZE = FieldOptions_CType_CType_MAX + 1;
+
+LIBPROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor* FieldOptions_CType_descriptor();
+inline const ::std::string& FieldOptions_CType_Name(FieldOptions_CType value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    FieldOptions_CType_descriptor(), value);
+}
+inline bool FieldOptions_CType_Parse(
+    const ::std::string& name, FieldOptions_CType* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<FieldOptions_CType>(
+    FieldOptions_CType_descriptor(), name, value);
+}
+enum FieldOptions_JSType {
+  FieldOptions_JSType_JS_NORMAL = 0,
+  FieldOptions_JSType_JS_STRING = 1,
+  FieldOptions_JSType_JS_NUMBER = 2
+};
+LIBPROTOBUF_EXPORT bool FieldOptions_JSType_IsValid(int value);
+const FieldOptions_JSType FieldOptions_JSType_JSType_MIN = FieldOptions_JSType_JS_NORMAL;
+const FieldOptions_JSType FieldOptions_JSType_JSType_MAX = FieldOptions_JSType_JS_NUMBER;
+const int FieldOptions_JSType_JSType_ARRAYSIZE = FieldOptions_JSType_JSType_MAX + 1;
+
+LIBPROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor* FieldOptions_JSType_descriptor();
+inline const ::std::string& FieldOptions_JSType_Name(FieldOptions_JSType value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    FieldOptions_JSType_descriptor(), value);
+}
+inline bool FieldOptions_JSType_Parse(
+    const ::std::string& name, FieldOptions_JSType* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<FieldOptions_JSType>(
+    FieldOptions_JSType_descriptor(), name, value);
+}
+enum MethodOptions_IdempotencyLevel {
+  MethodOptions_IdempotencyLevel_IDEMPOTENCY_UNKNOWN = 0,
+  MethodOptions_IdempotencyLevel_NO_SIDE_EFFECTS = 1,
+  MethodOptions_IdempotencyLevel_IDEMPOTENT = 2
+};
+LIBPROTOBUF_EXPORT bool MethodOptions_IdempotencyLevel_IsValid(int value);
+const MethodOptions_IdempotencyLevel MethodOptions_IdempotencyLevel_IdempotencyLevel_MIN = MethodOptions_IdempotencyLevel_IDEMPOTENCY_UNKNOWN;
+const MethodOptions_IdempotencyLevel MethodOptions_IdempotencyLevel_IdempotencyLevel_MAX = MethodOptions_IdempotencyLevel_IDEMPOTENT;
+const int MethodOptions_IdempotencyLevel_IdempotencyLevel_ARRAYSIZE = MethodOptions_IdempotencyLevel_IdempotencyLevel_MAX + 1;
+
+LIBPROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor* MethodOptions_IdempotencyLevel_descriptor();
+inline const ::std::string& MethodOptions_IdempotencyLevel_Name(MethodOptions_IdempotencyLevel value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    MethodOptions_IdempotencyLevel_descriptor(), value);
+}
+inline bool MethodOptions_IdempotencyLevel_Parse(
+    const ::std::string& name, MethodOptions_IdempotencyLevel* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<MethodOptions_IdempotencyLevel>(
+    MethodOptions_IdempotencyLevel_descriptor(), name, value);
+}
+// ===================================================================
+
+class LIBPROTOBUF_EXPORT FileDescriptorSet : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.FileDescriptorSet) */ {
+ public:
+  FileDescriptorSet();
+  virtual ~FileDescriptorSet();
+
+  FileDescriptorSet(const FileDescriptorSet& from);
+
+  inline FileDescriptorSet& operator=(const FileDescriptorSet& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  FileDescriptorSet(FileDescriptorSet&& from) noexcept
+    : FileDescriptorSet() {
+    *this = ::std::move(from);
+  }
+
+  inline FileDescriptorSet& operator=(FileDescriptorSet&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields();
+  }
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields();
+  }
+
+  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
+    return GetArenaNoVirtual();
+  }
+  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
+    return MaybeArenaPtr();
+  }
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const FileDescriptorSet& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const FileDescriptorSet* internal_default_instance() {
+    return reinterpret_cast<const FileDescriptorSet*>(
+               &_FileDescriptorSet_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    0;
+
+  void UnsafeArenaSwap(FileDescriptorSet* other);
+  void Swap(FileDescriptorSet* other);
+  friend void swap(FileDescriptorSet& a, FileDescriptorSet& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline FileDescriptorSet* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  FileDescriptorSet* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const FileDescriptorSet& from);
+  void MergeFrom(const FileDescriptorSet& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(FileDescriptorSet* other);
+  protected:
+  explicit FileDescriptorSet(::google::protobuf::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return _internal_metadata_.arena();
+  }
+  inline void* MaybeArenaPtr() const {
+    return _internal_metadata_.raw_arena_ptr();
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .google.protobuf.FileDescriptorProto file = 1;
+  int file_size() const;
+  void clear_file();
+  static const int kFileFieldNumber = 1;
+  const ::google::protobuf::FileDescriptorProto& file(int index) const;
+  ::google::protobuf::FileDescriptorProto* mutable_file(int index);
+  ::google::protobuf::FileDescriptorProto* add_file();
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::FileDescriptorProto >*
+      mutable_file();
+  const ::google::protobuf::RepeatedPtrField< ::google::protobuf::FileDescriptorProto >&
+      file() const;
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.FileDescriptorSet)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::google::protobuf::internal::HasBits<1> _has_bits_;
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::FileDescriptorProto > file_;
+  friend struct ::protobuf_google_2fprotobuf_2fdescriptor_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2fdescriptor_2eproto::InitDefaultsFileDescriptorSetImpl();
+};
+// -------------------------------------------------------------------
+
+class LIBPROTOBUF_EXPORT FileDescriptorProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.FileDescriptorProto) */ {
+ public:
+  FileDescriptorProto();
+  virtual ~FileDescriptorProto();
+
+  FileDescriptorProto(const FileDescriptorProto& from);
+
+  inline FileDescriptorProto& operator=(const FileDescriptorProto& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  FileDescriptorProto(FileDescriptorProto&& from) noexcept
+    : FileDescriptorProto() {
+    *this = ::std::move(from);
+  }
+
+  inline FileDescriptorProto& operator=(FileDescriptorProto&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields();
+  }
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields();
+  }
+
+  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
+    return GetArenaNoVirtual();
+  }
+  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
+    return MaybeArenaPtr();
+  }
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const FileDescriptorProto& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const FileDescriptorProto* internal_default_instance() {
+    return reinterpret_cast<const FileDescriptorProto*>(
+               &_FileDescriptorProto_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    1;
+
+  void UnsafeArenaSwap(FileDescriptorProto* other);
+  void Swap(FileDescriptorProto* other);
+  friend void swap(FileDescriptorProto& a, FileDescriptorProto& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline FileDescriptorProto* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  FileDescriptorProto* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const FileDescriptorProto& from);
+  void MergeFrom(const FileDescriptorProto& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(FileDescriptorProto* other);
+  protected:
+  explicit FileDescriptorProto(::google::protobuf::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return _internal_metadata_.arena();
+  }
+  inline void* MaybeArenaPtr() const {
+    return _internal_metadata_.raw_arena_ptr();
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated string dependency = 3;
+  int dependency_size() const;
+  void clear_dependency();
+  static const int kDependencyFieldNumber = 3;
+  const ::std::string& dependency(int index) const;
+  ::std::string* mutable_dependency(int index);
+  void set_dependency(int index, const ::std::string& value);
+  #if LANG_CXX11
+  void set_dependency(int index, ::std::string&& value);
+  #endif
+  void set_dependency(int index, const char* value);
+  void set_dependency(int index, const char* value, size_t size);
+  ::std::string* add_dependency();
+  void add_dependency(const ::std::string& value);
+  #if LANG_CXX11
+  void add_dependency(::std::string&& value);
+  #endif
+  void add_dependency(const char* value);
+  void add_dependency(const char* value, size_t size);
+  const ::google::protobuf::RepeatedPtrField< ::std::string>& dependency() const;
+  ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_dependency();
+
+  // repeated .google.protobuf.DescriptorProto message_type = 4;
+  int message_type_size() const;
+  void clear_message_type();
+  static const int kMessageTypeFieldNumber = 4;
+  const ::google::protobuf::DescriptorProto& message_type(int index) const;
+  ::google::protobuf::DescriptorProto* mutable_message_type(int index);
+  ::google::protobuf::DescriptorProto* add_message_type();
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto >*
+      mutable_message_type();
+  const ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto >&
+      message_type() const;
+
+  // repeated .google.protobuf.EnumDescriptorProto enum_type = 5;
+  int enum_type_size() const;
+  void clear_enum_type();
+  static const int kEnumTypeFieldNumber = 5;
+  const ::google::protobuf::EnumDescriptorProto& enum_type(int index) const;
+  ::google::protobuf::EnumDescriptorProto* mutable_enum_type(int index);
+  ::google::protobuf::EnumDescriptorProto* add_enum_type();
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumDescriptorProto >*
+      mutable_enum_type();
+  const ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumDescriptorProto >&
+      enum_type() const;
+
+  // repeated .google.protobuf.ServiceDescriptorProto service = 6;
+  int service_size() const;
+  void clear_service();
+  static const int kServiceFieldNumber = 6;
+  const ::google::protobuf::ServiceDescriptorProto& service(int index) const;
+  ::google::protobuf::ServiceDescriptorProto* mutable_service(int index);
+  ::google::protobuf::ServiceDescriptorProto* add_service();
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::ServiceDescriptorProto >*
+      mutable_service();
+  const ::google::protobuf::RepeatedPtrField< ::google::protobuf::ServiceDescriptorProto >&
+      service() const;
+
+  // repeated .google.protobuf.FieldDescriptorProto extension = 7;
+  int extension_size() const;
+  void clear_extension();
+  static const int kExtensionFieldNumber = 7;
+  const ::google::protobuf::FieldDescriptorProto& extension(int index) const;
+  ::google::protobuf::FieldDescriptorProto* mutable_extension(int index);
+  ::google::protobuf::FieldDescriptorProto* add_extension();
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >*
+      mutable_extension();
+  const ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >&
+      extension() const;
+
+  // repeated int32 public_dependency = 10;
+  int public_dependency_size() const;
+  void clear_public_dependency();
+  static const int kPublicDependencyFieldNumber = 10;
+  ::google::protobuf::int32 public_dependency(int index) const;
+  void set_public_dependency(int index, ::google::protobuf::int32 value);
+  void add_public_dependency(::google::protobuf::int32 value);
+  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
+      public_dependency() const;
+  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
+      mutable_public_dependency();
+
+  // repeated int32 weak_dependency = 11;
+  int weak_dependency_size() const;
+  void clear_weak_dependency();
+  static const int kWeakDependencyFieldNumber = 11;
+  ::google::protobuf::int32 weak_dependency(int index) const;
+  void set_weak_dependency(int index, ::google::protobuf::int32 value);
+  void add_weak_dependency(::google::protobuf::int32 value);
+  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
+      weak_dependency() const;
+  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
+      mutable_weak_dependency();
+
+  // optional string name = 1;
+  bool has_name() const;
+  void clear_name();
+  static const int kNameFieldNumber = 1;
+  const ::std::string& name() const;
+  void set_name(const ::std::string& value);
+  #if LANG_CXX11
+  void set_name(::std::string&& value);
+  #endif
+  void set_name(const char* value);
+  void set_name(const char* value, size_t size);
+  ::std::string* mutable_name();
+  ::std::string* release_name();
+  void set_allocated_name(::std::string* name);
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  ::std::string* unsafe_arena_release_name();
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  void unsafe_arena_set_allocated_name(
+      ::std::string* name);
+
+  // optional string package = 2;
+  bool has_package() const;
+  void clear_package();
+  static const int kPackageFieldNumber = 2;
+  const ::std::string& package() const;
+  void set_package(const ::std::string& value);
+  #if LANG_CXX11
+  void set_package(::std::string&& value);
+  #endif
+  void set_package(const char* value);
+  void set_package(const char* value, size_t size);
+  ::std::string* mutable_package();
+  ::std::string* release_package();
+  void set_allocated_package(::std::string* package);
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  ::std::string* unsafe_arena_release_package();
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  void unsafe_arena_set_allocated_package(
+      ::std::string* package);
+
+  // optional string syntax = 12;
+  bool has_syntax() const;
+  void clear_syntax();
+  static const int kSyntaxFieldNumber = 12;
+  const ::std::string& syntax() const;
+  void set_syntax(const ::std::string& value);
+  #if LANG_CXX11
+  void set_syntax(::std::string&& value);
+  #endif
+  void set_syntax(const char* value);
+  void set_syntax(const char* value, size_t size);
+  ::std::string* mutable_syntax();
+  ::std::string* release_syntax();
+  void set_allocated_syntax(::std::string* syntax);
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  ::std::string* unsafe_arena_release_syntax();
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  void unsafe_arena_set_allocated_syntax(
+      ::std::string* syntax);
+
+  // optional .google.protobuf.FileOptions options = 8;
+  bool has_options() const;
+  void clear_options();
+  static const int kOptionsFieldNumber = 8;
+  private:
+  void _slow_mutable_options();
+  public:
+  const ::google::protobuf::FileOptions& options() const;
+  ::google::protobuf::FileOptions* release_options();
+  ::google::protobuf::FileOptions* mutable_options();
+  void set_allocated_options(::google::protobuf::FileOptions* options);
+  void unsafe_arena_set_allocated_options(
+      ::google::protobuf::FileOptions* options);
+  ::google::protobuf::FileOptions* unsafe_arena_release_options();
+
+  // optional .google.protobuf.SourceCodeInfo source_code_info = 9;
+  bool has_source_code_info() const;
+  void clear_source_code_info();
+  static const int kSourceCodeInfoFieldNumber = 9;
+  private:
+  void _slow_mutable_source_code_info();
+  public:
+  const ::google::protobuf::SourceCodeInfo& source_code_info() const;
+  ::google::protobuf::SourceCodeInfo* release_source_code_info();
+  ::google::protobuf::SourceCodeInfo* mutable_source_code_info();
+  void set_allocated_source_code_info(::google::protobuf::SourceCodeInfo* source_code_info);
+  void unsafe_arena_set_allocated_source_code_info(
+      ::google::protobuf::SourceCodeInfo* source_code_info);
+  ::google::protobuf::SourceCodeInfo* unsafe_arena_release_source_code_info();
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.FileDescriptorProto)
+ private:
+  void set_has_name();
+  void clear_has_name();
+  void set_has_package();
+  void clear_has_package();
+  void set_has_options();
+  void clear_has_options();
+  void set_has_source_code_info();
+  void clear_has_source_code_info();
+  void set_has_syntax();
+  void clear_has_syntax();
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::google::protobuf::internal::HasBits<1> _has_bits_;
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::std::string> dependency_;
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto > message_type_;
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumDescriptorProto > enum_type_;
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::ServiceDescriptorProto > service_;
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto > extension_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > public_dependency_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > weak_dependency_;
+  ::google::protobuf::internal::ArenaStringPtr name_;
+  ::google::protobuf::internal::ArenaStringPtr package_;
+  ::google::protobuf::internal::ArenaStringPtr syntax_;
+  ::google::protobuf::FileOptions* options_;
+  ::google::protobuf::SourceCodeInfo* source_code_info_;
+  friend struct ::protobuf_google_2fprotobuf_2fdescriptor_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2fdescriptor_2eproto::InitDefaultsFileDescriptorProtoImpl();
+};
+// -------------------------------------------------------------------
+
+class LIBPROTOBUF_EXPORT DescriptorProto_ExtensionRange : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.DescriptorProto.ExtensionRange) */ {
+ public:
+  DescriptorProto_ExtensionRange();
+  virtual ~DescriptorProto_ExtensionRange();
+
+  DescriptorProto_ExtensionRange(const DescriptorProto_ExtensionRange& from);
+
+  inline DescriptorProto_ExtensionRange& operator=(const DescriptorProto_ExtensionRange& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  DescriptorProto_ExtensionRange(DescriptorProto_ExtensionRange&& from) noexcept
+    : DescriptorProto_ExtensionRange() {
+    *this = ::std::move(from);
+  }
+
+  inline DescriptorProto_ExtensionRange& operator=(DescriptorProto_ExtensionRange&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields();
+  }
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields();
+  }
+
+  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
+    return GetArenaNoVirtual();
+  }
+  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
+    return MaybeArenaPtr();
+  }
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const DescriptorProto_ExtensionRange& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const DescriptorProto_ExtensionRange* internal_default_instance() {
+    return reinterpret_cast<const DescriptorProto_ExtensionRange*>(
+               &_DescriptorProto_ExtensionRange_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    2;
+
+  void UnsafeArenaSwap(DescriptorProto_ExtensionRange* other);
+  void Swap(DescriptorProto_ExtensionRange* other);
+  friend void swap(DescriptorProto_ExtensionRange& a, DescriptorProto_ExtensionRange& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline DescriptorProto_ExtensionRange* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  DescriptorProto_ExtensionRange* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const DescriptorProto_ExtensionRange& from);
+  void MergeFrom(const DescriptorProto_ExtensionRange& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(DescriptorProto_ExtensionRange* other);
+  protected:
+  explicit DescriptorProto_ExtensionRange(::google::protobuf::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return _internal_metadata_.arena();
+  }
+  inline void* MaybeArenaPtr() const {
+    return _internal_metadata_.raw_arena_ptr();
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional .google.protobuf.ExtensionRangeOptions options = 3;
+  bool has_options() const;
+  void clear_options();
+  static const int kOptionsFieldNumber = 3;
+  private:
+  void _slow_mutable_options();
+  public:
+  const ::google::protobuf::ExtensionRangeOptions& options() const;
+  ::google::protobuf::ExtensionRangeOptions* release_options();
+  ::google::protobuf::ExtensionRangeOptions* mutable_options();
+  void set_allocated_options(::google::protobuf::ExtensionRangeOptions* options);
+  void unsafe_arena_set_allocated_options(
+      ::google::protobuf::ExtensionRangeOptions* options);
+  ::google::protobuf::ExtensionRangeOptions* unsafe_arena_release_options();
+
+  // optional int32 start = 1;
+  bool has_start() const;
+  void clear_start();
+  static const int kStartFieldNumber = 1;
+  ::google::protobuf::int32 start() const;
+  void set_start(::google::protobuf::int32 value);
+
+  // optional int32 end = 2;
+  bool has_end() const;
+  void clear_end();
+  static const int kEndFieldNumber = 2;
+  ::google::protobuf::int32 end() const;
+  void set_end(::google::protobuf::int32 value);
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.DescriptorProto.ExtensionRange)
+ private:
+  void set_has_start();
+  void clear_has_start();
+  void set_has_end();
+  void clear_has_end();
+  void set_has_options();
+  void clear_has_options();
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::google::protobuf::internal::HasBits<1> _has_bits_;
+  mutable int _cached_size_;
+  ::google::protobuf::ExtensionRangeOptions* options_;
+  ::google::protobuf::int32 start_;
+  ::google::protobuf::int32 end_;
+  friend struct ::protobuf_google_2fprotobuf_2fdescriptor_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2fdescriptor_2eproto::InitDefaultsDescriptorProto_ExtensionRangeImpl();
+};
+// -------------------------------------------------------------------
+
+class LIBPROTOBUF_EXPORT DescriptorProto_ReservedRange : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.DescriptorProto.ReservedRange) */ {
+ public:
+  DescriptorProto_ReservedRange();
+  virtual ~DescriptorProto_ReservedRange();
+
+  DescriptorProto_ReservedRange(const DescriptorProto_ReservedRange& from);
+
+  inline DescriptorProto_ReservedRange& operator=(const DescriptorProto_ReservedRange& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  DescriptorProto_ReservedRange(DescriptorProto_ReservedRange&& from) noexcept
+    : DescriptorProto_ReservedRange() {
+    *this = ::std::move(from);
+  }
+
+  inline DescriptorProto_ReservedRange& operator=(DescriptorProto_ReservedRange&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields();
+  }
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields();
+  }
+
+  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
+    return GetArenaNoVirtual();
+  }
+  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
+    return MaybeArenaPtr();
+  }
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const DescriptorProto_ReservedRange& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const DescriptorProto_ReservedRange* internal_default_instance() {
+    return reinterpret_cast<const DescriptorProto_ReservedRange*>(
+               &_DescriptorProto_ReservedRange_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    3;
+
+  void UnsafeArenaSwap(DescriptorProto_ReservedRange* other);
+  void Swap(DescriptorProto_ReservedRange* other);
+  friend void swap(DescriptorProto_ReservedRange& a, DescriptorProto_ReservedRange& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline DescriptorProto_ReservedRange* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  DescriptorProto_ReservedRange* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const DescriptorProto_ReservedRange& from);
+  void MergeFrom(const DescriptorProto_ReservedRange& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(DescriptorProto_ReservedRange* other);
+  protected:
+  explicit DescriptorProto_ReservedRange(::google::protobuf::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return _internal_metadata_.arena();
+  }
+  inline void* MaybeArenaPtr() const {
+    return _internal_metadata_.raw_arena_ptr();
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional int32 start = 1;
+  bool has_start() const;
+  void clear_start();
+  static const int kStartFieldNumber = 1;
+  ::google::protobuf::int32 start() const;
+  void set_start(::google::protobuf::int32 value);
+
+  // optional int32 end = 2;
+  bool has_end() const;
+  void clear_end();
+  static const int kEndFieldNumber = 2;
+  ::google::protobuf::int32 end() const;
+  void set_end(::google::protobuf::int32 value);
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.DescriptorProto.ReservedRange)
+ private:
+  void set_has_start();
+  void clear_has_start();
+  void set_has_end();
+  void clear_has_end();
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::google::protobuf::internal::HasBits<1> _has_bits_;
+  mutable int _cached_size_;
+  ::google::protobuf::int32 start_;
+  ::google::protobuf::int32 end_;
+  friend struct ::protobuf_google_2fprotobuf_2fdescriptor_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2fdescriptor_2eproto::InitDefaultsDescriptorProto_ReservedRangeImpl();
+};
+// -------------------------------------------------------------------
+
+class LIBPROTOBUF_EXPORT DescriptorProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.DescriptorProto) */ {
+ public:
+  DescriptorProto();
+  virtual ~DescriptorProto();
+
+  DescriptorProto(const DescriptorProto& from);
+
+  inline DescriptorProto& operator=(const DescriptorProto& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  DescriptorProto(DescriptorProto&& from) noexcept
+    : DescriptorProto() {
+    *this = ::std::move(from);
+  }
+
+  inline DescriptorProto& operator=(DescriptorProto&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields();
+  }
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields();
+  }
+
+  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
+    return GetArenaNoVirtual();
+  }
+  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
+    return MaybeArenaPtr();
+  }
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const DescriptorProto& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const DescriptorProto* internal_default_instance() {
+    return reinterpret_cast<const DescriptorProto*>(
+               &_DescriptorProto_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    4;
+
+  void UnsafeArenaSwap(DescriptorProto* other);
+  void Swap(DescriptorProto* other);
+  friend void swap(DescriptorProto& a, DescriptorProto& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline DescriptorProto* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  DescriptorProto* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const DescriptorProto& from);
+  void MergeFrom(const DescriptorProto& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(DescriptorProto* other);
+  protected:
+  explicit DescriptorProto(::google::protobuf::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return _internal_metadata_.arena();
+  }
+  inline void* MaybeArenaPtr() const {
+    return _internal_metadata_.raw_arena_ptr();
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  typedef DescriptorProto_ExtensionRange ExtensionRange;
+  typedef DescriptorProto_ReservedRange ReservedRange;
+
+  // accessors -------------------------------------------------------
+
+  // repeated .google.protobuf.FieldDescriptorProto field = 2;
+  int field_size() const;
+  void clear_field();
+  static const int kFieldFieldNumber = 2;
+  const ::google::protobuf::FieldDescriptorProto& field(int index) const;
+  ::google::protobuf::FieldDescriptorProto* mutable_field(int index);
+  ::google::protobuf::FieldDescriptorProto* add_field();
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >*
+      mutable_field();
+  const ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >&
+      field() const;
+
+  // repeated .google.protobuf.DescriptorProto nested_type = 3;
+  int nested_type_size() const;
+  void clear_nested_type();
+  static const int kNestedTypeFieldNumber = 3;
+  const ::google::protobuf::DescriptorProto& nested_type(int index) const;
+  ::google::protobuf::DescriptorProto* mutable_nested_type(int index);
+  ::google::protobuf::DescriptorProto* add_nested_type();
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto >*
+      mutable_nested_type();
+  const ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto >&
+      nested_type() const;
+
+  // repeated .google.protobuf.EnumDescriptorProto enum_type = 4;
+  int enum_type_size() const;
+  void clear_enum_type();
+  static const int kEnumTypeFieldNumber = 4;
+  const ::google::protobuf::EnumDescriptorProto& enum_type(int index) const;
+  ::google::protobuf::EnumDescriptorProto* mutable_enum_type(int index);
+  ::google::protobuf::EnumDescriptorProto* add_enum_type();
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumDescriptorProto >*
+      mutable_enum_type();
+  const ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumDescriptorProto >&
+      enum_type() const;
+
+  // repeated .google.protobuf.DescriptorProto.ExtensionRange extension_range = 5;
+  int extension_range_size() const;
+  void clear_extension_range();
+  static const int kExtensionRangeFieldNumber = 5;
+  const ::google::protobuf::DescriptorProto_ExtensionRange& extension_range(int index) const;
+  ::google::protobuf::DescriptorProto_ExtensionRange* mutable_extension_range(int index);
+  ::google::protobuf::DescriptorProto_ExtensionRange* add_extension_range();
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto_ExtensionRange >*
+      mutable_extension_range();
+  const ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto_ExtensionRange >&
+      extension_range() const;
+
+  // repeated .google.protobuf.FieldDescriptorProto extension = 6;
+  int extension_size() const;
+  void clear_extension();
+  static const int kExtensionFieldNumber = 6;
+  const ::google::protobuf::FieldDescriptorProto& extension(int index) const;
+  ::google::protobuf::FieldDescriptorProto* mutable_extension(int index);
+  ::google::protobuf::FieldDescriptorProto* add_extension();
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >*
+      mutable_extension();
+  const ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >&
+      extension() const;
+
+  // repeated .google.protobuf.OneofDescriptorProto oneof_decl = 8;
+  int oneof_decl_size() const;
+  void clear_oneof_decl();
+  static const int kOneofDeclFieldNumber = 8;
+  const ::google::protobuf::OneofDescriptorProto& oneof_decl(int index) const;
+  ::google::protobuf::OneofDescriptorProto* mutable_oneof_decl(int index);
+  ::google::protobuf::OneofDescriptorProto* add_oneof_decl();
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::OneofDescriptorProto >*
+      mutable_oneof_decl();
+  const ::google::protobuf::RepeatedPtrField< ::google::protobuf::OneofDescriptorProto >&
+      oneof_decl() const;
+
+  // repeated .google.protobuf.DescriptorProto.ReservedRange reserved_range = 9;
+  int reserved_range_size() const;
+  void clear_reserved_range();
+  static const int kReservedRangeFieldNumber = 9;
+  const ::google::protobuf::DescriptorProto_ReservedRange& reserved_range(int index) const;
+  ::google::protobuf::DescriptorProto_ReservedRange* mutable_reserved_range(int index);
+  ::google::protobuf::DescriptorProto_ReservedRange* add_reserved_range();
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto_ReservedRange >*
+      mutable_reserved_range();
+  const ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto_ReservedRange >&
+      reserved_range() const;
+
+  // repeated string reserved_name = 10;
+  int reserved_name_size() const;
+  void clear_reserved_name();
+  static const int kReservedNameFieldNumber = 10;
+  const ::std::string& reserved_name(int index) const;
+  ::std::string* mutable_reserved_name(int index);
+  void set_reserved_name(int index, const ::std::string& value);
+  #if LANG_CXX11
+  void set_reserved_name(int index, ::std::string&& value);
+  #endif
+  void set_reserved_name(int index, const char* value);
+  void set_reserved_name(int index, const char* value, size_t size);
+  ::std::string* add_reserved_name();
+  void add_reserved_name(const ::std::string& value);
+  #if LANG_CXX11
+  void add_reserved_name(::std::string&& value);
+  #endif
+  void add_reserved_name(const char* value);
+  void add_reserved_name(const char* value, size_t size);
+  const ::google::protobuf::RepeatedPtrField< ::std::string>& reserved_name() const;
+  ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_reserved_name();
+
+  // optional string name = 1;
+  bool has_name() const;
+  void clear_name();
+  static const int kNameFieldNumber = 1;
+  const ::std::string& name() const;
+  void set_name(const ::std::string& value);
+  #if LANG_CXX11
+  void set_name(::std::string&& value);
+  #endif
+  void set_name(const char* value);
+  void set_name(const char* value, size_t size);
+  ::std::string* mutable_name();
+  ::std::string* release_name();
+  void set_allocated_name(::std::string* name);
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  ::std::string* unsafe_arena_release_name();
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  void unsafe_arena_set_allocated_name(
+      ::std::string* name);
+
+  // optional .google.protobuf.MessageOptions options = 7;
+  bool has_options() const;
+  void clear_options();
+  static const int kOptionsFieldNumber = 7;
+  private:
+  void _slow_mutable_options();
+  public:
+  const ::google::protobuf::MessageOptions& options() const;
+  ::google::protobuf::MessageOptions* release_options();
+  ::google::protobuf::MessageOptions* mutable_options();
+  void set_allocated_options(::google::protobuf::MessageOptions* options);
+  void unsafe_arena_set_allocated_options(
+      ::google::protobuf::MessageOptions* options);
+  ::google::protobuf::MessageOptions* unsafe_arena_release_options();
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.DescriptorProto)
+ private:
+  void set_has_name();
+  void clear_has_name();
+  void set_has_options();
+  void clear_has_options();
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::google::protobuf::internal::HasBits<1> _has_bits_;
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto > field_;
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto > nested_type_;
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumDescriptorProto > enum_type_;
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto_ExtensionRange > extension_range_;
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto > extension_;
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::OneofDescriptorProto > oneof_decl_;
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto_ReservedRange > reserved_range_;
+  ::google::protobuf::RepeatedPtrField< ::std::string> reserved_name_;
+  ::google::protobuf::internal::ArenaStringPtr name_;
+  ::google::protobuf::MessageOptions* options_;
+  friend struct ::protobuf_google_2fprotobuf_2fdescriptor_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2fdescriptor_2eproto::InitDefaultsDescriptorProtoImpl();
+};
+// -------------------------------------------------------------------
+
+class LIBPROTOBUF_EXPORT ExtensionRangeOptions : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.ExtensionRangeOptions) */ {
+ public:
+  ExtensionRangeOptions();
+  virtual ~ExtensionRangeOptions();
+
+  ExtensionRangeOptions(const ExtensionRangeOptions& from);
+
+  inline ExtensionRangeOptions& operator=(const ExtensionRangeOptions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ExtensionRangeOptions(ExtensionRangeOptions&& from) noexcept
+    : ExtensionRangeOptions() {
+    *this = ::std::move(from);
+  }
+
+  inline ExtensionRangeOptions& operator=(ExtensionRangeOptions&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields();
+  }
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields();
+  }
+
+  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
+    return GetArenaNoVirtual();
+  }
+  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
+    return MaybeArenaPtr();
+  }
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ExtensionRangeOptions& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ExtensionRangeOptions* internal_default_instance() {
+    return reinterpret_cast<const ExtensionRangeOptions*>(
+               &_ExtensionRangeOptions_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    5;
+
+  void UnsafeArenaSwap(ExtensionRangeOptions* other);
+  void Swap(ExtensionRangeOptions* other);
+  friend void swap(ExtensionRangeOptions& a, ExtensionRangeOptions& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ExtensionRangeOptions* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ExtensionRangeOptions* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ExtensionRangeOptions& from);
+  void MergeFrom(const ExtensionRangeOptions& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ExtensionRangeOptions* other);
+  protected:
+  explicit ExtensionRangeOptions(::google::protobuf::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return _internal_metadata_.arena();
+  }
+  inline void* MaybeArenaPtr() const {
+    return _internal_metadata_.raw_arena_ptr();
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
+  int uninterpreted_option_size() const;
+  void clear_uninterpreted_option();
+  static const int kUninterpretedOptionFieldNumber = 999;
+  const ::google::protobuf::UninterpretedOption& uninterpreted_option(int index) const;
+  ::google::protobuf::UninterpretedOption* mutable_uninterpreted_option(int index);
+  ::google::protobuf::UninterpretedOption* add_uninterpreted_option();
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >*
+      mutable_uninterpreted_option();
+  const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >&
+      uninterpreted_option() const;
+
+  GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(ExtensionRangeOptions)
+  // @@protoc_insertion_point(class_scope:google.protobuf.ExtensionRangeOptions)
+ private:
+
+  ::google::protobuf::internal::ExtensionSet _extensions_;
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::google::protobuf::internal::HasBits<1> _has_bits_;
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption > uninterpreted_option_;
+  friend struct ::protobuf_google_2fprotobuf_2fdescriptor_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2fdescriptor_2eproto::InitDefaultsExtensionRangeOptionsImpl();
+};
+// -------------------------------------------------------------------
+
+class LIBPROTOBUF_EXPORT FieldDescriptorProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.FieldDescriptorProto) */ {
+ public:
+  FieldDescriptorProto();
+  virtual ~FieldDescriptorProto();
+
+  FieldDescriptorProto(const FieldDescriptorProto& from);
+
+  inline FieldDescriptorProto& operator=(const FieldDescriptorProto& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  FieldDescriptorProto(FieldDescriptorProto&& from) noexcept
+    : FieldDescriptorProto() {
+    *this = ::std::move(from);
+  }
+
+  inline FieldDescriptorProto& operator=(FieldDescriptorProto&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields();
+  }
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields();
+  }
+
+  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
+    return GetArenaNoVirtual();
+  }
+  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
+    return MaybeArenaPtr();
+  }
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const FieldDescriptorProto& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const FieldDescriptorProto* internal_default_instance() {
+    return reinterpret_cast<const FieldDescriptorProto*>(
+               &_FieldDescriptorProto_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    6;
+
+  void UnsafeArenaSwap(FieldDescriptorProto* other);
+  void Swap(FieldDescriptorProto* other);
+  friend void swap(FieldDescriptorProto& a, FieldDescriptorProto& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline FieldDescriptorProto* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  FieldDescriptorProto* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const FieldDescriptorProto& from);
+  void MergeFrom(const FieldDescriptorProto& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(FieldDescriptorProto* other);
+  protected:
+  explicit FieldDescriptorProto(::google::protobuf::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return _internal_metadata_.arena();
+  }
+  inline void* MaybeArenaPtr() const {
+    return _internal_metadata_.raw_arena_ptr();
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  typedef FieldDescriptorProto_Type Type;
+  static const Type TYPE_DOUBLE =
+    FieldDescriptorProto_Type_TYPE_DOUBLE;
+  static const Type TYPE_FLOAT =
+    FieldDescriptorProto_Type_TYPE_FLOAT;
+  static const Type TYPE_INT64 =
+    FieldDescriptorProto_Type_TYPE_INT64;
+  static const Type TYPE_UINT64 =
+    FieldDescriptorProto_Type_TYPE_UINT64;
+  static const Type TYPE_INT32 =
+    FieldDescriptorProto_Type_TYPE_INT32;
+  static const Type TYPE_FIXED64 =
+    FieldDescriptorProto_Type_TYPE_FIXED64;
+  static const Type TYPE_FIXED32 =
+    FieldDescriptorProto_Type_TYPE_FIXED32;
+  static const Type TYPE_BOOL =
+    FieldDescriptorProto_Type_TYPE_BOOL;
+  static const Type TYPE_STRING =
+    FieldDescriptorProto_Type_TYPE_STRING;
+  static const Type TYPE_GROUP =
+    FieldDescriptorProto_Type_TYPE_GROUP;
+  static const Type TYPE_MESSAGE =
+    FieldDescriptorProto_Type_TYPE_MESSAGE;
+  static const Type TYPE_BYTES =
+    FieldDescriptorProto_Type_TYPE_BYTES;
+  static const Type TYPE_UINT32 =
+    FieldDescriptorProto_Type_TYPE_UINT32;
+  static const Type TYPE_ENUM =
+    FieldDescriptorProto_Type_TYPE_ENUM;
+  static const Type TYPE_SFIXED32 =
+    FieldDescriptorProto_Type_TYPE_SFIXED32;
+  static const Type TYPE_SFIXED64 =
+    FieldDescriptorProto_Type_TYPE_SFIXED64;
+  static const Type TYPE_SINT32 =
+    FieldDescriptorProto_Type_TYPE_SINT32;
+  static const Type TYPE_SINT64 =
+    FieldDescriptorProto_Type_TYPE_SINT64;
+  static inline bool Type_IsValid(int value) {
+    return FieldDescriptorProto_Type_IsValid(value);
+  }
+  static const Type Type_MIN =
+    FieldDescriptorProto_Type_Type_MIN;
+  static const Type Type_MAX =
+    FieldDescriptorProto_Type_Type_MAX;
+  static const int Type_ARRAYSIZE =
+    FieldDescriptorProto_Type_Type_ARRAYSIZE;
+  static inline const ::google::protobuf::EnumDescriptor*
+  Type_descriptor() {
+    return FieldDescriptorProto_Type_descriptor();
+  }
+  static inline const ::std::string& Type_Name(Type value) {
+    return FieldDescriptorProto_Type_Name(value);
+  }
+  static inline bool Type_Parse(const ::std::string& name,
+      Type* value) {
+    return FieldDescriptorProto_Type_Parse(name, value);
+  }
+
+  typedef FieldDescriptorProto_Label Label;
+  static const Label LABEL_OPTIONAL =
+    FieldDescriptorProto_Label_LABEL_OPTIONAL;
+  static const Label LABEL_REQUIRED =
+    FieldDescriptorProto_Label_LABEL_REQUIRED;
+  static const Label LABEL_REPEATED =
+    FieldDescriptorProto_Label_LABEL_REPEATED;
+  static inline bool Label_IsValid(int value) {
+    return FieldDescriptorProto_Label_IsValid(value);
+  }
+  static const Label Label_MIN =
+    FieldDescriptorProto_Label_Label_MIN;
+  static const Label Label_MAX =
+    FieldDescriptorProto_Label_Label_MAX;
+  static const int Label_ARRAYSIZE =
+    FieldDescriptorProto_Label_Label_ARRAYSIZE;
+  static inline const ::google::protobuf::EnumDescriptor*
+  Label_descriptor() {
+    return FieldDescriptorProto_Label_descriptor();
+  }
+  static inline const ::std::string& Label_Name(Label value) {
+    return FieldDescriptorProto_Label_Name(value);
+  }
+  static inline bool Label_Parse(const ::std::string& name,
+      Label* value) {
+    return FieldDescriptorProto_Label_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  // optional string name = 1;
+  bool has_name() const;
+  void clear_name();
+  static const int kNameFieldNumber = 1;
+  const ::std::string& name() const;
+  void set_name(const ::std::string& value);
+  #if LANG_CXX11
+  void set_name(::std::string&& value);
+  #endif
+  void set_name(const char* value);
+  void set_name(const char* value, size_t size);
+  ::std::string* mutable_name();
+  ::std::string* release_name();
+  void set_allocated_name(::std::string* name);
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  ::std::string* unsafe_arena_release_name();
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  void unsafe_arena_set_allocated_name(
+      ::std::string* name);
+
+  // optional string extendee = 2;
+  bool has_extendee() const;
+  void clear_extendee();
+  static const int kExtendeeFieldNumber = 2;
+  const ::std::string& extendee() const;
+  void set_extendee(const ::std::string& value);
+  #if LANG_CXX11
+  void set_extendee(::std::string&& value);
+  #endif
+  void set_extendee(const char* value);
+  void set_extendee(const char* value, size_t size);
+  ::std::string* mutable_extendee();
+  ::std::string* release_extendee();
+  void set_allocated_extendee(::std::string* extendee);
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  ::std::string* unsafe_arena_release_extendee();
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  void unsafe_arena_set_allocated_extendee(
+      ::std::string* extendee);
+
+  // optional string type_name = 6;
+  bool has_type_name() const;
+  void clear_type_name();
+  static const int kTypeNameFieldNumber = 6;
+  const ::std::string& type_name() const;
+  void set_type_name(const ::std::string& value);
+  #if LANG_CXX11
+  void set_type_name(::std::string&& value);
+  #endif
+  void set_type_name(const char* value);
+  void set_type_name(const char* value, size_t size);
+  ::std::string* mutable_type_name();
+  ::std::string* release_type_name();
+  void set_allocated_type_name(::std::string* type_name);
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  ::std::string* unsafe_arena_release_type_name();
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  void unsafe_arena_set_allocated_type_name(
+      ::std::string* type_name);
+
+  // optional string default_value = 7;
+  bool has_default_value() const;
+  void clear_default_value();
+  static const int kDefaultValueFieldNumber = 7;
+  const ::std::string& default_value() const;
+  void set_default_value(const ::std::string& value);
+  #if LANG_CXX11
+  void set_default_value(::std::string&& value);
+  #endif
+  void set_default_value(const char* value);
+  void set_default_value(const char* value, size_t size);
+  ::std::string* mutable_default_value();
+  ::std::string* release_default_value();
+  void set_allocated_default_value(::std::string* default_value);
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  ::std::string* unsafe_arena_release_default_value();
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  void unsafe_arena_set_allocated_default_value(
+      ::std::string* default_value);
+
+  // optional string json_name = 10;
+  bool has_json_name() const;
+  void clear_json_name();
+  static const int kJsonNameFieldNumber = 10;
+  const ::std::string& json_name() const;
+  void set_json_name(const ::std::string& value);
+  #if LANG_CXX11
+  void set_json_name(::std::string&& value);
+  #endif
+  void set_json_name(const char* value);
+  void set_json_name(const char* value, size_t size);
+  ::std::string* mutable_json_name();
+  ::std::string* release_json_name();
+  void set_allocated_json_name(::std::string* json_name);
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  ::std::string* unsafe_arena_release_json_name();
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  void unsafe_arena_set_allocated_json_name(
+      ::std::string* json_name);
+
+  // optional .google.protobuf.FieldOptions options = 8;
+  bool has_options() const;
+  void clear_options();
+  static const int kOptionsFieldNumber = 8;
+  private:
+  void _slow_mutable_options();
+  public:
+  const ::google::protobuf::FieldOptions& options() const;
+  ::google::protobuf::FieldOptions* release_options();
+  ::google::protobuf::FieldOptions* mutable_options();
+  void set_allocated_options(::google::protobuf::FieldOptions* options);
+  void unsafe_arena_set_allocated_options(
+      ::google::protobuf::FieldOptions* options);
+  ::google::protobuf::FieldOptions* unsafe_arena_release_options();
+
+  // optional int32 number = 3;
+  bool has_number() const;
+  void clear_number();
+  static const int kNumberFieldNumber = 3;
+  ::google::protobuf::int32 number() const;
+  void set_number(::google::protobuf::int32 value);
+
+  // optional int32 oneof_index = 9;
+  bool has_oneof_index() const;
+  void clear_oneof_index();
+  static const int kOneofIndexFieldNumber = 9;
+  ::google::protobuf::int32 oneof_index() const;
+  void set_oneof_index(::google::protobuf::int32 value);
+
+  // optional .google.protobuf.FieldDescriptorProto.Label label = 4;
+  bool has_label() const;
+  void clear_label();
+  static const int kLabelFieldNumber = 4;
+  ::google::protobuf::FieldDescriptorProto_Label label() const;
+  void set_label(::google::protobuf::FieldDescriptorProto_Label value);
+
+  // optional .google.protobuf.FieldDescriptorProto.Type type = 5;
+  bool has_type() const;
+  void clear_type();
+  static const int kTypeFieldNumber = 5;
+  ::google::protobuf::FieldDescriptorProto_Type type() const;
+  void set_type(::google::protobuf::FieldDescriptorProto_Type value);
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.FieldDescriptorProto)
+ private:
+  void set_has_name();
+  void clear_has_name();
+  void set_has_number();
+  void clear_has_number();
+  void set_has_label();
+  void clear_has_label();
+  void set_has_type();
+  void clear_has_type();
+  void set_has_type_name();
+  void clear_has_type_name();
+  void set_has_extendee();
+  void clear_has_extendee();
+  void set_has_default_value();
+  void clear_has_default_value();
+  void set_has_oneof_index();
+  void clear_has_oneof_index();
+  void set_has_json_name();
+  void clear_has_json_name();
+  void set_has_options();
+  void clear_has_options();
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::google::protobuf::internal::HasBits<1> _has_bits_;
+  mutable int _cached_size_;
+  ::google::protobuf::internal::ArenaStringPtr name_;
+  ::google::protobuf::internal::ArenaStringPtr extendee_;
+  ::google::protobuf::internal::ArenaStringPtr type_name_;
+  ::google::protobuf::internal::ArenaStringPtr default_value_;
+  ::google::protobuf::internal::ArenaStringPtr json_name_;
+  ::google::protobuf::FieldOptions* options_;
+  ::google::protobuf::int32 number_;
+  ::google::protobuf::int32 oneof_index_;
+  int label_;
+  int type_;
+  friend struct ::protobuf_google_2fprotobuf_2fdescriptor_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2fdescriptor_2eproto::InitDefaultsFieldDescriptorProtoImpl();
+};
+// -------------------------------------------------------------------
+
+class LIBPROTOBUF_EXPORT OneofDescriptorProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.OneofDescriptorProto) */ {
+ public:
+  OneofDescriptorProto();
+  virtual ~OneofDescriptorProto();
+
+  OneofDescriptorProto(const OneofDescriptorProto& from);
+
+  inline OneofDescriptorProto& operator=(const OneofDescriptorProto& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  OneofDescriptorProto(OneofDescriptorProto&& from) noexcept
+    : OneofDescriptorProto() {
+    *this = ::std::move(from);
+  }
+
+  inline OneofDescriptorProto& operator=(OneofDescriptorProto&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields();
+  }
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields();
+  }
+
+  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
+    return GetArenaNoVirtual();
+  }
+  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
+    return MaybeArenaPtr();
+  }
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const OneofDescriptorProto& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const OneofDescriptorProto* internal_default_instance() {
+    return reinterpret_cast<const OneofDescriptorProto*>(
+               &_OneofDescriptorProto_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    7;
+
+  void UnsafeArenaSwap(OneofDescriptorProto* other);
+  void Swap(OneofDescriptorProto* other);
+  friend void swap(OneofDescriptorProto& a, OneofDescriptorProto& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline OneofDescriptorProto* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  OneofDescriptorProto* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const OneofDescriptorProto& from);
+  void MergeFrom(const OneofDescriptorProto& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(OneofDescriptorProto* other);
+  protected:
+  explicit OneofDescriptorProto(::google::protobuf::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return _internal_metadata_.arena();
+  }
+  inline void* MaybeArenaPtr() const {
+    return _internal_metadata_.raw_arena_ptr();
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional string name = 1;
+  bool has_name() const;
+  void clear_name();
+  static const int kNameFieldNumber = 1;
+  const ::std::string& name() const;
+  void set_name(const ::std::string& value);
+  #if LANG_CXX11
+  void set_name(::std::string&& value);
+  #endif
+  void set_name(const char* value);
+  void set_name(const char* value, size_t size);
+  ::std::string* mutable_name();
+  ::std::string* release_name();
+  void set_allocated_name(::std::string* name);
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  ::std::string* unsafe_arena_release_name();
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  void unsafe_arena_set_allocated_name(
+      ::std::string* name);
+
+  // optional .google.protobuf.OneofOptions options = 2;
+  bool has_options() const;
+  void clear_options();
+  static const int kOptionsFieldNumber = 2;
+  private:
+  void _slow_mutable_options();
+  public:
+  const ::google::protobuf::OneofOptions& options() const;
+  ::google::protobuf::OneofOptions* release_options();
+  ::google::protobuf::OneofOptions* mutable_options();
+  void set_allocated_options(::google::protobuf::OneofOptions* options);
+  void unsafe_arena_set_allocated_options(
+      ::google::protobuf::OneofOptions* options);
+  ::google::protobuf::OneofOptions* unsafe_arena_release_options();
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.OneofDescriptorProto)
+ private:
+  void set_has_name();
+  void clear_has_name();
+  void set_has_options();
+  void clear_has_options();
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::google::protobuf::internal::HasBits<1> _has_bits_;
+  mutable int _cached_size_;
+  ::google::protobuf::internal::ArenaStringPtr name_;
+  ::google::protobuf::OneofOptions* options_;
+  friend struct ::protobuf_google_2fprotobuf_2fdescriptor_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2fdescriptor_2eproto::InitDefaultsOneofDescriptorProtoImpl();
+};
+// -------------------------------------------------------------------
+
+class LIBPROTOBUF_EXPORT EnumDescriptorProto_EnumReservedRange : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.EnumDescriptorProto.EnumReservedRange) */ {
+ public:
+  EnumDescriptorProto_EnumReservedRange();
+  virtual ~EnumDescriptorProto_EnumReservedRange();
+
+  EnumDescriptorProto_EnumReservedRange(const EnumDescriptorProto_EnumReservedRange& from);
+
+  inline EnumDescriptorProto_EnumReservedRange& operator=(const EnumDescriptorProto_EnumReservedRange& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  EnumDescriptorProto_EnumReservedRange(EnumDescriptorProto_EnumReservedRange&& from) noexcept
+    : EnumDescriptorProto_EnumReservedRange() {
+    *this = ::std::move(from);
+  }
+
+  inline EnumDescriptorProto_EnumReservedRange& operator=(EnumDescriptorProto_EnumReservedRange&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields();
+  }
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields();
+  }
+
+  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
+    return GetArenaNoVirtual();
+  }
+  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
+    return MaybeArenaPtr();
+  }
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const EnumDescriptorProto_EnumReservedRange& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const EnumDescriptorProto_EnumReservedRange* internal_default_instance() {
+    return reinterpret_cast<const EnumDescriptorProto_EnumReservedRange*>(
+               &_EnumDescriptorProto_EnumReservedRange_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    8;
+
+  void UnsafeArenaSwap(EnumDescriptorProto_EnumReservedRange* other);
+  void Swap(EnumDescriptorProto_EnumReservedRange* other);
+  friend void swap(EnumDescriptorProto_EnumReservedRange& a, EnumDescriptorProto_EnumReservedRange& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline EnumDescriptorProto_EnumReservedRange* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  EnumDescriptorProto_EnumReservedRange* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const EnumDescriptorProto_EnumReservedRange& from);
+  void MergeFrom(const EnumDescriptorProto_EnumReservedRange& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(EnumDescriptorProto_EnumReservedRange* other);
+  protected:
+  explicit EnumDescriptorProto_EnumReservedRange(::google::protobuf::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return _internal_metadata_.arena();
+  }
+  inline void* MaybeArenaPtr() const {
+    return _internal_metadata_.raw_arena_ptr();
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional int32 start = 1;
+  bool has_start() const;
+  void clear_start();
+  static const int kStartFieldNumber = 1;
+  ::google::protobuf::int32 start() const;
+  void set_start(::google::protobuf::int32 value);
+
+  // optional int32 end = 2;
+  bool has_end() const;
+  void clear_end();
+  static const int kEndFieldNumber = 2;
+  ::google::protobuf::int32 end() const;
+  void set_end(::google::protobuf::int32 value);
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.EnumDescriptorProto.EnumReservedRange)
+ private:
+  void set_has_start();
+  void clear_has_start();
+  void set_has_end();
+  void clear_has_end();
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::google::protobuf::internal::HasBits<1> _has_bits_;
+  mutable int _cached_size_;
+  ::google::protobuf::int32 start_;
+  ::google::protobuf::int32 end_;
+  friend struct ::protobuf_google_2fprotobuf_2fdescriptor_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2fdescriptor_2eproto::InitDefaultsEnumDescriptorProto_EnumReservedRangeImpl();
+};
+// -------------------------------------------------------------------
+
+class LIBPROTOBUF_EXPORT EnumDescriptorProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.EnumDescriptorProto) */ {
+ public:
+  EnumDescriptorProto();
+  virtual ~EnumDescriptorProto();
+
+  EnumDescriptorProto(const EnumDescriptorProto& from);
+
+  inline EnumDescriptorProto& operator=(const EnumDescriptorProto& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  EnumDescriptorProto(EnumDescriptorProto&& from) noexcept
+    : EnumDescriptorProto() {
+    *this = ::std::move(from);
+  }
+
+  inline EnumDescriptorProto& operator=(EnumDescriptorProto&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields();
+  }
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields();
+  }
+
+  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
+    return GetArenaNoVirtual();
+  }
+  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
+    return MaybeArenaPtr();
+  }
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const EnumDescriptorProto& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const EnumDescriptorProto* internal_default_instance() {
+    return reinterpret_cast<const EnumDescriptorProto*>(
+               &_EnumDescriptorProto_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    9;
+
+  void UnsafeArenaSwap(EnumDescriptorProto* other);
+  void Swap(EnumDescriptorProto* other);
+  friend void swap(EnumDescriptorProto& a, EnumDescriptorProto& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline EnumDescriptorProto* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  EnumDescriptorProto* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const EnumDescriptorProto& from);
+  void MergeFrom(const EnumDescriptorProto& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(EnumDescriptorProto* other);
+  protected:
+  explicit EnumDescriptorProto(::google::protobuf::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return _internal_metadata_.arena();
+  }
+  inline void* MaybeArenaPtr() const {
+    return _internal_metadata_.raw_arena_ptr();
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  typedef EnumDescriptorProto_EnumReservedRange EnumReservedRange;
+
+  // accessors -------------------------------------------------------
+
+  // repeated .google.protobuf.EnumValueDescriptorProto value = 2;
+  int value_size() const;
+  void clear_value();
+  static const int kValueFieldNumber = 2;
+  const ::google::protobuf::EnumValueDescriptorProto& value(int index) const;
+  ::google::protobuf::EnumValueDescriptorProto* mutable_value(int index);
+  ::google::protobuf::EnumValueDescriptorProto* add_value();
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumValueDescriptorProto >*
+      mutable_value();
+  const ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumValueDescriptorProto >&
+      value() const;
+
+  // repeated .google.protobuf.EnumDescriptorProto.EnumReservedRange reserved_range = 4;
+  int reserved_range_size() const;
+  void clear_reserved_range();
+  static const int kReservedRangeFieldNumber = 4;
+  const ::google::protobuf::EnumDescriptorProto_EnumReservedRange& reserved_range(int index) const;
+  ::google::protobuf::EnumDescriptorProto_EnumReservedRange* mutable_reserved_range(int index);
+  ::google::protobuf::EnumDescriptorProto_EnumReservedRange* add_reserved_range();
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumDescriptorProto_EnumReservedRange >*
+      mutable_reserved_range();
+  const ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumDescriptorProto_EnumReservedRange >&
+      reserved_range() const;
+
+  // repeated string reserved_name = 5;
+  int reserved_name_size() const;
+  void clear_reserved_name();
+  static const int kReservedNameFieldNumber = 5;
+  const ::std::string& reserved_name(int index) const;
+  ::std::string* mutable_reserved_name(int index);
+  void set_reserved_name(int index, const ::std::string& value);
+  #if LANG_CXX11
+  void set_reserved_name(int index, ::std::string&& value);
+  #endif
+  void set_reserved_name(int index, const char* value);
+  void set_reserved_name(int index, const char* value, size_t size);
+  ::std::string* add_reserved_name();
+  void add_reserved_name(const ::std::string& value);
+  #if LANG_CXX11
+  void add_reserved_name(::std::string&& value);
+  #endif
+  void add_reserved_name(const char* value);
+  void add_reserved_name(const char* value, size_t size);
+  const ::google::protobuf::RepeatedPtrField< ::std::string>& reserved_name() const;
+  ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_reserved_name();
+
+  // optional string name = 1;
+  bool has_name() const;
+  void clear_name();
+  static const int kNameFieldNumber = 1;
+  const ::std::string& name() const;
+  void set_name(const ::std::string& value);
+  #if LANG_CXX11
+  void set_name(::std::string&& value);
+  #endif
+  void set_name(const char* value);
+  void set_name(const char* value, size_t size);
+  ::std::string* mutable_name();
+  ::std::string* release_name();
+  void set_allocated_name(::std::string* name);
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  ::std::string* unsafe_arena_release_name();
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  void unsafe_arena_set_allocated_name(
+      ::std::string* name);
+
+  // optional .google.protobuf.EnumOptions options = 3;
+  bool has_options() const;
+  void clear_options();
+  static const int kOptionsFieldNumber = 3;
+  private:
+  void _slow_mutable_options();
+  public:
+  const ::google::protobuf::EnumOptions& options() const;
+  ::google::protobuf::EnumOptions* release_options();
+  ::google::protobuf::EnumOptions* mutable_options();
+  void set_allocated_options(::google::protobuf::EnumOptions* options);
+  void unsafe_arena_set_allocated_options(
+      ::google::protobuf::EnumOptions* options);
+  ::google::protobuf::EnumOptions* unsafe_arena_release_options();
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.EnumDescriptorProto)
+ private:
+  void set_has_name();
+  void clear_has_name();
+  void set_has_options();
+  void clear_has_options();
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::google::protobuf::internal::HasBits<1> _has_bits_;
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumValueDescriptorProto > value_;
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumDescriptorProto_EnumReservedRange > reserved_range_;
+  ::google::protobuf::RepeatedPtrField< ::std::string> reserved_name_;
+  ::google::protobuf::internal::ArenaStringPtr name_;
+  ::google::protobuf::EnumOptions* options_;
+  friend struct ::protobuf_google_2fprotobuf_2fdescriptor_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2fdescriptor_2eproto::InitDefaultsEnumDescriptorProtoImpl();
+};
+// -------------------------------------------------------------------
+
+class LIBPROTOBUF_EXPORT EnumValueDescriptorProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.EnumValueDescriptorProto) */ {
+ public:
+  EnumValueDescriptorProto();
+  virtual ~EnumValueDescriptorProto();
+
+  EnumValueDescriptorProto(const EnumValueDescriptorProto& from);
+
+  inline EnumValueDescriptorProto& operator=(const EnumValueDescriptorProto& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  EnumValueDescriptorProto(EnumValueDescriptorProto&& from) noexcept
+    : EnumValueDescriptorProto() {
+    *this = ::std::move(from);
+  }
+
+  inline EnumValueDescriptorProto& operator=(EnumValueDescriptorProto&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields();
+  }
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields();
+  }
+
+  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
+    return GetArenaNoVirtual();
+  }
+  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
+    return MaybeArenaPtr();
+  }
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const EnumValueDescriptorProto& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const EnumValueDescriptorProto* internal_default_instance() {
+    return reinterpret_cast<const EnumValueDescriptorProto*>(
+               &_EnumValueDescriptorProto_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    10;
+
+  void UnsafeArenaSwap(EnumValueDescriptorProto* other);
+  void Swap(EnumValueDescriptorProto* other);
+  friend void swap(EnumValueDescriptorProto& a, EnumValueDescriptorProto& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline EnumValueDescriptorProto* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  EnumValueDescriptorProto* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const EnumValueDescriptorProto& from);
+  void MergeFrom(const EnumValueDescriptorProto& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(EnumValueDescriptorProto* other);
+  protected:
+  explicit EnumValueDescriptorProto(::google::protobuf::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return _internal_metadata_.arena();
+  }
+  inline void* MaybeArenaPtr() const {
+    return _internal_metadata_.raw_arena_ptr();
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional string name = 1;
+  bool has_name() const;
+  void clear_name();
+  static const int kNameFieldNumber = 1;
+  const ::std::string& name() const;
+  void set_name(const ::std::string& value);
+  #if LANG_CXX11
+  void set_name(::std::string&& value);
+  #endif
+  void set_name(const char* value);
+  void set_name(const char* value, size_t size);
+  ::std::string* mutable_name();
+  ::std::string* release_name();
+  void set_allocated_name(::std::string* name);
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  ::std::string* unsafe_arena_release_name();
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  void unsafe_arena_set_allocated_name(
+      ::std::string* name);
+
+  // optional .google.protobuf.EnumValueOptions options = 3;
+  bool has_options() const;
+  void clear_options();
+  static const int kOptionsFieldNumber = 3;
+  private:
+  void _slow_mutable_options();
+  public:
+  const ::google::protobuf::EnumValueOptions& options() const;
+  ::google::protobuf::EnumValueOptions* release_options();
+  ::google::protobuf::EnumValueOptions* mutable_options();
+  void set_allocated_options(::google::protobuf::EnumValueOptions* options);
+  void unsafe_arena_set_allocated_options(
+      ::google::protobuf::EnumValueOptions* options);
+  ::google::protobuf::EnumValueOptions* unsafe_arena_release_options();
+
+  // optional int32 number = 2;
+  bool has_number() const;
+  void clear_number();
+  static const int kNumberFieldNumber = 2;
+  ::google::protobuf::int32 number() const;
+  void set_number(::google::protobuf::int32 value);
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.EnumValueDescriptorProto)
+ private:
+  void set_has_name();
+  void clear_has_name();
+  void set_has_number();
+  void clear_has_number();
+  void set_has_options();
+  void clear_has_options();
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::google::protobuf::internal::HasBits<1> _has_bits_;
+  mutable int _cached_size_;
+  ::google::protobuf::internal::ArenaStringPtr name_;
+  ::google::protobuf::EnumValueOptions* options_;
+  ::google::protobuf::int32 number_;
+  friend struct ::protobuf_google_2fprotobuf_2fdescriptor_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2fdescriptor_2eproto::InitDefaultsEnumValueDescriptorProtoImpl();
+};
+// -------------------------------------------------------------------
+
+class LIBPROTOBUF_EXPORT ServiceDescriptorProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.ServiceDescriptorProto) */ {
+ public:
+  ServiceDescriptorProto();
+  virtual ~ServiceDescriptorProto();
+
+  ServiceDescriptorProto(const ServiceDescriptorProto& from);
+
+  inline ServiceDescriptorProto& operator=(const ServiceDescriptorProto& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ServiceDescriptorProto(ServiceDescriptorProto&& from) noexcept
+    : ServiceDescriptorProto() {
+    *this = ::std::move(from);
+  }
+
+  inline ServiceDescriptorProto& operator=(ServiceDescriptorProto&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields();
+  }
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields();
+  }
+
+  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
+    return GetArenaNoVirtual();
+  }
+  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
+    return MaybeArenaPtr();
+  }
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ServiceDescriptorProto& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ServiceDescriptorProto* internal_default_instance() {
+    return reinterpret_cast<const ServiceDescriptorProto*>(
+               &_ServiceDescriptorProto_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    11;
+
+  void UnsafeArenaSwap(ServiceDescriptorProto* other);
+  void Swap(ServiceDescriptorProto* other);
+  friend void swap(ServiceDescriptorProto& a, ServiceDescriptorProto& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ServiceDescriptorProto* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ServiceDescriptorProto* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ServiceDescriptorProto& from);
+  void MergeFrom(const ServiceDescriptorProto& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ServiceDescriptorProto* other);
+  protected:
+  explicit ServiceDescriptorProto(::google::protobuf::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return _internal_metadata_.arena();
+  }
+  inline void* MaybeArenaPtr() const {
+    return _internal_metadata_.raw_arena_ptr();
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .google.protobuf.MethodDescriptorProto method = 2;
+  int method_size() const;
+  void clear_method();
+  static const int kMethodFieldNumber = 2;
+  const ::google::protobuf::MethodDescriptorProto& method(int index) const;
+  ::google::protobuf::MethodDescriptorProto* mutable_method(int index);
+  ::google::protobuf::MethodDescriptorProto* add_method();
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::MethodDescriptorProto >*
+      mutable_method();
+  const ::google::protobuf::RepeatedPtrField< ::google::protobuf::MethodDescriptorProto >&
+      method() const;
+
+  // optional string name = 1;
+  bool has_name() const;
+  void clear_name();
+  static const int kNameFieldNumber = 1;
+  const ::std::string& name() const;
+  void set_name(const ::std::string& value);
+  #if LANG_CXX11
+  void set_name(::std::string&& value);
+  #endif
+  void set_name(const char* value);
+  void set_name(const char* value, size_t size);
+  ::std::string* mutable_name();
+  ::std::string* release_name();
+  void set_allocated_name(::std::string* name);
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  ::std::string* unsafe_arena_release_name();
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  void unsafe_arena_set_allocated_name(
+      ::std::string* name);
+
+  // optional .google.protobuf.ServiceOptions options = 3;
+  bool has_options() const;
+  void clear_options();
+  static const int kOptionsFieldNumber = 3;
+  private:
+  void _slow_mutable_options();
+  public:
+  const ::google::protobuf::ServiceOptions& options() const;
+  ::google::protobuf::ServiceOptions* release_options();
+  ::google::protobuf::ServiceOptions* mutable_options();
+  void set_allocated_options(::google::protobuf::ServiceOptions* options);
+  void unsafe_arena_set_allocated_options(
+      ::google::protobuf::ServiceOptions* options);
+  ::google::protobuf::ServiceOptions* unsafe_arena_release_options();
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.ServiceDescriptorProto)
+ private:
+  void set_has_name();
+  void clear_has_name();
+  void set_has_options();
+  void clear_has_options();
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::google::protobuf::internal::HasBits<1> _has_bits_;
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::MethodDescriptorProto > method_;
+  ::google::protobuf::internal::ArenaStringPtr name_;
+  ::google::protobuf::ServiceOptions* options_;
+  friend struct ::protobuf_google_2fprotobuf_2fdescriptor_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2fdescriptor_2eproto::InitDefaultsServiceDescriptorProtoImpl();
+};
+// -------------------------------------------------------------------
+
+class LIBPROTOBUF_EXPORT MethodDescriptorProto : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.MethodDescriptorProto) */ {
+ public:
+  MethodDescriptorProto();
+  virtual ~MethodDescriptorProto();
+
+  MethodDescriptorProto(const MethodDescriptorProto& from);
+
+  inline MethodDescriptorProto& operator=(const MethodDescriptorProto& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  MethodDescriptorProto(MethodDescriptorProto&& from) noexcept
+    : MethodDescriptorProto() {
+    *this = ::std::move(from);
+  }
+
+  inline MethodDescriptorProto& operator=(MethodDescriptorProto&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields();
+  }
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields();
+  }
+
+  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
+    return GetArenaNoVirtual();
+  }
+  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
+    return MaybeArenaPtr();
+  }
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const MethodDescriptorProto& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const MethodDescriptorProto* internal_default_instance() {
+    return reinterpret_cast<const MethodDescriptorProto*>(
+               &_MethodDescriptorProto_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    12;
+
+  void UnsafeArenaSwap(MethodDescriptorProto* other);
+  void Swap(MethodDescriptorProto* other);
+  friend void swap(MethodDescriptorProto& a, MethodDescriptorProto& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline MethodDescriptorProto* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  MethodDescriptorProto* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const MethodDescriptorProto& from);
+  void MergeFrom(const MethodDescriptorProto& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(MethodDescriptorProto* other);
+  protected:
+  explicit MethodDescriptorProto(::google::protobuf::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return _internal_metadata_.arena();
+  }
+  inline void* MaybeArenaPtr() const {
+    return _internal_metadata_.raw_arena_ptr();
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // optional string name = 1;
+  bool has_name() const;
+  void clear_name();
+  static const int kNameFieldNumber = 1;
+  const ::std::string& name() const;
+  void set_name(const ::std::string& value);
+  #if LANG_CXX11
+  void set_name(::std::string&& value);
+  #endif
+  void set_name(const char* value);
+  void set_name(const char* value, size_t size);
+  ::std::string* mutable_name();
+  ::std::string* release_name();
+  void set_allocated_name(::std::string* name);
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  ::std::string* unsafe_arena_release_name();
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  void unsafe_arena_set_allocated_name(
+      ::std::string* name);
+
+  // optional string input_type = 2;
+  bool has_input_type() const;
+  void clear_input_type();
+  static const int kInputTypeFieldNumber = 2;
+  const ::std::string& input_type() const;
+  void set_input_type(const ::std::string& value);
+  #if LANG_CXX11
+  void set_input_type(::std::string&& value);
+  #endif
+  void set_input_type(const char* value);
+  void set_input_type(const char* value, size_t size);
+  ::std::string* mutable_input_type();
+  ::std::string* release_input_type();
+  void set_allocated_input_type(::std::string* input_type);
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  ::std::string* unsafe_arena_release_input_type();
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  void unsafe_arena_set_allocated_input_type(
+      ::std::string* input_type);
+
+  // optional string output_type = 3;
+  bool has_output_type() const;
+  void clear_output_type();
+  static const int kOutputTypeFieldNumber = 3;
+  const ::std::string& output_type() const;
+  void set_output_type(const ::std::string& value);
+  #if LANG_CXX11
+  void set_output_type(::std::string&& value);
+  #endif
+  void set_output_type(const char* value);
+  void set_output_type(const char* value, size_t size);
+  ::std::string* mutable_output_type();
+  ::std::string* release_output_type();
+  void set_allocated_output_type(::std::string* output_type);
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  ::std::string* unsafe_arena_release_output_type();
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  void unsafe_arena_set_allocated_output_type(
+      ::std::string* output_type);
+
+  // optional .google.protobuf.MethodOptions options = 4;
+  bool has_options() const;
+  void clear_options();
+  static const int kOptionsFieldNumber = 4;
+  private:
+  void _slow_mutable_options();
+  public:
+  const ::google::protobuf::MethodOptions& options() const;
+  ::google::protobuf::MethodOptions* release_options();
+  ::google::protobuf::MethodOptions* mutable_options();
+  void set_allocated_options(::google::protobuf::MethodOptions* options);
+  void unsafe_arena_set_allocated_options(
+      ::google::protobuf::MethodOptions* options);
+  ::google::protobuf::MethodOptions* unsafe_arena_release_options();
+
+  // optional bool client_streaming = 5 [default = false];
+  bool has_client_streaming() const;
+  void clear_client_streaming();
+  static const int kClientStreamingFieldNumber = 5;
+  bool client_streaming() const;
+  void set_client_streaming(bool value);
+
+  // optional bool server_streaming = 6 [default = false];
+  bool has_server_streaming() const;
+  void clear_server_streaming();
+  static const int kServerStreamingFieldNumber = 6;
+  bool server_streaming() const;
+  void set_server_streaming(bool value);
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.MethodDescriptorProto)
+ private:
+  void set_has_name();
+  void clear_has_name();
+  void set_has_input_type();
+  void clear_has_input_type();
+  void set_has_output_type();
+  void clear_has_output_type();
+  void set_has_options();
+  void clear_has_options();
+  void set_has_client_streaming();
+  void clear_has_client_streaming();
+  void set_has_server_streaming();
+  void clear_has_server_streaming();
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::google::protobuf::internal::HasBits<1> _has_bits_;
+  mutable int _cached_size_;
+  ::google::protobuf::internal::ArenaStringPtr name_;
+  ::google::protobuf::internal::ArenaStringPtr input_type_;
+  ::google::protobuf::internal::ArenaStringPtr output_type_;
+  ::google::protobuf::MethodOptions* options_;
+  bool client_streaming_;
+  bool server_streaming_;
+  friend struct ::protobuf_google_2fprotobuf_2fdescriptor_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2fdescriptor_2eproto::InitDefaultsMethodDescriptorProtoImpl();
+};
+// -------------------------------------------------------------------
+
+class LIBPROTOBUF_EXPORT FileOptions : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.FileOptions) */ {
+ public:
+  FileOptions();
+  virtual ~FileOptions();
+
+  FileOptions(const FileOptions& from);
+
+  inline FileOptions& operator=(const FileOptions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  FileOptions(FileOptions&& from) noexcept
+    : FileOptions() {
+    *this = ::std::move(from);
+  }
+
+  inline FileOptions& operator=(FileOptions&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields();
+  }
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields();
+  }
+
+  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
+    return GetArenaNoVirtual();
+  }
+  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
+    return MaybeArenaPtr();
+  }
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const FileOptions& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const FileOptions* internal_default_instance() {
+    return reinterpret_cast<const FileOptions*>(
+               &_FileOptions_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    13;
+
+  void UnsafeArenaSwap(FileOptions* other);
+  void Swap(FileOptions* other);
+  friend void swap(FileOptions& a, FileOptions& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline FileOptions* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  FileOptions* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const FileOptions& from);
+  void MergeFrom(const FileOptions& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(FileOptions* other);
+  protected:
+  explicit FileOptions(::google::protobuf::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return _internal_metadata_.arena();
+  }
+  inline void* MaybeArenaPtr() const {
+    return _internal_metadata_.raw_arena_ptr();
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  typedef FileOptions_OptimizeMode OptimizeMode;
+  static const OptimizeMode SPEED =
+    FileOptions_OptimizeMode_SPEED;
+  static const OptimizeMode CODE_SIZE =
+    FileOptions_OptimizeMode_CODE_SIZE;
+  static const OptimizeMode LITE_RUNTIME =
+    FileOptions_OptimizeMode_LITE_RUNTIME;
+  static inline bool OptimizeMode_IsValid(int value) {
+    return FileOptions_OptimizeMode_IsValid(value);
+  }
+  static const OptimizeMode OptimizeMode_MIN =
+    FileOptions_OptimizeMode_OptimizeMode_MIN;
+  static const OptimizeMode OptimizeMode_MAX =
+    FileOptions_OptimizeMode_OptimizeMode_MAX;
+  static const int OptimizeMode_ARRAYSIZE =
+    FileOptions_OptimizeMode_OptimizeMode_ARRAYSIZE;
+  static inline const ::google::protobuf::EnumDescriptor*
+  OptimizeMode_descriptor() {
+    return FileOptions_OptimizeMode_descriptor();
+  }
+  static inline const ::std::string& OptimizeMode_Name(OptimizeMode value) {
+    return FileOptions_OptimizeMode_Name(value);
+  }
+  static inline bool OptimizeMode_Parse(const ::std::string& name,
+      OptimizeMode* value) {
+    return FileOptions_OptimizeMode_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
+  int uninterpreted_option_size() const;
+  void clear_uninterpreted_option();
+  static const int kUninterpretedOptionFieldNumber = 999;
+  const ::google::protobuf::UninterpretedOption& uninterpreted_option(int index) const;
+  ::google::protobuf::UninterpretedOption* mutable_uninterpreted_option(int index);
+  ::google::protobuf::UninterpretedOption* add_uninterpreted_option();
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >*
+      mutable_uninterpreted_option();
+  const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >&
+      uninterpreted_option() const;
+
+  // optional string java_package = 1;
+  bool has_java_package() const;
+  void clear_java_package();
+  static const int kJavaPackageFieldNumber = 1;
+  const ::std::string& java_package() const;
+  void set_java_package(const ::std::string& value);
+  #if LANG_CXX11
+  void set_java_package(::std::string&& value);
+  #endif
+  void set_java_package(const char* value);
+  void set_java_package(const char* value, size_t size);
+  ::std::string* mutable_java_package();
+  ::std::string* release_java_package();
+  void set_allocated_java_package(::std::string* java_package);
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  ::std::string* unsafe_arena_release_java_package();
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  void unsafe_arena_set_allocated_java_package(
+      ::std::string* java_package);
+
+  // optional string java_outer_classname = 8;
+  bool has_java_outer_classname() const;
+  void clear_java_outer_classname();
+  static const int kJavaOuterClassnameFieldNumber = 8;
+  const ::std::string& java_outer_classname() const;
+  void set_java_outer_classname(const ::std::string& value);
+  #if LANG_CXX11
+  void set_java_outer_classname(::std::string&& value);
+  #endif
+  void set_java_outer_classname(const char* value);
+  void set_java_outer_classname(const char* value, size_t size);
+  ::std::string* mutable_java_outer_classname();
+  ::std::string* release_java_outer_classname();
+  void set_allocated_java_outer_classname(::std::string* java_outer_classname);
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  ::std::string* unsafe_arena_release_java_outer_classname();
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  void unsafe_arena_set_allocated_java_outer_classname(
+      ::std::string* java_outer_classname);
+
+  // optional string go_package = 11;
+  bool has_go_package() const;
+  void clear_go_package();
+  static const int kGoPackageFieldNumber = 11;
+  const ::std::string& go_package() const;
+  void set_go_package(const ::std::string& value);
+  #if LANG_CXX11
+  void set_go_package(::std::string&& value);
+  #endif
+  void set_go_package(const char* value);
+  void set_go_package(const char* value, size_t size);
+  ::std::string* mutable_go_package();
+  ::std::string* release_go_package();
+  void set_allocated_go_package(::std::string* go_package);
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  ::std::string* unsafe_arena_release_go_package();
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  void unsafe_arena_set_allocated_go_package(
+      ::std::string* go_package);
+
+  // optional string objc_class_prefix = 36;
+  bool has_objc_class_prefix() const;
+  void clear_objc_class_prefix();
+  static const int kObjcClassPrefixFieldNumber = 36;
+  const ::std::string& objc_class_prefix() const;
+  void set_objc_class_prefix(const ::std::string& value);
+  #if LANG_CXX11
+  void set_objc_class_prefix(::std::string&& value);
+  #endif
+  void set_objc_class_prefix(const char* value);
+  void set_objc_class_prefix(const char* value, size_t size);
+  ::std::string* mutable_objc_class_prefix();
+  ::std::string* release_objc_class_prefix();
+  void set_allocated_objc_class_prefix(::std::string* objc_class_prefix);
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  ::std::string* unsafe_arena_release_objc_class_prefix();
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  void unsafe_arena_set_allocated_objc_class_prefix(
+      ::std::string* objc_class_prefix);
+
+  // optional string csharp_namespace = 37;
+  bool has_csharp_namespace() const;
+  void clear_csharp_namespace();
+  static const int kCsharpNamespaceFieldNumber = 37;
+  const ::std::string& csharp_namespace() const;
+  void set_csharp_namespace(const ::std::string& value);
+  #if LANG_CXX11
+  void set_csharp_namespace(::std::string&& value);
+  #endif
+  void set_csharp_namespace(const char* value);
+  void set_csharp_namespace(const char* value, size_t size);
+  ::std::string* mutable_csharp_namespace();
+  ::std::string* release_csharp_namespace();
+  void set_allocated_csharp_namespace(::std::string* csharp_namespace);
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  ::std::string* unsafe_arena_release_csharp_namespace();
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  void unsafe_arena_set_allocated_csharp_namespace(
+      ::std::string* csharp_namespace);
+
+  // optional string swift_prefix = 39;
+  bool has_swift_prefix() const;
+  void clear_swift_prefix();
+  static const int kSwiftPrefixFieldNumber = 39;
+  const ::std::string& swift_prefix() const;
+  void set_swift_prefix(const ::std::string& value);
+  #if LANG_CXX11
+  void set_swift_prefix(::std::string&& value);
+  #endif
+  void set_swift_prefix(const char* value);
+  void set_swift_prefix(const char* value, size_t size);
+  ::std::string* mutable_swift_prefix();
+  ::std::string* release_swift_prefix();
+  void set_allocated_swift_prefix(::std::string* swift_prefix);
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  ::std::string* unsafe_arena_release_swift_prefix();
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  void unsafe_arena_set_allocated_swift_prefix(
+      ::std::string* swift_prefix);
+
+  // optional string php_class_prefix = 40;
+  bool has_php_class_prefix() const;
+  void clear_php_class_prefix();
+  static const int kPhpClassPrefixFieldNumber = 40;
+  const ::std::string& php_class_prefix() const;
+  void set_php_class_prefix(const ::std::string& value);
+  #if LANG_CXX11
+  void set_php_class_prefix(::std::string&& value);
+  #endif
+  void set_php_class_prefix(const char* value);
+  void set_php_class_prefix(const char* value, size_t size);
+  ::std::string* mutable_php_class_prefix();
+  ::std::string* release_php_class_prefix();
+  void set_allocated_php_class_prefix(::std::string* php_class_prefix);
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  ::std::string* unsafe_arena_release_php_class_prefix();
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  void unsafe_arena_set_allocated_php_class_prefix(
+      ::std::string* php_class_prefix);
+
+  // optional string php_namespace = 41;
+  bool has_php_namespace() const;
+  void clear_php_namespace();
+  static const int kPhpNamespaceFieldNumber = 41;
+  const ::std::string& php_namespace() const;
+  void set_php_namespace(const ::std::string& value);
+  #if LANG_CXX11
+  void set_php_namespace(::std::string&& value);
+  #endif
+  void set_php_namespace(const char* value);
+  void set_php_namespace(const char* value, size_t size);
+  ::std::string* mutable_php_namespace();
+  ::std::string* release_php_namespace();
+  void set_allocated_php_namespace(::std::string* php_namespace);
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  ::std::string* unsafe_arena_release_php_namespace();
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  void unsafe_arena_set_allocated_php_namespace(
+      ::std::string* php_namespace);
+
+  // optional bool cc_enable_arenas = 31 [default = false];
+  bool has_cc_enable_arenas() const;
+  void clear_cc_enable_arenas();
+  static const int kCcEnableArenasFieldNumber = 31;
+  bool cc_enable_arenas() const;
+  void set_cc_enable_arenas(bool value);
+
+  // optional bool java_multiple_files = 10 [default = false];
+  bool has_java_multiple_files() const;
+  void clear_java_multiple_files();
+  static const int kJavaMultipleFilesFieldNumber = 10;
+  bool java_multiple_files() const;
+  void set_java_multiple_files(bool value);
+
+  // optional bool java_generate_equals_and_hash = 20 [deprecated = true];
+  GOOGLE_PROTOBUF_DEPRECATED_ATTR bool has_java_generate_equals_and_hash() const;
+  GOOGLE_PROTOBUF_DEPRECATED_ATTR void clear_java_generate_equals_and_hash();
+  GOOGLE_PROTOBUF_DEPRECATED_ATTR static const int kJavaGenerateEqualsAndHashFieldNumber = 20;
+  GOOGLE_PROTOBUF_DEPRECATED_ATTR bool java_generate_equals_and_hash() const;
+  GOOGLE_PROTOBUF_DEPRECATED_ATTR void set_java_generate_equals_and_hash(bool value);
+
+  // optional bool java_string_check_utf8 = 27 [default = false];
+  bool has_java_string_check_utf8() const;
+  void clear_java_string_check_utf8();
+  static const int kJavaStringCheckUtf8FieldNumber = 27;
+  bool java_string_check_utf8() const;
+  void set_java_string_check_utf8(bool value);
+
+  // optional bool cc_generic_services = 16 [default = false];
+  bool has_cc_generic_services() const;
+  void clear_cc_generic_services();
+  static const int kCcGenericServicesFieldNumber = 16;
+  bool cc_generic_services() const;
+  void set_cc_generic_services(bool value);
+
+  // optional bool java_generic_services = 17 [default = false];
+  bool has_java_generic_services() const;
+  void clear_java_generic_services();
+  static const int kJavaGenericServicesFieldNumber = 17;
+  bool java_generic_services() const;
+  void set_java_generic_services(bool value);
+
+  // optional bool py_generic_services = 18 [default = false];
+  bool has_py_generic_services() const;
+  void clear_py_generic_services();
+  static const int kPyGenericServicesFieldNumber = 18;
+  bool py_generic_services() const;
+  void set_py_generic_services(bool value);
+
+  // optional bool php_generic_services = 42 [default = false];
+  bool has_php_generic_services() const;
+  void clear_php_generic_services();
+  static const int kPhpGenericServicesFieldNumber = 42;
+  bool php_generic_services() const;
+  void set_php_generic_services(bool value);
+
+  // optional bool deprecated = 23 [default = false];
+  bool has_deprecated() const;
+  void clear_deprecated();
+  static const int kDeprecatedFieldNumber = 23;
+  bool deprecated() const;
+  void set_deprecated(bool value);
+
+  // optional .google.protobuf.FileOptions.OptimizeMode optimize_for = 9 [default = SPEED];
+  bool has_optimize_for() const;
+  void clear_optimize_for();
+  static const int kOptimizeForFieldNumber = 9;
+  ::google::protobuf::FileOptions_OptimizeMode optimize_for() const;
+  void set_optimize_for(::google::protobuf::FileOptions_OptimizeMode value);
+
+  GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(FileOptions)
+  // @@protoc_insertion_point(class_scope:google.protobuf.FileOptions)
+ private:
+  void set_has_java_package();
+  void clear_has_java_package();
+  void set_has_java_outer_classname();
+  void clear_has_java_outer_classname();
+  void set_has_java_multiple_files();
+  void clear_has_java_multiple_files();
+  void set_has_java_generate_equals_and_hash();
+  void clear_has_java_generate_equals_and_hash();
+  void set_has_java_string_check_utf8();
+  void clear_has_java_string_check_utf8();
+  void set_has_optimize_for();
+  void clear_has_optimize_for();
+  void set_has_go_package();
+  void clear_has_go_package();
+  void set_has_cc_generic_services();
+  void clear_has_cc_generic_services();
+  void set_has_java_generic_services();
+  void clear_has_java_generic_services();
+  void set_has_py_generic_services();
+  void clear_has_py_generic_services();
+  void set_has_php_generic_services();
+  void clear_has_php_generic_services();
+  void set_has_deprecated();
+  void clear_has_deprecated();
+  void set_has_cc_enable_arenas();
+  void clear_has_cc_enable_arenas();
+  void set_has_objc_class_prefix();
+  void clear_has_objc_class_prefix();
+  void set_has_csharp_namespace();
+  void clear_has_csharp_namespace();
+  void set_has_swift_prefix();
+  void clear_has_swift_prefix();
+  void set_has_php_class_prefix();
+  void clear_has_php_class_prefix();
+  void set_has_php_namespace();
+  void clear_has_php_namespace();
+
+  ::google::protobuf::internal::ExtensionSet _extensions_;
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::google::protobuf::internal::HasBits<1> _has_bits_;
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption > uninterpreted_option_;
+  ::google::protobuf::internal::ArenaStringPtr java_package_;
+  ::google::protobuf::internal::ArenaStringPtr java_outer_classname_;
+  ::google::protobuf::internal::ArenaStringPtr go_package_;
+  ::google::protobuf::internal::ArenaStringPtr objc_class_prefix_;
+  ::google::protobuf::internal::ArenaStringPtr csharp_namespace_;
+  ::google::protobuf::internal::ArenaStringPtr swift_prefix_;
+  ::google::protobuf::internal::ArenaStringPtr php_class_prefix_;
+  ::google::protobuf::internal::ArenaStringPtr php_namespace_;
+  bool cc_enable_arenas_;
+  bool java_multiple_files_;
+  bool java_generate_equals_and_hash_;
+  bool java_string_check_utf8_;
+  bool cc_generic_services_;
+  bool java_generic_services_;
+  bool py_generic_services_;
+  bool php_generic_services_;
+  bool deprecated_;
+  int optimize_for_;
+  friend struct ::protobuf_google_2fprotobuf_2fdescriptor_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2fdescriptor_2eproto::InitDefaultsFileOptionsImpl();
+};
+// -------------------------------------------------------------------
+
+class LIBPROTOBUF_EXPORT MessageOptions : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.MessageOptions) */ {
+ public:
+  MessageOptions();
+  virtual ~MessageOptions();
+
+  MessageOptions(const MessageOptions& from);
+
+  inline MessageOptions& operator=(const MessageOptions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  MessageOptions(MessageOptions&& from) noexcept
+    : MessageOptions() {
+    *this = ::std::move(from);
+  }
+
+  inline MessageOptions& operator=(MessageOptions&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields();
+  }
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields();
+  }
+
+  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
+    return GetArenaNoVirtual();
+  }
+  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
+    return MaybeArenaPtr();
+  }
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const MessageOptions& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const MessageOptions* internal_default_instance() {
+    return reinterpret_cast<const MessageOptions*>(
+               &_MessageOptions_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    14;
+
+  void UnsafeArenaSwap(MessageOptions* other);
+  void Swap(MessageOptions* other);
+  friend void swap(MessageOptions& a, MessageOptions& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline MessageOptions* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  MessageOptions* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const MessageOptions& from);
+  void MergeFrom(const MessageOptions& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(MessageOptions* other);
+  protected:
+  explicit MessageOptions(::google::protobuf::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return _internal_metadata_.arena();
+  }
+  inline void* MaybeArenaPtr() const {
+    return _internal_metadata_.raw_arena_ptr();
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
+  int uninterpreted_option_size() const;
+  void clear_uninterpreted_option();
+  static const int kUninterpretedOptionFieldNumber = 999;
+  const ::google::protobuf::UninterpretedOption& uninterpreted_option(int index) const;
+  ::google::protobuf::UninterpretedOption* mutable_uninterpreted_option(int index);
+  ::google::protobuf::UninterpretedOption* add_uninterpreted_option();
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >*
+      mutable_uninterpreted_option();
+  const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >&
+      uninterpreted_option() const;
+
+  // optional bool message_set_wire_format = 1 [default = false];
+  bool has_message_set_wire_format() const;
+  void clear_message_set_wire_format();
+  static const int kMessageSetWireFormatFieldNumber = 1;
+  bool message_set_wire_format() const;
+  void set_message_set_wire_format(bool value);
+
+  // optional bool no_standard_descriptor_accessor = 2 [default = false];
+  bool has_no_standard_descriptor_accessor() const;
+  void clear_no_standard_descriptor_accessor();
+  static const int kNoStandardDescriptorAccessorFieldNumber = 2;
+  bool no_standard_descriptor_accessor() const;
+  void set_no_standard_descriptor_accessor(bool value);
+
+  // optional bool deprecated = 3 [default = false];
+  bool has_deprecated() const;
+  void clear_deprecated();
+  static const int kDeprecatedFieldNumber = 3;
+  bool deprecated() const;
+  void set_deprecated(bool value);
+
+  // optional bool map_entry = 7;
+  bool has_map_entry() const;
+  void clear_map_entry();
+  static const int kMapEntryFieldNumber = 7;
+  bool map_entry() const;
+  void set_map_entry(bool value);
+
+  GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(MessageOptions)
+  // @@protoc_insertion_point(class_scope:google.protobuf.MessageOptions)
+ private:
+  void set_has_message_set_wire_format();
+  void clear_has_message_set_wire_format();
+  void set_has_no_standard_descriptor_accessor();
+  void clear_has_no_standard_descriptor_accessor();
+  void set_has_deprecated();
+  void clear_has_deprecated();
+  void set_has_map_entry();
+  void clear_has_map_entry();
+
+  ::google::protobuf::internal::ExtensionSet _extensions_;
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::google::protobuf::internal::HasBits<1> _has_bits_;
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption > uninterpreted_option_;
+  bool message_set_wire_format_;
+  bool no_standard_descriptor_accessor_;
+  bool deprecated_;
+  bool map_entry_;
+  friend struct ::protobuf_google_2fprotobuf_2fdescriptor_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2fdescriptor_2eproto::InitDefaultsMessageOptionsImpl();
+};
+// -------------------------------------------------------------------
+
+class LIBPROTOBUF_EXPORT FieldOptions : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.FieldOptions) */ {
+ public:
+  FieldOptions();
+  virtual ~FieldOptions();
+
+  FieldOptions(const FieldOptions& from);
+
+  inline FieldOptions& operator=(const FieldOptions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  FieldOptions(FieldOptions&& from) noexcept
+    : FieldOptions() {
+    *this = ::std::move(from);
+  }
+
+  inline FieldOptions& operator=(FieldOptions&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields();
+  }
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields();
+  }
+
+  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
+    return GetArenaNoVirtual();
+  }
+  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
+    return MaybeArenaPtr();
+  }
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const FieldOptions& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const FieldOptions* internal_default_instance() {
+    return reinterpret_cast<const FieldOptions*>(
+               &_FieldOptions_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    15;
+
+  void UnsafeArenaSwap(FieldOptions* other);
+  void Swap(FieldOptions* other);
+  friend void swap(FieldOptions& a, FieldOptions& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline FieldOptions* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  FieldOptions* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const FieldOptions& from);
+  void MergeFrom(const FieldOptions& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(FieldOptions* other);
+  protected:
+  explicit FieldOptions(::google::protobuf::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return _internal_metadata_.arena();
+  }
+  inline void* MaybeArenaPtr() const {
+    return _internal_metadata_.raw_arena_ptr();
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  typedef FieldOptions_CType CType;
+  static const CType STRING =
+    FieldOptions_CType_STRING;
+  static const CType CORD =
+    FieldOptions_CType_CORD;
+  static const CType STRING_PIECE =
+    FieldOptions_CType_STRING_PIECE;
+  static inline bool CType_IsValid(int value) {
+    return FieldOptions_CType_IsValid(value);
+  }
+  static const CType CType_MIN =
+    FieldOptions_CType_CType_MIN;
+  static const CType CType_MAX =
+    FieldOptions_CType_CType_MAX;
+  static const int CType_ARRAYSIZE =
+    FieldOptions_CType_CType_ARRAYSIZE;
+  static inline const ::google::protobuf::EnumDescriptor*
+  CType_descriptor() {
+    return FieldOptions_CType_descriptor();
+  }
+  static inline const ::std::string& CType_Name(CType value) {
+    return FieldOptions_CType_Name(value);
+  }
+  static inline bool CType_Parse(const ::std::string& name,
+      CType* value) {
+    return FieldOptions_CType_Parse(name, value);
+  }
+
+  typedef FieldOptions_JSType JSType;
+  static const JSType JS_NORMAL =
+    FieldOptions_JSType_JS_NORMAL;
+  static const JSType JS_STRING =
+    FieldOptions_JSType_JS_STRING;
+  static const JSType JS_NUMBER =
+    FieldOptions_JSType_JS_NUMBER;
+  static inline bool JSType_IsValid(int value) {
+    return FieldOptions_JSType_IsValid(value);
+  }
+  static const JSType JSType_MIN =
+    FieldOptions_JSType_JSType_MIN;
+  static const JSType JSType_MAX =
+    FieldOptions_JSType_JSType_MAX;
+  static const int JSType_ARRAYSIZE =
+    FieldOptions_JSType_JSType_ARRAYSIZE;
+  static inline const ::google::protobuf::EnumDescriptor*
+  JSType_descriptor() {
+    return FieldOptions_JSType_descriptor();
+  }
+  static inline const ::std::string& JSType_Name(JSType value) {
+    return FieldOptions_JSType_Name(value);
+  }
+  static inline bool JSType_Parse(const ::std::string& name,
+      JSType* value) {
+    return FieldOptions_JSType_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
+  int uninterpreted_option_size() const;
+  void clear_uninterpreted_option();
+  static const int kUninterpretedOptionFieldNumber = 999;
+  const ::google::protobuf::UninterpretedOption& uninterpreted_option(int index) const;
+  ::google::protobuf::UninterpretedOption* mutable_uninterpreted_option(int index);
+  ::google::protobuf::UninterpretedOption* add_uninterpreted_option();
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >*
+      mutable_uninterpreted_option();
+  const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >&
+      uninterpreted_option() const;
+
+  // optional .google.protobuf.FieldOptions.CType ctype = 1 [default = STRING];
+  bool has_ctype() const;
+  void clear_ctype();
+  static const int kCtypeFieldNumber = 1;
+  ::google::protobuf::FieldOptions_CType ctype() const;
+  void set_ctype(::google::protobuf::FieldOptions_CType value);
+
+  // optional bool packed = 2;
+  bool has_packed() const;
+  void clear_packed();
+  static const int kPackedFieldNumber = 2;
+  bool packed() const;
+  void set_packed(bool value);
+
+  // optional bool lazy = 5 [default = false];
+  bool has_lazy() const;
+  void clear_lazy();
+  static const int kLazyFieldNumber = 5;
+  bool lazy() const;
+  void set_lazy(bool value);
+
+  // optional bool deprecated = 3 [default = false];
+  bool has_deprecated() const;
+  void clear_deprecated();
+  static const int kDeprecatedFieldNumber = 3;
+  bool deprecated() const;
+  void set_deprecated(bool value);
+
+  // optional bool weak = 10 [default = false];
+  bool has_weak() const;
+  void clear_weak();
+  static const int kWeakFieldNumber = 10;
+  bool weak() const;
+  void set_weak(bool value);
+
+  // optional .google.protobuf.FieldOptions.JSType jstype = 6 [default = JS_NORMAL];
+  bool has_jstype() const;
+  void clear_jstype();
+  static const int kJstypeFieldNumber = 6;
+  ::google::protobuf::FieldOptions_JSType jstype() const;
+  void set_jstype(::google::protobuf::FieldOptions_JSType value);
+
+  GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(FieldOptions)
+  // @@protoc_insertion_point(class_scope:google.protobuf.FieldOptions)
+ private:
+  void set_has_ctype();
+  void clear_has_ctype();
+  void set_has_packed();
+  void clear_has_packed();
+  void set_has_jstype();
+  void clear_has_jstype();
+  void set_has_lazy();
+  void clear_has_lazy();
+  void set_has_deprecated();
+  void clear_has_deprecated();
+  void set_has_weak();
+  void clear_has_weak();
+
+  ::google::protobuf::internal::ExtensionSet _extensions_;
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::google::protobuf::internal::HasBits<1> _has_bits_;
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption > uninterpreted_option_;
+  int ctype_;
+  bool packed_;
+  bool lazy_;
+  bool deprecated_;
+  bool weak_;
+  int jstype_;
+  friend struct ::protobuf_google_2fprotobuf_2fdescriptor_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2fdescriptor_2eproto::InitDefaultsFieldOptionsImpl();
+};
+// -------------------------------------------------------------------
+
+class LIBPROTOBUF_EXPORT OneofOptions : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.OneofOptions) */ {
+ public:
+  OneofOptions();
+  virtual ~OneofOptions();
+
+  OneofOptions(const OneofOptions& from);
+
+  inline OneofOptions& operator=(const OneofOptions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  OneofOptions(OneofOptions&& from) noexcept
+    : OneofOptions() {
+    *this = ::std::move(from);
+  }
+
+  inline OneofOptions& operator=(OneofOptions&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields();
+  }
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields();
+  }
+
+  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
+    return GetArenaNoVirtual();
+  }
+  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
+    return MaybeArenaPtr();
+  }
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const OneofOptions& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const OneofOptions* internal_default_instance() {
+    return reinterpret_cast<const OneofOptions*>(
+               &_OneofOptions_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    16;
+
+  void UnsafeArenaSwap(OneofOptions* other);
+  void Swap(OneofOptions* other);
+  friend void swap(OneofOptions& a, OneofOptions& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline OneofOptions* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  OneofOptions* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const OneofOptions& from);
+  void MergeFrom(const OneofOptions& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(OneofOptions* other);
+  protected:
+  explicit OneofOptions(::google::protobuf::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return _internal_metadata_.arena();
+  }
+  inline void* MaybeArenaPtr() const {
+    return _internal_metadata_.raw_arena_ptr();
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
+  int uninterpreted_option_size() const;
+  void clear_uninterpreted_option();
+  static const int kUninterpretedOptionFieldNumber = 999;
+  const ::google::protobuf::UninterpretedOption& uninterpreted_option(int index) const;
+  ::google::protobuf::UninterpretedOption* mutable_uninterpreted_option(int index);
+  ::google::protobuf::UninterpretedOption* add_uninterpreted_option();
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >*
+      mutable_uninterpreted_option();
+  const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >&
+      uninterpreted_option() const;
+
+  GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(OneofOptions)
+  // @@protoc_insertion_point(class_scope:google.protobuf.OneofOptions)
+ private:
+
+  ::google::protobuf::internal::ExtensionSet _extensions_;
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::google::protobuf::internal::HasBits<1> _has_bits_;
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption > uninterpreted_option_;
+  friend struct ::protobuf_google_2fprotobuf_2fdescriptor_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2fdescriptor_2eproto::InitDefaultsOneofOptionsImpl();
+};
+// -------------------------------------------------------------------
+
+class LIBPROTOBUF_EXPORT EnumOptions : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.EnumOptions) */ {
+ public:
+  EnumOptions();
+  virtual ~EnumOptions();
+
+  EnumOptions(const EnumOptions& from);
+
+  inline EnumOptions& operator=(const EnumOptions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  EnumOptions(EnumOptions&& from) noexcept
+    : EnumOptions() {
+    *this = ::std::move(from);
+  }
+
+  inline EnumOptions& operator=(EnumOptions&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields();
+  }
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields();
+  }
+
+  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
+    return GetArenaNoVirtual();
+  }
+  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
+    return MaybeArenaPtr();
+  }
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const EnumOptions& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const EnumOptions* internal_default_instance() {
+    return reinterpret_cast<const EnumOptions*>(
+               &_EnumOptions_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    17;
+
+  void UnsafeArenaSwap(EnumOptions* other);
+  void Swap(EnumOptions* other);
+  friend void swap(EnumOptions& a, EnumOptions& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline EnumOptions* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  EnumOptions* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const EnumOptions& from);
+  void MergeFrom(const EnumOptions& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(EnumOptions* other);
+  protected:
+  explicit EnumOptions(::google::protobuf::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return _internal_metadata_.arena();
+  }
+  inline void* MaybeArenaPtr() const {
+    return _internal_metadata_.raw_arena_ptr();
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
+  int uninterpreted_option_size() const;
+  void clear_uninterpreted_option();
+  static const int kUninterpretedOptionFieldNumber = 999;
+  const ::google::protobuf::UninterpretedOption& uninterpreted_option(int index) const;
+  ::google::protobuf::UninterpretedOption* mutable_uninterpreted_option(int index);
+  ::google::protobuf::UninterpretedOption* add_uninterpreted_option();
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >*
+      mutable_uninterpreted_option();
+  const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >&
+      uninterpreted_option() const;
+
+  // optional bool allow_alias = 2;
+  bool has_allow_alias() const;
+  void clear_allow_alias();
+  static const int kAllowAliasFieldNumber = 2;
+  bool allow_alias() const;
+  void set_allow_alias(bool value);
+
+  // optional bool deprecated = 3 [default = false];
+  bool has_deprecated() const;
+  void clear_deprecated();
+  static const int kDeprecatedFieldNumber = 3;
+  bool deprecated() const;
+  void set_deprecated(bool value);
+
+  GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(EnumOptions)
+  // @@protoc_insertion_point(class_scope:google.protobuf.EnumOptions)
+ private:
+  void set_has_allow_alias();
+  void clear_has_allow_alias();
+  void set_has_deprecated();
+  void clear_has_deprecated();
+
+  ::google::protobuf::internal::ExtensionSet _extensions_;
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::google::protobuf::internal::HasBits<1> _has_bits_;
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption > uninterpreted_option_;
+  bool allow_alias_;
+  bool deprecated_;
+  friend struct ::protobuf_google_2fprotobuf_2fdescriptor_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2fdescriptor_2eproto::InitDefaultsEnumOptionsImpl();
+};
+// -------------------------------------------------------------------
+
+class LIBPROTOBUF_EXPORT EnumValueOptions : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.EnumValueOptions) */ {
+ public:
+  EnumValueOptions();
+  virtual ~EnumValueOptions();
+
+  EnumValueOptions(const EnumValueOptions& from);
+
+  inline EnumValueOptions& operator=(const EnumValueOptions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  EnumValueOptions(EnumValueOptions&& from) noexcept
+    : EnumValueOptions() {
+    *this = ::std::move(from);
+  }
+
+  inline EnumValueOptions& operator=(EnumValueOptions&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields();
+  }
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields();
+  }
+
+  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
+    return GetArenaNoVirtual();
+  }
+  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
+    return MaybeArenaPtr();
+  }
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const EnumValueOptions& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const EnumValueOptions* internal_default_instance() {
+    return reinterpret_cast<const EnumValueOptions*>(
+               &_EnumValueOptions_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    18;
+
+  void UnsafeArenaSwap(EnumValueOptions* other);
+  void Swap(EnumValueOptions* other);
+  friend void swap(EnumValueOptions& a, EnumValueOptions& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline EnumValueOptions* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  EnumValueOptions* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const EnumValueOptions& from);
+  void MergeFrom(const EnumValueOptions& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(EnumValueOptions* other);
+  protected:
+  explicit EnumValueOptions(::google::protobuf::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return _internal_metadata_.arena();
+  }
+  inline void* MaybeArenaPtr() const {
+    return _internal_metadata_.raw_arena_ptr();
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
+  int uninterpreted_option_size() const;
+  void clear_uninterpreted_option();
+  static const int kUninterpretedOptionFieldNumber = 999;
+  const ::google::protobuf::UninterpretedOption& uninterpreted_option(int index) const;
+  ::google::protobuf::UninterpretedOption* mutable_uninterpreted_option(int index);
+  ::google::protobuf::UninterpretedOption* add_uninterpreted_option();
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >*
+      mutable_uninterpreted_option();
+  const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >&
+      uninterpreted_option() const;
+
+  // optional bool deprecated = 1 [default = false];
+  bool has_deprecated() const;
+  void clear_deprecated();
+  static const int kDeprecatedFieldNumber = 1;
+  bool deprecated() const;
+  void set_deprecated(bool value);
+
+  GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(EnumValueOptions)
+  // @@protoc_insertion_point(class_scope:google.protobuf.EnumValueOptions)
+ private:
+  void set_has_deprecated();
+  void clear_has_deprecated();
+
+  ::google::protobuf::internal::ExtensionSet _extensions_;
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::google::protobuf::internal::HasBits<1> _has_bits_;
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption > uninterpreted_option_;
+  bool deprecated_;
+  friend struct ::protobuf_google_2fprotobuf_2fdescriptor_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2fdescriptor_2eproto::InitDefaultsEnumValueOptionsImpl();
+};
+// -------------------------------------------------------------------
+
+class LIBPROTOBUF_EXPORT ServiceOptions : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.ServiceOptions) */ {
+ public:
+  ServiceOptions();
+  virtual ~ServiceOptions();
+
+  ServiceOptions(const ServiceOptions& from);
+
+  inline ServiceOptions& operator=(const ServiceOptions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ServiceOptions(ServiceOptions&& from) noexcept
+    : ServiceOptions() {
+    *this = ::std::move(from);
+  }
+
+  inline ServiceOptions& operator=(ServiceOptions&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields();
+  }
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields();
+  }
+
+  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
+    return GetArenaNoVirtual();
+  }
+  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
+    return MaybeArenaPtr();
+  }
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ServiceOptions& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ServiceOptions* internal_default_instance() {
+    return reinterpret_cast<const ServiceOptions*>(
+               &_ServiceOptions_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    19;
+
+  void UnsafeArenaSwap(ServiceOptions* other);
+  void Swap(ServiceOptions* other);
+  friend void swap(ServiceOptions& a, ServiceOptions& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ServiceOptions* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ServiceOptions* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ServiceOptions& from);
+  void MergeFrom(const ServiceOptions& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ServiceOptions* other);
+  protected:
+  explicit ServiceOptions(::google::protobuf::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return _internal_metadata_.arena();
+  }
+  inline void* MaybeArenaPtr() const {
+    return _internal_metadata_.raw_arena_ptr();
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
+  int uninterpreted_option_size() const;
+  void clear_uninterpreted_option();
+  static const int kUninterpretedOptionFieldNumber = 999;
+  const ::google::protobuf::UninterpretedOption& uninterpreted_option(int index) const;
+  ::google::protobuf::UninterpretedOption* mutable_uninterpreted_option(int index);
+  ::google::protobuf::UninterpretedOption* add_uninterpreted_option();
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >*
+      mutable_uninterpreted_option();
+  const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >&
+      uninterpreted_option() const;
+
+  // optional bool deprecated = 33 [default = false];
+  bool has_deprecated() const;
+  void clear_deprecated();
+  static const int kDeprecatedFieldNumber = 33;
+  bool deprecated() const;
+  void set_deprecated(bool value);
+
+  GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(ServiceOptions)
+  // @@protoc_insertion_point(class_scope:google.protobuf.ServiceOptions)
+ private:
+  void set_has_deprecated();
+  void clear_has_deprecated();
+
+  ::google::protobuf::internal::ExtensionSet _extensions_;
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::google::protobuf::internal::HasBits<1> _has_bits_;
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption > uninterpreted_option_;
+  bool deprecated_;
+  friend struct ::protobuf_google_2fprotobuf_2fdescriptor_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2fdescriptor_2eproto::InitDefaultsServiceOptionsImpl();
+};
+// -------------------------------------------------------------------
+
+class LIBPROTOBUF_EXPORT MethodOptions : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.MethodOptions) */ {
+ public:
+  MethodOptions();
+  virtual ~MethodOptions();
+
+  MethodOptions(const MethodOptions& from);
+
+  inline MethodOptions& operator=(const MethodOptions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  MethodOptions(MethodOptions&& from) noexcept
+    : MethodOptions() {
+    *this = ::std::move(from);
+  }
+
+  inline MethodOptions& operator=(MethodOptions&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields();
+  }
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields();
+  }
+
+  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
+    return GetArenaNoVirtual();
+  }
+  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
+    return MaybeArenaPtr();
+  }
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const MethodOptions& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const MethodOptions* internal_default_instance() {
+    return reinterpret_cast<const MethodOptions*>(
+               &_MethodOptions_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    20;
+
+  void UnsafeArenaSwap(MethodOptions* other);
+  void Swap(MethodOptions* other);
+  friend void swap(MethodOptions& a, MethodOptions& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline MethodOptions* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  MethodOptions* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const MethodOptions& from);
+  void MergeFrom(const MethodOptions& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(MethodOptions* other);
+  protected:
+  explicit MethodOptions(::google::protobuf::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return _internal_metadata_.arena();
+  }
+  inline void* MaybeArenaPtr() const {
+    return _internal_metadata_.raw_arena_ptr();
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  typedef MethodOptions_IdempotencyLevel IdempotencyLevel;
+  static const IdempotencyLevel IDEMPOTENCY_UNKNOWN =
+    MethodOptions_IdempotencyLevel_IDEMPOTENCY_UNKNOWN;
+  static const IdempotencyLevel NO_SIDE_EFFECTS =
+    MethodOptions_IdempotencyLevel_NO_SIDE_EFFECTS;
+  static const IdempotencyLevel IDEMPOTENT =
+    MethodOptions_IdempotencyLevel_IDEMPOTENT;
+  static inline bool IdempotencyLevel_IsValid(int value) {
+    return MethodOptions_IdempotencyLevel_IsValid(value);
+  }
+  static const IdempotencyLevel IdempotencyLevel_MIN =
+    MethodOptions_IdempotencyLevel_IdempotencyLevel_MIN;
+  static const IdempotencyLevel IdempotencyLevel_MAX =
+    MethodOptions_IdempotencyLevel_IdempotencyLevel_MAX;
+  static const int IdempotencyLevel_ARRAYSIZE =
+    MethodOptions_IdempotencyLevel_IdempotencyLevel_ARRAYSIZE;
+  static inline const ::google::protobuf::EnumDescriptor*
+  IdempotencyLevel_descriptor() {
+    return MethodOptions_IdempotencyLevel_descriptor();
+  }
+  static inline const ::std::string& IdempotencyLevel_Name(IdempotencyLevel value) {
+    return MethodOptions_IdempotencyLevel_Name(value);
+  }
+  static inline bool IdempotencyLevel_Parse(const ::std::string& name,
+      IdempotencyLevel* value) {
+    return MethodOptions_IdempotencyLevel_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  // repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
+  int uninterpreted_option_size() const;
+  void clear_uninterpreted_option();
+  static const int kUninterpretedOptionFieldNumber = 999;
+  const ::google::protobuf::UninterpretedOption& uninterpreted_option(int index) const;
+  ::google::protobuf::UninterpretedOption* mutable_uninterpreted_option(int index);
+  ::google::protobuf::UninterpretedOption* add_uninterpreted_option();
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >*
+      mutable_uninterpreted_option();
+  const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >&
+      uninterpreted_option() const;
+
+  // optional bool deprecated = 33 [default = false];
+  bool has_deprecated() const;
+  void clear_deprecated();
+  static const int kDeprecatedFieldNumber = 33;
+  bool deprecated() const;
+  void set_deprecated(bool value);
+
+  // optional .google.protobuf.MethodOptions.IdempotencyLevel idempotency_level = 34 [default = IDEMPOTENCY_UNKNOWN];
+  bool has_idempotency_level() const;
+  void clear_idempotency_level();
+  static const int kIdempotencyLevelFieldNumber = 34;
+  ::google::protobuf::MethodOptions_IdempotencyLevel idempotency_level() const;
+  void set_idempotency_level(::google::protobuf::MethodOptions_IdempotencyLevel value);
+
+  GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(MethodOptions)
+  // @@protoc_insertion_point(class_scope:google.protobuf.MethodOptions)
+ private:
+  void set_has_deprecated();
+  void clear_has_deprecated();
+  void set_has_idempotency_level();
+  void clear_has_idempotency_level();
+
+  ::google::protobuf::internal::ExtensionSet _extensions_;
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::google::protobuf::internal::HasBits<1> _has_bits_;
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption > uninterpreted_option_;
+  bool deprecated_;
+  int idempotency_level_;
+  friend struct ::protobuf_google_2fprotobuf_2fdescriptor_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2fdescriptor_2eproto::InitDefaultsMethodOptionsImpl();
+};
+// -------------------------------------------------------------------
+
+class LIBPROTOBUF_EXPORT UninterpretedOption_NamePart : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.UninterpretedOption.NamePart) */ {
+ public:
+  UninterpretedOption_NamePart();
+  virtual ~UninterpretedOption_NamePart();
+
+  UninterpretedOption_NamePart(const UninterpretedOption_NamePart& from);
+
+  inline UninterpretedOption_NamePart& operator=(const UninterpretedOption_NamePart& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  UninterpretedOption_NamePart(UninterpretedOption_NamePart&& from) noexcept
+    : UninterpretedOption_NamePart() {
+    *this = ::std::move(from);
+  }
+
+  inline UninterpretedOption_NamePart& operator=(UninterpretedOption_NamePart&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields();
+  }
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields();
+  }
+
+  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
+    return GetArenaNoVirtual();
+  }
+  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
+    return MaybeArenaPtr();
+  }
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const UninterpretedOption_NamePart& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const UninterpretedOption_NamePart* internal_default_instance() {
+    return reinterpret_cast<const UninterpretedOption_NamePart*>(
+               &_UninterpretedOption_NamePart_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    21;
+
+  void UnsafeArenaSwap(UninterpretedOption_NamePart* other);
+  void Swap(UninterpretedOption_NamePart* other);
+  friend void swap(UninterpretedOption_NamePart& a, UninterpretedOption_NamePart& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline UninterpretedOption_NamePart* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  UninterpretedOption_NamePart* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const UninterpretedOption_NamePart& from);
+  void MergeFrom(const UninterpretedOption_NamePart& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(UninterpretedOption_NamePart* other);
+  protected:
+  explicit UninterpretedOption_NamePart(::google::protobuf::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return _internal_metadata_.arena();
+  }
+  inline void* MaybeArenaPtr() const {
+    return _internal_metadata_.raw_arena_ptr();
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // required string name_part = 1;
+  bool has_name_part() const;
+  void clear_name_part();
+  static const int kNamePartFieldNumber = 1;
+  const ::std::string& name_part() const;
+  void set_name_part(const ::std::string& value);
+  #if LANG_CXX11
+  void set_name_part(::std::string&& value);
+  #endif
+  void set_name_part(const char* value);
+  void set_name_part(const char* value, size_t size);
+  ::std::string* mutable_name_part();
+  ::std::string* release_name_part();
+  void set_allocated_name_part(::std::string* name_part);
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  ::std::string* unsafe_arena_release_name_part();
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  void unsafe_arena_set_allocated_name_part(
+      ::std::string* name_part);
+
+  // required bool is_extension = 2;
+  bool has_is_extension() const;
+  void clear_is_extension();
+  static const int kIsExtensionFieldNumber = 2;
+  bool is_extension() const;
+  void set_is_extension(bool value);
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.UninterpretedOption.NamePart)
+ private:
+  void set_has_name_part();
+  void clear_has_name_part();
+  void set_has_is_extension();
+  void clear_has_is_extension();
+
+  // helper for ByteSizeLong()
+  size_t RequiredFieldsByteSizeFallback() const;
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::google::protobuf::internal::HasBits<1> _has_bits_;
+  mutable int _cached_size_;
+  ::google::protobuf::internal::ArenaStringPtr name_part_;
+  bool is_extension_;
+  friend struct ::protobuf_google_2fprotobuf_2fdescriptor_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2fdescriptor_2eproto::InitDefaultsUninterpretedOption_NamePartImpl();
+};
+// -------------------------------------------------------------------
+
+class LIBPROTOBUF_EXPORT UninterpretedOption : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.UninterpretedOption) */ {
+ public:
+  UninterpretedOption();
+  virtual ~UninterpretedOption();
+
+  UninterpretedOption(const UninterpretedOption& from);
+
+  inline UninterpretedOption& operator=(const UninterpretedOption& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  UninterpretedOption(UninterpretedOption&& from) noexcept
+    : UninterpretedOption() {
+    *this = ::std::move(from);
+  }
+
+  inline UninterpretedOption& operator=(UninterpretedOption&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields();
+  }
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields();
+  }
+
+  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
+    return GetArenaNoVirtual();
+  }
+  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
+    return MaybeArenaPtr();
+  }
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const UninterpretedOption& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const UninterpretedOption* internal_default_instance() {
+    return reinterpret_cast<const UninterpretedOption*>(
+               &_UninterpretedOption_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    22;
+
+  void UnsafeArenaSwap(UninterpretedOption* other);
+  void Swap(UninterpretedOption* other);
+  friend void swap(UninterpretedOption& a, UninterpretedOption& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline UninterpretedOption* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  UninterpretedOption* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const UninterpretedOption& from);
+  void MergeFrom(const UninterpretedOption& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(UninterpretedOption* other);
+  protected:
+  explicit UninterpretedOption(::google::protobuf::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return _internal_metadata_.arena();
+  }
+  inline void* MaybeArenaPtr() const {
+    return _internal_metadata_.raw_arena_ptr();
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  typedef UninterpretedOption_NamePart NamePart;
+
+  // accessors -------------------------------------------------------
+
+  // repeated .google.protobuf.UninterpretedOption.NamePart name = 2;
+  int name_size() const;
+  void clear_name();
+  static const int kNameFieldNumber = 2;
+  const ::google::protobuf::UninterpretedOption_NamePart& name(int index) const;
+  ::google::protobuf::UninterpretedOption_NamePart* mutable_name(int index);
+  ::google::protobuf::UninterpretedOption_NamePart* add_name();
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption_NamePart >*
+      mutable_name();
+  const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption_NamePart >&
+      name() const;
+
+  // optional string identifier_value = 3;
+  bool has_identifier_value() const;
+  void clear_identifier_value();
+  static const int kIdentifierValueFieldNumber = 3;
+  const ::std::string& identifier_value() const;
+  void set_identifier_value(const ::std::string& value);
+  #if LANG_CXX11
+  void set_identifier_value(::std::string&& value);
+  #endif
+  void set_identifier_value(const char* value);
+  void set_identifier_value(const char* value, size_t size);
+  ::std::string* mutable_identifier_value();
+  ::std::string* release_identifier_value();
+  void set_allocated_identifier_value(::std::string* identifier_value);
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  ::std::string* unsafe_arena_release_identifier_value();
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  void unsafe_arena_set_allocated_identifier_value(
+      ::std::string* identifier_value);
+
+  // optional bytes string_value = 7;
+  bool has_string_value() const;
+  void clear_string_value();
+  static const int kStringValueFieldNumber = 7;
+  const ::std::string& string_value() const;
+  void set_string_value(const ::std::string& value);
+  #if LANG_CXX11
+  void set_string_value(::std::string&& value);
+  #endif
+  void set_string_value(const char* value);
+  void set_string_value(const void* value, size_t size);
+  ::std::string* mutable_string_value();
+  ::std::string* release_string_value();
+  void set_allocated_string_value(::std::string* string_value);
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  ::std::string* unsafe_arena_release_string_value();
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  void unsafe_arena_set_allocated_string_value(
+      ::std::string* string_value);
+
+  // optional string aggregate_value = 8;
+  bool has_aggregate_value() const;
+  void clear_aggregate_value();
+  static const int kAggregateValueFieldNumber = 8;
+  const ::std::string& aggregate_value() const;
+  void set_aggregate_value(const ::std::string& value);
+  #if LANG_CXX11
+  void set_aggregate_value(::std::string&& value);
+  #endif
+  void set_aggregate_value(const char* value);
+  void set_aggregate_value(const char* value, size_t size);
+  ::std::string* mutable_aggregate_value();
+  ::std::string* release_aggregate_value();
+  void set_allocated_aggregate_value(::std::string* aggregate_value);
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  ::std::string* unsafe_arena_release_aggregate_value();
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  void unsafe_arena_set_allocated_aggregate_value(
+      ::std::string* aggregate_value);
+
+  // optional uint64 positive_int_value = 4;
+  bool has_positive_int_value() const;
+  void clear_positive_int_value();
+  static const int kPositiveIntValueFieldNumber = 4;
+  ::google::protobuf::uint64 positive_int_value() const;
+  void set_positive_int_value(::google::protobuf::uint64 value);
+
+  // optional int64 negative_int_value = 5;
+  bool has_negative_int_value() const;
+  void clear_negative_int_value();
+  static const int kNegativeIntValueFieldNumber = 5;
+  ::google::protobuf::int64 negative_int_value() const;
+  void set_negative_int_value(::google::protobuf::int64 value);
+
+  // optional double double_value = 6;
+  bool has_double_value() const;
+  void clear_double_value();
+  static const int kDoubleValueFieldNumber = 6;
+  double double_value() const;
+  void set_double_value(double value);
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.UninterpretedOption)
+ private:
+  void set_has_identifier_value();
+  void clear_has_identifier_value();
+  void set_has_positive_int_value();
+  void clear_has_positive_int_value();
+  void set_has_negative_int_value();
+  void clear_has_negative_int_value();
+  void set_has_double_value();
+  void clear_has_double_value();
+  void set_has_string_value();
+  void clear_has_string_value();
+  void set_has_aggregate_value();
+  void clear_has_aggregate_value();
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::google::protobuf::internal::HasBits<1> _has_bits_;
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption_NamePart > name_;
+  ::google::protobuf::internal::ArenaStringPtr identifier_value_;
+  ::google::protobuf::internal::ArenaStringPtr string_value_;
+  ::google::protobuf::internal::ArenaStringPtr aggregate_value_;
+  ::google::protobuf::uint64 positive_int_value_;
+  ::google::protobuf::int64 negative_int_value_;
+  double double_value_;
+  friend struct ::protobuf_google_2fprotobuf_2fdescriptor_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2fdescriptor_2eproto::InitDefaultsUninterpretedOptionImpl();
+};
+// -------------------------------------------------------------------
+
+class LIBPROTOBUF_EXPORT SourceCodeInfo_Location : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.SourceCodeInfo.Location) */ {
+ public:
+  SourceCodeInfo_Location();
+  virtual ~SourceCodeInfo_Location();
+
+  SourceCodeInfo_Location(const SourceCodeInfo_Location& from);
+
+  inline SourceCodeInfo_Location& operator=(const SourceCodeInfo_Location& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  SourceCodeInfo_Location(SourceCodeInfo_Location&& from) noexcept
+    : SourceCodeInfo_Location() {
+    *this = ::std::move(from);
+  }
+
+  inline SourceCodeInfo_Location& operator=(SourceCodeInfo_Location&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields();
+  }
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields();
+  }
+
+  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
+    return GetArenaNoVirtual();
+  }
+  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
+    return MaybeArenaPtr();
+  }
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SourceCodeInfo_Location& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const SourceCodeInfo_Location* internal_default_instance() {
+    return reinterpret_cast<const SourceCodeInfo_Location*>(
+               &_SourceCodeInfo_Location_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    23;
+
+  void UnsafeArenaSwap(SourceCodeInfo_Location* other);
+  void Swap(SourceCodeInfo_Location* other);
+  friend void swap(SourceCodeInfo_Location& a, SourceCodeInfo_Location& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SourceCodeInfo_Location* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  SourceCodeInfo_Location* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const SourceCodeInfo_Location& from);
+  void MergeFrom(const SourceCodeInfo_Location& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(SourceCodeInfo_Location* other);
+  protected:
+  explicit SourceCodeInfo_Location(::google::protobuf::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return _internal_metadata_.arena();
+  }
+  inline void* MaybeArenaPtr() const {
+    return _internal_metadata_.raw_arena_ptr();
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated int32 path = 1 [packed = true];
+  int path_size() const;
+  void clear_path();
+  static const int kPathFieldNumber = 1;
+  ::google::protobuf::int32 path(int index) const;
+  void set_path(int index, ::google::protobuf::int32 value);
+  void add_path(::google::protobuf::int32 value);
+  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
+      path() const;
+  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
+      mutable_path();
+
+  // repeated int32 span = 2 [packed = true];
+  int span_size() const;
+  void clear_span();
+  static const int kSpanFieldNumber = 2;
+  ::google::protobuf::int32 span(int index) const;
+  void set_span(int index, ::google::protobuf::int32 value);
+  void add_span(::google::protobuf::int32 value);
+  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
+      span() const;
+  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
+      mutable_span();
+
+  // repeated string leading_detached_comments = 6;
+  int leading_detached_comments_size() const;
+  void clear_leading_detached_comments();
+  static const int kLeadingDetachedCommentsFieldNumber = 6;
+  const ::std::string& leading_detached_comments(int index) const;
+  ::std::string* mutable_leading_detached_comments(int index);
+  void set_leading_detached_comments(int index, const ::std::string& value);
+  #if LANG_CXX11
+  void set_leading_detached_comments(int index, ::std::string&& value);
+  #endif
+  void set_leading_detached_comments(int index, const char* value);
+  void set_leading_detached_comments(int index, const char* value, size_t size);
+  ::std::string* add_leading_detached_comments();
+  void add_leading_detached_comments(const ::std::string& value);
+  #if LANG_CXX11
+  void add_leading_detached_comments(::std::string&& value);
+  #endif
+  void add_leading_detached_comments(const char* value);
+  void add_leading_detached_comments(const char* value, size_t size);
+  const ::google::protobuf::RepeatedPtrField< ::std::string>& leading_detached_comments() const;
+  ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_leading_detached_comments();
+
+  // optional string leading_comments = 3;
+  bool has_leading_comments() const;
+  void clear_leading_comments();
+  static const int kLeadingCommentsFieldNumber = 3;
+  const ::std::string& leading_comments() const;
+  void set_leading_comments(const ::std::string& value);
+  #if LANG_CXX11
+  void set_leading_comments(::std::string&& value);
+  #endif
+  void set_leading_comments(const char* value);
+  void set_leading_comments(const char* value, size_t size);
+  ::std::string* mutable_leading_comments();
+  ::std::string* release_leading_comments();
+  void set_allocated_leading_comments(::std::string* leading_comments);
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  ::std::string* unsafe_arena_release_leading_comments();
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  void unsafe_arena_set_allocated_leading_comments(
+      ::std::string* leading_comments);
+
+  // optional string trailing_comments = 4;
+  bool has_trailing_comments() const;
+  void clear_trailing_comments();
+  static const int kTrailingCommentsFieldNumber = 4;
+  const ::std::string& trailing_comments() const;
+  void set_trailing_comments(const ::std::string& value);
+  #if LANG_CXX11
+  void set_trailing_comments(::std::string&& value);
+  #endif
+  void set_trailing_comments(const char* value);
+  void set_trailing_comments(const char* value, size_t size);
+  ::std::string* mutable_trailing_comments();
+  ::std::string* release_trailing_comments();
+  void set_allocated_trailing_comments(::std::string* trailing_comments);
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  ::std::string* unsafe_arena_release_trailing_comments();
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  void unsafe_arena_set_allocated_trailing_comments(
+      ::std::string* trailing_comments);
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.SourceCodeInfo.Location)
+ private:
+  void set_has_leading_comments();
+  void clear_has_leading_comments();
+  void set_has_trailing_comments();
+  void clear_has_trailing_comments();
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::google::protobuf::internal::HasBits<1> _has_bits_;
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > path_;
+  mutable int _path_cached_byte_size_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > span_;
+  mutable int _span_cached_byte_size_;
+  ::google::protobuf::RepeatedPtrField< ::std::string> leading_detached_comments_;
+  ::google::protobuf::internal::ArenaStringPtr leading_comments_;
+  ::google::protobuf::internal::ArenaStringPtr trailing_comments_;
+  friend struct ::protobuf_google_2fprotobuf_2fdescriptor_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2fdescriptor_2eproto::InitDefaultsSourceCodeInfo_LocationImpl();
+};
+// -------------------------------------------------------------------
+
+class LIBPROTOBUF_EXPORT SourceCodeInfo : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.SourceCodeInfo) */ {
+ public:
+  SourceCodeInfo();
+  virtual ~SourceCodeInfo();
+
+  SourceCodeInfo(const SourceCodeInfo& from);
+
+  inline SourceCodeInfo& operator=(const SourceCodeInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  SourceCodeInfo(SourceCodeInfo&& from) noexcept
+    : SourceCodeInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline SourceCodeInfo& operator=(SourceCodeInfo&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields();
+  }
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields();
+  }
+
+  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
+    return GetArenaNoVirtual();
+  }
+  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
+    return MaybeArenaPtr();
+  }
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SourceCodeInfo& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const SourceCodeInfo* internal_default_instance() {
+    return reinterpret_cast<const SourceCodeInfo*>(
+               &_SourceCodeInfo_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    24;
+
+  void UnsafeArenaSwap(SourceCodeInfo* other);
+  void Swap(SourceCodeInfo* other);
+  friend void swap(SourceCodeInfo& a, SourceCodeInfo& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SourceCodeInfo* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  SourceCodeInfo* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const SourceCodeInfo& from);
+  void MergeFrom(const SourceCodeInfo& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(SourceCodeInfo* other);
+  protected:
+  explicit SourceCodeInfo(::google::protobuf::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return _internal_metadata_.arena();
+  }
+  inline void* MaybeArenaPtr() const {
+    return _internal_metadata_.raw_arena_ptr();
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  typedef SourceCodeInfo_Location Location;
+
+  // accessors -------------------------------------------------------
+
+  // repeated .google.protobuf.SourceCodeInfo.Location location = 1;
+  int location_size() const;
+  void clear_location();
+  static const int kLocationFieldNumber = 1;
+  const ::google::protobuf::SourceCodeInfo_Location& location(int index) const;
+  ::google::protobuf::SourceCodeInfo_Location* mutable_location(int index);
+  ::google::protobuf::SourceCodeInfo_Location* add_location();
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::SourceCodeInfo_Location >*
+      mutable_location();
+  const ::google::protobuf::RepeatedPtrField< ::google::protobuf::SourceCodeInfo_Location >&
+      location() const;
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.SourceCodeInfo)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::google::protobuf::internal::HasBits<1> _has_bits_;
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::SourceCodeInfo_Location > location_;
+  friend struct ::protobuf_google_2fprotobuf_2fdescriptor_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2fdescriptor_2eproto::InitDefaultsSourceCodeInfoImpl();
+};
+// -------------------------------------------------------------------
+
+class LIBPROTOBUF_EXPORT GeneratedCodeInfo_Annotation : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.GeneratedCodeInfo.Annotation) */ {
+ public:
+  GeneratedCodeInfo_Annotation();
+  virtual ~GeneratedCodeInfo_Annotation();
+
+  GeneratedCodeInfo_Annotation(const GeneratedCodeInfo_Annotation& from);
+
+  inline GeneratedCodeInfo_Annotation& operator=(const GeneratedCodeInfo_Annotation& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  GeneratedCodeInfo_Annotation(GeneratedCodeInfo_Annotation&& from) noexcept
+    : GeneratedCodeInfo_Annotation() {
+    *this = ::std::move(from);
+  }
+
+  inline GeneratedCodeInfo_Annotation& operator=(GeneratedCodeInfo_Annotation&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields();
+  }
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields();
+  }
+
+  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
+    return GetArenaNoVirtual();
+  }
+  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
+    return MaybeArenaPtr();
+  }
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const GeneratedCodeInfo_Annotation& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const GeneratedCodeInfo_Annotation* internal_default_instance() {
+    return reinterpret_cast<const GeneratedCodeInfo_Annotation*>(
+               &_GeneratedCodeInfo_Annotation_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    25;
+
+  void UnsafeArenaSwap(GeneratedCodeInfo_Annotation* other);
+  void Swap(GeneratedCodeInfo_Annotation* other);
+  friend void swap(GeneratedCodeInfo_Annotation& a, GeneratedCodeInfo_Annotation& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline GeneratedCodeInfo_Annotation* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  GeneratedCodeInfo_Annotation* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const GeneratedCodeInfo_Annotation& from);
+  void MergeFrom(const GeneratedCodeInfo_Annotation& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(GeneratedCodeInfo_Annotation* other);
+  protected:
+  explicit GeneratedCodeInfo_Annotation(::google::protobuf::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return _internal_metadata_.arena();
+  }
+  inline void* MaybeArenaPtr() const {
+    return _internal_metadata_.raw_arena_ptr();
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated int32 path = 1 [packed = true];
+  int path_size() const;
+  void clear_path();
+  static const int kPathFieldNumber = 1;
+  ::google::protobuf::int32 path(int index) const;
+  void set_path(int index, ::google::protobuf::int32 value);
+  void add_path(::google::protobuf::int32 value);
+  const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
+      path() const;
+  ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
+      mutable_path();
+
+  // optional string source_file = 2;
+  bool has_source_file() const;
+  void clear_source_file();
+  static const int kSourceFileFieldNumber = 2;
+  const ::std::string& source_file() const;
+  void set_source_file(const ::std::string& value);
+  #if LANG_CXX11
+  void set_source_file(::std::string&& value);
+  #endif
+  void set_source_file(const char* value);
+  void set_source_file(const char* value, size_t size);
+  ::std::string* mutable_source_file();
+  ::std::string* release_source_file();
+  void set_allocated_source_file(::std::string* source_file);
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  ::std::string* unsafe_arena_release_source_file();
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  void unsafe_arena_set_allocated_source_file(
+      ::std::string* source_file);
+
+  // optional int32 begin = 3;
+  bool has_begin() const;
+  void clear_begin();
+  static const int kBeginFieldNumber = 3;
+  ::google::protobuf::int32 begin() const;
+  void set_begin(::google::protobuf::int32 value);
+
+  // optional int32 end = 4;
+  bool has_end() const;
+  void clear_end();
+  static const int kEndFieldNumber = 4;
+  ::google::protobuf::int32 end() const;
+  void set_end(::google::protobuf::int32 value);
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.GeneratedCodeInfo.Annotation)
+ private:
+  void set_has_source_file();
+  void clear_has_source_file();
+  void set_has_begin();
+  void clear_has_begin();
+  void set_has_end();
+  void clear_has_end();
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::google::protobuf::internal::HasBits<1> _has_bits_;
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::int32 > path_;
+  mutable int _path_cached_byte_size_;
+  ::google::protobuf::internal::ArenaStringPtr source_file_;
+  ::google::protobuf::int32 begin_;
+  ::google::protobuf::int32 end_;
+  friend struct ::protobuf_google_2fprotobuf_2fdescriptor_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2fdescriptor_2eproto::InitDefaultsGeneratedCodeInfo_AnnotationImpl();
+};
+// -------------------------------------------------------------------
+
+class LIBPROTOBUF_EXPORT GeneratedCodeInfo : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.GeneratedCodeInfo) */ {
+ public:
+  GeneratedCodeInfo();
+  virtual ~GeneratedCodeInfo();
+
+  GeneratedCodeInfo(const GeneratedCodeInfo& from);
+
+  inline GeneratedCodeInfo& operator=(const GeneratedCodeInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  GeneratedCodeInfo(GeneratedCodeInfo&& from) noexcept
+    : GeneratedCodeInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline GeneratedCodeInfo& operator=(GeneratedCodeInfo&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields();
+  }
+  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields();
+  }
+
+  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
+    return GetArenaNoVirtual();
+  }
+  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
+    return MaybeArenaPtr();
+  }
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const GeneratedCodeInfo& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const GeneratedCodeInfo* internal_default_instance() {
+    return reinterpret_cast<const GeneratedCodeInfo*>(
+               &_GeneratedCodeInfo_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    26;
+
+  void UnsafeArenaSwap(GeneratedCodeInfo* other);
+  void Swap(GeneratedCodeInfo* other);
+  friend void swap(GeneratedCodeInfo& a, GeneratedCodeInfo& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline GeneratedCodeInfo* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  GeneratedCodeInfo* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const GeneratedCodeInfo& from);
+  void MergeFrom(const GeneratedCodeInfo& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(GeneratedCodeInfo* other);
+  protected:
+  explicit GeneratedCodeInfo(::google::protobuf::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return _internal_metadata_.arena();
+  }
+  inline void* MaybeArenaPtr() const {
+    return _internal_metadata_.raw_arena_ptr();
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  typedef GeneratedCodeInfo_Annotation Annotation;
+
+  // accessors -------------------------------------------------------
+
+  // repeated .google.protobuf.GeneratedCodeInfo.Annotation annotation = 1;
+  int annotation_size() const;
+  void clear_annotation();
+  static const int kAnnotationFieldNumber = 1;
+  const ::google::protobuf::GeneratedCodeInfo_Annotation& annotation(int index) const;
+  ::google::protobuf::GeneratedCodeInfo_Annotation* mutable_annotation(int index);
+  ::google::protobuf::GeneratedCodeInfo_Annotation* add_annotation();
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::GeneratedCodeInfo_Annotation >*
+      mutable_annotation();
+  const ::google::protobuf::RepeatedPtrField< ::google::protobuf::GeneratedCodeInfo_Annotation >&
+      annotation() const;
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.GeneratedCodeInfo)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::google::protobuf::internal::HasBits<1> _has_bits_;
+  mutable int _cached_size_;
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::GeneratedCodeInfo_Annotation > annotation_;
+  friend struct ::protobuf_google_2fprotobuf_2fdescriptor_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2fdescriptor_2eproto::InitDefaultsGeneratedCodeInfoImpl();
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// FileDescriptorSet
+
+// repeated .google.protobuf.FileDescriptorProto file = 1;
+inline int FileDescriptorSet::file_size() const {
+  return file_.size();
+}
+inline void FileDescriptorSet::clear_file() {
+  file_.Clear();
+}
+inline const ::google::protobuf::FileDescriptorProto& FileDescriptorSet::file(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorSet.file)
+  return file_.Get(index);
+}
+inline ::google::protobuf::FileDescriptorProto* FileDescriptorSet::mutable_file(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FileDescriptorSet.file)
+  return file_.Mutable(index);
+}
+inline ::google::protobuf::FileDescriptorProto* FileDescriptorSet::add_file() {
+  // @@protoc_insertion_point(field_add:google.protobuf.FileDescriptorSet.file)
+  return file_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::FileDescriptorProto >*
+FileDescriptorSet::mutable_file() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.FileDescriptorSet.file)
+  return &file_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::FileDescriptorProto >&
+FileDescriptorSet::file() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.FileDescriptorSet.file)
+  return file_;
+}
+
+// -------------------------------------------------------------------
+
+// FileDescriptorProto
+
+// optional string name = 1;
+inline bool FileDescriptorProto::has_name() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void FileDescriptorProto::set_has_name() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void FileDescriptorProto::clear_has_name() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void FileDescriptorProto::clear_name() {
+  name_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+  clear_has_name();
+}
+inline const ::std::string& FileDescriptorProto::name() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.name)
+  return name_.Get();
+}
+inline void FileDescriptorProto::set_name(const ::std::string& value) {
+  set_has_name();
+  name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set:google.protobuf.FileDescriptorProto.name)
+}
+#if LANG_CXX11
+inline void FileDescriptorProto::set_name(::std::string&& value) {
+  set_has_name();
+  name_.Set(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.FileDescriptorProto.name)
+}
+#endif
+inline void FileDescriptorProto::set_name(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  set_has_name();
+  name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
+              GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_char:google.protobuf.FileDescriptorProto.name)
+}
+inline void FileDescriptorProto::set_name(const char* value,
+    size_t size) {
+  set_has_name();
+  name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
+      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.FileDescriptorProto.name)
+}
+inline ::std::string* FileDescriptorProto::mutable_name() {
+  set_has_name();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FileDescriptorProto.name)
+  return name_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline ::std::string* FileDescriptorProto::release_name() {
+  // @@protoc_insertion_point(field_release:google.protobuf.FileDescriptorProto.name)
+  clear_has_name();
+  return name_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline void FileDescriptorProto::set_allocated_name(::std::string* name) {
+  if (name != NULL) {
+    set_has_name();
+  } else {
+    clear_has_name();
+  }
+  name_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name,
+      GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileDescriptorProto.name)
+}
+inline ::std::string* FileDescriptorProto::unsafe_arena_release_name() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.FileDescriptorProto.name)
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  clear_has_name();
+  return name_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      GetArenaNoVirtual());
+}
+inline void FileDescriptorProto::unsafe_arena_set_allocated_name(
+    ::std::string* name) {
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  if (name != NULL) {
+    set_has_name();
+  } else {
+    clear_has_name();
+  }
+  name_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      name, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.FileDescriptorProto.name)
+}
+
+// optional string package = 2;
+inline bool FileDescriptorProto::has_package() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void FileDescriptorProto::set_has_package() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void FileDescriptorProto::clear_has_package() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void FileDescriptorProto::clear_package() {
+  package_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+  clear_has_package();
+}
+inline const ::std::string& FileDescriptorProto::package() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.package)
+  return package_.Get();
+}
+inline void FileDescriptorProto::set_package(const ::std::string& value) {
+  set_has_package();
+  package_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set:google.protobuf.FileDescriptorProto.package)
+}
+#if LANG_CXX11
+inline void FileDescriptorProto::set_package(::std::string&& value) {
+  set_has_package();
+  package_.Set(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.FileDescriptorProto.package)
+}
+#endif
+inline void FileDescriptorProto::set_package(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  set_has_package();
+  package_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
+              GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_char:google.protobuf.FileDescriptorProto.package)
+}
+inline void FileDescriptorProto::set_package(const char* value,
+    size_t size) {
+  set_has_package();
+  package_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
+      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.FileDescriptorProto.package)
+}
+inline ::std::string* FileDescriptorProto::mutable_package() {
+  set_has_package();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FileDescriptorProto.package)
+  return package_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline ::std::string* FileDescriptorProto::release_package() {
+  // @@protoc_insertion_point(field_release:google.protobuf.FileDescriptorProto.package)
+  clear_has_package();
+  return package_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline void FileDescriptorProto::set_allocated_package(::std::string* package) {
+  if (package != NULL) {
+    set_has_package();
+  } else {
+    clear_has_package();
+  }
+  package_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), package,
+      GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileDescriptorProto.package)
+}
+inline ::std::string* FileDescriptorProto::unsafe_arena_release_package() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.FileDescriptorProto.package)
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  clear_has_package();
+  return package_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      GetArenaNoVirtual());
+}
+inline void FileDescriptorProto::unsafe_arena_set_allocated_package(
+    ::std::string* package) {
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  if (package != NULL) {
+    set_has_package();
+  } else {
+    clear_has_package();
+  }
+  package_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      package, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.FileDescriptorProto.package)
+}
+
+// repeated string dependency = 3;
+inline int FileDescriptorProto::dependency_size() const {
+  return dependency_.size();
+}
+inline void FileDescriptorProto::clear_dependency() {
+  dependency_.Clear();
+}
+inline const ::std::string& FileDescriptorProto::dependency(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.dependency)
+  return dependency_.Get(index);
+}
+inline ::std::string* FileDescriptorProto::mutable_dependency(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FileDescriptorProto.dependency)
+  return dependency_.Mutable(index);
+}
+inline void FileDescriptorProto::set_dependency(int index, const ::std::string& value) {
+  // @@protoc_insertion_point(field_set:google.protobuf.FileDescriptorProto.dependency)
+  dependency_.Mutable(index)->assign(value);
+}
+#if LANG_CXX11
+inline void FileDescriptorProto::set_dependency(int index, ::std::string&& value) {
+  // @@protoc_insertion_point(field_set:google.protobuf.FileDescriptorProto.dependency)
+  dependency_.Mutable(index)->assign(std::move(value));
+}
+#endif
+inline void FileDescriptorProto::set_dependency(int index, const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  dependency_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:google.protobuf.FileDescriptorProto.dependency)
+}
+inline void FileDescriptorProto::set_dependency(int index, const char* value, size_t size) {
+  dependency_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.FileDescriptorProto.dependency)
+}
+inline ::std::string* FileDescriptorProto::add_dependency() {
+  // @@protoc_insertion_point(field_add_mutable:google.protobuf.FileDescriptorProto.dependency)
+  return dependency_.Add();
+}
+inline void FileDescriptorProto::add_dependency(const ::std::string& value) {
+  dependency_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:google.protobuf.FileDescriptorProto.dependency)
+}
+#if LANG_CXX11
+inline void FileDescriptorProto::add_dependency(::std::string&& value) {
+  dependency_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:google.protobuf.FileDescriptorProto.dependency)
+}
+#endif
+inline void FileDescriptorProto::add_dependency(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  dependency_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:google.protobuf.FileDescriptorProto.dependency)
+}
+inline void FileDescriptorProto::add_dependency(const char* value, size_t size) {
+  dependency_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:google.protobuf.FileDescriptorProto.dependency)
+}
+inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
+FileDescriptorProto::dependency() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.FileDescriptorProto.dependency)
+  return dependency_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::std::string>*
+FileDescriptorProto::mutable_dependency() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.FileDescriptorProto.dependency)
+  return &dependency_;
+}
+
+// repeated int32 public_dependency = 10;
+inline int FileDescriptorProto::public_dependency_size() const {
+  return public_dependency_.size();
+}
+inline void FileDescriptorProto::clear_public_dependency() {
+  public_dependency_.Clear();
+}
+inline ::google::protobuf::int32 FileDescriptorProto::public_dependency(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.public_dependency)
+  return public_dependency_.Get(index);
+}
+inline void FileDescriptorProto::set_public_dependency(int index, ::google::protobuf::int32 value) {
+  public_dependency_.Set(index, value);
+  // @@protoc_insertion_point(field_set:google.protobuf.FileDescriptorProto.public_dependency)
+}
+inline void FileDescriptorProto::add_public_dependency(::google::protobuf::int32 value) {
+  public_dependency_.Add(value);
+  // @@protoc_insertion_point(field_add:google.protobuf.FileDescriptorProto.public_dependency)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
+FileDescriptorProto::public_dependency() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.FileDescriptorProto.public_dependency)
+  return public_dependency_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
+FileDescriptorProto::mutable_public_dependency() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.FileDescriptorProto.public_dependency)
+  return &public_dependency_;
+}
+
+// repeated int32 weak_dependency = 11;
+inline int FileDescriptorProto::weak_dependency_size() const {
+  return weak_dependency_.size();
+}
+inline void FileDescriptorProto::clear_weak_dependency() {
+  weak_dependency_.Clear();
+}
+inline ::google::protobuf::int32 FileDescriptorProto::weak_dependency(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.weak_dependency)
+  return weak_dependency_.Get(index);
+}
+inline void FileDescriptorProto::set_weak_dependency(int index, ::google::protobuf::int32 value) {
+  weak_dependency_.Set(index, value);
+  // @@protoc_insertion_point(field_set:google.protobuf.FileDescriptorProto.weak_dependency)
+}
+inline void FileDescriptorProto::add_weak_dependency(::google::protobuf::int32 value) {
+  weak_dependency_.Add(value);
+  // @@protoc_insertion_point(field_add:google.protobuf.FileDescriptorProto.weak_dependency)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
+FileDescriptorProto::weak_dependency() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.FileDescriptorProto.weak_dependency)
+  return weak_dependency_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
+FileDescriptorProto::mutable_weak_dependency() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.FileDescriptorProto.weak_dependency)
+  return &weak_dependency_;
+}
+
+// repeated .google.protobuf.DescriptorProto message_type = 4;
+inline int FileDescriptorProto::message_type_size() const {
+  return message_type_.size();
+}
+inline void FileDescriptorProto::clear_message_type() {
+  message_type_.Clear();
+}
+inline const ::google::protobuf::DescriptorProto& FileDescriptorProto::message_type(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.message_type)
+  return message_type_.Get(index);
+}
+inline ::google::protobuf::DescriptorProto* FileDescriptorProto::mutable_message_type(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FileDescriptorProto.message_type)
+  return message_type_.Mutable(index);
+}
+inline ::google::protobuf::DescriptorProto* FileDescriptorProto::add_message_type() {
+  // @@protoc_insertion_point(field_add:google.protobuf.FileDescriptorProto.message_type)
+  return message_type_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto >*
+FileDescriptorProto::mutable_message_type() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.FileDescriptorProto.message_type)
+  return &message_type_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto >&
+FileDescriptorProto::message_type() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.FileDescriptorProto.message_type)
+  return message_type_;
+}
+
+// repeated .google.protobuf.EnumDescriptorProto enum_type = 5;
+inline int FileDescriptorProto::enum_type_size() const {
+  return enum_type_.size();
+}
+inline void FileDescriptorProto::clear_enum_type() {
+  enum_type_.Clear();
+}
+inline const ::google::protobuf::EnumDescriptorProto& FileDescriptorProto::enum_type(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.enum_type)
+  return enum_type_.Get(index);
+}
+inline ::google::protobuf::EnumDescriptorProto* FileDescriptorProto::mutable_enum_type(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FileDescriptorProto.enum_type)
+  return enum_type_.Mutable(index);
+}
+inline ::google::protobuf::EnumDescriptorProto* FileDescriptorProto::add_enum_type() {
+  // @@protoc_insertion_point(field_add:google.protobuf.FileDescriptorProto.enum_type)
+  return enum_type_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumDescriptorProto >*
+FileDescriptorProto::mutable_enum_type() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.FileDescriptorProto.enum_type)
+  return &enum_type_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumDescriptorProto >&
+FileDescriptorProto::enum_type() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.FileDescriptorProto.enum_type)
+  return enum_type_;
+}
+
+// repeated .google.protobuf.ServiceDescriptorProto service = 6;
+inline int FileDescriptorProto::service_size() const {
+  return service_.size();
+}
+inline void FileDescriptorProto::clear_service() {
+  service_.Clear();
+}
+inline const ::google::protobuf::ServiceDescriptorProto& FileDescriptorProto::service(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.service)
+  return service_.Get(index);
+}
+inline ::google::protobuf::ServiceDescriptorProto* FileDescriptorProto::mutable_service(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FileDescriptorProto.service)
+  return service_.Mutable(index);
+}
+inline ::google::protobuf::ServiceDescriptorProto* FileDescriptorProto::add_service() {
+  // @@protoc_insertion_point(field_add:google.protobuf.FileDescriptorProto.service)
+  return service_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::ServiceDescriptorProto >*
+FileDescriptorProto::mutable_service() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.FileDescriptorProto.service)
+  return &service_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::ServiceDescriptorProto >&
+FileDescriptorProto::service() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.FileDescriptorProto.service)
+  return service_;
+}
+
+// repeated .google.protobuf.FieldDescriptorProto extension = 7;
+inline int FileDescriptorProto::extension_size() const {
+  return extension_.size();
+}
+inline void FileDescriptorProto::clear_extension() {
+  extension_.Clear();
+}
+inline const ::google::protobuf::FieldDescriptorProto& FileDescriptorProto::extension(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.extension)
+  return extension_.Get(index);
+}
+inline ::google::protobuf::FieldDescriptorProto* FileDescriptorProto::mutable_extension(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FileDescriptorProto.extension)
+  return extension_.Mutable(index);
+}
+inline ::google::protobuf::FieldDescriptorProto* FileDescriptorProto::add_extension() {
+  // @@protoc_insertion_point(field_add:google.protobuf.FileDescriptorProto.extension)
+  return extension_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >*
+FileDescriptorProto::mutable_extension() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.FileDescriptorProto.extension)
+  return &extension_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >&
+FileDescriptorProto::extension() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.FileDescriptorProto.extension)
+  return extension_;
+}
+
+// optional .google.protobuf.FileOptions options = 8;
+inline bool FileDescriptorProto::has_options() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void FileDescriptorProto::set_has_options() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void FileDescriptorProto::clear_has_options() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void FileDescriptorProto::clear_options() {
+  if (options_ != NULL) options_->Clear();
+  clear_has_options();
+}
+inline const ::google::protobuf::FileOptions& FileDescriptorProto::options() const {
+  const ::google::protobuf::FileOptions* p = options_;
+  // @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.options)
+  return p != NULL ? *p : *reinterpret_cast<const ::google::protobuf::FileOptions*>(
+      &::google::protobuf::_FileOptions_default_instance_);
+}
+inline ::google::protobuf::FileOptions* FileDescriptorProto::release_options() {
+  // @@protoc_insertion_point(field_release:google.protobuf.FileDescriptorProto.options)
+  clear_has_options();
+  ::google::protobuf::FileOptions* temp = options_;
+  if (GetArenaNoVirtual() != NULL) {
+    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp, NULL);
+  }
+  options_ = NULL;
+  return temp;
+}
+inline ::google::protobuf::FileOptions* FileDescriptorProto::unsafe_arena_release_options() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.FileDescriptorProto.options)
+  clear_has_options();
+  ::google::protobuf::FileOptions* temp = options_;
+  options_ = NULL;
+  return temp;
+}
+inline ::google::protobuf::FileOptions* FileDescriptorProto::mutable_options() {
+  set_has_options();
+  if (options_ == NULL) {
+    _slow_mutable_options();
+  }
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FileDescriptorProto.options)
+  return options_;
+}
+inline void FileDescriptorProto::set_allocated_options(::google::protobuf::FileOptions* options) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete options_;
+  }
+  if (options) {
+    ::google::protobuf::Arena* submessage_arena =
+      ::google::protobuf::Arena::GetArena(options);
+    if (message_arena != submessage_arena) {
+      options = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, options, submessage_arena);
+    }
+    set_has_options();
+  } else {
+    clear_has_options();
+  }
+  options_ = options;
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileDescriptorProto.options)
+}
+
+// optional .google.protobuf.SourceCodeInfo source_code_info = 9;
+inline bool FileDescriptorProto::has_source_code_info() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void FileDescriptorProto::set_has_source_code_info() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void FileDescriptorProto::clear_has_source_code_info() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void FileDescriptorProto::clear_source_code_info() {
+  if (source_code_info_ != NULL) source_code_info_->Clear();
+  clear_has_source_code_info();
+}
+inline const ::google::protobuf::SourceCodeInfo& FileDescriptorProto::source_code_info() const {
+  const ::google::protobuf::SourceCodeInfo* p = source_code_info_;
+  // @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.source_code_info)
+  return p != NULL ? *p : *reinterpret_cast<const ::google::protobuf::SourceCodeInfo*>(
+      &::google::protobuf::_SourceCodeInfo_default_instance_);
+}
+inline ::google::protobuf::SourceCodeInfo* FileDescriptorProto::release_source_code_info() {
+  // @@protoc_insertion_point(field_release:google.protobuf.FileDescriptorProto.source_code_info)
+  clear_has_source_code_info();
+  ::google::protobuf::SourceCodeInfo* temp = source_code_info_;
+  if (GetArenaNoVirtual() != NULL) {
+    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp, NULL);
+  }
+  source_code_info_ = NULL;
+  return temp;
+}
+inline ::google::protobuf::SourceCodeInfo* FileDescriptorProto::unsafe_arena_release_source_code_info() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.FileDescriptorProto.source_code_info)
+  clear_has_source_code_info();
+  ::google::protobuf::SourceCodeInfo* temp = source_code_info_;
+  source_code_info_ = NULL;
+  return temp;
+}
+inline ::google::protobuf::SourceCodeInfo* FileDescriptorProto::mutable_source_code_info() {
+  set_has_source_code_info();
+  if (source_code_info_ == NULL) {
+    _slow_mutable_source_code_info();
+  }
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FileDescriptorProto.source_code_info)
+  return source_code_info_;
+}
+inline void FileDescriptorProto::set_allocated_source_code_info(::google::protobuf::SourceCodeInfo* source_code_info) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete source_code_info_;
+  }
+  if (source_code_info) {
+    ::google::protobuf::Arena* submessage_arena =
+      ::google::protobuf::Arena::GetArena(source_code_info);
+    if (message_arena != submessage_arena) {
+      source_code_info = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, source_code_info, submessage_arena);
+    }
+    set_has_source_code_info();
+  } else {
+    clear_has_source_code_info();
+  }
+  source_code_info_ = source_code_info;
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileDescriptorProto.source_code_info)
+}
+
+// optional string syntax = 12;
+inline bool FileDescriptorProto::has_syntax() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void FileDescriptorProto::set_has_syntax() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void FileDescriptorProto::clear_has_syntax() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void FileDescriptorProto::clear_syntax() {
+  syntax_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+  clear_has_syntax();
+}
+inline const ::std::string& FileDescriptorProto::syntax() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileDescriptorProto.syntax)
+  return syntax_.Get();
+}
+inline void FileDescriptorProto::set_syntax(const ::std::string& value) {
+  set_has_syntax();
+  syntax_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set:google.protobuf.FileDescriptorProto.syntax)
+}
+#if LANG_CXX11
+inline void FileDescriptorProto::set_syntax(::std::string&& value) {
+  set_has_syntax();
+  syntax_.Set(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.FileDescriptorProto.syntax)
+}
+#endif
+inline void FileDescriptorProto::set_syntax(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  set_has_syntax();
+  syntax_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
+              GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_char:google.protobuf.FileDescriptorProto.syntax)
+}
+inline void FileDescriptorProto::set_syntax(const char* value,
+    size_t size) {
+  set_has_syntax();
+  syntax_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
+      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.FileDescriptorProto.syntax)
+}
+inline ::std::string* FileDescriptorProto::mutable_syntax() {
+  set_has_syntax();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FileDescriptorProto.syntax)
+  return syntax_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline ::std::string* FileDescriptorProto::release_syntax() {
+  // @@protoc_insertion_point(field_release:google.protobuf.FileDescriptorProto.syntax)
+  clear_has_syntax();
+  return syntax_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline void FileDescriptorProto::set_allocated_syntax(::std::string* syntax) {
+  if (syntax != NULL) {
+    set_has_syntax();
+  } else {
+    clear_has_syntax();
+  }
+  syntax_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), syntax,
+      GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileDescriptorProto.syntax)
+}
+inline ::std::string* FileDescriptorProto::unsafe_arena_release_syntax() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.FileDescriptorProto.syntax)
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  clear_has_syntax();
+  return syntax_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      GetArenaNoVirtual());
+}
+inline void FileDescriptorProto::unsafe_arena_set_allocated_syntax(
+    ::std::string* syntax) {
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  if (syntax != NULL) {
+    set_has_syntax();
+  } else {
+    clear_has_syntax();
+  }
+  syntax_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      syntax, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.FileDescriptorProto.syntax)
+}
+
+// -------------------------------------------------------------------
+
+// DescriptorProto_ExtensionRange
+
+// optional int32 start = 1;
+inline bool DescriptorProto_ExtensionRange::has_start() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void DescriptorProto_ExtensionRange::set_has_start() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void DescriptorProto_ExtensionRange::clear_has_start() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void DescriptorProto_ExtensionRange::clear_start() {
+  start_ = 0;
+  clear_has_start();
+}
+inline ::google::protobuf::int32 DescriptorProto_ExtensionRange::start() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.ExtensionRange.start)
+  return start_;
+}
+inline void DescriptorProto_ExtensionRange::set_start(::google::protobuf::int32 value) {
+  set_has_start();
+  start_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.DescriptorProto.ExtensionRange.start)
+}
+
+// optional int32 end = 2;
+inline bool DescriptorProto_ExtensionRange::has_end() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void DescriptorProto_ExtensionRange::set_has_end() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void DescriptorProto_ExtensionRange::clear_has_end() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void DescriptorProto_ExtensionRange::clear_end() {
+  end_ = 0;
+  clear_has_end();
+}
+inline ::google::protobuf::int32 DescriptorProto_ExtensionRange::end() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.ExtensionRange.end)
+  return end_;
+}
+inline void DescriptorProto_ExtensionRange::set_end(::google::protobuf::int32 value) {
+  set_has_end();
+  end_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.DescriptorProto.ExtensionRange.end)
+}
+
+// optional .google.protobuf.ExtensionRangeOptions options = 3;
+inline bool DescriptorProto_ExtensionRange::has_options() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void DescriptorProto_ExtensionRange::set_has_options() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void DescriptorProto_ExtensionRange::clear_has_options() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void DescriptorProto_ExtensionRange::clear_options() {
+  if (options_ != NULL) options_->Clear();
+  clear_has_options();
+}
+inline const ::google::protobuf::ExtensionRangeOptions& DescriptorProto_ExtensionRange::options() const {
+  const ::google::protobuf::ExtensionRangeOptions* p = options_;
+  // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.ExtensionRange.options)
+  return p != NULL ? *p : *reinterpret_cast<const ::google::protobuf::ExtensionRangeOptions*>(
+      &::google::protobuf::_ExtensionRangeOptions_default_instance_);
+}
+inline ::google::protobuf::ExtensionRangeOptions* DescriptorProto_ExtensionRange::release_options() {
+  // @@protoc_insertion_point(field_release:google.protobuf.DescriptorProto.ExtensionRange.options)
+  clear_has_options();
+  ::google::protobuf::ExtensionRangeOptions* temp = options_;
+  if (GetArenaNoVirtual() != NULL) {
+    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp, NULL);
+  }
+  options_ = NULL;
+  return temp;
+}
+inline ::google::protobuf::ExtensionRangeOptions* DescriptorProto_ExtensionRange::unsafe_arena_release_options() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.DescriptorProto.ExtensionRange.options)
+  clear_has_options();
+  ::google::protobuf::ExtensionRangeOptions* temp = options_;
+  options_ = NULL;
+  return temp;
+}
+inline ::google::protobuf::ExtensionRangeOptions* DescriptorProto_ExtensionRange::mutable_options() {
+  set_has_options();
+  if (options_ == NULL) {
+    _slow_mutable_options();
+  }
+  // @@protoc_insertion_point(field_mutable:google.protobuf.DescriptorProto.ExtensionRange.options)
+  return options_;
+}
+inline void DescriptorProto_ExtensionRange::set_allocated_options(::google::protobuf::ExtensionRangeOptions* options) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete options_;
+  }
+  if (options) {
+    ::google::protobuf::Arena* submessage_arena =
+      ::google::protobuf::Arena::GetArena(options);
+    if (message_arena != submessage_arena) {
+      options = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, options, submessage_arena);
+    }
+    set_has_options();
+  } else {
+    clear_has_options();
+  }
+  options_ = options;
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.DescriptorProto.ExtensionRange.options)
+}
+
+// -------------------------------------------------------------------
+
+// DescriptorProto_ReservedRange
+
+// optional int32 start = 1;
+inline bool DescriptorProto_ReservedRange::has_start() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void DescriptorProto_ReservedRange::set_has_start() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void DescriptorProto_ReservedRange::clear_has_start() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void DescriptorProto_ReservedRange::clear_start() {
+  start_ = 0;
+  clear_has_start();
+}
+inline ::google::protobuf::int32 DescriptorProto_ReservedRange::start() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.ReservedRange.start)
+  return start_;
+}
+inline void DescriptorProto_ReservedRange::set_start(::google::protobuf::int32 value) {
+  set_has_start();
+  start_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.DescriptorProto.ReservedRange.start)
+}
+
+// optional int32 end = 2;
+inline bool DescriptorProto_ReservedRange::has_end() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void DescriptorProto_ReservedRange::set_has_end() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void DescriptorProto_ReservedRange::clear_has_end() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void DescriptorProto_ReservedRange::clear_end() {
+  end_ = 0;
+  clear_has_end();
+}
+inline ::google::protobuf::int32 DescriptorProto_ReservedRange::end() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.ReservedRange.end)
+  return end_;
+}
+inline void DescriptorProto_ReservedRange::set_end(::google::protobuf::int32 value) {
+  set_has_end();
+  end_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.DescriptorProto.ReservedRange.end)
+}
+
+// -------------------------------------------------------------------
+
+// DescriptorProto
+
+// optional string name = 1;
+inline bool DescriptorProto::has_name() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void DescriptorProto::set_has_name() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void DescriptorProto::clear_has_name() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void DescriptorProto::clear_name() {
+  name_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+  clear_has_name();
+}
+inline const ::std::string& DescriptorProto::name() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.name)
+  return name_.Get();
+}
+inline void DescriptorProto::set_name(const ::std::string& value) {
+  set_has_name();
+  name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set:google.protobuf.DescriptorProto.name)
+}
+#if LANG_CXX11
+inline void DescriptorProto::set_name(::std::string&& value) {
+  set_has_name();
+  name_.Set(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.DescriptorProto.name)
+}
+#endif
+inline void DescriptorProto::set_name(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  set_has_name();
+  name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
+              GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_char:google.protobuf.DescriptorProto.name)
+}
+inline void DescriptorProto::set_name(const char* value,
+    size_t size) {
+  set_has_name();
+  name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
+      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.DescriptorProto.name)
+}
+inline ::std::string* DescriptorProto::mutable_name() {
+  set_has_name();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.DescriptorProto.name)
+  return name_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline ::std::string* DescriptorProto::release_name() {
+  // @@protoc_insertion_point(field_release:google.protobuf.DescriptorProto.name)
+  clear_has_name();
+  return name_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline void DescriptorProto::set_allocated_name(::std::string* name) {
+  if (name != NULL) {
+    set_has_name();
+  } else {
+    clear_has_name();
+  }
+  name_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name,
+      GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.DescriptorProto.name)
+}
+inline ::std::string* DescriptorProto::unsafe_arena_release_name() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.DescriptorProto.name)
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  clear_has_name();
+  return name_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      GetArenaNoVirtual());
+}
+inline void DescriptorProto::unsafe_arena_set_allocated_name(
+    ::std::string* name) {
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  if (name != NULL) {
+    set_has_name();
+  } else {
+    clear_has_name();
+  }
+  name_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      name, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.DescriptorProto.name)
+}
+
+// repeated .google.protobuf.FieldDescriptorProto field = 2;
+inline int DescriptorProto::field_size() const {
+  return field_.size();
+}
+inline void DescriptorProto::clear_field() {
+  field_.Clear();
+}
+inline const ::google::protobuf::FieldDescriptorProto& DescriptorProto::field(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.field)
+  return field_.Get(index);
+}
+inline ::google::protobuf::FieldDescriptorProto* DescriptorProto::mutable_field(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.DescriptorProto.field)
+  return field_.Mutable(index);
+}
+inline ::google::protobuf::FieldDescriptorProto* DescriptorProto::add_field() {
+  // @@protoc_insertion_point(field_add:google.protobuf.DescriptorProto.field)
+  return field_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >*
+DescriptorProto::mutable_field() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.DescriptorProto.field)
+  return &field_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >&
+DescriptorProto::field() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.DescriptorProto.field)
+  return field_;
+}
+
+// repeated .google.protobuf.FieldDescriptorProto extension = 6;
+inline int DescriptorProto::extension_size() const {
+  return extension_.size();
+}
+inline void DescriptorProto::clear_extension() {
+  extension_.Clear();
+}
+inline const ::google::protobuf::FieldDescriptorProto& DescriptorProto::extension(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.extension)
+  return extension_.Get(index);
+}
+inline ::google::protobuf::FieldDescriptorProto* DescriptorProto::mutable_extension(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.DescriptorProto.extension)
+  return extension_.Mutable(index);
+}
+inline ::google::protobuf::FieldDescriptorProto* DescriptorProto::add_extension() {
+  // @@protoc_insertion_point(field_add:google.protobuf.DescriptorProto.extension)
+  return extension_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >*
+DescriptorProto::mutable_extension() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.DescriptorProto.extension)
+  return &extension_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::FieldDescriptorProto >&
+DescriptorProto::extension() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.DescriptorProto.extension)
+  return extension_;
+}
+
+// repeated .google.protobuf.DescriptorProto nested_type = 3;
+inline int DescriptorProto::nested_type_size() const {
+  return nested_type_.size();
+}
+inline void DescriptorProto::clear_nested_type() {
+  nested_type_.Clear();
+}
+inline const ::google::protobuf::DescriptorProto& DescriptorProto::nested_type(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.nested_type)
+  return nested_type_.Get(index);
+}
+inline ::google::protobuf::DescriptorProto* DescriptorProto::mutable_nested_type(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.DescriptorProto.nested_type)
+  return nested_type_.Mutable(index);
+}
+inline ::google::protobuf::DescriptorProto* DescriptorProto::add_nested_type() {
+  // @@protoc_insertion_point(field_add:google.protobuf.DescriptorProto.nested_type)
+  return nested_type_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto >*
+DescriptorProto::mutable_nested_type() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.DescriptorProto.nested_type)
+  return &nested_type_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto >&
+DescriptorProto::nested_type() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.DescriptorProto.nested_type)
+  return nested_type_;
+}
+
+// repeated .google.protobuf.EnumDescriptorProto enum_type = 4;
+inline int DescriptorProto::enum_type_size() const {
+  return enum_type_.size();
+}
+inline void DescriptorProto::clear_enum_type() {
+  enum_type_.Clear();
+}
+inline const ::google::protobuf::EnumDescriptorProto& DescriptorProto::enum_type(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.enum_type)
+  return enum_type_.Get(index);
+}
+inline ::google::protobuf::EnumDescriptorProto* DescriptorProto::mutable_enum_type(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.DescriptorProto.enum_type)
+  return enum_type_.Mutable(index);
+}
+inline ::google::protobuf::EnumDescriptorProto* DescriptorProto::add_enum_type() {
+  // @@protoc_insertion_point(field_add:google.protobuf.DescriptorProto.enum_type)
+  return enum_type_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumDescriptorProto >*
+DescriptorProto::mutable_enum_type() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.DescriptorProto.enum_type)
+  return &enum_type_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumDescriptorProto >&
+DescriptorProto::enum_type() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.DescriptorProto.enum_type)
+  return enum_type_;
+}
+
+// repeated .google.protobuf.DescriptorProto.ExtensionRange extension_range = 5;
+inline int DescriptorProto::extension_range_size() const {
+  return extension_range_.size();
+}
+inline void DescriptorProto::clear_extension_range() {
+  extension_range_.Clear();
+}
+inline const ::google::protobuf::DescriptorProto_ExtensionRange& DescriptorProto::extension_range(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.extension_range)
+  return extension_range_.Get(index);
+}
+inline ::google::protobuf::DescriptorProto_ExtensionRange* DescriptorProto::mutable_extension_range(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.DescriptorProto.extension_range)
+  return extension_range_.Mutable(index);
+}
+inline ::google::protobuf::DescriptorProto_ExtensionRange* DescriptorProto::add_extension_range() {
+  // @@protoc_insertion_point(field_add:google.protobuf.DescriptorProto.extension_range)
+  return extension_range_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto_ExtensionRange >*
+DescriptorProto::mutable_extension_range() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.DescriptorProto.extension_range)
+  return &extension_range_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto_ExtensionRange >&
+DescriptorProto::extension_range() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.DescriptorProto.extension_range)
+  return extension_range_;
+}
+
+// repeated .google.protobuf.OneofDescriptorProto oneof_decl = 8;
+inline int DescriptorProto::oneof_decl_size() const {
+  return oneof_decl_.size();
+}
+inline void DescriptorProto::clear_oneof_decl() {
+  oneof_decl_.Clear();
+}
+inline const ::google::protobuf::OneofDescriptorProto& DescriptorProto::oneof_decl(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.oneof_decl)
+  return oneof_decl_.Get(index);
+}
+inline ::google::protobuf::OneofDescriptorProto* DescriptorProto::mutable_oneof_decl(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.DescriptorProto.oneof_decl)
+  return oneof_decl_.Mutable(index);
+}
+inline ::google::protobuf::OneofDescriptorProto* DescriptorProto::add_oneof_decl() {
+  // @@protoc_insertion_point(field_add:google.protobuf.DescriptorProto.oneof_decl)
+  return oneof_decl_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::OneofDescriptorProto >*
+DescriptorProto::mutable_oneof_decl() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.DescriptorProto.oneof_decl)
+  return &oneof_decl_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::OneofDescriptorProto >&
+DescriptorProto::oneof_decl() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.DescriptorProto.oneof_decl)
+  return oneof_decl_;
+}
+
+// optional .google.protobuf.MessageOptions options = 7;
+inline bool DescriptorProto::has_options() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void DescriptorProto::set_has_options() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void DescriptorProto::clear_has_options() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void DescriptorProto::clear_options() {
+  if (options_ != NULL) options_->Clear();
+  clear_has_options();
+}
+inline const ::google::protobuf::MessageOptions& DescriptorProto::options() const {
+  const ::google::protobuf::MessageOptions* p = options_;
+  // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.options)
+  return p != NULL ? *p : *reinterpret_cast<const ::google::protobuf::MessageOptions*>(
+      &::google::protobuf::_MessageOptions_default_instance_);
+}
+inline ::google::protobuf::MessageOptions* DescriptorProto::release_options() {
+  // @@protoc_insertion_point(field_release:google.protobuf.DescriptorProto.options)
+  clear_has_options();
+  ::google::protobuf::MessageOptions* temp = options_;
+  if (GetArenaNoVirtual() != NULL) {
+    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp, NULL);
+  }
+  options_ = NULL;
+  return temp;
+}
+inline ::google::protobuf::MessageOptions* DescriptorProto::unsafe_arena_release_options() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.DescriptorProto.options)
+  clear_has_options();
+  ::google::protobuf::MessageOptions* temp = options_;
+  options_ = NULL;
+  return temp;
+}
+inline ::google::protobuf::MessageOptions* DescriptorProto::mutable_options() {
+  set_has_options();
+  if (options_ == NULL) {
+    _slow_mutable_options();
+  }
+  // @@protoc_insertion_point(field_mutable:google.protobuf.DescriptorProto.options)
+  return options_;
+}
+inline void DescriptorProto::set_allocated_options(::google::protobuf::MessageOptions* options) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete options_;
+  }
+  if (options) {
+    ::google::protobuf::Arena* submessage_arena =
+      ::google::protobuf::Arena::GetArena(options);
+    if (message_arena != submessage_arena) {
+      options = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, options, submessage_arena);
+    }
+    set_has_options();
+  } else {
+    clear_has_options();
+  }
+  options_ = options;
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.DescriptorProto.options)
+}
+
+// repeated .google.protobuf.DescriptorProto.ReservedRange reserved_range = 9;
+inline int DescriptorProto::reserved_range_size() const {
+  return reserved_range_.size();
+}
+inline void DescriptorProto::clear_reserved_range() {
+  reserved_range_.Clear();
+}
+inline const ::google::protobuf::DescriptorProto_ReservedRange& DescriptorProto::reserved_range(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.reserved_range)
+  return reserved_range_.Get(index);
+}
+inline ::google::protobuf::DescriptorProto_ReservedRange* DescriptorProto::mutable_reserved_range(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.DescriptorProto.reserved_range)
+  return reserved_range_.Mutable(index);
+}
+inline ::google::protobuf::DescriptorProto_ReservedRange* DescriptorProto::add_reserved_range() {
+  // @@protoc_insertion_point(field_add:google.protobuf.DescriptorProto.reserved_range)
+  return reserved_range_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto_ReservedRange >*
+DescriptorProto::mutable_reserved_range() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.DescriptorProto.reserved_range)
+  return &reserved_range_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::DescriptorProto_ReservedRange >&
+DescriptorProto::reserved_range() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.DescriptorProto.reserved_range)
+  return reserved_range_;
+}
+
+// repeated string reserved_name = 10;
+inline int DescriptorProto::reserved_name_size() const {
+  return reserved_name_.size();
+}
+inline void DescriptorProto::clear_reserved_name() {
+  reserved_name_.Clear();
+}
+inline const ::std::string& DescriptorProto::reserved_name(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.DescriptorProto.reserved_name)
+  return reserved_name_.Get(index);
+}
+inline ::std::string* DescriptorProto::mutable_reserved_name(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.DescriptorProto.reserved_name)
+  return reserved_name_.Mutable(index);
+}
+inline void DescriptorProto::set_reserved_name(int index, const ::std::string& value) {
+  // @@protoc_insertion_point(field_set:google.protobuf.DescriptorProto.reserved_name)
+  reserved_name_.Mutable(index)->assign(value);
+}
+#if LANG_CXX11
+inline void DescriptorProto::set_reserved_name(int index, ::std::string&& value) {
+  // @@protoc_insertion_point(field_set:google.protobuf.DescriptorProto.reserved_name)
+  reserved_name_.Mutable(index)->assign(std::move(value));
+}
+#endif
+inline void DescriptorProto::set_reserved_name(int index, const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  reserved_name_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:google.protobuf.DescriptorProto.reserved_name)
+}
+inline void DescriptorProto::set_reserved_name(int index, const char* value, size_t size) {
+  reserved_name_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.DescriptorProto.reserved_name)
+}
+inline ::std::string* DescriptorProto::add_reserved_name() {
+  // @@protoc_insertion_point(field_add_mutable:google.protobuf.DescriptorProto.reserved_name)
+  return reserved_name_.Add();
+}
+inline void DescriptorProto::add_reserved_name(const ::std::string& value) {
+  reserved_name_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:google.protobuf.DescriptorProto.reserved_name)
+}
+#if LANG_CXX11
+inline void DescriptorProto::add_reserved_name(::std::string&& value) {
+  reserved_name_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:google.protobuf.DescriptorProto.reserved_name)
+}
+#endif
+inline void DescriptorProto::add_reserved_name(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  reserved_name_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:google.protobuf.DescriptorProto.reserved_name)
+}
+inline void DescriptorProto::add_reserved_name(const char* value, size_t size) {
+  reserved_name_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:google.protobuf.DescriptorProto.reserved_name)
+}
+inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
+DescriptorProto::reserved_name() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.DescriptorProto.reserved_name)
+  return reserved_name_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::std::string>*
+DescriptorProto::mutable_reserved_name() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.DescriptorProto.reserved_name)
+  return &reserved_name_;
+}
+
+// -------------------------------------------------------------------
+
+// ExtensionRangeOptions
+
+// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
+inline int ExtensionRangeOptions::uninterpreted_option_size() const {
+  return uninterpreted_option_.size();
+}
+inline void ExtensionRangeOptions::clear_uninterpreted_option() {
+  uninterpreted_option_.Clear();
+}
+inline const ::google::protobuf::UninterpretedOption& ExtensionRangeOptions::uninterpreted_option(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.ExtensionRangeOptions.uninterpreted_option)
+  return uninterpreted_option_.Get(index);
+}
+inline ::google::protobuf::UninterpretedOption* ExtensionRangeOptions::mutable_uninterpreted_option(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.ExtensionRangeOptions.uninterpreted_option)
+  return uninterpreted_option_.Mutable(index);
+}
+inline ::google::protobuf::UninterpretedOption* ExtensionRangeOptions::add_uninterpreted_option() {
+  // @@protoc_insertion_point(field_add:google.protobuf.ExtensionRangeOptions.uninterpreted_option)
+  return uninterpreted_option_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >*
+ExtensionRangeOptions::mutable_uninterpreted_option() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.ExtensionRangeOptions.uninterpreted_option)
+  return &uninterpreted_option_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >&
+ExtensionRangeOptions::uninterpreted_option() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.ExtensionRangeOptions.uninterpreted_option)
+  return uninterpreted_option_;
+}
+
+// -------------------------------------------------------------------
+
+// FieldDescriptorProto
+
+// optional string name = 1;
+inline bool FieldDescriptorProto::has_name() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void FieldDescriptorProto::set_has_name() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void FieldDescriptorProto::clear_has_name() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void FieldDescriptorProto::clear_name() {
+  name_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+  clear_has_name();
+}
+inline const ::std::string& FieldDescriptorProto::name() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FieldDescriptorProto.name)
+  return name_.Get();
+}
+inline void FieldDescriptorProto::set_name(const ::std::string& value) {
+  set_has_name();
+  name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set:google.protobuf.FieldDescriptorProto.name)
+}
+#if LANG_CXX11
+inline void FieldDescriptorProto::set_name(::std::string&& value) {
+  set_has_name();
+  name_.Set(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.FieldDescriptorProto.name)
+}
+#endif
+inline void FieldDescriptorProto::set_name(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  set_has_name();
+  name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
+              GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_char:google.protobuf.FieldDescriptorProto.name)
+}
+inline void FieldDescriptorProto::set_name(const char* value,
+    size_t size) {
+  set_has_name();
+  name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
+      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.FieldDescriptorProto.name)
+}
+inline ::std::string* FieldDescriptorProto::mutable_name() {
+  set_has_name();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FieldDescriptorProto.name)
+  return name_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline ::std::string* FieldDescriptorProto::release_name() {
+  // @@protoc_insertion_point(field_release:google.protobuf.FieldDescriptorProto.name)
+  clear_has_name();
+  return name_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline void FieldDescriptorProto::set_allocated_name(::std::string* name) {
+  if (name != NULL) {
+    set_has_name();
+  } else {
+    clear_has_name();
+  }
+  name_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name,
+      GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FieldDescriptorProto.name)
+}
+inline ::std::string* FieldDescriptorProto::unsafe_arena_release_name() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.FieldDescriptorProto.name)
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  clear_has_name();
+  return name_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      GetArenaNoVirtual());
+}
+inline void FieldDescriptorProto::unsafe_arena_set_allocated_name(
+    ::std::string* name) {
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  if (name != NULL) {
+    set_has_name();
+  } else {
+    clear_has_name();
+  }
+  name_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      name, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.FieldDescriptorProto.name)
+}
+
+// optional int32 number = 3;
+inline bool FieldDescriptorProto::has_number() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void FieldDescriptorProto::set_has_number() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void FieldDescriptorProto::clear_has_number() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void FieldDescriptorProto::clear_number() {
+  number_ = 0;
+  clear_has_number();
+}
+inline ::google::protobuf::int32 FieldDescriptorProto::number() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FieldDescriptorProto.number)
+  return number_;
+}
+inline void FieldDescriptorProto::set_number(::google::protobuf::int32 value) {
+  set_has_number();
+  number_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.FieldDescriptorProto.number)
+}
+
+// optional .google.protobuf.FieldDescriptorProto.Label label = 4;
+inline bool FieldDescriptorProto::has_label() const {
+  return (_has_bits_[0] & 0x00000100u) != 0;
+}
+inline void FieldDescriptorProto::set_has_label() {
+  _has_bits_[0] |= 0x00000100u;
+}
+inline void FieldDescriptorProto::clear_has_label() {
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline void FieldDescriptorProto::clear_label() {
+  label_ = 1;
+  clear_has_label();
+}
+inline ::google::protobuf::FieldDescriptorProto_Label FieldDescriptorProto::label() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FieldDescriptorProto.label)
+  return static_cast< ::google::protobuf::FieldDescriptorProto_Label >(label_);
+}
+inline void FieldDescriptorProto::set_label(::google::protobuf::FieldDescriptorProto_Label value) {
+  assert(::google::protobuf::FieldDescriptorProto_Label_IsValid(value));
+  set_has_label();
+  label_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.FieldDescriptorProto.label)
+}
+
+// optional .google.protobuf.FieldDescriptorProto.Type type = 5;
+inline bool FieldDescriptorProto::has_type() const {
+  return (_has_bits_[0] & 0x00000200u) != 0;
+}
+inline void FieldDescriptorProto::set_has_type() {
+  _has_bits_[0] |= 0x00000200u;
+}
+inline void FieldDescriptorProto::clear_has_type() {
+  _has_bits_[0] &= ~0x00000200u;
+}
+inline void FieldDescriptorProto::clear_type() {
+  type_ = 1;
+  clear_has_type();
+}
+inline ::google::protobuf::FieldDescriptorProto_Type FieldDescriptorProto::type() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FieldDescriptorProto.type)
+  return static_cast< ::google::protobuf::FieldDescriptorProto_Type >(type_);
+}
+inline void FieldDescriptorProto::set_type(::google::protobuf::FieldDescriptorProto_Type value) {
+  assert(::google::protobuf::FieldDescriptorProto_Type_IsValid(value));
+  set_has_type();
+  type_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.FieldDescriptorProto.type)
+}
+
+// optional string type_name = 6;
+inline bool FieldDescriptorProto::has_type_name() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void FieldDescriptorProto::set_has_type_name() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void FieldDescriptorProto::clear_has_type_name() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void FieldDescriptorProto::clear_type_name() {
+  type_name_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+  clear_has_type_name();
+}
+inline const ::std::string& FieldDescriptorProto::type_name() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FieldDescriptorProto.type_name)
+  return type_name_.Get();
+}
+inline void FieldDescriptorProto::set_type_name(const ::std::string& value) {
+  set_has_type_name();
+  type_name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set:google.protobuf.FieldDescriptorProto.type_name)
+}
+#if LANG_CXX11
+inline void FieldDescriptorProto::set_type_name(::std::string&& value) {
+  set_has_type_name();
+  type_name_.Set(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.FieldDescriptorProto.type_name)
+}
+#endif
+inline void FieldDescriptorProto::set_type_name(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  set_has_type_name();
+  type_name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
+              GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_char:google.protobuf.FieldDescriptorProto.type_name)
+}
+inline void FieldDescriptorProto::set_type_name(const char* value,
+    size_t size) {
+  set_has_type_name();
+  type_name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
+      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.FieldDescriptorProto.type_name)
+}
+inline ::std::string* FieldDescriptorProto::mutable_type_name() {
+  set_has_type_name();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FieldDescriptorProto.type_name)
+  return type_name_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline ::std::string* FieldDescriptorProto::release_type_name() {
+  // @@protoc_insertion_point(field_release:google.protobuf.FieldDescriptorProto.type_name)
+  clear_has_type_name();
+  return type_name_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline void FieldDescriptorProto::set_allocated_type_name(::std::string* type_name) {
+  if (type_name != NULL) {
+    set_has_type_name();
+  } else {
+    clear_has_type_name();
+  }
+  type_name_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), type_name,
+      GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FieldDescriptorProto.type_name)
+}
+inline ::std::string* FieldDescriptorProto::unsafe_arena_release_type_name() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.FieldDescriptorProto.type_name)
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  clear_has_type_name();
+  return type_name_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      GetArenaNoVirtual());
+}
+inline void FieldDescriptorProto::unsafe_arena_set_allocated_type_name(
+    ::std::string* type_name) {
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  if (type_name != NULL) {
+    set_has_type_name();
+  } else {
+    clear_has_type_name();
+  }
+  type_name_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      type_name, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.FieldDescriptorProto.type_name)
+}
+
+// optional string extendee = 2;
+inline bool FieldDescriptorProto::has_extendee() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void FieldDescriptorProto::set_has_extendee() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void FieldDescriptorProto::clear_has_extendee() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void FieldDescriptorProto::clear_extendee() {
+  extendee_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+  clear_has_extendee();
+}
+inline const ::std::string& FieldDescriptorProto::extendee() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FieldDescriptorProto.extendee)
+  return extendee_.Get();
+}
+inline void FieldDescriptorProto::set_extendee(const ::std::string& value) {
+  set_has_extendee();
+  extendee_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set:google.protobuf.FieldDescriptorProto.extendee)
+}
+#if LANG_CXX11
+inline void FieldDescriptorProto::set_extendee(::std::string&& value) {
+  set_has_extendee();
+  extendee_.Set(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.FieldDescriptorProto.extendee)
+}
+#endif
+inline void FieldDescriptorProto::set_extendee(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  set_has_extendee();
+  extendee_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
+              GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_char:google.protobuf.FieldDescriptorProto.extendee)
+}
+inline void FieldDescriptorProto::set_extendee(const char* value,
+    size_t size) {
+  set_has_extendee();
+  extendee_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
+      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.FieldDescriptorProto.extendee)
+}
+inline ::std::string* FieldDescriptorProto::mutable_extendee() {
+  set_has_extendee();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FieldDescriptorProto.extendee)
+  return extendee_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline ::std::string* FieldDescriptorProto::release_extendee() {
+  // @@protoc_insertion_point(field_release:google.protobuf.FieldDescriptorProto.extendee)
+  clear_has_extendee();
+  return extendee_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline void FieldDescriptorProto::set_allocated_extendee(::std::string* extendee) {
+  if (extendee != NULL) {
+    set_has_extendee();
+  } else {
+    clear_has_extendee();
+  }
+  extendee_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), extendee,
+      GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FieldDescriptorProto.extendee)
+}
+inline ::std::string* FieldDescriptorProto::unsafe_arena_release_extendee() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.FieldDescriptorProto.extendee)
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  clear_has_extendee();
+  return extendee_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      GetArenaNoVirtual());
+}
+inline void FieldDescriptorProto::unsafe_arena_set_allocated_extendee(
+    ::std::string* extendee) {
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  if (extendee != NULL) {
+    set_has_extendee();
+  } else {
+    clear_has_extendee();
+  }
+  extendee_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      extendee, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.FieldDescriptorProto.extendee)
+}
+
+// optional string default_value = 7;
+inline bool FieldDescriptorProto::has_default_value() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void FieldDescriptorProto::set_has_default_value() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void FieldDescriptorProto::clear_has_default_value() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void FieldDescriptorProto::clear_default_value() {
+  default_value_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+  clear_has_default_value();
+}
+inline const ::std::string& FieldDescriptorProto::default_value() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FieldDescriptorProto.default_value)
+  return default_value_.Get();
+}
+inline void FieldDescriptorProto::set_default_value(const ::std::string& value) {
+  set_has_default_value();
+  default_value_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set:google.protobuf.FieldDescriptorProto.default_value)
+}
+#if LANG_CXX11
+inline void FieldDescriptorProto::set_default_value(::std::string&& value) {
+  set_has_default_value();
+  default_value_.Set(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.FieldDescriptorProto.default_value)
+}
+#endif
+inline void FieldDescriptorProto::set_default_value(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  set_has_default_value();
+  default_value_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
+              GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_char:google.protobuf.FieldDescriptorProto.default_value)
+}
+inline void FieldDescriptorProto::set_default_value(const char* value,
+    size_t size) {
+  set_has_default_value();
+  default_value_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
+      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.FieldDescriptorProto.default_value)
+}
+inline ::std::string* FieldDescriptorProto::mutable_default_value() {
+  set_has_default_value();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FieldDescriptorProto.default_value)
+  return default_value_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline ::std::string* FieldDescriptorProto::release_default_value() {
+  // @@protoc_insertion_point(field_release:google.protobuf.FieldDescriptorProto.default_value)
+  clear_has_default_value();
+  return default_value_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline void FieldDescriptorProto::set_allocated_default_value(::std::string* default_value) {
+  if (default_value != NULL) {
+    set_has_default_value();
+  } else {
+    clear_has_default_value();
+  }
+  default_value_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), default_value,
+      GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FieldDescriptorProto.default_value)
+}
+inline ::std::string* FieldDescriptorProto::unsafe_arena_release_default_value() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.FieldDescriptorProto.default_value)
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  clear_has_default_value();
+  return default_value_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      GetArenaNoVirtual());
+}
+inline void FieldDescriptorProto::unsafe_arena_set_allocated_default_value(
+    ::std::string* default_value) {
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  if (default_value != NULL) {
+    set_has_default_value();
+  } else {
+    clear_has_default_value();
+  }
+  default_value_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      default_value, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.FieldDescriptorProto.default_value)
+}
+
+// optional int32 oneof_index = 9;
+inline bool FieldDescriptorProto::has_oneof_index() const {
+  return (_has_bits_[0] & 0x00000080u) != 0;
+}
+inline void FieldDescriptorProto::set_has_oneof_index() {
+  _has_bits_[0] |= 0x00000080u;
+}
+inline void FieldDescriptorProto::clear_has_oneof_index() {
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline void FieldDescriptorProto::clear_oneof_index() {
+  oneof_index_ = 0;
+  clear_has_oneof_index();
+}
+inline ::google::protobuf::int32 FieldDescriptorProto::oneof_index() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FieldDescriptorProto.oneof_index)
+  return oneof_index_;
+}
+inline void FieldDescriptorProto::set_oneof_index(::google::protobuf::int32 value) {
+  set_has_oneof_index();
+  oneof_index_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.FieldDescriptorProto.oneof_index)
+}
+
+// optional string json_name = 10;
+inline bool FieldDescriptorProto::has_json_name() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void FieldDescriptorProto::set_has_json_name() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void FieldDescriptorProto::clear_has_json_name() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void FieldDescriptorProto::clear_json_name() {
+  json_name_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+  clear_has_json_name();
+}
+inline const ::std::string& FieldDescriptorProto::json_name() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FieldDescriptorProto.json_name)
+  return json_name_.Get();
+}
+inline void FieldDescriptorProto::set_json_name(const ::std::string& value) {
+  set_has_json_name();
+  json_name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set:google.protobuf.FieldDescriptorProto.json_name)
+}
+#if LANG_CXX11
+inline void FieldDescriptorProto::set_json_name(::std::string&& value) {
+  set_has_json_name();
+  json_name_.Set(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.FieldDescriptorProto.json_name)
+}
+#endif
+inline void FieldDescriptorProto::set_json_name(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  set_has_json_name();
+  json_name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
+              GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_char:google.protobuf.FieldDescriptorProto.json_name)
+}
+inline void FieldDescriptorProto::set_json_name(const char* value,
+    size_t size) {
+  set_has_json_name();
+  json_name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
+      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.FieldDescriptorProto.json_name)
+}
+inline ::std::string* FieldDescriptorProto::mutable_json_name() {
+  set_has_json_name();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FieldDescriptorProto.json_name)
+  return json_name_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline ::std::string* FieldDescriptorProto::release_json_name() {
+  // @@protoc_insertion_point(field_release:google.protobuf.FieldDescriptorProto.json_name)
+  clear_has_json_name();
+  return json_name_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline void FieldDescriptorProto::set_allocated_json_name(::std::string* json_name) {
+  if (json_name != NULL) {
+    set_has_json_name();
+  } else {
+    clear_has_json_name();
+  }
+  json_name_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), json_name,
+      GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FieldDescriptorProto.json_name)
+}
+inline ::std::string* FieldDescriptorProto::unsafe_arena_release_json_name() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.FieldDescriptorProto.json_name)
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  clear_has_json_name();
+  return json_name_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      GetArenaNoVirtual());
+}
+inline void FieldDescriptorProto::unsafe_arena_set_allocated_json_name(
+    ::std::string* json_name) {
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  if (json_name != NULL) {
+    set_has_json_name();
+  } else {
+    clear_has_json_name();
+  }
+  json_name_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      json_name, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.FieldDescriptorProto.json_name)
+}
+
+// optional .google.protobuf.FieldOptions options = 8;
+inline bool FieldDescriptorProto::has_options() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void FieldDescriptorProto::set_has_options() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void FieldDescriptorProto::clear_has_options() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void FieldDescriptorProto::clear_options() {
+  if (options_ != NULL) options_->Clear();
+  clear_has_options();
+}
+inline const ::google::protobuf::FieldOptions& FieldDescriptorProto::options() const {
+  const ::google::protobuf::FieldOptions* p = options_;
+  // @@protoc_insertion_point(field_get:google.protobuf.FieldDescriptorProto.options)
+  return p != NULL ? *p : *reinterpret_cast<const ::google::protobuf::FieldOptions*>(
+      &::google::protobuf::_FieldOptions_default_instance_);
+}
+inline ::google::protobuf::FieldOptions* FieldDescriptorProto::release_options() {
+  // @@protoc_insertion_point(field_release:google.protobuf.FieldDescriptorProto.options)
+  clear_has_options();
+  ::google::protobuf::FieldOptions* temp = options_;
+  if (GetArenaNoVirtual() != NULL) {
+    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp, NULL);
+  }
+  options_ = NULL;
+  return temp;
+}
+inline ::google::protobuf::FieldOptions* FieldDescriptorProto::unsafe_arena_release_options() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.FieldDescriptorProto.options)
+  clear_has_options();
+  ::google::protobuf::FieldOptions* temp = options_;
+  options_ = NULL;
+  return temp;
+}
+inline ::google::protobuf::FieldOptions* FieldDescriptorProto::mutable_options() {
+  set_has_options();
+  if (options_ == NULL) {
+    _slow_mutable_options();
+  }
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FieldDescriptorProto.options)
+  return options_;
+}
+inline void FieldDescriptorProto::set_allocated_options(::google::protobuf::FieldOptions* options) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete options_;
+  }
+  if (options) {
+    ::google::protobuf::Arena* submessage_arena =
+      ::google::protobuf::Arena::GetArena(options);
+    if (message_arena != submessage_arena) {
+      options = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, options, submessage_arena);
+    }
+    set_has_options();
+  } else {
+    clear_has_options();
+  }
+  options_ = options;
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FieldDescriptorProto.options)
+}
+
+// -------------------------------------------------------------------
+
+// OneofDescriptorProto
+
+// optional string name = 1;
+inline bool OneofDescriptorProto::has_name() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void OneofDescriptorProto::set_has_name() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void OneofDescriptorProto::clear_has_name() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void OneofDescriptorProto::clear_name() {
+  name_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+  clear_has_name();
+}
+inline const ::std::string& OneofDescriptorProto::name() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.OneofDescriptorProto.name)
+  return name_.Get();
+}
+inline void OneofDescriptorProto::set_name(const ::std::string& value) {
+  set_has_name();
+  name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set:google.protobuf.OneofDescriptorProto.name)
+}
+#if LANG_CXX11
+inline void OneofDescriptorProto::set_name(::std::string&& value) {
+  set_has_name();
+  name_.Set(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.OneofDescriptorProto.name)
+}
+#endif
+inline void OneofDescriptorProto::set_name(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  set_has_name();
+  name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
+              GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_char:google.protobuf.OneofDescriptorProto.name)
+}
+inline void OneofDescriptorProto::set_name(const char* value,
+    size_t size) {
+  set_has_name();
+  name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
+      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.OneofDescriptorProto.name)
+}
+inline ::std::string* OneofDescriptorProto::mutable_name() {
+  set_has_name();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.OneofDescriptorProto.name)
+  return name_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline ::std::string* OneofDescriptorProto::release_name() {
+  // @@protoc_insertion_point(field_release:google.protobuf.OneofDescriptorProto.name)
+  clear_has_name();
+  return name_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline void OneofDescriptorProto::set_allocated_name(::std::string* name) {
+  if (name != NULL) {
+    set_has_name();
+  } else {
+    clear_has_name();
+  }
+  name_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name,
+      GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.OneofDescriptorProto.name)
+}
+inline ::std::string* OneofDescriptorProto::unsafe_arena_release_name() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.OneofDescriptorProto.name)
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  clear_has_name();
+  return name_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      GetArenaNoVirtual());
+}
+inline void OneofDescriptorProto::unsafe_arena_set_allocated_name(
+    ::std::string* name) {
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  if (name != NULL) {
+    set_has_name();
+  } else {
+    clear_has_name();
+  }
+  name_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      name, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.OneofDescriptorProto.name)
+}
+
+// optional .google.protobuf.OneofOptions options = 2;
+inline bool OneofDescriptorProto::has_options() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void OneofDescriptorProto::set_has_options() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void OneofDescriptorProto::clear_has_options() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void OneofDescriptorProto::clear_options() {
+  if (options_ != NULL) options_->Clear();
+  clear_has_options();
+}
+inline const ::google::protobuf::OneofOptions& OneofDescriptorProto::options() const {
+  const ::google::protobuf::OneofOptions* p = options_;
+  // @@protoc_insertion_point(field_get:google.protobuf.OneofDescriptorProto.options)
+  return p != NULL ? *p : *reinterpret_cast<const ::google::protobuf::OneofOptions*>(
+      &::google::protobuf::_OneofOptions_default_instance_);
+}
+inline ::google::protobuf::OneofOptions* OneofDescriptorProto::release_options() {
+  // @@protoc_insertion_point(field_release:google.protobuf.OneofDescriptorProto.options)
+  clear_has_options();
+  ::google::protobuf::OneofOptions* temp = options_;
+  if (GetArenaNoVirtual() != NULL) {
+    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp, NULL);
+  }
+  options_ = NULL;
+  return temp;
+}
+inline ::google::protobuf::OneofOptions* OneofDescriptorProto::unsafe_arena_release_options() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.OneofDescriptorProto.options)
+  clear_has_options();
+  ::google::protobuf::OneofOptions* temp = options_;
+  options_ = NULL;
+  return temp;
+}
+inline ::google::protobuf::OneofOptions* OneofDescriptorProto::mutable_options() {
+  set_has_options();
+  if (options_ == NULL) {
+    _slow_mutable_options();
+  }
+  // @@protoc_insertion_point(field_mutable:google.protobuf.OneofDescriptorProto.options)
+  return options_;
+}
+inline void OneofDescriptorProto::set_allocated_options(::google::protobuf::OneofOptions* options) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete options_;
+  }
+  if (options) {
+    ::google::protobuf::Arena* submessage_arena =
+      ::google::protobuf::Arena::GetArena(options);
+    if (message_arena != submessage_arena) {
+      options = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, options, submessage_arena);
+    }
+    set_has_options();
+  } else {
+    clear_has_options();
+  }
+  options_ = options;
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.OneofDescriptorProto.options)
+}
+
+// -------------------------------------------------------------------
+
+// EnumDescriptorProto_EnumReservedRange
+
+// optional int32 start = 1;
+inline bool EnumDescriptorProto_EnumReservedRange::has_start() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void EnumDescriptorProto_EnumReservedRange::set_has_start() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void EnumDescriptorProto_EnumReservedRange::clear_has_start() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void EnumDescriptorProto_EnumReservedRange::clear_start() {
+  start_ = 0;
+  clear_has_start();
+}
+inline ::google::protobuf::int32 EnumDescriptorProto_EnumReservedRange::start() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.EnumDescriptorProto.EnumReservedRange.start)
+  return start_;
+}
+inline void EnumDescriptorProto_EnumReservedRange::set_start(::google::protobuf::int32 value) {
+  set_has_start();
+  start_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.EnumDescriptorProto.EnumReservedRange.start)
+}
+
+// optional int32 end = 2;
+inline bool EnumDescriptorProto_EnumReservedRange::has_end() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void EnumDescriptorProto_EnumReservedRange::set_has_end() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void EnumDescriptorProto_EnumReservedRange::clear_has_end() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void EnumDescriptorProto_EnumReservedRange::clear_end() {
+  end_ = 0;
+  clear_has_end();
+}
+inline ::google::protobuf::int32 EnumDescriptorProto_EnumReservedRange::end() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.EnumDescriptorProto.EnumReservedRange.end)
+  return end_;
+}
+inline void EnumDescriptorProto_EnumReservedRange::set_end(::google::protobuf::int32 value) {
+  set_has_end();
+  end_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.EnumDescriptorProto.EnumReservedRange.end)
+}
+
+// -------------------------------------------------------------------
+
+// EnumDescriptorProto
+
+// optional string name = 1;
+inline bool EnumDescriptorProto::has_name() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void EnumDescriptorProto::set_has_name() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void EnumDescriptorProto::clear_has_name() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void EnumDescriptorProto::clear_name() {
+  name_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+  clear_has_name();
+}
+inline const ::std::string& EnumDescriptorProto::name() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.EnumDescriptorProto.name)
+  return name_.Get();
+}
+inline void EnumDescriptorProto::set_name(const ::std::string& value) {
+  set_has_name();
+  name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set:google.protobuf.EnumDescriptorProto.name)
+}
+#if LANG_CXX11
+inline void EnumDescriptorProto::set_name(::std::string&& value) {
+  set_has_name();
+  name_.Set(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.EnumDescriptorProto.name)
+}
+#endif
+inline void EnumDescriptorProto::set_name(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  set_has_name();
+  name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
+              GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_char:google.protobuf.EnumDescriptorProto.name)
+}
+inline void EnumDescriptorProto::set_name(const char* value,
+    size_t size) {
+  set_has_name();
+  name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
+      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.EnumDescriptorProto.name)
+}
+inline ::std::string* EnumDescriptorProto::mutable_name() {
+  set_has_name();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.EnumDescriptorProto.name)
+  return name_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline ::std::string* EnumDescriptorProto::release_name() {
+  // @@protoc_insertion_point(field_release:google.protobuf.EnumDescriptorProto.name)
+  clear_has_name();
+  return name_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline void EnumDescriptorProto::set_allocated_name(::std::string* name) {
+  if (name != NULL) {
+    set_has_name();
+  } else {
+    clear_has_name();
+  }
+  name_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name,
+      GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.EnumDescriptorProto.name)
+}
+inline ::std::string* EnumDescriptorProto::unsafe_arena_release_name() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.EnumDescriptorProto.name)
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  clear_has_name();
+  return name_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      GetArenaNoVirtual());
+}
+inline void EnumDescriptorProto::unsafe_arena_set_allocated_name(
+    ::std::string* name) {
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  if (name != NULL) {
+    set_has_name();
+  } else {
+    clear_has_name();
+  }
+  name_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      name, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.EnumDescriptorProto.name)
+}
+
+// repeated .google.protobuf.EnumValueDescriptorProto value = 2;
+inline int EnumDescriptorProto::value_size() const {
+  return value_.size();
+}
+inline void EnumDescriptorProto::clear_value() {
+  value_.Clear();
+}
+inline const ::google::protobuf::EnumValueDescriptorProto& EnumDescriptorProto::value(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.EnumDescriptorProto.value)
+  return value_.Get(index);
+}
+inline ::google::protobuf::EnumValueDescriptorProto* EnumDescriptorProto::mutable_value(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.EnumDescriptorProto.value)
+  return value_.Mutable(index);
+}
+inline ::google::protobuf::EnumValueDescriptorProto* EnumDescriptorProto::add_value() {
+  // @@protoc_insertion_point(field_add:google.protobuf.EnumDescriptorProto.value)
+  return value_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumValueDescriptorProto >*
+EnumDescriptorProto::mutable_value() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.EnumDescriptorProto.value)
+  return &value_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumValueDescriptorProto >&
+EnumDescriptorProto::value() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.EnumDescriptorProto.value)
+  return value_;
+}
+
+// optional .google.protobuf.EnumOptions options = 3;
+inline bool EnumDescriptorProto::has_options() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void EnumDescriptorProto::set_has_options() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void EnumDescriptorProto::clear_has_options() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void EnumDescriptorProto::clear_options() {
+  if (options_ != NULL) options_->Clear();
+  clear_has_options();
+}
+inline const ::google::protobuf::EnumOptions& EnumDescriptorProto::options() const {
+  const ::google::protobuf::EnumOptions* p = options_;
+  // @@protoc_insertion_point(field_get:google.protobuf.EnumDescriptorProto.options)
+  return p != NULL ? *p : *reinterpret_cast<const ::google::protobuf::EnumOptions*>(
+      &::google::protobuf::_EnumOptions_default_instance_);
+}
+inline ::google::protobuf::EnumOptions* EnumDescriptorProto::release_options() {
+  // @@protoc_insertion_point(field_release:google.protobuf.EnumDescriptorProto.options)
+  clear_has_options();
+  ::google::protobuf::EnumOptions* temp = options_;
+  if (GetArenaNoVirtual() != NULL) {
+    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp, NULL);
+  }
+  options_ = NULL;
+  return temp;
+}
+inline ::google::protobuf::EnumOptions* EnumDescriptorProto::unsafe_arena_release_options() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.EnumDescriptorProto.options)
+  clear_has_options();
+  ::google::protobuf::EnumOptions* temp = options_;
+  options_ = NULL;
+  return temp;
+}
+inline ::google::protobuf::EnumOptions* EnumDescriptorProto::mutable_options() {
+  set_has_options();
+  if (options_ == NULL) {
+    _slow_mutable_options();
+  }
+  // @@protoc_insertion_point(field_mutable:google.protobuf.EnumDescriptorProto.options)
+  return options_;
+}
+inline void EnumDescriptorProto::set_allocated_options(::google::protobuf::EnumOptions* options) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete options_;
+  }
+  if (options) {
+    ::google::protobuf::Arena* submessage_arena =
+      ::google::protobuf::Arena::GetArena(options);
+    if (message_arena != submessage_arena) {
+      options = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, options, submessage_arena);
+    }
+    set_has_options();
+  } else {
+    clear_has_options();
+  }
+  options_ = options;
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.EnumDescriptorProto.options)
+}
+
+// repeated .google.protobuf.EnumDescriptorProto.EnumReservedRange reserved_range = 4;
+inline int EnumDescriptorProto::reserved_range_size() const {
+  return reserved_range_.size();
+}
+inline void EnumDescriptorProto::clear_reserved_range() {
+  reserved_range_.Clear();
+}
+inline const ::google::protobuf::EnumDescriptorProto_EnumReservedRange& EnumDescriptorProto::reserved_range(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.EnumDescriptorProto.reserved_range)
+  return reserved_range_.Get(index);
+}
+inline ::google::protobuf::EnumDescriptorProto_EnumReservedRange* EnumDescriptorProto::mutable_reserved_range(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.EnumDescriptorProto.reserved_range)
+  return reserved_range_.Mutable(index);
+}
+inline ::google::protobuf::EnumDescriptorProto_EnumReservedRange* EnumDescriptorProto::add_reserved_range() {
+  // @@protoc_insertion_point(field_add:google.protobuf.EnumDescriptorProto.reserved_range)
+  return reserved_range_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumDescriptorProto_EnumReservedRange >*
+EnumDescriptorProto::mutable_reserved_range() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.EnumDescriptorProto.reserved_range)
+  return &reserved_range_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumDescriptorProto_EnumReservedRange >&
+EnumDescriptorProto::reserved_range() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.EnumDescriptorProto.reserved_range)
+  return reserved_range_;
+}
+
+// repeated string reserved_name = 5;
+inline int EnumDescriptorProto::reserved_name_size() const {
+  return reserved_name_.size();
+}
+inline void EnumDescriptorProto::clear_reserved_name() {
+  reserved_name_.Clear();
+}
+inline const ::std::string& EnumDescriptorProto::reserved_name(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.EnumDescriptorProto.reserved_name)
+  return reserved_name_.Get(index);
+}
+inline ::std::string* EnumDescriptorProto::mutable_reserved_name(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.EnumDescriptorProto.reserved_name)
+  return reserved_name_.Mutable(index);
+}
+inline void EnumDescriptorProto::set_reserved_name(int index, const ::std::string& value) {
+  // @@protoc_insertion_point(field_set:google.protobuf.EnumDescriptorProto.reserved_name)
+  reserved_name_.Mutable(index)->assign(value);
+}
+#if LANG_CXX11
+inline void EnumDescriptorProto::set_reserved_name(int index, ::std::string&& value) {
+  // @@protoc_insertion_point(field_set:google.protobuf.EnumDescriptorProto.reserved_name)
+  reserved_name_.Mutable(index)->assign(std::move(value));
+}
+#endif
+inline void EnumDescriptorProto::set_reserved_name(int index, const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  reserved_name_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:google.protobuf.EnumDescriptorProto.reserved_name)
+}
+inline void EnumDescriptorProto::set_reserved_name(int index, const char* value, size_t size) {
+  reserved_name_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.EnumDescriptorProto.reserved_name)
+}
+inline ::std::string* EnumDescriptorProto::add_reserved_name() {
+  // @@protoc_insertion_point(field_add_mutable:google.protobuf.EnumDescriptorProto.reserved_name)
+  return reserved_name_.Add();
+}
+inline void EnumDescriptorProto::add_reserved_name(const ::std::string& value) {
+  reserved_name_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:google.protobuf.EnumDescriptorProto.reserved_name)
+}
+#if LANG_CXX11
+inline void EnumDescriptorProto::add_reserved_name(::std::string&& value) {
+  reserved_name_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:google.protobuf.EnumDescriptorProto.reserved_name)
+}
+#endif
+inline void EnumDescriptorProto::add_reserved_name(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  reserved_name_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:google.protobuf.EnumDescriptorProto.reserved_name)
+}
+inline void EnumDescriptorProto::add_reserved_name(const char* value, size_t size) {
+  reserved_name_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:google.protobuf.EnumDescriptorProto.reserved_name)
+}
+inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
+EnumDescriptorProto::reserved_name() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.EnumDescriptorProto.reserved_name)
+  return reserved_name_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::std::string>*
+EnumDescriptorProto::mutable_reserved_name() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.EnumDescriptorProto.reserved_name)
+  return &reserved_name_;
+}
+
+// -------------------------------------------------------------------
+
+// EnumValueDescriptorProto
+
+// optional string name = 1;
+inline bool EnumValueDescriptorProto::has_name() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void EnumValueDescriptorProto::set_has_name() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void EnumValueDescriptorProto::clear_has_name() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void EnumValueDescriptorProto::clear_name() {
+  name_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+  clear_has_name();
+}
+inline const ::std::string& EnumValueDescriptorProto::name() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.EnumValueDescriptorProto.name)
+  return name_.Get();
+}
+inline void EnumValueDescriptorProto::set_name(const ::std::string& value) {
+  set_has_name();
+  name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set:google.protobuf.EnumValueDescriptorProto.name)
+}
+#if LANG_CXX11
+inline void EnumValueDescriptorProto::set_name(::std::string&& value) {
+  set_has_name();
+  name_.Set(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.EnumValueDescriptorProto.name)
+}
+#endif
+inline void EnumValueDescriptorProto::set_name(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  set_has_name();
+  name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
+              GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_char:google.protobuf.EnumValueDescriptorProto.name)
+}
+inline void EnumValueDescriptorProto::set_name(const char* value,
+    size_t size) {
+  set_has_name();
+  name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
+      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.EnumValueDescriptorProto.name)
+}
+inline ::std::string* EnumValueDescriptorProto::mutable_name() {
+  set_has_name();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.EnumValueDescriptorProto.name)
+  return name_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline ::std::string* EnumValueDescriptorProto::release_name() {
+  // @@protoc_insertion_point(field_release:google.protobuf.EnumValueDescriptorProto.name)
+  clear_has_name();
+  return name_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline void EnumValueDescriptorProto::set_allocated_name(::std::string* name) {
+  if (name != NULL) {
+    set_has_name();
+  } else {
+    clear_has_name();
+  }
+  name_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name,
+      GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.EnumValueDescriptorProto.name)
+}
+inline ::std::string* EnumValueDescriptorProto::unsafe_arena_release_name() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.EnumValueDescriptorProto.name)
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  clear_has_name();
+  return name_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      GetArenaNoVirtual());
+}
+inline void EnumValueDescriptorProto::unsafe_arena_set_allocated_name(
+    ::std::string* name) {
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  if (name != NULL) {
+    set_has_name();
+  } else {
+    clear_has_name();
+  }
+  name_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      name, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.EnumValueDescriptorProto.name)
+}
+
+// optional int32 number = 2;
+inline bool EnumValueDescriptorProto::has_number() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void EnumValueDescriptorProto::set_has_number() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void EnumValueDescriptorProto::clear_has_number() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void EnumValueDescriptorProto::clear_number() {
+  number_ = 0;
+  clear_has_number();
+}
+inline ::google::protobuf::int32 EnumValueDescriptorProto::number() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.EnumValueDescriptorProto.number)
+  return number_;
+}
+inline void EnumValueDescriptorProto::set_number(::google::protobuf::int32 value) {
+  set_has_number();
+  number_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.EnumValueDescriptorProto.number)
+}
+
+// optional .google.protobuf.EnumValueOptions options = 3;
+inline bool EnumValueDescriptorProto::has_options() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void EnumValueDescriptorProto::set_has_options() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void EnumValueDescriptorProto::clear_has_options() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void EnumValueDescriptorProto::clear_options() {
+  if (options_ != NULL) options_->Clear();
+  clear_has_options();
+}
+inline const ::google::protobuf::EnumValueOptions& EnumValueDescriptorProto::options() const {
+  const ::google::protobuf::EnumValueOptions* p = options_;
+  // @@protoc_insertion_point(field_get:google.protobuf.EnumValueDescriptorProto.options)
+  return p != NULL ? *p : *reinterpret_cast<const ::google::protobuf::EnumValueOptions*>(
+      &::google::protobuf::_EnumValueOptions_default_instance_);
+}
+inline ::google::protobuf::EnumValueOptions* EnumValueDescriptorProto::release_options() {
+  // @@protoc_insertion_point(field_release:google.protobuf.EnumValueDescriptorProto.options)
+  clear_has_options();
+  ::google::protobuf::EnumValueOptions* temp = options_;
+  if (GetArenaNoVirtual() != NULL) {
+    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp, NULL);
+  }
+  options_ = NULL;
+  return temp;
+}
+inline ::google::protobuf::EnumValueOptions* EnumValueDescriptorProto::unsafe_arena_release_options() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.EnumValueDescriptorProto.options)
+  clear_has_options();
+  ::google::protobuf::EnumValueOptions* temp = options_;
+  options_ = NULL;
+  return temp;
+}
+inline ::google::protobuf::EnumValueOptions* EnumValueDescriptorProto::mutable_options() {
+  set_has_options();
+  if (options_ == NULL) {
+    _slow_mutable_options();
+  }
+  // @@protoc_insertion_point(field_mutable:google.protobuf.EnumValueDescriptorProto.options)
+  return options_;
+}
+inline void EnumValueDescriptorProto::set_allocated_options(::google::protobuf::EnumValueOptions* options) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete options_;
+  }
+  if (options) {
+    ::google::protobuf::Arena* submessage_arena =
+      ::google::protobuf::Arena::GetArena(options);
+    if (message_arena != submessage_arena) {
+      options = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, options, submessage_arena);
+    }
+    set_has_options();
+  } else {
+    clear_has_options();
+  }
+  options_ = options;
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.EnumValueDescriptorProto.options)
+}
+
+// -------------------------------------------------------------------
+
+// ServiceDescriptorProto
+
+// optional string name = 1;
+inline bool ServiceDescriptorProto::has_name() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ServiceDescriptorProto::set_has_name() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ServiceDescriptorProto::clear_has_name() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ServiceDescriptorProto::clear_name() {
+  name_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+  clear_has_name();
+}
+inline const ::std::string& ServiceDescriptorProto::name() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.ServiceDescriptorProto.name)
+  return name_.Get();
+}
+inline void ServiceDescriptorProto::set_name(const ::std::string& value) {
+  set_has_name();
+  name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set:google.protobuf.ServiceDescriptorProto.name)
+}
+#if LANG_CXX11
+inline void ServiceDescriptorProto::set_name(::std::string&& value) {
+  set_has_name();
+  name_.Set(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.ServiceDescriptorProto.name)
+}
+#endif
+inline void ServiceDescriptorProto::set_name(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  set_has_name();
+  name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
+              GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_char:google.protobuf.ServiceDescriptorProto.name)
+}
+inline void ServiceDescriptorProto::set_name(const char* value,
+    size_t size) {
+  set_has_name();
+  name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
+      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.ServiceDescriptorProto.name)
+}
+inline ::std::string* ServiceDescriptorProto::mutable_name() {
+  set_has_name();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.ServiceDescriptorProto.name)
+  return name_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline ::std::string* ServiceDescriptorProto::release_name() {
+  // @@protoc_insertion_point(field_release:google.protobuf.ServiceDescriptorProto.name)
+  clear_has_name();
+  return name_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline void ServiceDescriptorProto::set_allocated_name(::std::string* name) {
+  if (name != NULL) {
+    set_has_name();
+  } else {
+    clear_has_name();
+  }
+  name_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name,
+      GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.ServiceDescriptorProto.name)
+}
+inline ::std::string* ServiceDescriptorProto::unsafe_arena_release_name() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.ServiceDescriptorProto.name)
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  clear_has_name();
+  return name_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      GetArenaNoVirtual());
+}
+inline void ServiceDescriptorProto::unsafe_arena_set_allocated_name(
+    ::std::string* name) {
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  if (name != NULL) {
+    set_has_name();
+  } else {
+    clear_has_name();
+  }
+  name_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      name, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.ServiceDescriptorProto.name)
+}
+
+// repeated .google.protobuf.MethodDescriptorProto method = 2;
+inline int ServiceDescriptorProto::method_size() const {
+  return method_.size();
+}
+inline void ServiceDescriptorProto::clear_method() {
+  method_.Clear();
+}
+inline const ::google::protobuf::MethodDescriptorProto& ServiceDescriptorProto::method(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.ServiceDescriptorProto.method)
+  return method_.Get(index);
+}
+inline ::google::protobuf::MethodDescriptorProto* ServiceDescriptorProto::mutable_method(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.ServiceDescriptorProto.method)
+  return method_.Mutable(index);
+}
+inline ::google::protobuf::MethodDescriptorProto* ServiceDescriptorProto::add_method() {
+  // @@protoc_insertion_point(field_add:google.protobuf.ServiceDescriptorProto.method)
+  return method_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::MethodDescriptorProto >*
+ServiceDescriptorProto::mutable_method() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.ServiceDescriptorProto.method)
+  return &method_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::MethodDescriptorProto >&
+ServiceDescriptorProto::method() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.ServiceDescriptorProto.method)
+  return method_;
+}
+
+// optional .google.protobuf.ServiceOptions options = 3;
+inline bool ServiceDescriptorProto::has_options() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void ServiceDescriptorProto::set_has_options() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void ServiceDescriptorProto::clear_has_options() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void ServiceDescriptorProto::clear_options() {
+  if (options_ != NULL) options_->Clear();
+  clear_has_options();
+}
+inline const ::google::protobuf::ServiceOptions& ServiceDescriptorProto::options() const {
+  const ::google::protobuf::ServiceOptions* p = options_;
+  // @@protoc_insertion_point(field_get:google.protobuf.ServiceDescriptorProto.options)
+  return p != NULL ? *p : *reinterpret_cast<const ::google::protobuf::ServiceOptions*>(
+      &::google::protobuf::_ServiceOptions_default_instance_);
+}
+inline ::google::protobuf::ServiceOptions* ServiceDescriptorProto::release_options() {
+  // @@protoc_insertion_point(field_release:google.protobuf.ServiceDescriptorProto.options)
+  clear_has_options();
+  ::google::protobuf::ServiceOptions* temp = options_;
+  if (GetArenaNoVirtual() != NULL) {
+    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp, NULL);
+  }
+  options_ = NULL;
+  return temp;
+}
+inline ::google::protobuf::ServiceOptions* ServiceDescriptorProto::unsafe_arena_release_options() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.ServiceDescriptorProto.options)
+  clear_has_options();
+  ::google::protobuf::ServiceOptions* temp = options_;
+  options_ = NULL;
+  return temp;
+}
+inline ::google::protobuf::ServiceOptions* ServiceDescriptorProto::mutable_options() {
+  set_has_options();
+  if (options_ == NULL) {
+    _slow_mutable_options();
+  }
+  // @@protoc_insertion_point(field_mutable:google.protobuf.ServiceDescriptorProto.options)
+  return options_;
+}
+inline void ServiceDescriptorProto::set_allocated_options(::google::protobuf::ServiceOptions* options) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete options_;
+  }
+  if (options) {
+    ::google::protobuf::Arena* submessage_arena =
+      ::google::protobuf::Arena::GetArena(options);
+    if (message_arena != submessage_arena) {
+      options = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, options, submessage_arena);
+    }
+    set_has_options();
+  } else {
+    clear_has_options();
+  }
+  options_ = options;
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.ServiceDescriptorProto.options)
+}
+
+// -------------------------------------------------------------------
+
+// MethodDescriptorProto
+
+// optional string name = 1;
+inline bool MethodDescriptorProto::has_name() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void MethodDescriptorProto::set_has_name() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void MethodDescriptorProto::clear_has_name() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void MethodDescriptorProto::clear_name() {
+  name_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+  clear_has_name();
+}
+inline const ::std::string& MethodDescriptorProto::name() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.MethodDescriptorProto.name)
+  return name_.Get();
+}
+inline void MethodDescriptorProto::set_name(const ::std::string& value) {
+  set_has_name();
+  name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set:google.protobuf.MethodDescriptorProto.name)
+}
+#if LANG_CXX11
+inline void MethodDescriptorProto::set_name(::std::string&& value) {
+  set_has_name();
+  name_.Set(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.MethodDescriptorProto.name)
+}
+#endif
+inline void MethodDescriptorProto::set_name(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  set_has_name();
+  name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
+              GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_char:google.protobuf.MethodDescriptorProto.name)
+}
+inline void MethodDescriptorProto::set_name(const char* value,
+    size_t size) {
+  set_has_name();
+  name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
+      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.MethodDescriptorProto.name)
+}
+inline ::std::string* MethodDescriptorProto::mutable_name() {
+  set_has_name();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.MethodDescriptorProto.name)
+  return name_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline ::std::string* MethodDescriptorProto::release_name() {
+  // @@protoc_insertion_point(field_release:google.protobuf.MethodDescriptorProto.name)
+  clear_has_name();
+  return name_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline void MethodDescriptorProto::set_allocated_name(::std::string* name) {
+  if (name != NULL) {
+    set_has_name();
+  } else {
+    clear_has_name();
+  }
+  name_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name,
+      GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.MethodDescriptorProto.name)
+}
+inline ::std::string* MethodDescriptorProto::unsafe_arena_release_name() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.MethodDescriptorProto.name)
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  clear_has_name();
+  return name_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      GetArenaNoVirtual());
+}
+inline void MethodDescriptorProto::unsafe_arena_set_allocated_name(
+    ::std::string* name) {
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  if (name != NULL) {
+    set_has_name();
+  } else {
+    clear_has_name();
+  }
+  name_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      name, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.MethodDescriptorProto.name)
+}
+
+// optional string input_type = 2;
+inline bool MethodDescriptorProto::has_input_type() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void MethodDescriptorProto::set_has_input_type() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void MethodDescriptorProto::clear_has_input_type() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void MethodDescriptorProto::clear_input_type() {
+  input_type_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+  clear_has_input_type();
+}
+inline const ::std::string& MethodDescriptorProto::input_type() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.MethodDescriptorProto.input_type)
+  return input_type_.Get();
+}
+inline void MethodDescriptorProto::set_input_type(const ::std::string& value) {
+  set_has_input_type();
+  input_type_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set:google.protobuf.MethodDescriptorProto.input_type)
+}
+#if LANG_CXX11
+inline void MethodDescriptorProto::set_input_type(::std::string&& value) {
+  set_has_input_type();
+  input_type_.Set(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.MethodDescriptorProto.input_type)
+}
+#endif
+inline void MethodDescriptorProto::set_input_type(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  set_has_input_type();
+  input_type_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
+              GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_char:google.protobuf.MethodDescriptorProto.input_type)
+}
+inline void MethodDescriptorProto::set_input_type(const char* value,
+    size_t size) {
+  set_has_input_type();
+  input_type_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
+      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.MethodDescriptorProto.input_type)
+}
+inline ::std::string* MethodDescriptorProto::mutable_input_type() {
+  set_has_input_type();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.MethodDescriptorProto.input_type)
+  return input_type_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline ::std::string* MethodDescriptorProto::release_input_type() {
+  // @@protoc_insertion_point(field_release:google.protobuf.MethodDescriptorProto.input_type)
+  clear_has_input_type();
+  return input_type_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline void MethodDescriptorProto::set_allocated_input_type(::std::string* input_type) {
+  if (input_type != NULL) {
+    set_has_input_type();
+  } else {
+    clear_has_input_type();
+  }
+  input_type_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), input_type,
+      GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.MethodDescriptorProto.input_type)
+}
+inline ::std::string* MethodDescriptorProto::unsafe_arena_release_input_type() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.MethodDescriptorProto.input_type)
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  clear_has_input_type();
+  return input_type_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      GetArenaNoVirtual());
+}
+inline void MethodDescriptorProto::unsafe_arena_set_allocated_input_type(
+    ::std::string* input_type) {
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  if (input_type != NULL) {
+    set_has_input_type();
+  } else {
+    clear_has_input_type();
+  }
+  input_type_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      input_type, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.MethodDescriptorProto.input_type)
+}
+
+// optional string output_type = 3;
+inline bool MethodDescriptorProto::has_output_type() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void MethodDescriptorProto::set_has_output_type() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void MethodDescriptorProto::clear_has_output_type() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void MethodDescriptorProto::clear_output_type() {
+  output_type_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+  clear_has_output_type();
+}
+inline const ::std::string& MethodDescriptorProto::output_type() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.MethodDescriptorProto.output_type)
+  return output_type_.Get();
+}
+inline void MethodDescriptorProto::set_output_type(const ::std::string& value) {
+  set_has_output_type();
+  output_type_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set:google.protobuf.MethodDescriptorProto.output_type)
+}
+#if LANG_CXX11
+inline void MethodDescriptorProto::set_output_type(::std::string&& value) {
+  set_has_output_type();
+  output_type_.Set(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.MethodDescriptorProto.output_type)
+}
+#endif
+inline void MethodDescriptorProto::set_output_type(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  set_has_output_type();
+  output_type_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
+              GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_char:google.protobuf.MethodDescriptorProto.output_type)
+}
+inline void MethodDescriptorProto::set_output_type(const char* value,
+    size_t size) {
+  set_has_output_type();
+  output_type_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
+      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.MethodDescriptorProto.output_type)
+}
+inline ::std::string* MethodDescriptorProto::mutable_output_type() {
+  set_has_output_type();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.MethodDescriptorProto.output_type)
+  return output_type_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline ::std::string* MethodDescriptorProto::release_output_type() {
+  // @@protoc_insertion_point(field_release:google.protobuf.MethodDescriptorProto.output_type)
+  clear_has_output_type();
+  return output_type_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline void MethodDescriptorProto::set_allocated_output_type(::std::string* output_type) {
+  if (output_type != NULL) {
+    set_has_output_type();
+  } else {
+    clear_has_output_type();
+  }
+  output_type_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), output_type,
+      GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.MethodDescriptorProto.output_type)
+}
+inline ::std::string* MethodDescriptorProto::unsafe_arena_release_output_type() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.MethodDescriptorProto.output_type)
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  clear_has_output_type();
+  return output_type_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      GetArenaNoVirtual());
+}
+inline void MethodDescriptorProto::unsafe_arena_set_allocated_output_type(
+    ::std::string* output_type) {
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  if (output_type != NULL) {
+    set_has_output_type();
+  } else {
+    clear_has_output_type();
+  }
+  output_type_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      output_type, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.MethodDescriptorProto.output_type)
+}
+
+// optional .google.protobuf.MethodOptions options = 4;
+inline bool MethodDescriptorProto::has_options() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void MethodDescriptorProto::set_has_options() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void MethodDescriptorProto::clear_has_options() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void MethodDescriptorProto::clear_options() {
+  if (options_ != NULL) options_->Clear();
+  clear_has_options();
+}
+inline const ::google::protobuf::MethodOptions& MethodDescriptorProto::options() const {
+  const ::google::protobuf::MethodOptions* p = options_;
+  // @@protoc_insertion_point(field_get:google.protobuf.MethodDescriptorProto.options)
+  return p != NULL ? *p : *reinterpret_cast<const ::google::protobuf::MethodOptions*>(
+      &::google::protobuf::_MethodOptions_default_instance_);
+}
+inline ::google::protobuf::MethodOptions* MethodDescriptorProto::release_options() {
+  // @@protoc_insertion_point(field_release:google.protobuf.MethodDescriptorProto.options)
+  clear_has_options();
+  ::google::protobuf::MethodOptions* temp = options_;
+  if (GetArenaNoVirtual() != NULL) {
+    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp, NULL);
+  }
+  options_ = NULL;
+  return temp;
+}
+inline ::google::protobuf::MethodOptions* MethodDescriptorProto::unsafe_arena_release_options() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.MethodDescriptorProto.options)
+  clear_has_options();
+  ::google::protobuf::MethodOptions* temp = options_;
+  options_ = NULL;
+  return temp;
+}
+inline ::google::protobuf::MethodOptions* MethodDescriptorProto::mutable_options() {
+  set_has_options();
+  if (options_ == NULL) {
+    _slow_mutable_options();
+  }
+  // @@protoc_insertion_point(field_mutable:google.protobuf.MethodDescriptorProto.options)
+  return options_;
+}
+inline void MethodDescriptorProto::set_allocated_options(::google::protobuf::MethodOptions* options) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete options_;
+  }
+  if (options) {
+    ::google::protobuf::Arena* submessage_arena =
+      ::google::protobuf::Arena::GetArena(options);
+    if (message_arena != submessage_arena) {
+      options = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, options, submessage_arena);
+    }
+    set_has_options();
+  } else {
+    clear_has_options();
+  }
+  options_ = options;
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.MethodDescriptorProto.options)
+}
+
+// optional bool client_streaming = 5 [default = false];
+inline bool MethodDescriptorProto::has_client_streaming() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void MethodDescriptorProto::set_has_client_streaming() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void MethodDescriptorProto::clear_has_client_streaming() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void MethodDescriptorProto::clear_client_streaming() {
+  client_streaming_ = false;
+  clear_has_client_streaming();
+}
+inline bool MethodDescriptorProto::client_streaming() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.MethodDescriptorProto.client_streaming)
+  return client_streaming_;
+}
+inline void MethodDescriptorProto::set_client_streaming(bool value) {
+  set_has_client_streaming();
+  client_streaming_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.MethodDescriptorProto.client_streaming)
+}
+
+// optional bool server_streaming = 6 [default = false];
+inline bool MethodDescriptorProto::has_server_streaming() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void MethodDescriptorProto::set_has_server_streaming() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void MethodDescriptorProto::clear_has_server_streaming() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void MethodDescriptorProto::clear_server_streaming() {
+  server_streaming_ = false;
+  clear_has_server_streaming();
+}
+inline bool MethodDescriptorProto::server_streaming() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.MethodDescriptorProto.server_streaming)
+  return server_streaming_;
+}
+inline void MethodDescriptorProto::set_server_streaming(bool value) {
+  set_has_server_streaming();
+  server_streaming_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.MethodDescriptorProto.server_streaming)
+}
+
+// -------------------------------------------------------------------
+
+// FileOptions
+
+// optional string java_package = 1;
+inline bool FileOptions::has_java_package() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void FileOptions::set_has_java_package() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void FileOptions::clear_has_java_package() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void FileOptions::clear_java_package() {
+  java_package_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+  clear_has_java_package();
+}
+inline const ::std::string& FileOptions::java_package() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.java_package)
+  return java_package_.Get();
+}
+inline void FileOptions::set_java_package(const ::std::string& value) {
+  set_has_java_package();
+  java_package_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.java_package)
+}
+#if LANG_CXX11
+inline void FileOptions::set_java_package(::std::string&& value) {
+  set_has_java_package();
+  java_package_.Set(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.FileOptions.java_package)
+}
+#endif
+inline void FileOptions::set_java_package(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  set_has_java_package();
+  java_package_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
+              GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_char:google.protobuf.FileOptions.java_package)
+}
+inline void FileOptions::set_java_package(const char* value,
+    size_t size) {
+  set_has_java_package();
+  java_package_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
+      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.FileOptions.java_package)
+}
+inline ::std::string* FileOptions::mutable_java_package() {
+  set_has_java_package();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FileOptions.java_package)
+  return java_package_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline ::std::string* FileOptions::release_java_package() {
+  // @@protoc_insertion_point(field_release:google.protobuf.FileOptions.java_package)
+  clear_has_java_package();
+  return java_package_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline void FileOptions::set_allocated_java_package(::std::string* java_package) {
+  if (java_package != NULL) {
+    set_has_java_package();
+  } else {
+    clear_has_java_package();
+  }
+  java_package_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), java_package,
+      GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileOptions.java_package)
+}
+inline ::std::string* FileOptions::unsafe_arena_release_java_package() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.FileOptions.java_package)
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  clear_has_java_package();
+  return java_package_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      GetArenaNoVirtual());
+}
+inline void FileOptions::unsafe_arena_set_allocated_java_package(
+    ::std::string* java_package) {
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  if (java_package != NULL) {
+    set_has_java_package();
+  } else {
+    clear_has_java_package();
+  }
+  java_package_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      java_package, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.FileOptions.java_package)
+}
+
+// optional string java_outer_classname = 8;
+inline bool FileOptions::has_java_outer_classname() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void FileOptions::set_has_java_outer_classname() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void FileOptions::clear_has_java_outer_classname() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void FileOptions::clear_java_outer_classname() {
+  java_outer_classname_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+  clear_has_java_outer_classname();
+}
+inline const ::std::string& FileOptions::java_outer_classname() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.java_outer_classname)
+  return java_outer_classname_.Get();
+}
+inline void FileOptions::set_java_outer_classname(const ::std::string& value) {
+  set_has_java_outer_classname();
+  java_outer_classname_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.java_outer_classname)
+}
+#if LANG_CXX11
+inline void FileOptions::set_java_outer_classname(::std::string&& value) {
+  set_has_java_outer_classname();
+  java_outer_classname_.Set(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.FileOptions.java_outer_classname)
+}
+#endif
+inline void FileOptions::set_java_outer_classname(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  set_has_java_outer_classname();
+  java_outer_classname_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
+              GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_char:google.protobuf.FileOptions.java_outer_classname)
+}
+inline void FileOptions::set_java_outer_classname(const char* value,
+    size_t size) {
+  set_has_java_outer_classname();
+  java_outer_classname_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
+      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.FileOptions.java_outer_classname)
+}
+inline ::std::string* FileOptions::mutable_java_outer_classname() {
+  set_has_java_outer_classname();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FileOptions.java_outer_classname)
+  return java_outer_classname_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline ::std::string* FileOptions::release_java_outer_classname() {
+  // @@protoc_insertion_point(field_release:google.protobuf.FileOptions.java_outer_classname)
+  clear_has_java_outer_classname();
+  return java_outer_classname_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline void FileOptions::set_allocated_java_outer_classname(::std::string* java_outer_classname) {
+  if (java_outer_classname != NULL) {
+    set_has_java_outer_classname();
+  } else {
+    clear_has_java_outer_classname();
+  }
+  java_outer_classname_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), java_outer_classname,
+      GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileOptions.java_outer_classname)
+}
+inline ::std::string* FileOptions::unsafe_arena_release_java_outer_classname() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.FileOptions.java_outer_classname)
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  clear_has_java_outer_classname();
+  return java_outer_classname_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      GetArenaNoVirtual());
+}
+inline void FileOptions::unsafe_arena_set_allocated_java_outer_classname(
+    ::std::string* java_outer_classname) {
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  if (java_outer_classname != NULL) {
+    set_has_java_outer_classname();
+  } else {
+    clear_has_java_outer_classname();
+  }
+  java_outer_classname_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      java_outer_classname, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.FileOptions.java_outer_classname)
+}
+
+// optional bool java_multiple_files = 10 [default = false];
+inline bool FileOptions::has_java_multiple_files() const {
+  return (_has_bits_[0] & 0x00000200u) != 0;
+}
+inline void FileOptions::set_has_java_multiple_files() {
+  _has_bits_[0] |= 0x00000200u;
+}
+inline void FileOptions::clear_has_java_multiple_files() {
+  _has_bits_[0] &= ~0x00000200u;
+}
+inline void FileOptions::clear_java_multiple_files() {
+  java_multiple_files_ = false;
+  clear_has_java_multiple_files();
+}
+inline bool FileOptions::java_multiple_files() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.java_multiple_files)
+  return java_multiple_files_;
+}
+inline void FileOptions::set_java_multiple_files(bool value) {
+  set_has_java_multiple_files();
+  java_multiple_files_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.java_multiple_files)
+}
+
+// optional bool java_generate_equals_and_hash = 20 [deprecated = true];
+inline bool FileOptions::has_java_generate_equals_and_hash() const {
+  return (_has_bits_[0] & 0x00000400u) != 0;
+}
+inline void FileOptions::set_has_java_generate_equals_and_hash() {
+  _has_bits_[0] |= 0x00000400u;
+}
+inline void FileOptions::clear_has_java_generate_equals_and_hash() {
+  _has_bits_[0] &= ~0x00000400u;
+}
+inline void FileOptions::clear_java_generate_equals_and_hash() {
+  java_generate_equals_and_hash_ = false;
+  clear_has_java_generate_equals_and_hash();
+}
+inline bool FileOptions::java_generate_equals_and_hash() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.java_generate_equals_and_hash)
+  return java_generate_equals_and_hash_;
+}
+inline void FileOptions::set_java_generate_equals_and_hash(bool value) {
+  set_has_java_generate_equals_and_hash();
+  java_generate_equals_and_hash_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.java_generate_equals_and_hash)
+}
+
+// optional bool java_string_check_utf8 = 27 [default = false];
+inline bool FileOptions::has_java_string_check_utf8() const {
+  return (_has_bits_[0] & 0x00000800u) != 0;
+}
+inline void FileOptions::set_has_java_string_check_utf8() {
+  _has_bits_[0] |= 0x00000800u;
+}
+inline void FileOptions::clear_has_java_string_check_utf8() {
+  _has_bits_[0] &= ~0x00000800u;
+}
+inline void FileOptions::clear_java_string_check_utf8() {
+  java_string_check_utf8_ = false;
+  clear_has_java_string_check_utf8();
+}
+inline bool FileOptions::java_string_check_utf8() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.java_string_check_utf8)
+  return java_string_check_utf8_;
+}
+inline void FileOptions::set_java_string_check_utf8(bool value) {
+  set_has_java_string_check_utf8();
+  java_string_check_utf8_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.java_string_check_utf8)
+}
+
+// optional .google.protobuf.FileOptions.OptimizeMode optimize_for = 9 [default = SPEED];
+inline bool FileOptions::has_optimize_for() const {
+  return (_has_bits_[0] & 0x00020000u) != 0;
+}
+inline void FileOptions::set_has_optimize_for() {
+  _has_bits_[0] |= 0x00020000u;
+}
+inline void FileOptions::clear_has_optimize_for() {
+  _has_bits_[0] &= ~0x00020000u;
+}
+inline void FileOptions::clear_optimize_for() {
+  optimize_for_ = 1;
+  clear_has_optimize_for();
+}
+inline ::google::protobuf::FileOptions_OptimizeMode FileOptions::optimize_for() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.optimize_for)
+  return static_cast< ::google::protobuf::FileOptions_OptimizeMode >(optimize_for_);
+}
+inline void FileOptions::set_optimize_for(::google::protobuf::FileOptions_OptimizeMode value) {
+  assert(::google::protobuf::FileOptions_OptimizeMode_IsValid(value));
+  set_has_optimize_for();
+  optimize_for_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.optimize_for)
+}
+
+// optional string go_package = 11;
+inline bool FileOptions::has_go_package() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void FileOptions::set_has_go_package() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void FileOptions::clear_has_go_package() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void FileOptions::clear_go_package() {
+  go_package_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+  clear_has_go_package();
+}
+inline const ::std::string& FileOptions::go_package() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.go_package)
+  return go_package_.Get();
+}
+inline void FileOptions::set_go_package(const ::std::string& value) {
+  set_has_go_package();
+  go_package_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.go_package)
+}
+#if LANG_CXX11
+inline void FileOptions::set_go_package(::std::string&& value) {
+  set_has_go_package();
+  go_package_.Set(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.FileOptions.go_package)
+}
+#endif
+inline void FileOptions::set_go_package(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  set_has_go_package();
+  go_package_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
+              GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_char:google.protobuf.FileOptions.go_package)
+}
+inline void FileOptions::set_go_package(const char* value,
+    size_t size) {
+  set_has_go_package();
+  go_package_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
+      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.FileOptions.go_package)
+}
+inline ::std::string* FileOptions::mutable_go_package() {
+  set_has_go_package();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FileOptions.go_package)
+  return go_package_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline ::std::string* FileOptions::release_go_package() {
+  // @@protoc_insertion_point(field_release:google.protobuf.FileOptions.go_package)
+  clear_has_go_package();
+  return go_package_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline void FileOptions::set_allocated_go_package(::std::string* go_package) {
+  if (go_package != NULL) {
+    set_has_go_package();
+  } else {
+    clear_has_go_package();
+  }
+  go_package_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), go_package,
+      GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileOptions.go_package)
+}
+inline ::std::string* FileOptions::unsafe_arena_release_go_package() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.FileOptions.go_package)
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  clear_has_go_package();
+  return go_package_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      GetArenaNoVirtual());
+}
+inline void FileOptions::unsafe_arena_set_allocated_go_package(
+    ::std::string* go_package) {
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  if (go_package != NULL) {
+    set_has_go_package();
+  } else {
+    clear_has_go_package();
+  }
+  go_package_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      go_package, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.FileOptions.go_package)
+}
+
+// optional bool cc_generic_services = 16 [default = false];
+inline bool FileOptions::has_cc_generic_services() const {
+  return (_has_bits_[0] & 0x00001000u) != 0;
+}
+inline void FileOptions::set_has_cc_generic_services() {
+  _has_bits_[0] |= 0x00001000u;
+}
+inline void FileOptions::clear_has_cc_generic_services() {
+  _has_bits_[0] &= ~0x00001000u;
+}
+inline void FileOptions::clear_cc_generic_services() {
+  cc_generic_services_ = false;
+  clear_has_cc_generic_services();
+}
+inline bool FileOptions::cc_generic_services() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.cc_generic_services)
+  return cc_generic_services_;
+}
+inline void FileOptions::set_cc_generic_services(bool value) {
+  set_has_cc_generic_services();
+  cc_generic_services_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.cc_generic_services)
+}
+
+// optional bool java_generic_services = 17 [default = false];
+inline bool FileOptions::has_java_generic_services() const {
+  return (_has_bits_[0] & 0x00002000u) != 0;
+}
+inline void FileOptions::set_has_java_generic_services() {
+  _has_bits_[0] |= 0x00002000u;
+}
+inline void FileOptions::clear_has_java_generic_services() {
+  _has_bits_[0] &= ~0x00002000u;
+}
+inline void FileOptions::clear_java_generic_services() {
+  java_generic_services_ = false;
+  clear_has_java_generic_services();
+}
+inline bool FileOptions::java_generic_services() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.java_generic_services)
+  return java_generic_services_;
+}
+inline void FileOptions::set_java_generic_services(bool value) {
+  set_has_java_generic_services();
+  java_generic_services_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.java_generic_services)
+}
+
+// optional bool py_generic_services = 18 [default = false];
+inline bool FileOptions::has_py_generic_services() const {
+  return (_has_bits_[0] & 0x00004000u) != 0;
+}
+inline void FileOptions::set_has_py_generic_services() {
+  _has_bits_[0] |= 0x00004000u;
+}
+inline void FileOptions::clear_has_py_generic_services() {
+  _has_bits_[0] &= ~0x00004000u;
+}
+inline void FileOptions::clear_py_generic_services() {
+  py_generic_services_ = false;
+  clear_has_py_generic_services();
+}
+inline bool FileOptions::py_generic_services() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.py_generic_services)
+  return py_generic_services_;
+}
+inline void FileOptions::set_py_generic_services(bool value) {
+  set_has_py_generic_services();
+  py_generic_services_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.py_generic_services)
+}
+
+// optional bool php_generic_services = 42 [default = false];
+inline bool FileOptions::has_php_generic_services() const {
+  return (_has_bits_[0] & 0x00008000u) != 0;
+}
+inline void FileOptions::set_has_php_generic_services() {
+  _has_bits_[0] |= 0x00008000u;
+}
+inline void FileOptions::clear_has_php_generic_services() {
+  _has_bits_[0] &= ~0x00008000u;
+}
+inline void FileOptions::clear_php_generic_services() {
+  php_generic_services_ = false;
+  clear_has_php_generic_services();
+}
+inline bool FileOptions::php_generic_services() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.php_generic_services)
+  return php_generic_services_;
+}
+inline void FileOptions::set_php_generic_services(bool value) {
+  set_has_php_generic_services();
+  php_generic_services_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.php_generic_services)
+}
+
+// optional bool deprecated = 23 [default = false];
+inline bool FileOptions::has_deprecated() const {
+  return (_has_bits_[0] & 0x00010000u) != 0;
+}
+inline void FileOptions::set_has_deprecated() {
+  _has_bits_[0] |= 0x00010000u;
+}
+inline void FileOptions::clear_has_deprecated() {
+  _has_bits_[0] &= ~0x00010000u;
+}
+inline void FileOptions::clear_deprecated() {
+  deprecated_ = false;
+  clear_has_deprecated();
+}
+inline bool FileOptions::deprecated() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.deprecated)
+  return deprecated_;
+}
+inline void FileOptions::set_deprecated(bool value) {
+  set_has_deprecated();
+  deprecated_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.deprecated)
+}
+
+// optional bool cc_enable_arenas = 31 [default = false];
+inline bool FileOptions::has_cc_enable_arenas() const {
+  return (_has_bits_[0] & 0x00000100u) != 0;
+}
+inline void FileOptions::set_has_cc_enable_arenas() {
+  _has_bits_[0] |= 0x00000100u;
+}
+inline void FileOptions::clear_has_cc_enable_arenas() {
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline void FileOptions::clear_cc_enable_arenas() {
+  cc_enable_arenas_ = false;
+  clear_has_cc_enable_arenas();
+}
+inline bool FileOptions::cc_enable_arenas() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.cc_enable_arenas)
+  return cc_enable_arenas_;
+}
+inline void FileOptions::set_cc_enable_arenas(bool value) {
+  set_has_cc_enable_arenas();
+  cc_enable_arenas_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.cc_enable_arenas)
+}
+
+// optional string objc_class_prefix = 36;
+inline bool FileOptions::has_objc_class_prefix() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void FileOptions::set_has_objc_class_prefix() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void FileOptions::clear_has_objc_class_prefix() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void FileOptions::clear_objc_class_prefix() {
+  objc_class_prefix_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+  clear_has_objc_class_prefix();
+}
+inline const ::std::string& FileOptions::objc_class_prefix() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.objc_class_prefix)
+  return objc_class_prefix_.Get();
+}
+inline void FileOptions::set_objc_class_prefix(const ::std::string& value) {
+  set_has_objc_class_prefix();
+  objc_class_prefix_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.objc_class_prefix)
+}
+#if LANG_CXX11
+inline void FileOptions::set_objc_class_prefix(::std::string&& value) {
+  set_has_objc_class_prefix();
+  objc_class_prefix_.Set(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.FileOptions.objc_class_prefix)
+}
+#endif
+inline void FileOptions::set_objc_class_prefix(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  set_has_objc_class_prefix();
+  objc_class_prefix_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
+              GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_char:google.protobuf.FileOptions.objc_class_prefix)
+}
+inline void FileOptions::set_objc_class_prefix(const char* value,
+    size_t size) {
+  set_has_objc_class_prefix();
+  objc_class_prefix_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
+      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.FileOptions.objc_class_prefix)
+}
+inline ::std::string* FileOptions::mutable_objc_class_prefix() {
+  set_has_objc_class_prefix();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FileOptions.objc_class_prefix)
+  return objc_class_prefix_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline ::std::string* FileOptions::release_objc_class_prefix() {
+  // @@protoc_insertion_point(field_release:google.protobuf.FileOptions.objc_class_prefix)
+  clear_has_objc_class_prefix();
+  return objc_class_prefix_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline void FileOptions::set_allocated_objc_class_prefix(::std::string* objc_class_prefix) {
+  if (objc_class_prefix != NULL) {
+    set_has_objc_class_prefix();
+  } else {
+    clear_has_objc_class_prefix();
+  }
+  objc_class_prefix_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), objc_class_prefix,
+      GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileOptions.objc_class_prefix)
+}
+inline ::std::string* FileOptions::unsafe_arena_release_objc_class_prefix() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.FileOptions.objc_class_prefix)
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  clear_has_objc_class_prefix();
+  return objc_class_prefix_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      GetArenaNoVirtual());
+}
+inline void FileOptions::unsafe_arena_set_allocated_objc_class_prefix(
+    ::std::string* objc_class_prefix) {
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  if (objc_class_prefix != NULL) {
+    set_has_objc_class_prefix();
+  } else {
+    clear_has_objc_class_prefix();
+  }
+  objc_class_prefix_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      objc_class_prefix, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.FileOptions.objc_class_prefix)
+}
+
+// optional string csharp_namespace = 37;
+inline bool FileOptions::has_csharp_namespace() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void FileOptions::set_has_csharp_namespace() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void FileOptions::clear_has_csharp_namespace() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void FileOptions::clear_csharp_namespace() {
+  csharp_namespace_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+  clear_has_csharp_namespace();
+}
+inline const ::std::string& FileOptions::csharp_namespace() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.csharp_namespace)
+  return csharp_namespace_.Get();
+}
+inline void FileOptions::set_csharp_namespace(const ::std::string& value) {
+  set_has_csharp_namespace();
+  csharp_namespace_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.csharp_namespace)
+}
+#if LANG_CXX11
+inline void FileOptions::set_csharp_namespace(::std::string&& value) {
+  set_has_csharp_namespace();
+  csharp_namespace_.Set(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.FileOptions.csharp_namespace)
+}
+#endif
+inline void FileOptions::set_csharp_namespace(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  set_has_csharp_namespace();
+  csharp_namespace_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
+              GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_char:google.protobuf.FileOptions.csharp_namespace)
+}
+inline void FileOptions::set_csharp_namespace(const char* value,
+    size_t size) {
+  set_has_csharp_namespace();
+  csharp_namespace_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
+      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.FileOptions.csharp_namespace)
+}
+inline ::std::string* FileOptions::mutable_csharp_namespace() {
+  set_has_csharp_namespace();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FileOptions.csharp_namespace)
+  return csharp_namespace_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline ::std::string* FileOptions::release_csharp_namespace() {
+  // @@protoc_insertion_point(field_release:google.protobuf.FileOptions.csharp_namespace)
+  clear_has_csharp_namespace();
+  return csharp_namespace_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline void FileOptions::set_allocated_csharp_namespace(::std::string* csharp_namespace) {
+  if (csharp_namespace != NULL) {
+    set_has_csharp_namespace();
+  } else {
+    clear_has_csharp_namespace();
+  }
+  csharp_namespace_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), csharp_namespace,
+      GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileOptions.csharp_namespace)
+}
+inline ::std::string* FileOptions::unsafe_arena_release_csharp_namespace() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.FileOptions.csharp_namespace)
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  clear_has_csharp_namespace();
+  return csharp_namespace_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      GetArenaNoVirtual());
+}
+inline void FileOptions::unsafe_arena_set_allocated_csharp_namespace(
+    ::std::string* csharp_namespace) {
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  if (csharp_namespace != NULL) {
+    set_has_csharp_namespace();
+  } else {
+    clear_has_csharp_namespace();
+  }
+  csharp_namespace_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      csharp_namespace, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.FileOptions.csharp_namespace)
+}
+
+// optional string swift_prefix = 39;
+inline bool FileOptions::has_swift_prefix() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void FileOptions::set_has_swift_prefix() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void FileOptions::clear_has_swift_prefix() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void FileOptions::clear_swift_prefix() {
+  swift_prefix_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+  clear_has_swift_prefix();
+}
+inline const ::std::string& FileOptions::swift_prefix() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.swift_prefix)
+  return swift_prefix_.Get();
+}
+inline void FileOptions::set_swift_prefix(const ::std::string& value) {
+  set_has_swift_prefix();
+  swift_prefix_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.swift_prefix)
+}
+#if LANG_CXX11
+inline void FileOptions::set_swift_prefix(::std::string&& value) {
+  set_has_swift_prefix();
+  swift_prefix_.Set(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.FileOptions.swift_prefix)
+}
+#endif
+inline void FileOptions::set_swift_prefix(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  set_has_swift_prefix();
+  swift_prefix_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
+              GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_char:google.protobuf.FileOptions.swift_prefix)
+}
+inline void FileOptions::set_swift_prefix(const char* value,
+    size_t size) {
+  set_has_swift_prefix();
+  swift_prefix_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
+      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.FileOptions.swift_prefix)
+}
+inline ::std::string* FileOptions::mutable_swift_prefix() {
+  set_has_swift_prefix();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FileOptions.swift_prefix)
+  return swift_prefix_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline ::std::string* FileOptions::release_swift_prefix() {
+  // @@protoc_insertion_point(field_release:google.protobuf.FileOptions.swift_prefix)
+  clear_has_swift_prefix();
+  return swift_prefix_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline void FileOptions::set_allocated_swift_prefix(::std::string* swift_prefix) {
+  if (swift_prefix != NULL) {
+    set_has_swift_prefix();
+  } else {
+    clear_has_swift_prefix();
+  }
+  swift_prefix_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), swift_prefix,
+      GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileOptions.swift_prefix)
+}
+inline ::std::string* FileOptions::unsafe_arena_release_swift_prefix() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.FileOptions.swift_prefix)
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  clear_has_swift_prefix();
+  return swift_prefix_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      GetArenaNoVirtual());
+}
+inline void FileOptions::unsafe_arena_set_allocated_swift_prefix(
+    ::std::string* swift_prefix) {
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  if (swift_prefix != NULL) {
+    set_has_swift_prefix();
+  } else {
+    clear_has_swift_prefix();
+  }
+  swift_prefix_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      swift_prefix, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.FileOptions.swift_prefix)
+}
+
+// optional string php_class_prefix = 40;
+inline bool FileOptions::has_php_class_prefix() const {
+  return (_has_bits_[0] & 0x00000040u) != 0;
+}
+inline void FileOptions::set_has_php_class_prefix() {
+  _has_bits_[0] |= 0x00000040u;
+}
+inline void FileOptions::clear_has_php_class_prefix() {
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline void FileOptions::clear_php_class_prefix() {
+  php_class_prefix_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+  clear_has_php_class_prefix();
+}
+inline const ::std::string& FileOptions::php_class_prefix() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.php_class_prefix)
+  return php_class_prefix_.Get();
+}
+inline void FileOptions::set_php_class_prefix(const ::std::string& value) {
+  set_has_php_class_prefix();
+  php_class_prefix_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.php_class_prefix)
+}
+#if LANG_CXX11
+inline void FileOptions::set_php_class_prefix(::std::string&& value) {
+  set_has_php_class_prefix();
+  php_class_prefix_.Set(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.FileOptions.php_class_prefix)
+}
+#endif
+inline void FileOptions::set_php_class_prefix(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  set_has_php_class_prefix();
+  php_class_prefix_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
+              GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_char:google.protobuf.FileOptions.php_class_prefix)
+}
+inline void FileOptions::set_php_class_prefix(const char* value,
+    size_t size) {
+  set_has_php_class_prefix();
+  php_class_prefix_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
+      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.FileOptions.php_class_prefix)
+}
+inline ::std::string* FileOptions::mutable_php_class_prefix() {
+  set_has_php_class_prefix();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FileOptions.php_class_prefix)
+  return php_class_prefix_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline ::std::string* FileOptions::release_php_class_prefix() {
+  // @@protoc_insertion_point(field_release:google.protobuf.FileOptions.php_class_prefix)
+  clear_has_php_class_prefix();
+  return php_class_prefix_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline void FileOptions::set_allocated_php_class_prefix(::std::string* php_class_prefix) {
+  if (php_class_prefix != NULL) {
+    set_has_php_class_prefix();
+  } else {
+    clear_has_php_class_prefix();
+  }
+  php_class_prefix_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), php_class_prefix,
+      GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileOptions.php_class_prefix)
+}
+inline ::std::string* FileOptions::unsafe_arena_release_php_class_prefix() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.FileOptions.php_class_prefix)
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  clear_has_php_class_prefix();
+  return php_class_prefix_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      GetArenaNoVirtual());
+}
+inline void FileOptions::unsafe_arena_set_allocated_php_class_prefix(
+    ::std::string* php_class_prefix) {
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  if (php_class_prefix != NULL) {
+    set_has_php_class_prefix();
+  } else {
+    clear_has_php_class_prefix();
+  }
+  php_class_prefix_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      php_class_prefix, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.FileOptions.php_class_prefix)
+}
+
+// optional string php_namespace = 41;
+inline bool FileOptions::has_php_namespace() const {
+  return (_has_bits_[0] & 0x00000080u) != 0;
+}
+inline void FileOptions::set_has_php_namespace() {
+  _has_bits_[0] |= 0x00000080u;
+}
+inline void FileOptions::clear_has_php_namespace() {
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline void FileOptions::clear_php_namespace() {
+  php_namespace_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+  clear_has_php_namespace();
+}
+inline const ::std::string& FileOptions::php_namespace() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.php_namespace)
+  return php_namespace_.Get();
+}
+inline void FileOptions::set_php_namespace(const ::std::string& value) {
+  set_has_php_namespace();
+  php_namespace_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set:google.protobuf.FileOptions.php_namespace)
+}
+#if LANG_CXX11
+inline void FileOptions::set_php_namespace(::std::string&& value) {
+  set_has_php_namespace();
+  php_namespace_.Set(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.FileOptions.php_namespace)
+}
+#endif
+inline void FileOptions::set_php_namespace(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  set_has_php_namespace();
+  php_namespace_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
+              GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_char:google.protobuf.FileOptions.php_namespace)
+}
+inline void FileOptions::set_php_namespace(const char* value,
+    size_t size) {
+  set_has_php_namespace();
+  php_namespace_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
+      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.FileOptions.php_namespace)
+}
+inline ::std::string* FileOptions::mutable_php_namespace() {
+  set_has_php_namespace();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FileOptions.php_namespace)
+  return php_namespace_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline ::std::string* FileOptions::release_php_namespace() {
+  // @@protoc_insertion_point(field_release:google.protobuf.FileOptions.php_namespace)
+  clear_has_php_namespace();
+  return php_namespace_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline void FileOptions::set_allocated_php_namespace(::std::string* php_namespace) {
+  if (php_namespace != NULL) {
+    set_has_php_namespace();
+  } else {
+    clear_has_php_namespace();
+  }
+  php_namespace_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), php_namespace,
+      GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.FileOptions.php_namespace)
+}
+inline ::std::string* FileOptions::unsafe_arena_release_php_namespace() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.FileOptions.php_namespace)
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  clear_has_php_namespace();
+  return php_namespace_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      GetArenaNoVirtual());
+}
+inline void FileOptions::unsafe_arena_set_allocated_php_namespace(
+    ::std::string* php_namespace) {
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  if (php_namespace != NULL) {
+    set_has_php_namespace();
+  } else {
+    clear_has_php_namespace();
+  }
+  php_namespace_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      php_namespace, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.FileOptions.php_namespace)
+}
+
+// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
+inline int FileOptions::uninterpreted_option_size() const {
+  return uninterpreted_option_.size();
+}
+inline void FileOptions::clear_uninterpreted_option() {
+  uninterpreted_option_.Clear();
+}
+inline const ::google::protobuf::UninterpretedOption& FileOptions::uninterpreted_option(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FileOptions.uninterpreted_option)
+  return uninterpreted_option_.Get(index);
+}
+inline ::google::protobuf::UninterpretedOption* FileOptions::mutable_uninterpreted_option(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FileOptions.uninterpreted_option)
+  return uninterpreted_option_.Mutable(index);
+}
+inline ::google::protobuf::UninterpretedOption* FileOptions::add_uninterpreted_option() {
+  // @@protoc_insertion_point(field_add:google.protobuf.FileOptions.uninterpreted_option)
+  return uninterpreted_option_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >*
+FileOptions::mutable_uninterpreted_option() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.FileOptions.uninterpreted_option)
+  return &uninterpreted_option_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >&
+FileOptions::uninterpreted_option() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.FileOptions.uninterpreted_option)
+  return uninterpreted_option_;
+}
+
+// -------------------------------------------------------------------
+
+// MessageOptions
+
+// optional bool message_set_wire_format = 1 [default = false];
+inline bool MessageOptions::has_message_set_wire_format() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void MessageOptions::set_has_message_set_wire_format() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void MessageOptions::clear_has_message_set_wire_format() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void MessageOptions::clear_message_set_wire_format() {
+  message_set_wire_format_ = false;
+  clear_has_message_set_wire_format();
+}
+inline bool MessageOptions::message_set_wire_format() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.MessageOptions.message_set_wire_format)
+  return message_set_wire_format_;
+}
+inline void MessageOptions::set_message_set_wire_format(bool value) {
+  set_has_message_set_wire_format();
+  message_set_wire_format_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.MessageOptions.message_set_wire_format)
+}
+
+// optional bool no_standard_descriptor_accessor = 2 [default = false];
+inline bool MessageOptions::has_no_standard_descriptor_accessor() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void MessageOptions::set_has_no_standard_descriptor_accessor() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void MessageOptions::clear_has_no_standard_descriptor_accessor() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void MessageOptions::clear_no_standard_descriptor_accessor() {
+  no_standard_descriptor_accessor_ = false;
+  clear_has_no_standard_descriptor_accessor();
+}
+inline bool MessageOptions::no_standard_descriptor_accessor() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.MessageOptions.no_standard_descriptor_accessor)
+  return no_standard_descriptor_accessor_;
+}
+inline void MessageOptions::set_no_standard_descriptor_accessor(bool value) {
+  set_has_no_standard_descriptor_accessor();
+  no_standard_descriptor_accessor_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.MessageOptions.no_standard_descriptor_accessor)
+}
+
+// optional bool deprecated = 3 [default = false];
+inline bool MessageOptions::has_deprecated() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void MessageOptions::set_has_deprecated() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void MessageOptions::clear_has_deprecated() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void MessageOptions::clear_deprecated() {
+  deprecated_ = false;
+  clear_has_deprecated();
+}
+inline bool MessageOptions::deprecated() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.MessageOptions.deprecated)
+  return deprecated_;
+}
+inline void MessageOptions::set_deprecated(bool value) {
+  set_has_deprecated();
+  deprecated_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.MessageOptions.deprecated)
+}
+
+// optional bool map_entry = 7;
+inline bool MessageOptions::has_map_entry() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void MessageOptions::set_has_map_entry() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void MessageOptions::clear_has_map_entry() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void MessageOptions::clear_map_entry() {
+  map_entry_ = false;
+  clear_has_map_entry();
+}
+inline bool MessageOptions::map_entry() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.MessageOptions.map_entry)
+  return map_entry_;
+}
+inline void MessageOptions::set_map_entry(bool value) {
+  set_has_map_entry();
+  map_entry_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.MessageOptions.map_entry)
+}
+
+// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
+inline int MessageOptions::uninterpreted_option_size() const {
+  return uninterpreted_option_.size();
+}
+inline void MessageOptions::clear_uninterpreted_option() {
+  uninterpreted_option_.Clear();
+}
+inline const ::google::protobuf::UninterpretedOption& MessageOptions::uninterpreted_option(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.MessageOptions.uninterpreted_option)
+  return uninterpreted_option_.Get(index);
+}
+inline ::google::protobuf::UninterpretedOption* MessageOptions::mutable_uninterpreted_option(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.MessageOptions.uninterpreted_option)
+  return uninterpreted_option_.Mutable(index);
+}
+inline ::google::protobuf::UninterpretedOption* MessageOptions::add_uninterpreted_option() {
+  // @@protoc_insertion_point(field_add:google.protobuf.MessageOptions.uninterpreted_option)
+  return uninterpreted_option_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >*
+MessageOptions::mutable_uninterpreted_option() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.MessageOptions.uninterpreted_option)
+  return &uninterpreted_option_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >&
+MessageOptions::uninterpreted_option() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.MessageOptions.uninterpreted_option)
+  return uninterpreted_option_;
+}
+
+// -------------------------------------------------------------------
+
+// FieldOptions
+
+// optional .google.protobuf.FieldOptions.CType ctype = 1 [default = STRING];
+inline bool FieldOptions::has_ctype() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void FieldOptions::set_has_ctype() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void FieldOptions::clear_has_ctype() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void FieldOptions::clear_ctype() {
+  ctype_ = 0;
+  clear_has_ctype();
+}
+inline ::google::protobuf::FieldOptions_CType FieldOptions::ctype() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FieldOptions.ctype)
+  return static_cast< ::google::protobuf::FieldOptions_CType >(ctype_);
+}
+inline void FieldOptions::set_ctype(::google::protobuf::FieldOptions_CType value) {
+  assert(::google::protobuf::FieldOptions_CType_IsValid(value));
+  set_has_ctype();
+  ctype_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.FieldOptions.ctype)
+}
+
+// optional bool packed = 2;
+inline bool FieldOptions::has_packed() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void FieldOptions::set_has_packed() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void FieldOptions::clear_has_packed() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void FieldOptions::clear_packed() {
+  packed_ = false;
+  clear_has_packed();
+}
+inline bool FieldOptions::packed() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FieldOptions.packed)
+  return packed_;
+}
+inline void FieldOptions::set_packed(bool value) {
+  set_has_packed();
+  packed_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.FieldOptions.packed)
+}
+
+// optional .google.protobuf.FieldOptions.JSType jstype = 6 [default = JS_NORMAL];
+inline bool FieldOptions::has_jstype() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void FieldOptions::set_has_jstype() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void FieldOptions::clear_has_jstype() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void FieldOptions::clear_jstype() {
+  jstype_ = 0;
+  clear_has_jstype();
+}
+inline ::google::protobuf::FieldOptions_JSType FieldOptions::jstype() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FieldOptions.jstype)
+  return static_cast< ::google::protobuf::FieldOptions_JSType >(jstype_);
+}
+inline void FieldOptions::set_jstype(::google::protobuf::FieldOptions_JSType value) {
+  assert(::google::protobuf::FieldOptions_JSType_IsValid(value));
+  set_has_jstype();
+  jstype_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.FieldOptions.jstype)
+}
+
+// optional bool lazy = 5 [default = false];
+inline bool FieldOptions::has_lazy() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void FieldOptions::set_has_lazy() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void FieldOptions::clear_has_lazy() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void FieldOptions::clear_lazy() {
+  lazy_ = false;
+  clear_has_lazy();
+}
+inline bool FieldOptions::lazy() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FieldOptions.lazy)
+  return lazy_;
+}
+inline void FieldOptions::set_lazy(bool value) {
+  set_has_lazy();
+  lazy_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.FieldOptions.lazy)
+}
+
+// optional bool deprecated = 3 [default = false];
+inline bool FieldOptions::has_deprecated() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void FieldOptions::set_has_deprecated() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void FieldOptions::clear_has_deprecated() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void FieldOptions::clear_deprecated() {
+  deprecated_ = false;
+  clear_has_deprecated();
+}
+inline bool FieldOptions::deprecated() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FieldOptions.deprecated)
+  return deprecated_;
+}
+inline void FieldOptions::set_deprecated(bool value) {
+  set_has_deprecated();
+  deprecated_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.FieldOptions.deprecated)
+}
+
+// optional bool weak = 10 [default = false];
+inline bool FieldOptions::has_weak() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void FieldOptions::set_has_weak() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void FieldOptions::clear_has_weak() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void FieldOptions::clear_weak() {
+  weak_ = false;
+  clear_has_weak();
+}
+inline bool FieldOptions::weak() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FieldOptions.weak)
+  return weak_;
+}
+inline void FieldOptions::set_weak(bool value) {
+  set_has_weak();
+  weak_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.FieldOptions.weak)
+}
+
+// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
+inline int FieldOptions::uninterpreted_option_size() const {
+  return uninterpreted_option_.size();
+}
+inline void FieldOptions::clear_uninterpreted_option() {
+  uninterpreted_option_.Clear();
+}
+inline const ::google::protobuf::UninterpretedOption& FieldOptions::uninterpreted_option(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FieldOptions.uninterpreted_option)
+  return uninterpreted_option_.Get(index);
+}
+inline ::google::protobuf::UninterpretedOption* FieldOptions::mutable_uninterpreted_option(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FieldOptions.uninterpreted_option)
+  return uninterpreted_option_.Mutable(index);
+}
+inline ::google::protobuf::UninterpretedOption* FieldOptions::add_uninterpreted_option() {
+  // @@protoc_insertion_point(field_add:google.protobuf.FieldOptions.uninterpreted_option)
+  return uninterpreted_option_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >*
+FieldOptions::mutable_uninterpreted_option() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.FieldOptions.uninterpreted_option)
+  return &uninterpreted_option_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >&
+FieldOptions::uninterpreted_option() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.FieldOptions.uninterpreted_option)
+  return uninterpreted_option_;
+}
+
+// -------------------------------------------------------------------
+
+// OneofOptions
+
+// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
+inline int OneofOptions::uninterpreted_option_size() const {
+  return uninterpreted_option_.size();
+}
+inline void OneofOptions::clear_uninterpreted_option() {
+  uninterpreted_option_.Clear();
+}
+inline const ::google::protobuf::UninterpretedOption& OneofOptions::uninterpreted_option(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.OneofOptions.uninterpreted_option)
+  return uninterpreted_option_.Get(index);
+}
+inline ::google::protobuf::UninterpretedOption* OneofOptions::mutable_uninterpreted_option(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.OneofOptions.uninterpreted_option)
+  return uninterpreted_option_.Mutable(index);
+}
+inline ::google::protobuf::UninterpretedOption* OneofOptions::add_uninterpreted_option() {
+  // @@protoc_insertion_point(field_add:google.protobuf.OneofOptions.uninterpreted_option)
+  return uninterpreted_option_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >*
+OneofOptions::mutable_uninterpreted_option() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.OneofOptions.uninterpreted_option)
+  return &uninterpreted_option_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >&
+OneofOptions::uninterpreted_option() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.OneofOptions.uninterpreted_option)
+  return uninterpreted_option_;
+}
+
+// -------------------------------------------------------------------
+
+// EnumOptions
+
+// optional bool allow_alias = 2;
+inline bool EnumOptions::has_allow_alias() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void EnumOptions::set_has_allow_alias() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void EnumOptions::clear_has_allow_alias() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void EnumOptions::clear_allow_alias() {
+  allow_alias_ = false;
+  clear_has_allow_alias();
+}
+inline bool EnumOptions::allow_alias() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.EnumOptions.allow_alias)
+  return allow_alias_;
+}
+inline void EnumOptions::set_allow_alias(bool value) {
+  set_has_allow_alias();
+  allow_alias_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.EnumOptions.allow_alias)
+}
+
+// optional bool deprecated = 3 [default = false];
+inline bool EnumOptions::has_deprecated() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void EnumOptions::set_has_deprecated() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void EnumOptions::clear_has_deprecated() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void EnumOptions::clear_deprecated() {
+  deprecated_ = false;
+  clear_has_deprecated();
+}
+inline bool EnumOptions::deprecated() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.EnumOptions.deprecated)
+  return deprecated_;
+}
+inline void EnumOptions::set_deprecated(bool value) {
+  set_has_deprecated();
+  deprecated_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.EnumOptions.deprecated)
+}
+
+// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
+inline int EnumOptions::uninterpreted_option_size() const {
+  return uninterpreted_option_.size();
+}
+inline void EnumOptions::clear_uninterpreted_option() {
+  uninterpreted_option_.Clear();
+}
+inline const ::google::protobuf::UninterpretedOption& EnumOptions::uninterpreted_option(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.EnumOptions.uninterpreted_option)
+  return uninterpreted_option_.Get(index);
+}
+inline ::google::protobuf::UninterpretedOption* EnumOptions::mutable_uninterpreted_option(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.EnumOptions.uninterpreted_option)
+  return uninterpreted_option_.Mutable(index);
+}
+inline ::google::protobuf::UninterpretedOption* EnumOptions::add_uninterpreted_option() {
+  // @@protoc_insertion_point(field_add:google.protobuf.EnumOptions.uninterpreted_option)
+  return uninterpreted_option_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >*
+EnumOptions::mutable_uninterpreted_option() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.EnumOptions.uninterpreted_option)
+  return &uninterpreted_option_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >&
+EnumOptions::uninterpreted_option() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.EnumOptions.uninterpreted_option)
+  return uninterpreted_option_;
+}
+
+// -------------------------------------------------------------------
+
+// EnumValueOptions
+
+// optional bool deprecated = 1 [default = false];
+inline bool EnumValueOptions::has_deprecated() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void EnumValueOptions::set_has_deprecated() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void EnumValueOptions::clear_has_deprecated() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void EnumValueOptions::clear_deprecated() {
+  deprecated_ = false;
+  clear_has_deprecated();
+}
+inline bool EnumValueOptions::deprecated() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.EnumValueOptions.deprecated)
+  return deprecated_;
+}
+inline void EnumValueOptions::set_deprecated(bool value) {
+  set_has_deprecated();
+  deprecated_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.EnumValueOptions.deprecated)
+}
+
+// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
+inline int EnumValueOptions::uninterpreted_option_size() const {
+  return uninterpreted_option_.size();
+}
+inline void EnumValueOptions::clear_uninterpreted_option() {
+  uninterpreted_option_.Clear();
+}
+inline const ::google::protobuf::UninterpretedOption& EnumValueOptions::uninterpreted_option(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.EnumValueOptions.uninterpreted_option)
+  return uninterpreted_option_.Get(index);
+}
+inline ::google::protobuf::UninterpretedOption* EnumValueOptions::mutable_uninterpreted_option(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.EnumValueOptions.uninterpreted_option)
+  return uninterpreted_option_.Mutable(index);
+}
+inline ::google::protobuf::UninterpretedOption* EnumValueOptions::add_uninterpreted_option() {
+  // @@protoc_insertion_point(field_add:google.protobuf.EnumValueOptions.uninterpreted_option)
+  return uninterpreted_option_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >*
+EnumValueOptions::mutable_uninterpreted_option() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.EnumValueOptions.uninterpreted_option)
+  return &uninterpreted_option_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >&
+EnumValueOptions::uninterpreted_option() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.EnumValueOptions.uninterpreted_option)
+  return uninterpreted_option_;
+}
+
+// -------------------------------------------------------------------
+
+// ServiceOptions
+
+// optional bool deprecated = 33 [default = false];
+inline bool ServiceOptions::has_deprecated() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void ServiceOptions::set_has_deprecated() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void ServiceOptions::clear_has_deprecated() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void ServiceOptions::clear_deprecated() {
+  deprecated_ = false;
+  clear_has_deprecated();
+}
+inline bool ServiceOptions::deprecated() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.ServiceOptions.deprecated)
+  return deprecated_;
+}
+inline void ServiceOptions::set_deprecated(bool value) {
+  set_has_deprecated();
+  deprecated_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.ServiceOptions.deprecated)
+}
+
+// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
+inline int ServiceOptions::uninterpreted_option_size() const {
+  return uninterpreted_option_.size();
+}
+inline void ServiceOptions::clear_uninterpreted_option() {
+  uninterpreted_option_.Clear();
+}
+inline const ::google::protobuf::UninterpretedOption& ServiceOptions::uninterpreted_option(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.ServiceOptions.uninterpreted_option)
+  return uninterpreted_option_.Get(index);
+}
+inline ::google::protobuf::UninterpretedOption* ServiceOptions::mutable_uninterpreted_option(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.ServiceOptions.uninterpreted_option)
+  return uninterpreted_option_.Mutable(index);
+}
+inline ::google::protobuf::UninterpretedOption* ServiceOptions::add_uninterpreted_option() {
+  // @@protoc_insertion_point(field_add:google.protobuf.ServiceOptions.uninterpreted_option)
+  return uninterpreted_option_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >*
+ServiceOptions::mutable_uninterpreted_option() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.ServiceOptions.uninterpreted_option)
+  return &uninterpreted_option_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >&
+ServiceOptions::uninterpreted_option() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.ServiceOptions.uninterpreted_option)
+  return uninterpreted_option_;
+}
+
+// -------------------------------------------------------------------
+
+// MethodOptions
+
+// optional bool deprecated = 33 [default = false];
+inline bool MethodOptions::has_deprecated() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void MethodOptions::set_has_deprecated() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void MethodOptions::clear_has_deprecated() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void MethodOptions::clear_deprecated() {
+  deprecated_ = false;
+  clear_has_deprecated();
+}
+inline bool MethodOptions::deprecated() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.MethodOptions.deprecated)
+  return deprecated_;
+}
+inline void MethodOptions::set_deprecated(bool value) {
+  set_has_deprecated();
+  deprecated_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.MethodOptions.deprecated)
+}
+
+// optional .google.protobuf.MethodOptions.IdempotencyLevel idempotency_level = 34 [default = IDEMPOTENCY_UNKNOWN];
+inline bool MethodOptions::has_idempotency_level() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void MethodOptions::set_has_idempotency_level() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void MethodOptions::clear_has_idempotency_level() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void MethodOptions::clear_idempotency_level() {
+  idempotency_level_ = 0;
+  clear_has_idempotency_level();
+}
+inline ::google::protobuf::MethodOptions_IdempotencyLevel MethodOptions::idempotency_level() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.MethodOptions.idempotency_level)
+  return static_cast< ::google::protobuf::MethodOptions_IdempotencyLevel >(idempotency_level_);
+}
+inline void MethodOptions::set_idempotency_level(::google::protobuf::MethodOptions_IdempotencyLevel value) {
+  assert(::google::protobuf::MethodOptions_IdempotencyLevel_IsValid(value));
+  set_has_idempotency_level();
+  idempotency_level_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.MethodOptions.idempotency_level)
+}
+
+// repeated .google.protobuf.UninterpretedOption uninterpreted_option = 999;
+inline int MethodOptions::uninterpreted_option_size() const {
+  return uninterpreted_option_.size();
+}
+inline void MethodOptions::clear_uninterpreted_option() {
+  uninterpreted_option_.Clear();
+}
+inline const ::google::protobuf::UninterpretedOption& MethodOptions::uninterpreted_option(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.MethodOptions.uninterpreted_option)
+  return uninterpreted_option_.Get(index);
+}
+inline ::google::protobuf::UninterpretedOption* MethodOptions::mutable_uninterpreted_option(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.MethodOptions.uninterpreted_option)
+  return uninterpreted_option_.Mutable(index);
+}
+inline ::google::protobuf::UninterpretedOption* MethodOptions::add_uninterpreted_option() {
+  // @@protoc_insertion_point(field_add:google.protobuf.MethodOptions.uninterpreted_option)
+  return uninterpreted_option_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >*
+MethodOptions::mutable_uninterpreted_option() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.MethodOptions.uninterpreted_option)
+  return &uninterpreted_option_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption >&
+MethodOptions::uninterpreted_option() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.MethodOptions.uninterpreted_option)
+  return uninterpreted_option_;
+}
+
+// -------------------------------------------------------------------
+
+// UninterpretedOption_NamePart
+
+// required string name_part = 1;
+inline bool UninterpretedOption_NamePart::has_name_part() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void UninterpretedOption_NamePart::set_has_name_part() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void UninterpretedOption_NamePart::clear_has_name_part() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void UninterpretedOption_NamePart::clear_name_part() {
+  name_part_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+  clear_has_name_part();
+}
+inline const ::std::string& UninterpretedOption_NamePart::name_part() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.UninterpretedOption.NamePart.name_part)
+  return name_part_.Get();
+}
+inline void UninterpretedOption_NamePart::set_name_part(const ::std::string& value) {
+  set_has_name_part();
+  name_part_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set:google.protobuf.UninterpretedOption.NamePart.name_part)
+}
+#if LANG_CXX11
+inline void UninterpretedOption_NamePart::set_name_part(::std::string&& value) {
+  set_has_name_part();
+  name_part_.Set(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.UninterpretedOption.NamePart.name_part)
+}
+#endif
+inline void UninterpretedOption_NamePart::set_name_part(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  set_has_name_part();
+  name_part_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
+              GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_char:google.protobuf.UninterpretedOption.NamePart.name_part)
+}
+inline void UninterpretedOption_NamePart::set_name_part(const char* value,
+    size_t size) {
+  set_has_name_part();
+  name_part_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
+      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.UninterpretedOption.NamePart.name_part)
+}
+inline ::std::string* UninterpretedOption_NamePart::mutable_name_part() {
+  set_has_name_part();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.UninterpretedOption.NamePart.name_part)
+  return name_part_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline ::std::string* UninterpretedOption_NamePart::release_name_part() {
+  // @@protoc_insertion_point(field_release:google.protobuf.UninterpretedOption.NamePart.name_part)
+  clear_has_name_part();
+  return name_part_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline void UninterpretedOption_NamePart::set_allocated_name_part(::std::string* name_part) {
+  if (name_part != NULL) {
+    set_has_name_part();
+  } else {
+    clear_has_name_part();
+  }
+  name_part_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name_part,
+      GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.UninterpretedOption.NamePart.name_part)
+}
+inline ::std::string* UninterpretedOption_NamePart::unsafe_arena_release_name_part() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.UninterpretedOption.NamePart.name_part)
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  clear_has_name_part();
+  return name_part_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      GetArenaNoVirtual());
+}
+inline void UninterpretedOption_NamePart::unsafe_arena_set_allocated_name_part(
+    ::std::string* name_part) {
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  if (name_part != NULL) {
+    set_has_name_part();
+  } else {
+    clear_has_name_part();
+  }
+  name_part_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      name_part, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.UninterpretedOption.NamePart.name_part)
+}
+
+// required bool is_extension = 2;
+inline bool UninterpretedOption_NamePart::has_is_extension() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void UninterpretedOption_NamePart::set_has_is_extension() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void UninterpretedOption_NamePart::clear_has_is_extension() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void UninterpretedOption_NamePart::clear_is_extension() {
+  is_extension_ = false;
+  clear_has_is_extension();
+}
+inline bool UninterpretedOption_NamePart::is_extension() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.UninterpretedOption.NamePart.is_extension)
+  return is_extension_;
+}
+inline void UninterpretedOption_NamePart::set_is_extension(bool value) {
+  set_has_is_extension();
+  is_extension_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.UninterpretedOption.NamePart.is_extension)
+}
+
+// -------------------------------------------------------------------
+
+// UninterpretedOption
+
+// repeated .google.protobuf.UninterpretedOption.NamePart name = 2;
+inline int UninterpretedOption::name_size() const {
+  return name_.size();
+}
+inline void UninterpretedOption::clear_name() {
+  name_.Clear();
+}
+inline const ::google::protobuf::UninterpretedOption_NamePart& UninterpretedOption::name(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.UninterpretedOption.name)
+  return name_.Get(index);
+}
+inline ::google::protobuf::UninterpretedOption_NamePart* UninterpretedOption::mutable_name(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.UninterpretedOption.name)
+  return name_.Mutable(index);
+}
+inline ::google::protobuf::UninterpretedOption_NamePart* UninterpretedOption::add_name() {
+  // @@protoc_insertion_point(field_add:google.protobuf.UninterpretedOption.name)
+  return name_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption_NamePart >*
+UninterpretedOption::mutable_name() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.UninterpretedOption.name)
+  return &name_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::UninterpretedOption_NamePart >&
+UninterpretedOption::name() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.UninterpretedOption.name)
+  return name_;
+}
+
+// optional string identifier_value = 3;
+inline bool UninterpretedOption::has_identifier_value() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void UninterpretedOption::set_has_identifier_value() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void UninterpretedOption::clear_has_identifier_value() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void UninterpretedOption::clear_identifier_value() {
+  identifier_value_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+  clear_has_identifier_value();
+}
+inline const ::std::string& UninterpretedOption::identifier_value() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.UninterpretedOption.identifier_value)
+  return identifier_value_.Get();
+}
+inline void UninterpretedOption::set_identifier_value(const ::std::string& value) {
+  set_has_identifier_value();
+  identifier_value_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set:google.protobuf.UninterpretedOption.identifier_value)
+}
+#if LANG_CXX11
+inline void UninterpretedOption::set_identifier_value(::std::string&& value) {
+  set_has_identifier_value();
+  identifier_value_.Set(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.UninterpretedOption.identifier_value)
+}
+#endif
+inline void UninterpretedOption::set_identifier_value(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  set_has_identifier_value();
+  identifier_value_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
+              GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_char:google.protobuf.UninterpretedOption.identifier_value)
+}
+inline void UninterpretedOption::set_identifier_value(const char* value,
+    size_t size) {
+  set_has_identifier_value();
+  identifier_value_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
+      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.UninterpretedOption.identifier_value)
+}
+inline ::std::string* UninterpretedOption::mutable_identifier_value() {
+  set_has_identifier_value();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.UninterpretedOption.identifier_value)
+  return identifier_value_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline ::std::string* UninterpretedOption::release_identifier_value() {
+  // @@protoc_insertion_point(field_release:google.protobuf.UninterpretedOption.identifier_value)
+  clear_has_identifier_value();
+  return identifier_value_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline void UninterpretedOption::set_allocated_identifier_value(::std::string* identifier_value) {
+  if (identifier_value != NULL) {
+    set_has_identifier_value();
+  } else {
+    clear_has_identifier_value();
+  }
+  identifier_value_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), identifier_value,
+      GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.UninterpretedOption.identifier_value)
+}
+inline ::std::string* UninterpretedOption::unsafe_arena_release_identifier_value() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.UninterpretedOption.identifier_value)
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  clear_has_identifier_value();
+  return identifier_value_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      GetArenaNoVirtual());
+}
+inline void UninterpretedOption::unsafe_arena_set_allocated_identifier_value(
+    ::std::string* identifier_value) {
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  if (identifier_value != NULL) {
+    set_has_identifier_value();
+  } else {
+    clear_has_identifier_value();
+  }
+  identifier_value_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      identifier_value, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.UninterpretedOption.identifier_value)
+}
+
+// optional uint64 positive_int_value = 4;
+inline bool UninterpretedOption::has_positive_int_value() const {
+  return (_has_bits_[0] & 0x00000008u) != 0;
+}
+inline void UninterpretedOption::set_has_positive_int_value() {
+  _has_bits_[0] |= 0x00000008u;
+}
+inline void UninterpretedOption::clear_has_positive_int_value() {
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline void UninterpretedOption::clear_positive_int_value() {
+  positive_int_value_ = GOOGLE_ULONGLONG(0);
+  clear_has_positive_int_value();
+}
+inline ::google::protobuf::uint64 UninterpretedOption::positive_int_value() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.UninterpretedOption.positive_int_value)
+  return positive_int_value_;
+}
+inline void UninterpretedOption::set_positive_int_value(::google::protobuf::uint64 value) {
+  set_has_positive_int_value();
+  positive_int_value_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.UninterpretedOption.positive_int_value)
+}
+
+// optional int64 negative_int_value = 5;
+inline bool UninterpretedOption::has_negative_int_value() const {
+  return (_has_bits_[0] & 0x00000010u) != 0;
+}
+inline void UninterpretedOption::set_has_negative_int_value() {
+  _has_bits_[0] |= 0x00000010u;
+}
+inline void UninterpretedOption::clear_has_negative_int_value() {
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline void UninterpretedOption::clear_negative_int_value() {
+  negative_int_value_ = GOOGLE_LONGLONG(0);
+  clear_has_negative_int_value();
+}
+inline ::google::protobuf::int64 UninterpretedOption::negative_int_value() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.UninterpretedOption.negative_int_value)
+  return negative_int_value_;
+}
+inline void UninterpretedOption::set_negative_int_value(::google::protobuf::int64 value) {
+  set_has_negative_int_value();
+  negative_int_value_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.UninterpretedOption.negative_int_value)
+}
+
+// optional double double_value = 6;
+inline bool UninterpretedOption::has_double_value() const {
+  return (_has_bits_[0] & 0x00000020u) != 0;
+}
+inline void UninterpretedOption::set_has_double_value() {
+  _has_bits_[0] |= 0x00000020u;
+}
+inline void UninterpretedOption::clear_has_double_value() {
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline void UninterpretedOption::clear_double_value() {
+  double_value_ = 0;
+  clear_has_double_value();
+}
+inline double UninterpretedOption::double_value() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.UninterpretedOption.double_value)
+  return double_value_;
+}
+inline void UninterpretedOption::set_double_value(double value) {
+  set_has_double_value();
+  double_value_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.UninterpretedOption.double_value)
+}
+
+// optional bytes string_value = 7;
+inline bool UninterpretedOption::has_string_value() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void UninterpretedOption::set_has_string_value() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void UninterpretedOption::clear_has_string_value() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void UninterpretedOption::clear_string_value() {
+  string_value_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+  clear_has_string_value();
+}
+inline const ::std::string& UninterpretedOption::string_value() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.UninterpretedOption.string_value)
+  return string_value_.Get();
+}
+inline void UninterpretedOption::set_string_value(const ::std::string& value) {
+  set_has_string_value();
+  string_value_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set:google.protobuf.UninterpretedOption.string_value)
+}
+#if LANG_CXX11
+inline void UninterpretedOption::set_string_value(::std::string&& value) {
+  set_has_string_value();
+  string_value_.Set(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.UninterpretedOption.string_value)
+}
+#endif
+inline void UninterpretedOption::set_string_value(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  set_has_string_value();
+  string_value_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
+              GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_char:google.protobuf.UninterpretedOption.string_value)
+}
+inline void UninterpretedOption::set_string_value(const void* value,
+    size_t size) {
+  set_has_string_value();
+  string_value_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
+      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.UninterpretedOption.string_value)
+}
+inline ::std::string* UninterpretedOption::mutable_string_value() {
+  set_has_string_value();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.UninterpretedOption.string_value)
+  return string_value_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline ::std::string* UninterpretedOption::release_string_value() {
+  // @@protoc_insertion_point(field_release:google.protobuf.UninterpretedOption.string_value)
+  clear_has_string_value();
+  return string_value_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline void UninterpretedOption::set_allocated_string_value(::std::string* string_value) {
+  if (string_value != NULL) {
+    set_has_string_value();
+  } else {
+    clear_has_string_value();
+  }
+  string_value_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), string_value,
+      GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.UninterpretedOption.string_value)
+}
+inline ::std::string* UninterpretedOption::unsafe_arena_release_string_value() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.UninterpretedOption.string_value)
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  clear_has_string_value();
+  return string_value_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      GetArenaNoVirtual());
+}
+inline void UninterpretedOption::unsafe_arena_set_allocated_string_value(
+    ::std::string* string_value) {
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  if (string_value != NULL) {
+    set_has_string_value();
+  } else {
+    clear_has_string_value();
+  }
+  string_value_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      string_value, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.UninterpretedOption.string_value)
+}
+
+// optional string aggregate_value = 8;
+inline bool UninterpretedOption::has_aggregate_value() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void UninterpretedOption::set_has_aggregate_value() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void UninterpretedOption::clear_has_aggregate_value() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void UninterpretedOption::clear_aggregate_value() {
+  aggregate_value_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+  clear_has_aggregate_value();
+}
+inline const ::std::string& UninterpretedOption::aggregate_value() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.UninterpretedOption.aggregate_value)
+  return aggregate_value_.Get();
+}
+inline void UninterpretedOption::set_aggregate_value(const ::std::string& value) {
+  set_has_aggregate_value();
+  aggregate_value_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set:google.protobuf.UninterpretedOption.aggregate_value)
+}
+#if LANG_CXX11
+inline void UninterpretedOption::set_aggregate_value(::std::string&& value) {
+  set_has_aggregate_value();
+  aggregate_value_.Set(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.UninterpretedOption.aggregate_value)
+}
+#endif
+inline void UninterpretedOption::set_aggregate_value(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  set_has_aggregate_value();
+  aggregate_value_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
+              GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_char:google.protobuf.UninterpretedOption.aggregate_value)
+}
+inline void UninterpretedOption::set_aggregate_value(const char* value,
+    size_t size) {
+  set_has_aggregate_value();
+  aggregate_value_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
+      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.UninterpretedOption.aggregate_value)
+}
+inline ::std::string* UninterpretedOption::mutable_aggregate_value() {
+  set_has_aggregate_value();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.UninterpretedOption.aggregate_value)
+  return aggregate_value_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline ::std::string* UninterpretedOption::release_aggregate_value() {
+  // @@protoc_insertion_point(field_release:google.protobuf.UninterpretedOption.aggregate_value)
+  clear_has_aggregate_value();
+  return aggregate_value_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline void UninterpretedOption::set_allocated_aggregate_value(::std::string* aggregate_value) {
+  if (aggregate_value != NULL) {
+    set_has_aggregate_value();
+  } else {
+    clear_has_aggregate_value();
+  }
+  aggregate_value_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), aggregate_value,
+      GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.UninterpretedOption.aggregate_value)
+}
+inline ::std::string* UninterpretedOption::unsafe_arena_release_aggregate_value() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.UninterpretedOption.aggregate_value)
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  clear_has_aggregate_value();
+  return aggregate_value_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      GetArenaNoVirtual());
+}
+inline void UninterpretedOption::unsafe_arena_set_allocated_aggregate_value(
+    ::std::string* aggregate_value) {
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  if (aggregate_value != NULL) {
+    set_has_aggregate_value();
+  } else {
+    clear_has_aggregate_value();
+  }
+  aggregate_value_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      aggregate_value, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.UninterpretedOption.aggregate_value)
+}
+
+// -------------------------------------------------------------------
+
+// SourceCodeInfo_Location
+
+// repeated int32 path = 1 [packed = true];
+inline int SourceCodeInfo_Location::path_size() const {
+  return path_.size();
+}
+inline void SourceCodeInfo_Location::clear_path() {
+  path_.Clear();
+}
+inline ::google::protobuf::int32 SourceCodeInfo_Location::path(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.SourceCodeInfo.Location.path)
+  return path_.Get(index);
+}
+inline void SourceCodeInfo_Location::set_path(int index, ::google::protobuf::int32 value) {
+  path_.Set(index, value);
+  // @@protoc_insertion_point(field_set:google.protobuf.SourceCodeInfo.Location.path)
+}
+inline void SourceCodeInfo_Location::add_path(::google::protobuf::int32 value) {
+  path_.Add(value);
+  // @@protoc_insertion_point(field_add:google.protobuf.SourceCodeInfo.Location.path)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
+SourceCodeInfo_Location::path() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.SourceCodeInfo.Location.path)
+  return path_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
+SourceCodeInfo_Location::mutable_path() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.SourceCodeInfo.Location.path)
+  return &path_;
+}
+
+// repeated int32 span = 2 [packed = true];
+inline int SourceCodeInfo_Location::span_size() const {
+  return span_.size();
+}
+inline void SourceCodeInfo_Location::clear_span() {
+  span_.Clear();
+}
+inline ::google::protobuf::int32 SourceCodeInfo_Location::span(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.SourceCodeInfo.Location.span)
+  return span_.Get(index);
+}
+inline void SourceCodeInfo_Location::set_span(int index, ::google::protobuf::int32 value) {
+  span_.Set(index, value);
+  // @@protoc_insertion_point(field_set:google.protobuf.SourceCodeInfo.Location.span)
+}
+inline void SourceCodeInfo_Location::add_span(::google::protobuf::int32 value) {
+  span_.Add(value);
+  // @@protoc_insertion_point(field_add:google.protobuf.SourceCodeInfo.Location.span)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
+SourceCodeInfo_Location::span() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.SourceCodeInfo.Location.span)
+  return span_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
+SourceCodeInfo_Location::mutable_span() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.SourceCodeInfo.Location.span)
+  return &span_;
+}
+
+// optional string leading_comments = 3;
+inline bool SourceCodeInfo_Location::has_leading_comments() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void SourceCodeInfo_Location::set_has_leading_comments() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void SourceCodeInfo_Location::clear_has_leading_comments() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void SourceCodeInfo_Location::clear_leading_comments() {
+  leading_comments_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+  clear_has_leading_comments();
+}
+inline const ::std::string& SourceCodeInfo_Location::leading_comments() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.SourceCodeInfo.Location.leading_comments)
+  return leading_comments_.Get();
+}
+inline void SourceCodeInfo_Location::set_leading_comments(const ::std::string& value) {
+  set_has_leading_comments();
+  leading_comments_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set:google.protobuf.SourceCodeInfo.Location.leading_comments)
+}
+#if LANG_CXX11
+inline void SourceCodeInfo_Location::set_leading_comments(::std::string&& value) {
+  set_has_leading_comments();
+  leading_comments_.Set(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.SourceCodeInfo.Location.leading_comments)
+}
+#endif
+inline void SourceCodeInfo_Location::set_leading_comments(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  set_has_leading_comments();
+  leading_comments_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
+              GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_char:google.protobuf.SourceCodeInfo.Location.leading_comments)
+}
+inline void SourceCodeInfo_Location::set_leading_comments(const char* value,
+    size_t size) {
+  set_has_leading_comments();
+  leading_comments_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
+      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.SourceCodeInfo.Location.leading_comments)
+}
+inline ::std::string* SourceCodeInfo_Location::mutable_leading_comments() {
+  set_has_leading_comments();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.SourceCodeInfo.Location.leading_comments)
+  return leading_comments_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline ::std::string* SourceCodeInfo_Location::release_leading_comments() {
+  // @@protoc_insertion_point(field_release:google.protobuf.SourceCodeInfo.Location.leading_comments)
+  clear_has_leading_comments();
+  return leading_comments_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline void SourceCodeInfo_Location::set_allocated_leading_comments(::std::string* leading_comments) {
+  if (leading_comments != NULL) {
+    set_has_leading_comments();
+  } else {
+    clear_has_leading_comments();
+  }
+  leading_comments_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), leading_comments,
+      GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.SourceCodeInfo.Location.leading_comments)
+}
+inline ::std::string* SourceCodeInfo_Location::unsafe_arena_release_leading_comments() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.SourceCodeInfo.Location.leading_comments)
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  clear_has_leading_comments();
+  return leading_comments_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      GetArenaNoVirtual());
+}
+inline void SourceCodeInfo_Location::unsafe_arena_set_allocated_leading_comments(
+    ::std::string* leading_comments) {
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  if (leading_comments != NULL) {
+    set_has_leading_comments();
+  } else {
+    clear_has_leading_comments();
+  }
+  leading_comments_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      leading_comments, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.SourceCodeInfo.Location.leading_comments)
+}
+
+// optional string trailing_comments = 4;
+inline bool SourceCodeInfo_Location::has_trailing_comments() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void SourceCodeInfo_Location::set_has_trailing_comments() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void SourceCodeInfo_Location::clear_has_trailing_comments() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void SourceCodeInfo_Location::clear_trailing_comments() {
+  trailing_comments_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+  clear_has_trailing_comments();
+}
+inline const ::std::string& SourceCodeInfo_Location::trailing_comments() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.SourceCodeInfo.Location.trailing_comments)
+  return trailing_comments_.Get();
+}
+inline void SourceCodeInfo_Location::set_trailing_comments(const ::std::string& value) {
+  set_has_trailing_comments();
+  trailing_comments_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set:google.protobuf.SourceCodeInfo.Location.trailing_comments)
+}
+#if LANG_CXX11
+inline void SourceCodeInfo_Location::set_trailing_comments(::std::string&& value) {
+  set_has_trailing_comments();
+  trailing_comments_.Set(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.SourceCodeInfo.Location.trailing_comments)
+}
+#endif
+inline void SourceCodeInfo_Location::set_trailing_comments(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  set_has_trailing_comments();
+  trailing_comments_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
+              GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_char:google.protobuf.SourceCodeInfo.Location.trailing_comments)
+}
+inline void SourceCodeInfo_Location::set_trailing_comments(const char* value,
+    size_t size) {
+  set_has_trailing_comments();
+  trailing_comments_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
+      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.SourceCodeInfo.Location.trailing_comments)
+}
+inline ::std::string* SourceCodeInfo_Location::mutable_trailing_comments() {
+  set_has_trailing_comments();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.SourceCodeInfo.Location.trailing_comments)
+  return trailing_comments_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline ::std::string* SourceCodeInfo_Location::release_trailing_comments() {
+  // @@protoc_insertion_point(field_release:google.protobuf.SourceCodeInfo.Location.trailing_comments)
+  clear_has_trailing_comments();
+  return trailing_comments_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline void SourceCodeInfo_Location::set_allocated_trailing_comments(::std::string* trailing_comments) {
+  if (trailing_comments != NULL) {
+    set_has_trailing_comments();
+  } else {
+    clear_has_trailing_comments();
+  }
+  trailing_comments_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), trailing_comments,
+      GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.SourceCodeInfo.Location.trailing_comments)
+}
+inline ::std::string* SourceCodeInfo_Location::unsafe_arena_release_trailing_comments() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.SourceCodeInfo.Location.trailing_comments)
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  clear_has_trailing_comments();
+  return trailing_comments_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      GetArenaNoVirtual());
+}
+inline void SourceCodeInfo_Location::unsafe_arena_set_allocated_trailing_comments(
+    ::std::string* trailing_comments) {
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  if (trailing_comments != NULL) {
+    set_has_trailing_comments();
+  } else {
+    clear_has_trailing_comments();
+  }
+  trailing_comments_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      trailing_comments, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.SourceCodeInfo.Location.trailing_comments)
+}
+
+// repeated string leading_detached_comments = 6;
+inline int SourceCodeInfo_Location::leading_detached_comments_size() const {
+  return leading_detached_comments_.size();
+}
+inline void SourceCodeInfo_Location::clear_leading_detached_comments() {
+  leading_detached_comments_.Clear();
+}
+inline const ::std::string& SourceCodeInfo_Location::leading_detached_comments(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
+  return leading_detached_comments_.Get(index);
+}
+inline ::std::string* SourceCodeInfo_Location::mutable_leading_detached_comments(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
+  return leading_detached_comments_.Mutable(index);
+}
+inline void SourceCodeInfo_Location::set_leading_detached_comments(int index, const ::std::string& value) {
+  // @@protoc_insertion_point(field_set:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
+  leading_detached_comments_.Mutable(index)->assign(value);
+}
+#if LANG_CXX11
+inline void SourceCodeInfo_Location::set_leading_detached_comments(int index, ::std::string&& value) {
+  // @@protoc_insertion_point(field_set:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
+  leading_detached_comments_.Mutable(index)->assign(std::move(value));
+}
+#endif
+inline void SourceCodeInfo_Location::set_leading_detached_comments(int index, const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  leading_detached_comments_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
+}
+inline void SourceCodeInfo_Location::set_leading_detached_comments(int index, const char* value, size_t size) {
+  leading_detached_comments_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
+}
+inline ::std::string* SourceCodeInfo_Location::add_leading_detached_comments() {
+  // @@protoc_insertion_point(field_add_mutable:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
+  return leading_detached_comments_.Add();
+}
+inline void SourceCodeInfo_Location::add_leading_detached_comments(const ::std::string& value) {
+  leading_detached_comments_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
+}
+#if LANG_CXX11
+inline void SourceCodeInfo_Location::add_leading_detached_comments(::std::string&& value) {
+  leading_detached_comments_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
+}
+#endif
+inline void SourceCodeInfo_Location::add_leading_detached_comments(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  leading_detached_comments_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
+}
+inline void SourceCodeInfo_Location::add_leading_detached_comments(const char* value, size_t size) {
+  leading_detached_comments_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
+}
+inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
+SourceCodeInfo_Location::leading_detached_comments() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
+  return leading_detached_comments_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::std::string>*
+SourceCodeInfo_Location::mutable_leading_detached_comments() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.SourceCodeInfo.Location.leading_detached_comments)
+  return &leading_detached_comments_;
+}
+
+// -------------------------------------------------------------------
+
+// SourceCodeInfo
+
+// repeated .google.protobuf.SourceCodeInfo.Location location = 1;
+inline int SourceCodeInfo::location_size() const {
+  return location_.size();
+}
+inline void SourceCodeInfo::clear_location() {
+  location_.Clear();
+}
+inline const ::google::protobuf::SourceCodeInfo_Location& SourceCodeInfo::location(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.SourceCodeInfo.location)
+  return location_.Get(index);
+}
+inline ::google::protobuf::SourceCodeInfo_Location* SourceCodeInfo::mutable_location(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.SourceCodeInfo.location)
+  return location_.Mutable(index);
+}
+inline ::google::protobuf::SourceCodeInfo_Location* SourceCodeInfo::add_location() {
+  // @@protoc_insertion_point(field_add:google.protobuf.SourceCodeInfo.location)
+  return location_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::SourceCodeInfo_Location >*
+SourceCodeInfo::mutable_location() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.SourceCodeInfo.location)
+  return &location_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::SourceCodeInfo_Location >&
+SourceCodeInfo::location() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.SourceCodeInfo.location)
+  return location_;
+}
+
+// -------------------------------------------------------------------
+
+// GeneratedCodeInfo_Annotation
+
+// repeated int32 path = 1 [packed = true];
+inline int GeneratedCodeInfo_Annotation::path_size() const {
+  return path_.size();
+}
+inline void GeneratedCodeInfo_Annotation::clear_path() {
+  path_.Clear();
+}
+inline ::google::protobuf::int32 GeneratedCodeInfo_Annotation::path(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.GeneratedCodeInfo.Annotation.path)
+  return path_.Get(index);
+}
+inline void GeneratedCodeInfo_Annotation::set_path(int index, ::google::protobuf::int32 value) {
+  path_.Set(index, value);
+  // @@protoc_insertion_point(field_set:google.protobuf.GeneratedCodeInfo.Annotation.path)
+}
+inline void GeneratedCodeInfo_Annotation::add_path(::google::protobuf::int32 value) {
+  path_.Add(value);
+  // @@protoc_insertion_point(field_add:google.protobuf.GeneratedCodeInfo.Annotation.path)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::int32 >&
+GeneratedCodeInfo_Annotation::path() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.GeneratedCodeInfo.Annotation.path)
+  return path_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::int32 >*
+GeneratedCodeInfo_Annotation::mutable_path() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.GeneratedCodeInfo.Annotation.path)
+  return &path_;
+}
+
+// optional string source_file = 2;
+inline bool GeneratedCodeInfo_Annotation::has_source_file() const {
+  return (_has_bits_[0] & 0x00000001u) != 0;
+}
+inline void GeneratedCodeInfo_Annotation::set_has_source_file() {
+  _has_bits_[0] |= 0x00000001u;
+}
+inline void GeneratedCodeInfo_Annotation::clear_has_source_file() {
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline void GeneratedCodeInfo_Annotation::clear_source_file() {
+  source_file_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+  clear_has_source_file();
+}
+inline const ::std::string& GeneratedCodeInfo_Annotation::source_file() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.GeneratedCodeInfo.Annotation.source_file)
+  return source_file_.Get();
+}
+inline void GeneratedCodeInfo_Annotation::set_source_file(const ::std::string& value) {
+  set_has_source_file();
+  source_file_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set:google.protobuf.GeneratedCodeInfo.Annotation.source_file)
+}
+#if LANG_CXX11
+inline void GeneratedCodeInfo_Annotation::set_source_file(::std::string&& value) {
+  set_has_source_file();
+  source_file_.Set(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.GeneratedCodeInfo.Annotation.source_file)
+}
+#endif
+inline void GeneratedCodeInfo_Annotation::set_source_file(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  set_has_source_file();
+  source_file_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
+              GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_char:google.protobuf.GeneratedCodeInfo.Annotation.source_file)
+}
+inline void GeneratedCodeInfo_Annotation::set_source_file(const char* value,
+    size_t size) {
+  set_has_source_file();
+  source_file_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
+      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.GeneratedCodeInfo.Annotation.source_file)
+}
+inline ::std::string* GeneratedCodeInfo_Annotation::mutable_source_file() {
+  set_has_source_file();
+  // @@protoc_insertion_point(field_mutable:google.protobuf.GeneratedCodeInfo.Annotation.source_file)
+  return source_file_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline ::std::string* GeneratedCodeInfo_Annotation::release_source_file() {
+  // @@protoc_insertion_point(field_release:google.protobuf.GeneratedCodeInfo.Annotation.source_file)
+  clear_has_source_file();
+  return source_file_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline void GeneratedCodeInfo_Annotation::set_allocated_source_file(::std::string* source_file) {
+  if (source_file != NULL) {
+    set_has_source_file();
+  } else {
+    clear_has_source_file();
+  }
+  source_file_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), source_file,
+      GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.GeneratedCodeInfo.Annotation.source_file)
+}
+inline ::std::string* GeneratedCodeInfo_Annotation::unsafe_arena_release_source_file() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.GeneratedCodeInfo.Annotation.source_file)
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  clear_has_source_file();
+  return source_file_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      GetArenaNoVirtual());
+}
+inline void GeneratedCodeInfo_Annotation::unsafe_arena_set_allocated_source_file(
+    ::std::string* source_file) {
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  if (source_file != NULL) {
+    set_has_source_file();
+  } else {
+    clear_has_source_file();
+  }
+  source_file_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      source_file, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.GeneratedCodeInfo.Annotation.source_file)
+}
+
+// optional int32 begin = 3;
+inline bool GeneratedCodeInfo_Annotation::has_begin() const {
+  return (_has_bits_[0] & 0x00000002u) != 0;
+}
+inline void GeneratedCodeInfo_Annotation::set_has_begin() {
+  _has_bits_[0] |= 0x00000002u;
+}
+inline void GeneratedCodeInfo_Annotation::clear_has_begin() {
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline void GeneratedCodeInfo_Annotation::clear_begin() {
+  begin_ = 0;
+  clear_has_begin();
+}
+inline ::google::protobuf::int32 GeneratedCodeInfo_Annotation::begin() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.GeneratedCodeInfo.Annotation.begin)
+  return begin_;
+}
+inline void GeneratedCodeInfo_Annotation::set_begin(::google::protobuf::int32 value) {
+  set_has_begin();
+  begin_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.GeneratedCodeInfo.Annotation.begin)
+}
+
+// optional int32 end = 4;
+inline bool GeneratedCodeInfo_Annotation::has_end() const {
+  return (_has_bits_[0] & 0x00000004u) != 0;
+}
+inline void GeneratedCodeInfo_Annotation::set_has_end() {
+  _has_bits_[0] |= 0x00000004u;
+}
+inline void GeneratedCodeInfo_Annotation::clear_has_end() {
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline void GeneratedCodeInfo_Annotation::clear_end() {
+  end_ = 0;
+  clear_has_end();
+}
+inline ::google::protobuf::int32 GeneratedCodeInfo_Annotation::end() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.GeneratedCodeInfo.Annotation.end)
+  return end_;
+}
+inline void GeneratedCodeInfo_Annotation::set_end(::google::protobuf::int32 value) {
+  set_has_end();
+  end_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.GeneratedCodeInfo.Annotation.end)
+}
+
+// -------------------------------------------------------------------
+
+// GeneratedCodeInfo
+
+// repeated .google.protobuf.GeneratedCodeInfo.Annotation annotation = 1;
+inline int GeneratedCodeInfo::annotation_size() const {
+  return annotation_.size();
+}
+inline void GeneratedCodeInfo::clear_annotation() {
+  annotation_.Clear();
+}
+inline const ::google::protobuf::GeneratedCodeInfo_Annotation& GeneratedCodeInfo::annotation(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.GeneratedCodeInfo.annotation)
+  return annotation_.Get(index);
+}
+inline ::google::protobuf::GeneratedCodeInfo_Annotation* GeneratedCodeInfo::mutable_annotation(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.GeneratedCodeInfo.annotation)
+  return annotation_.Mutable(index);
+}
+inline ::google::protobuf::GeneratedCodeInfo_Annotation* GeneratedCodeInfo::add_annotation() {
+  // @@protoc_insertion_point(field_add:google.protobuf.GeneratedCodeInfo.annotation)
+  return annotation_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::GeneratedCodeInfo_Annotation >*
+GeneratedCodeInfo::mutable_annotation() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.GeneratedCodeInfo.annotation)
+  return &annotation_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::GeneratedCodeInfo_Annotation >&
+GeneratedCodeInfo::annotation() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.GeneratedCodeInfo.annotation)
+  return annotation_;
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace protobuf
+}  // namespace google
+
+namespace google {
+namespace protobuf {
+
+template <> struct is_proto_enum< ::google::protobuf::FieldDescriptorProto_Type> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::google::protobuf::FieldDescriptorProto_Type>() {
+  return ::google::protobuf::FieldDescriptorProto_Type_descriptor();
+}
+template <> struct is_proto_enum< ::google::protobuf::FieldDescriptorProto_Label> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::google::protobuf::FieldDescriptorProto_Label>() {
+  return ::google::protobuf::FieldDescriptorProto_Label_descriptor();
+}
+template <> struct is_proto_enum< ::google::protobuf::FileOptions_OptimizeMode> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::google::protobuf::FileOptions_OptimizeMode>() {
+  return ::google::protobuf::FileOptions_OptimizeMode_descriptor();
+}
+template <> struct is_proto_enum< ::google::protobuf::FieldOptions_CType> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::google::protobuf::FieldOptions_CType>() {
+  return ::google::protobuf::FieldOptions_CType_descriptor();
+}
+template <> struct is_proto_enum< ::google::protobuf::FieldOptions_JSType> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::google::protobuf::FieldOptions_JSType>() {
+  return ::google::protobuf::FieldOptions_JSType_descriptor();
+}
+template <> struct is_proto_enum< ::google::protobuf::MethodOptions_IdempotencyLevel> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::google::protobuf::MethodOptions_IdempotencyLevel>() {
+  return ::google::protobuf::MethodOptions_IdempotencyLevel_descriptor();
+}
+
+}  // namespace protobuf
+}  // namespace google
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_google_2fprotobuf_2fdescriptor_2eproto__INCLUDED
diff --git a/kortex_api/include/google/protobuf/descriptor_database.h b/kortex_api/include/google/protobuf/descriptor_database.h
new file mode 100644
index 0000000000000000000000000000000000000000..28f8af7a2da0089159a9fa056cc55fed4469aff7
--- /dev/null
+++ b/kortex_api/include/google/protobuf/descriptor_database.h
@@ -0,0 +1,383 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// Interface for manipulating databases of descriptors.
+
+#ifndef GOOGLE_PROTOBUF_DESCRIPTOR_DATABASE_H__
+#define GOOGLE_PROTOBUF_DESCRIPTOR_DATABASE_H__
+
+#include <map>
+#include <string>
+#include <utility>
+#include <vector>
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/descriptor.h>
+
+namespace google {
+namespace protobuf {
+
+// Defined in this file.
+class DescriptorDatabase;
+class SimpleDescriptorDatabase;
+class EncodedDescriptorDatabase;
+class DescriptorPoolDatabase;
+class MergedDescriptorDatabase;
+
+// Abstract interface for a database of descriptors.
+//
+// This is useful if you want to create a DescriptorPool which loads
+// descriptors on-demand from some sort of large database.  If the database
+// is large, it may be inefficient to enumerate every .proto file inside it
+// calling DescriptorPool::BuildFile() for each one.  Instead, a DescriptorPool
+// can be created which wraps a DescriptorDatabase and only builds particular
+// descriptors when they are needed.
+class LIBPROTOBUF_EXPORT DescriptorDatabase {
+ public:
+  inline DescriptorDatabase() {}
+  virtual ~DescriptorDatabase();
+
+  // Find a file by file name.  Fills in in *output and returns true if found.
+  // Otherwise, returns false, leaving the contents of *output undefined.
+  virtual bool FindFileByName(const string& filename,
+                              FileDescriptorProto* output) = 0;
+
+  // Find the file that declares the given fully-qualified symbol name.
+  // If found, fills in *output and returns true, otherwise returns false
+  // and leaves *output undefined.
+  virtual bool FindFileContainingSymbol(const string& symbol_name,
+                                        FileDescriptorProto* output) = 0;
+
+  // Find the file which defines an extension extending the given message type
+  // with the given field number.  If found, fills in *output and returns true,
+  // otherwise returns false and leaves *output undefined.  containing_type
+  // must be a fully-qualified type name.
+  virtual bool FindFileContainingExtension(const string& containing_type,
+                                           int field_number,
+                                           FileDescriptorProto* output) = 0;
+
+  // Finds the tag numbers used by all known extensions of
+  // extendee_type, and appends them to output in an undefined
+  // order. This method is best-effort: it's not guaranteed that the
+  // database will find all extensions, and it's not guaranteed that
+  // FindFileContainingExtension will return true on all of the found
+  // numbers. Returns true if the search was successful, otherwise
+  // returns false and leaves output unchanged.
+  //
+  // This method has a default implementation that always returns
+  // false.
+  virtual bool FindAllExtensionNumbers(const string& /* extendee_type */,
+                                       std::vector<int>* /* output */) {
+    return false;
+  }
+
+
+  // Finds the file names and appends them to the output in an
+  // undefined order. This method is best-effort: it's not guaranteed that the
+  // database will find all files. Returns true if the database supports
+  // searching all file names, otherwise returns false and leaves output
+  // unchanged.
+  //
+  // This method has a default implementation that always returns
+  // false.
+  virtual bool FindAllFileNames(std::vector<string>* output) {
+    return false;
+  }
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(DescriptorDatabase);
+};
+
+// A DescriptorDatabase into which you can insert files manually.
+//
+// FindFileContainingSymbol() is fully-implemented.  When you add a file, its
+// symbols will be indexed for this purpose.  Note that the implementation
+// may return false positives, but only if it isn't possible for the symbol
+// to be defined in any other file.  In particular, if a file defines a symbol
+// "Foo", then searching for "Foo.[anything]" will match that file.  This way,
+// the database does not need to aggressively index all children of a symbol.
+//
+// FindFileContainingExtension() is mostly-implemented.  It works if and only
+// if the original FieldDescriptorProto defining the extension has a
+// fully-qualified type name in its "extendee" field (i.e. starts with a '.').
+// If the extendee is a relative name, SimpleDescriptorDatabase will not
+// attempt to resolve the type, so it will not know what type the extension is
+// extending.  Therefore, calling FindFileContainingExtension() with the
+// extension's containing type will never actually find that extension.  Note
+// that this is an unlikely problem, as all FileDescriptorProtos created by the
+// protocol compiler (as well as ones created by calling
+// FileDescriptor::CopyTo()) will always use fully-qualified names for all
+// types.  You only need to worry if you are constructing FileDescriptorProtos
+// yourself, or are calling compiler::Parser directly.
+class LIBPROTOBUF_EXPORT SimpleDescriptorDatabase : public DescriptorDatabase {
+ public:
+  SimpleDescriptorDatabase();
+  ~SimpleDescriptorDatabase();
+
+  // Adds the FileDescriptorProto to the database, making a copy.  The object
+  // can be deleted after Add() returns.  Returns false if the file conflicted
+  // with a file already in the database, in which case an error will have
+  // been written to GOOGLE_LOG(ERROR).
+  bool Add(const FileDescriptorProto& file);
+
+  // Adds the FileDescriptorProto to the database and takes ownership of it.
+  bool AddAndOwn(const FileDescriptorProto* file);
+
+  // implements DescriptorDatabase -----------------------------------
+  bool FindFileByName(const string& filename,
+                      FileDescriptorProto* output);
+  bool FindFileContainingSymbol(const string& symbol_name,
+                                FileDescriptorProto* output);
+  bool FindFileContainingExtension(const string& containing_type,
+                                   int field_number,
+                                   FileDescriptorProto* output);
+  bool FindAllExtensionNumbers(const string& extendee_type,
+                               std::vector<int>* output);
+
+ private:
+  // So that it can use DescriptorIndex.
+  friend class EncodedDescriptorDatabase;
+
+  // An index mapping file names, symbol names, and extension numbers to
+  // some sort of values.
+  template <typename Value>
+  class DescriptorIndex {
+   public:
+    // Helpers to recursively add particular descriptors and all their contents
+    // to the index.
+    bool AddFile(const FileDescriptorProto& file,
+                 Value value);
+    bool AddSymbol(const string& name, Value value);
+    bool AddNestedExtensions(const DescriptorProto& message_type,
+                             Value value);
+    bool AddExtension(const FieldDescriptorProto& field,
+                      Value value);
+
+    Value FindFile(const string& filename);
+    Value FindSymbol(const string& name);
+    Value FindExtension(const string& containing_type, int field_number);
+    bool FindAllExtensionNumbers(const string& containing_type,
+                                 std::vector<int>* output);
+
+   private:
+    std::map<string, Value> by_name_;
+    std::map<string, Value> by_symbol_;
+    std::map<std::pair<string, int>, Value> by_extension_;
+
+    // Invariant:  The by_symbol_ map does not contain any symbols which are
+    // prefixes of other symbols in the map.  For example, "foo.bar" is a
+    // prefix of "foo.bar.baz" (but is not a prefix of "foo.barbaz").
+    //
+    // This invariant is important because it means that given a symbol name,
+    // we can find a key in the map which is a prefix of the symbol in O(lg n)
+    // time, and we know that there is at most one such key.
+    //
+    // The prefix lookup algorithm works like so:
+    // 1) Find the last key in the map which is less than or equal to the
+    //    search key.
+    // 2) If the found key is a prefix of the search key, then return it.
+    //    Otherwise, there is no match.
+    //
+    // I am sure this algorithm has been described elsewhere, but since I
+    // wasn't able to find it quickly I will instead prove that it works
+    // myself.  The key to the algorithm is that if a match exists, step (1)
+    // will find it.  Proof:
+    // 1) Define the "search key" to be the key we are looking for, the "found
+    //    key" to be the key found in step (1), and the "match key" to be the
+    //    key which actually matches the serach key (i.e. the key we're trying
+    //    to find).
+    // 2) The found key must be less than or equal to the search key by
+    //    definition.
+    // 3) The match key must also be less than or equal to the search key
+    //    (because it is a prefix).
+    // 4) The match key cannot be greater than the found key, because if it
+    //    were, then step (1) of the algorithm would have returned the match
+    //    key instead (since it finds the *greatest* key which is less than or
+    //    equal to the search key).
+    // 5) Therefore, the found key must be between the match key and the search
+    //    key, inclusive.
+    // 6) Since the search key must be a sub-symbol of the match key, if it is
+    //    not equal to the match key, then search_key[match_key.size()] must
+    //    be '.'.
+    // 7) Since '.' sorts before any other character that is valid in a symbol
+    //    name, then if the found key is not equal to the match key, then
+    //    found_key[match_key.size()] must also be '.', because any other value
+    //    would make it sort after the search key.
+    // 8) Therefore, if the found key is not equal to the match key, then the
+    //    found key must be a sub-symbol of the match key.  However, this would
+    //    contradict our map invariant which says that no symbol in the map is
+    //    a sub-symbol of any other.
+    // 9) Therefore, the found key must match the match key.
+    //
+    // The above proof assumes the match key exists.  In the case that the
+    // match key does not exist, then step (1) will return some other symbol.
+    // That symbol cannot be a super-symbol of the search key since if it were,
+    // then it would be a match, and we're assuming the match key doesn't exist.
+    // Therefore, step 2 will correctly return no match.
+
+    // Find the last entry in the by_symbol_ map whose key is less than or
+    // equal to the given name.
+    typename std::map<string, Value>::iterator FindLastLessOrEqual(
+        const string& name);
+
+    // True if either the arguments are equal or super_symbol identifies a
+    // parent symbol of sub_symbol (e.g. "foo.bar" is a parent of
+    // "foo.bar.baz", but not a parent of "foo.barbaz").
+    bool IsSubSymbol(const string& sub_symbol, const string& super_symbol);
+
+    // Returns true if and only if all characters in the name are alphanumerics,
+    // underscores, or periods.
+    bool ValidateSymbolName(const string& name);
+  };
+
+
+  DescriptorIndex<const FileDescriptorProto*> index_;
+  std::vector<const FileDescriptorProto*> files_to_delete_;
+
+  // If file is non-NULL, copy it into *output and return true, otherwise
+  // return false.
+  bool MaybeCopy(const FileDescriptorProto* file,
+                 FileDescriptorProto* output);
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(SimpleDescriptorDatabase);
+};
+
+// Very similar to SimpleDescriptorDatabase, but stores all the descriptors
+// as raw bytes and generally tries to use as little memory as possible.
+//
+// The same caveats regarding FindFileContainingExtension() apply as with
+// SimpleDescriptorDatabase.
+class LIBPROTOBUF_EXPORT EncodedDescriptorDatabase : public DescriptorDatabase {
+ public:
+  EncodedDescriptorDatabase();
+  ~EncodedDescriptorDatabase();
+
+  // Adds the FileDescriptorProto to the database.  The descriptor is provided
+  // in encoded form.  The database does not make a copy of the bytes, nor
+  // does it take ownership; it's up to the caller to make sure the bytes
+  // remain valid for the life of the database.  Returns false and logs an error
+  // if the bytes are not a valid FileDescriptorProto or if the file conflicted
+  // with a file already in the database.
+  bool Add(const void* encoded_file_descriptor, int size);
+
+  // Like Add(), but makes a copy of the data, so that the caller does not
+  // need to keep it around.
+  bool AddCopy(const void* encoded_file_descriptor, int size);
+
+  // Like FindFileContainingSymbol but returns only the name of the file.
+  bool FindNameOfFileContainingSymbol(const string& symbol_name,
+                                      string* output);
+
+  // implements DescriptorDatabase -----------------------------------
+  bool FindFileByName(const string& filename,
+                      FileDescriptorProto* output);
+  bool FindFileContainingSymbol(const string& symbol_name,
+                                FileDescriptorProto* output);
+  bool FindFileContainingExtension(const string& containing_type,
+                                   int field_number,
+                                   FileDescriptorProto* output);
+  bool FindAllExtensionNumbers(const string& extendee_type,
+                               std::vector<int>* output);
+
+ private:
+  SimpleDescriptorDatabase::DescriptorIndex<std::pair<const void*, int> >
+      index_;
+  std::vector<void*> files_to_delete_;
+
+  // If encoded_file.first is non-NULL, parse the data into *output and return
+  // true, otherwise return false.
+  bool MaybeParse(std::pair<const void*, int> encoded_file,
+                  FileDescriptorProto* output);
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(EncodedDescriptorDatabase);
+};
+
+// A DescriptorDatabase that fetches files from a given pool.
+class LIBPROTOBUF_EXPORT DescriptorPoolDatabase : public DescriptorDatabase {
+ public:
+  explicit DescriptorPoolDatabase(const DescriptorPool& pool);
+  ~DescriptorPoolDatabase();
+
+  // implements DescriptorDatabase -----------------------------------
+  bool FindFileByName(const string& filename,
+                      FileDescriptorProto* output);
+  bool FindFileContainingSymbol(const string& symbol_name,
+                                FileDescriptorProto* output);
+  bool FindFileContainingExtension(const string& containing_type,
+                                   int field_number,
+                                   FileDescriptorProto* output);
+  bool FindAllExtensionNumbers(const string& extendee_type,
+                               std::vector<int>* output);
+
+ private:
+  const DescriptorPool& pool_;
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(DescriptorPoolDatabase);
+};
+
+// A DescriptorDatabase that wraps two or more others.  It first searches the
+// first database and, if that fails, tries the second, and so on.
+class LIBPROTOBUF_EXPORT MergedDescriptorDatabase : public DescriptorDatabase {
+ public:
+  // Merge just two databases.  The sources remain property of the caller.
+  MergedDescriptorDatabase(DescriptorDatabase* source1,
+                           DescriptorDatabase* source2);
+  // Merge more than two databases.  The sources remain property of the caller.
+  // The vector may be deleted after the constructor returns but the
+  // DescriptorDatabases need to stick around.
+  explicit MergedDescriptorDatabase(
+      const std::vector<DescriptorDatabase*>& sources);
+  ~MergedDescriptorDatabase();
+
+  // implements DescriptorDatabase -----------------------------------
+  bool FindFileByName(const string& filename,
+                      FileDescriptorProto* output);
+  bool FindFileContainingSymbol(const string& symbol_name,
+                                FileDescriptorProto* output);
+  bool FindFileContainingExtension(const string& containing_type,
+                                   int field_number,
+                                   FileDescriptorProto* output);
+  // Merges the results of calling all databases. Returns true iff any
+  // of the databases returned true.
+  bool FindAllExtensionNumbers(const string& extendee_type,
+                               std::vector<int>* output);
+
+
+ private:
+  std::vector<DescriptorDatabase*> sources_;
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MergedDescriptorDatabase);
+};
+
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_DESCRIPTOR_DATABASE_H__
diff --git a/kortex_api/include/google/protobuf/duration.pb.h b/kortex_api/include/google/protobuf/duration.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..e13328ac23f3331a70a46c52f02a245291cae818
--- /dev/null
+++ b/kortex_api/include/google/protobuf/duration.pb.h
@@ -0,0 +1,232 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: google/protobuf/duration.proto
+
+#ifndef PROTOBUF_google_2fprotobuf_2fduration_2eproto__INCLUDED
+#define PROTOBUF_google_2fprotobuf_2fduration_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 3005000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 3005001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+// @@protoc_insertion_point(includes)
+
+namespace protobuf_google_2fprotobuf_2fduration_2eproto {
+// Internal implementation detail -- do not use these members.
+struct LIBPROTOBUF_EXPORT TableStruct {
+  static const ::google::protobuf::internal::ParseTableField entries[];
+  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
+  static const ::google::protobuf::internal::ParseTable schema[1];
+  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
+  static const ::google::protobuf::internal::SerializationTable serialization_table[];
+  static const ::google::protobuf::uint32 offsets[];
+};
+void LIBPROTOBUF_EXPORT AddDescriptors();
+void LIBPROTOBUF_EXPORT InitDefaultsDurationImpl();
+void LIBPROTOBUF_EXPORT InitDefaultsDuration();
+inline void LIBPROTOBUF_EXPORT InitDefaults() {
+  InitDefaultsDuration();
+}
+}  // namespace protobuf_google_2fprotobuf_2fduration_2eproto
+namespace google {
+namespace protobuf {
+class Duration;
+class DurationDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern DurationDefaultTypeInternal _Duration_default_instance_;
+}  // namespace protobuf
+}  // namespace google
+namespace google {
+namespace protobuf {
+
+// ===================================================================
+
+class LIBPROTOBUF_EXPORT Duration : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Duration) */ {
+ public:
+  Duration();
+  virtual ~Duration();
+
+  Duration(const Duration& from);
+
+  inline Duration& operator=(const Duration& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Duration(Duration&& from) noexcept
+    : Duration() {
+    *this = ::std::move(from);
+  }
+
+  inline Duration& operator=(Duration&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
+    return GetArenaNoVirtual();
+  }
+  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
+    return MaybeArenaPtr();
+  }
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Duration& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Duration* internal_default_instance() {
+    return reinterpret_cast<const Duration*>(
+               &_Duration_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    0;
+
+  void UnsafeArenaSwap(Duration* other);
+  void Swap(Duration* other);
+  friend void swap(Duration& a, Duration& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Duration* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Duration* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Duration& from);
+  void MergeFrom(const Duration& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Duration* other);
+  protected:
+  explicit Duration(::google::protobuf::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return _internal_metadata_.arena();
+  }
+  inline void* MaybeArenaPtr() const {
+    return _internal_metadata_.raw_arena_ptr();
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // int64 seconds = 1;
+  void clear_seconds();
+  static const int kSecondsFieldNumber = 1;
+  ::google::protobuf::int64 seconds() const;
+  void set_seconds(::google::protobuf::int64 value);
+
+  // int32 nanos = 2;
+  void clear_nanos();
+  static const int kNanosFieldNumber = 2;
+  ::google::protobuf::int32 nanos() const;
+  void set_nanos(::google::protobuf::int32 value);
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.Duration)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::google::protobuf::int64 seconds_;
+  ::google::protobuf::int32 nanos_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_google_2fprotobuf_2fduration_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2fduration_2eproto::InitDefaultsDurationImpl();
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// Duration
+
+// int64 seconds = 1;
+inline void Duration::clear_seconds() {
+  seconds_ = GOOGLE_LONGLONG(0);
+}
+inline ::google::protobuf::int64 Duration::seconds() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Duration.seconds)
+  return seconds_;
+}
+inline void Duration::set_seconds(::google::protobuf::int64 value) {
+  
+  seconds_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.Duration.seconds)
+}
+
+// int32 nanos = 2;
+inline void Duration::clear_nanos() {
+  nanos_ = 0;
+}
+inline ::google::protobuf::int32 Duration::nanos() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Duration.nanos)
+  return nanos_;
+}
+inline void Duration::set_nanos(::google::protobuf::int32 value) {
+  
+  nanos_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.Duration.nanos)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace protobuf
+}  // namespace google
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_google_2fprotobuf_2fduration_2eproto__INCLUDED
diff --git a/kortex_api/include/google/protobuf/dynamic_message.h b/kortex_api/include/google/protobuf/dynamic_message.h
new file mode 100644
index 0000000000000000000000000000000000000000..e29b148d6a6b1bcd809c87bc9b2f7c61b3124d2d
--- /dev/null
+++ b/kortex_api/include/google/protobuf/dynamic_message.h
@@ -0,0 +1,236 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// Defines an implementation of Message which can emulate types which are not
+// known at compile-time.
+
+#ifndef GOOGLE_PROTOBUF_DYNAMIC_MESSAGE_H__
+#define GOOGLE_PROTOBUF_DYNAMIC_MESSAGE_H__
+
+#include <algorithm>
+#include <memory>
+#ifndef _SHARED_PTR_H
+#include <google/protobuf/stubs/shared_ptr.h>
+#endif
+#include <vector>
+
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/mutex.h>
+
+namespace google {
+namespace protobuf {
+
+// Defined in other files.
+class Descriptor;        // descriptor.h
+class DescriptorPool;    // descriptor.h
+
+// Constructs implementations of Message which can emulate types which are not
+// known at compile-time.
+//
+// Sometimes you want to be able to manipulate protocol types that you don't
+// know about at compile time.  It would be nice to be able to construct
+// a Message object which implements the message type given by any arbitrary
+// Descriptor.  DynamicMessage provides this.
+//
+// As it turns out, a DynamicMessage needs to construct extra
+// information about its type in order to operate.  Most of this information
+// can be shared between all DynamicMessages of the same type.  But, caching
+// this information in some sort of global map would be a bad idea, since
+// the cached information for a particular descriptor could outlive the
+// descriptor itself.  To avoid this problem, DynamicMessageFactory
+// encapsulates this "cache".  All DynamicMessages of the same type created
+// from the same factory will share the same support data.  Any Descriptors
+// used with a particular factory must outlive the factory.
+class LIBPROTOBUF_EXPORT DynamicMessageFactory : public MessageFactory {
+ public:
+  // Construct a DynamicMessageFactory that will search for extensions in
+  // the DescriptorPool in which the extendee is defined.
+  DynamicMessageFactory();
+
+  // Construct a DynamicMessageFactory that will search for extensions in
+  // the given DescriptorPool.
+  //
+  // DEPRECATED:  Use CodedInputStream::SetExtensionRegistry() to tell the
+  //   parser to look for extensions in an alternate pool.  However, note that
+  //   this is almost never what you want to do.  Almost all users should use
+  //   the zero-arg constructor.
+  DynamicMessageFactory(const DescriptorPool* pool);
+
+  ~DynamicMessageFactory();
+
+  // Call this to tell the DynamicMessageFactory that if it is given a
+  // Descriptor d for which:
+  //   d->file()->pool() == DescriptorPool::generated_pool(),
+  // then it should delegate to MessageFactory::generated_factory() instead
+  // of constructing a dynamic implementation of the message.  In theory there
+  // is no down side to doing this, so it may become the default in the future.
+  void SetDelegateToGeneratedFactory(bool enable) {
+    delegate_to_generated_factory_ = enable;
+  }
+
+  // implements MessageFactory ---------------------------------------
+
+  // Given a Descriptor, constructs the default (prototype) Message of that
+  // type.  You can then call that message's New() method to construct a
+  // mutable message of that type.
+  //
+  // Calling this method twice with the same Descriptor returns the same
+  // object.  The returned object remains property of the factory and will
+  // be destroyed when the factory is destroyed.  Also, any objects created
+  // by calling the prototype's New() method share some data with the
+  // prototype, so these must be destroyed before the DynamicMessageFactory
+  // is destroyed.
+  //
+  // The given descriptor must outlive the returned message, and hence must
+  // outlive the DynamicMessageFactory.
+  //
+  // The method is thread-safe.
+  const Message* GetPrototype(const Descriptor* type);
+
+ private:
+  const DescriptorPool* pool_;
+  bool delegate_to_generated_factory_;
+
+  // This struct just contains a hash_map.  We can't #include <google/protobuf/stubs/hash.h> from
+  // this header due to hacks needed for hash_map portability in the open source
+  // release.  Namely, stubs/hash.h, which defines hash_map portably, is not a
+  // public header (for good reason), but dynamic_message.h is, and public
+  // headers may only #include other public headers.
+  struct PrototypeMap;
+  google::protobuf::scoped_ptr<PrototypeMap> prototypes_;
+  mutable Mutex prototypes_mutex_;
+
+  friend class DynamicMessage;
+  const Message* GetPrototypeNoLock(const Descriptor* type);
+
+  // Construct default oneof instance for reflection usage if oneof
+  // is defined.
+  static void ConstructDefaultOneofInstance(const Descriptor* type,
+                                            const uint32 offsets[],
+                                            void* default_oneof_instance);
+  // Delete default oneof instance. Called by ~DynamicMessageFactory.
+  static void DeleteDefaultOneofInstance(const Descriptor* type,
+                                         const uint32 offsets[],
+                                         const void* default_oneof_instance);
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(DynamicMessageFactory);
+};
+
+// Helper for computing a sorted list of map entries via reflection.
+class LIBPROTOBUF_EXPORT DynamicMapSorter {
+ public:
+  static std::vector<const Message*> Sort(const Message& message,
+                                          int map_size,
+                                          const Reflection* reflection,
+                                          const FieldDescriptor* field) {
+    std::vector<const Message*> result(static_cast<size_t>(map_size));
+    const RepeatedPtrField<Message>& map_field =
+        reflection->GetRepeatedPtrField<Message>(message, field);
+    size_t i = 0;
+    for (RepeatedPtrField<Message>::const_pointer_iterator it =
+             map_field.pointer_begin(); it != map_field.pointer_end(); ) {
+      result[i++] = *it++;
+    }
+    GOOGLE_DCHECK_EQ(result.size(), i);
+    MapEntryMessageComparator comparator(field->message_type());
+    std::stable_sort(result.begin(), result.end(), comparator);
+    // Complain if the keys aren't in ascending order.
+#ifndef NDEBUG
+    for (size_t j = 1; j < static_cast<size_t>(map_size); j++) {
+      if (!comparator(result[j - 1], result[j])) {
+        GOOGLE_LOG(ERROR) << (comparator(result[j], result[j - 1]) ?
+                      "internal error in map key sorting" :
+                      "map keys are not unique");
+      }
+    }
+#endif
+    return result;
+  }
+
+ private:
+  class LIBPROTOBUF_EXPORT MapEntryMessageComparator {
+   public:
+    explicit MapEntryMessageComparator(const Descriptor* descriptor)
+        : field_(descriptor->field(0)) {}
+
+    bool operator()(const Message* a, const Message* b) {
+      const Reflection* reflection = a->GetReflection();
+      switch (field_->cpp_type()) {
+        case FieldDescriptor::CPPTYPE_BOOL: {
+          bool first = reflection->GetBool(*a, field_);
+          bool second = reflection->GetBool(*b, field_);
+          return first < second;
+        }
+        case FieldDescriptor::CPPTYPE_INT32: {
+          int32 first = reflection->GetInt32(*a, field_);
+          int32 second = reflection->GetInt32(*b, field_);
+          return first < second;
+        }
+        case FieldDescriptor::CPPTYPE_INT64: {
+          int64 first = reflection->GetInt64(*a, field_);
+          int64 second = reflection->GetInt64(*b, field_);
+          return first < second;
+        }
+        case FieldDescriptor::CPPTYPE_UINT32: {
+          uint32 first = reflection->GetUInt32(*a, field_);
+          uint32 second = reflection->GetUInt32(*b, field_);
+          return first < second;
+        }
+        case FieldDescriptor::CPPTYPE_UINT64: {
+          uint64 first = reflection->GetUInt64(*a, field_);
+          uint64 second = reflection->GetUInt64(*b, field_);
+          return first < second;
+        }
+        case FieldDescriptor::CPPTYPE_STRING: {
+          string first = reflection->GetString(*a, field_);
+          string second = reflection->GetString(*b, field_);
+          return first < second;
+        }
+        default:
+          GOOGLE_LOG(DFATAL) << "Invalid key for map field.";
+          return true;
+      }
+    }
+
+   private:
+    const FieldDescriptor* field_;
+  };
+};
+
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_DYNAMIC_MESSAGE_H__
diff --git a/kortex_api/include/google/protobuf/empty.pb.h b/kortex_api/include/google/protobuf/empty.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..76e0e4c6b748e1ff2a5cc235ba4d9ab4abea81c6
--- /dev/null
+++ b/kortex_api/include/google/protobuf/empty.pb.h
@@ -0,0 +1,190 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: google/protobuf/empty.proto
+
+#ifndef PROTOBUF_google_2fprotobuf_2fempty_2eproto__INCLUDED
+#define PROTOBUF_google_2fprotobuf_2fempty_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 3005000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 3005001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+// @@protoc_insertion_point(includes)
+
+namespace protobuf_google_2fprotobuf_2fempty_2eproto {
+// Internal implementation detail -- do not use these members.
+struct LIBPROTOBUF_EXPORT TableStruct {
+  static const ::google::protobuf::internal::ParseTableField entries[];
+  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
+  static const ::google::protobuf::internal::ParseTable schema[1];
+  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
+  static const ::google::protobuf::internal::SerializationTable serialization_table[];
+  static const ::google::protobuf::uint32 offsets[];
+};
+void LIBPROTOBUF_EXPORT AddDescriptors();
+void LIBPROTOBUF_EXPORT InitDefaultsEmptyImpl();
+void LIBPROTOBUF_EXPORT InitDefaultsEmpty();
+inline void LIBPROTOBUF_EXPORT InitDefaults() {
+  InitDefaultsEmpty();
+}
+}  // namespace protobuf_google_2fprotobuf_2fempty_2eproto
+namespace google {
+namespace protobuf {
+class Empty;
+class EmptyDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern EmptyDefaultTypeInternal _Empty_default_instance_;
+}  // namespace protobuf
+}  // namespace google
+namespace google {
+namespace protobuf {
+
+// ===================================================================
+
+class LIBPROTOBUF_EXPORT Empty : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Empty) */ {
+ public:
+  Empty();
+  virtual ~Empty();
+
+  Empty(const Empty& from);
+
+  inline Empty& operator=(const Empty& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Empty(Empty&& from) noexcept
+    : Empty() {
+    *this = ::std::move(from);
+  }
+
+  inline Empty& operator=(Empty&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
+    return GetArenaNoVirtual();
+  }
+  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
+    return MaybeArenaPtr();
+  }
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Empty& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Empty* internal_default_instance() {
+    return reinterpret_cast<const Empty*>(
+               &_Empty_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    0;
+
+  void UnsafeArenaSwap(Empty* other);
+  void Swap(Empty* other);
+  friend void swap(Empty& a, Empty& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Empty* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Empty* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Empty& from);
+  void MergeFrom(const Empty& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Empty* other);
+  protected:
+  explicit Empty(::google::protobuf::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return _internal_metadata_.arena();
+  }
+  inline void* MaybeArenaPtr() const {
+    return _internal_metadata_.raw_arena_ptr();
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.Empty)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_google_2fprotobuf_2fempty_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2fempty_2eproto::InitDefaultsEmptyImpl();
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// Empty
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace protobuf
+}  // namespace google
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_google_2fprotobuf_2fempty_2eproto__INCLUDED
diff --git a/kortex_api/include/google/protobuf/extension_set.h b/kortex_api/include/google/protobuf/extension_set.h
new file mode 100644
index 0000000000000000000000000000000000000000..0a5d98f286c096a4abfc9850d4120460d32e19d6
--- /dev/null
+++ b/kortex_api/include/google/protobuf/extension_set.h
@@ -0,0 +1,1379 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// This header is logically internal, but is made public because it is used
+// from protocol-compiler-generated code, which may reside in other components.
+
+#ifndef GOOGLE_PROTOBUF_EXTENSION_SET_H__
+#define GOOGLE_PROTOBUF_EXTENSION_SET_H__
+
+#include <vector>
+#include <map>
+#include <utility>
+#include <string>
+
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/logging.h>
+#include <google/protobuf/stubs/once.h>
+
+#include <google/protobuf/repeated_field.h>
+
+namespace google {
+
+namespace protobuf {
+  class Arena;
+  class Descriptor;                                    // descriptor.h
+  class FieldDescriptor;                               // descriptor.h
+  class DescriptorPool;                                // descriptor.h
+  class MessageLite;                                   // message_lite.h
+  class Message;                                       // message.h
+  class MessageFactory;                                // message.h
+  class UnknownFieldSet;                               // unknown_field_set.h
+  namespace io {
+    class CodedInputStream;                              // coded_stream.h
+    class CodedOutputStream;                             // coded_stream.h
+  }
+  namespace internal {
+    class FieldSkipper;                                  // wire_format_lite.h
+  }
+}
+
+namespace protobuf {
+namespace internal {
+
+// Used to store values of type WireFormatLite::FieldType without having to
+// #include wire_format_lite.h.  Also, ensures that we use only one byte to
+// store these values, which is important to keep the layout of
+// ExtensionSet::Extension small.
+typedef uint8 FieldType;
+
+// A function which, given an integer value, returns true if the number
+// matches one of the defined values for the corresponding enum type.  This
+// is used with RegisterEnumExtension, below.
+typedef bool EnumValidityFunc(int number);
+
+// Version of the above which takes an argument.  This is needed to deal with
+// extensions that are not compiled in.
+typedef bool EnumValidityFuncWithArg(const void* arg, int number);
+
+// Information about a registered extension.
+struct ExtensionInfo {
+  inline ExtensionInfo() {}
+  inline ExtensionInfo(FieldType type_param, bool isrepeated, bool ispacked)
+      : type(type_param), is_repeated(isrepeated), is_packed(ispacked),
+        descriptor(NULL) {}
+
+  FieldType type;
+  bool is_repeated;
+  bool is_packed;
+
+  struct EnumValidityCheck {
+    EnumValidityFuncWithArg* func;
+    const void* arg;
+  };
+
+  union {
+    EnumValidityCheck enum_validity_check;
+    const MessageLite* message_prototype;
+  };
+
+  // The descriptor for this extension, if one exists and is known.  May be
+  // NULL.  Must not be NULL if the descriptor for the extension does not
+  // live in the same pool as the descriptor for the containing type.
+  const FieldDescriptor* descriptor;
+};
+
+// Abstract interface for an object which looks up extension definitions.  Used
+// when parsing.
+class LIBPROTOBUF_EXPORT ExtensionFinder {
+ public:
+  virtual ~ExtensionFinder();
+
+  // Find the extension with the given containing type and number.
+  virtual bool Find(int number, ExtensionInfo* output) = 0;
+};
+
+// Implementation of ExtensionFinder which finds extensions defined in .proto
+// files which have been compiled into the binary.
+class LIBPROTOBUF_EXPORT GeneratedExtensionFinder : public ExtensionFinder {
+ public:
+  GeneratedExtensionFinder(const MessageLite* containing_type)
+      : containing_type_(containing_type) {}
+  virtual ~GeneratedExtensionFinder() {}
+
+  // Returns true and fills in *output if found, otherwise returns false.
+  virtual bool Find(int number, ExtensionInfo* output);
+
+ private:
+  const MessageLite* containing_type_;
+};
+
+// A FieldSkipper used for parsing MessageSet.
+class MessageSetFieldSkipper;
+
+// Note:  extension_set_heavy.cc defines DescriptorPoolExtensionFinder for
+// finding extensions from a DescriptorPool.
+
+// This is an internal helper class intended for use within the protocol buffer
+// library and generated classes.  Clients should not use it directly.  Instead,
+// use the generated accessors such as GetExtension() of the class being
+// extended.
+//
+// This class manages extensions for a protocol message object.  The
+// message's HasExtension(), GetExtension(), MutableExtension(), and
+// ClearExtension() methods are just thin wrappers around the embedded
+// ExtensionSet.  When parsing, if a tag number is encountered which is
+// inside one of the message type's extension ranges, the tag is passed
+// off to the ExtensionSet for parsing.  Etc.
+class LIBPROTOBUF_EXPORT ExtensionSet {
+ public:
+  ExtensionSet();
+  explicit ExtensionSet(::google::protobuf::Arena* arena);
+  ~ExtensionSet();
+
+  // These are called at startup by protocol-compiler-generated code to
+  // register known extensions.  The registrations are used by ParseField()
+  // to look up extensions for parsed field numbers.  Note that dynamic parsing
+  // does not use ParseField(); only protocol-compiler-generated parsing
+  // methods do.
+  static void RegisterExtension(const MessageLite* containing_type,
+                                int number, FieldType type,
+                                bool is_repeated, bool is_packed);
+  static void RegisterEnumExtension(const MessageLite* containing_type,
+                                    int number, FieldType type,
+                                    bool is_repeated, bool is_packed,
+                                    EnumValidityFunc* is_valid);
+  static void RegisterMessageExtension(const MessageLite* containing_type,
+                                       int number, FieldType type,
+                                       bool is_repeated, bool is_packed,
+                                       const MessageLite* prototype);
+
+  // =================================================================
+
+  // Add all fields which are currently present to the given vector.  This
+  // is useful to implement Reflection::ListFields().
+  void AppendToList(const Descriptor* containing_type,
+                    const DescriptorPool* pool,
+                    std::vector<const FieldDescriptor*>* output) const;
+
+  // =================================================================
+  // Accessors
+  //
+  // Generated message classes include type-safe templated wrappers around
+  // these methods.  Generally you should use those rather than call these
+  // directly, unless you are doing low-level memory management.
+  //
+  // When calling any of these accessors, the extension number requested
+  // MUST exist in the DescriptorPool provided to the constructor.  Otherwise,
+  // the method will fail an assert.  Normally, though, you would not call
+  // these directly; you would either call the generated accessors of your
+  // message class (e.g. GetExtension()) or you would call the accessors
+  // of the reflection interface.  In both cases, it is impossible to
+  // trigger this assert failure:  the generated accessors only accept
+  // linked-in extension types as parameters, while the Reflection interface
+  // requires you to provide the FieldDescriptor describing the extension.
+  //
+  // When calling any of these accessors, a protocol-compiler-generated
+  // implementation of the extension corresponding to the number MUST
+  // be linked in, and the FieldDescriptor used to refer to it MUST be
+  // the one generated by that linked-in code.  Otherwise, the method will
+  // die on an assert failure.  The message objects returned by the message
+  // accessors are guaranteed to be of the correct linked-in type.
+  //
+  // These methods pretty much match Reflection except that:
+  // - They're not virtual.
+  // - They identify fields by number rather than FieldDescriptors.
+  // - They identify enum values using integers rather than descriptors.
+  // - Strings provide Mutable() in addition to Set() accessors.
+
+  bool Has(int number) const;
+  int ExtensionSize(int number) const;   // Size of a repeated extension.
+  int NumExtensions() const;  // The number of extensions
+  FieldType ExtensionType(int number) const;
+  void ClearExtension(int number);
+
+  // singular fields -------------------------------------------------
+
+  int32  GetInt32 (int number, int32  default_value) const;
+  int64  GetInt64 (int number, int64  default_value) const;
+  uint32 GetUInt32(int number, uint32 default_value) const;
+  uint64 GetUInt64(int number, uint64 default_value) const;
+  float  GetFloat (int number, float  default_value) const;
+  double GetDouble(int number, double default_value) const;
+  bool   GetBool  (int number, bool   default_value) const;
+  int    GetEnum  (int number, int    default_value) const;
+  const string & GetString (int number, const string&  default_value) const;
+  const MessageLite& GetMessage(int number,
+                                const MessageLite& default_value) const;
+  const MessageLite& GetMessage(int number, const Descriptor* message_type,
+                                MessageFactory* factory) const;
+
+  // |descriptor| may be NULL so long as it is known that the descriptor for
+  // the extension lives in the same pool as the descriptor for the containing
+  // type.
+#define desc const FieldDescriptor* descriptor  // avoid line wrapping
+  void SetInt32 (int number, FieldType type, int32  value, desc);
+  void SetInt64 (int number, FieldType type, int64  value, desc);
+  void SetUInt32(int number, FieldType type, uint32 value, desc);
+  void SetUInt64(int number, FieldType type, uint64 value, desc);
+  void SetFloat (int number, FieldType type, float  value, desc);
+  void SetDouble(int number, FieldType type, double value, desc);
+  void SetBool  (int number, FieldType type, bool   value, desc);
+  void SetEnum  (int number, FieldType type, int    value, desc);
+  void SetString(int number, FieldType type, const string& value, desc);
+  string * MutableString (int number, FieldType type, desc);
+  MessageLite* MutableMessage(int number, FieldType type,
+                              const MessageLite& prototype, desc);
+  MessageLite* MutableMessage(const FieldDescriptor* decsriptor,
+                              MessageFactory* factory);
+  // Adds the given message to the ExtensionSet, taking ownership of the
+  // message object. Existing message with the same number will be deleted.
+  // If "message" is NULL, this is equivalent to "ClearExtension(number)".
+  void SetAllocatedMessage(int number, FieldType type,
+                           const FieldDescriptor* descriptor,
+                           MessageLite* message);
+  void UnsafeArenaSetAllocatedMessage(int number, FieldType type,
+                                      const FieldDescriptor* descriptor,
+                                      MessageLite* message);
+  MessageLite* ReleaseMessage(int number, const MessageLite& prototype);
+  MessageLite* UnsafeArenaReleaseMessage(
+      int number, const MessageLite& prototype);
+
+  MessageLite* ReleaseMessage(const FieldDescriptor* descriptor,
+                              MessageFactory* factory);
+  MessageLite* UnsafeArenaReleaseMessage(const FieldDescriptor* descriptor,
+                                         MessageFactory* factory);
+#undef desc
+  ::google::protobuf::Arena* GetArenaNoVirtual() const { return arena_; }
+
+  // repeated fields -------------------------------------------------
+
+  // Fetches a RepeatedField extension by number; returns |default_value|
+  // if no such extension exists. User should not touch this directly; it is
+  // used by the GetRepeatedExtension() method.
+  const void* GetRawRepeatedField(int number, const void* default_value) const;
+  // Fetches a mutable version of a RepeatedField extension by number,
+  // instantiating one if none exists. Similar to above, user should not use
+  // this directly; it underlies MutableRepeatedExtension().
+  void* MutableRawRepeatedField(int number, FieldType field_type,
+                                bool packed, const FieldDescriptor* desc);
+
+  // This is an overload of MutableRawRepeatedField to maintain compatibility
+  // with old code using a previous API. This version of
+  // MutableRawRepeatedField() will GOOGLE_CHECK-fail on a missing extension.
+  // (E.g.: borg/clients/internal/proto1/proto2_reflection.cc.)
+  void* MutableRawRepeatedField(int number);
+
+  int32  GetRepeatedInt32 (int number, int index) const;
+  int64  GetRepeatedInt64 (int number, int index) const;
+  uint32 GetRepeatedUInt32(int number, int index) const;
+  uint64 GetRepeatedUInt64(int number, int index) const;
+  float  GetRepeatedFloat (int number, int index) const;
+  double GetRepeatedDouble(int number, int index) const;
+  bool   GetRepeatedBool  (int number, int index) const;
+  int    GetRepeatedEnum  (int number, int index) const;
+  const string & GetRepeatedString (int number, int index) const;
+  const MessageLite& GetRepeatedMessage(int number, int index) const;
+
+  void SetRepeatedInt32 (int number, int index, int32  value);
+  void SetRepeatedInt64 (int number, int index, int64  value);
+  void SetRepeatedUInt32(int number, int index, uint32 value);
+  void SetRepeatedUInt64(int number, int index, uint64 value);
+  void SetRepeatedFloat (int number, int index, float  value);
+  void SetRepeatedDouble(int number, int index, double value);
+  void SetRepeatedBool  (int number, int index, bool   value);
+  void SetRepeatedEnum  (int number, int index, int    value);
+  void SetRepeatedString(int number, int index, const string& value);
+  string * MutableRepeatedString (int number, int index);
+  MessageLite* MutableRepeatedMessage(int number, int index);
+
+#define desc const FieldDescriptor* descriptor  // avoid line wrapping
+  void AddInt32 (int number, FieldType type, bool packed, int32  value, desc);
+  void AddInt64 (int number, FieldType type, bool packed, int64  value, desc);
+  void AddUInt32(int number, FieldType type, bool packed, uint32 value, desc);
+  void AddUInt64(int number, FieldType type, bool packed, uint64 value, desc);
+  void AddFloat (int number, FieldType type, bool packed, float  value, desc);
+  void AddDouble(int number, FieldType type, bool packed, double value, desc);
+  void AddBool  (int number, FieldType type, bool packed, bool   value, desc);
+  void AddEnum  (int number, FieldType type, bool packed, int    value, desc);
+  void AddString(int number, FieldType type, const string& value, desc);
+  string * AddString (int number, FieldType type, desc);
+  MessageLite* AddMessage(int number, FieldType type,
+                          const MessageLite& prototype, desc);
+  MessageLite* AddMessage(const FieldDescriptor* descriptor,
+                          MessageFactory* factory);
+  void AddAllocatedMessage(const FieldDescriptor* descriptor,
+                           MessageLite* new_entry);
+#undef desc
+
+  void RemoveLast(int number);
+  MessageLite* ReleaseLast(int number);
+  void SwapElements(int number, int index1, int index2);
+
+  // -----------------------------------------------------------------
+  // TODO(kenton):  Hardcore memory management accessors
+
+  // =================================================================
+  // convenience methods for implementing methods of Message
+  //
+  // These could all be implemented in terms of the other methods of this
+  // class, but providing them here helps keep the generated code size down.
+
+  void Clear();
+  void MergeFrom(const ExtensionSet& other);
+  void Swap(ExtensionSet* other);
+  void SwapExtension(ExtensionSet* other, int number);
+  bool IsInitialized() const;
+
+  // Parses a single extension from the input. The input should start out
+  // positioned immediately after the tag.
+  bool ParseField(uint32 tag, io::CodedInputStream* input,
+                  ExtensionFinder* extension_finder,
+                  FieldSkipper* field_skipper);
+
+  // Specific versions for lite or full messages (constructs the appropriate
+  // FieldSkipper automatically).  |containing_type| is the default
+  // instance for the containing message; it is used only to look up the
+  // extension by number.  See RegisterExtension(), above.  Unlike the other
+  // methods of ExtensionSet, this only works for generated message types --
+  // it looks up extensions registered using RegisterExtension().
+  bool ParseField(uint32 tag, io::CodedInputStream* input,
+                  const MessageLite* containing_type);
+  bool ParseField(uint32 tag, io::CodedInputStream* input,
+                  const Message* containing_type,
+                  UnknownFieldSet* unknown_fields);
+  bool ParseField(uint32 tag, io::CodedInputStream* input,
+                  const MessageLite* containing_type,
+                  io::CodedOutputStream* unknown_fields);
+
+  // Parse an entire message in MessageSet format.  Such messages have no
+  // fields, only extensions.
+  bool ParseMessageSet(io::CodedInputStream* input,
+                       ExtensionFinder* extension_finder,
+                       MessageSetFieldSkipper* field_skipper);
+
+  // Specific versions for lite or full messages (constructs the appropriate
+  // FieldSkipper automatically).
+  bool ParseMessageSet(io::CodedInputStream* input,
+                       const MessageLite* containing_type);
+  bool ParseMessageSet(io::CodedInputStream* input,
+                       const Message* containing_type,
+                       UnknownFieldSet* unknown_fields);
+
+  // Write all extension fields with field numbers in the range
+  //   [start_field_number, end_field_number)
+  // to the output stream, using the cached sizes computed when ByteSize() was
+  // last called.  Note that the range bounds are inclusive-exclusive.
+  void SerializeWithCachedSizes(int start_field_number,
+                                int end_field_number,
+                                io::CodedOutputStream* output) const;
+
+  // Same as SerializeWithCachedSizes, but without any bounds checking.
+  // The caller must ensure that target has sufficient capacity for the
+  // serialized extensions.
+  //
+  // Returns a pointer past the last written byte.
+  uint8* InternalSerializeWithCachedSizesToArray(int start_field_number,
+                                                 int end_field_number,
+                                                 bool deterministic,
+                                                 uint8* target) const;
+
+  // Like above but serializes in MessageSet format.
+  void SerializeMessageSetWithCachedSizes(io::CodedOutputStream* output) const;
+  uint8* InternalSerializeMessageSetWithCachedSizesToArray(bool deterministic,
+                                                           uint8* target) const;
+
+  // For backward-compatibility, versions of two of the above methods that
+  // serialize deterministically iff SetDefaultSerializationDeterministic()
+  // has been called.
+  uint8* SerializeWithCachedSizesToArray(int start_field_number,
+                                         int end_field_number,
+                                         uint8* target) const;
+  uint8* SerializeMessageSetWithCachedSizesToArray(uint8* target) const;
+
+  // Returns the total serialized size of all the extensions.
+  size_t ByteSize() const;
+
+  // Like ByteSize() but uses MessageSet format.
+  size_t MessageSetByteSize() const;
+
+  // Returns (an estimate of) the total number of bytes used for storing the
+  // extensions in memory, excluding sizeof(*this).  If the ExtensionSet is
+  // for a lite message (and thus possibly contains lite messages), the results
+  // are undefined (might work, might crash, might corrupt data, might not even
+  // be linked in).  It's up to the protocol compiler to avoid calling this on
+  // such ExtensionSets (easy enough since lite messages don't implement
+  // SpaceUsed()).
+  size_t SpaceUsedExcludingSelfLong() const;
+
+  // This method just calls SpaceUsedExcludingSelfLong() but it can not be
+  // inlined because the definition of SpaceUsedExcludingSelfLong() is not
+  // included in lite runtime and when an inline method refers to it MSVC
+  // will complain about unresolved symbols when building the lite runtime
+  // as .dll.
+  int SpaceUsedExcludingSelf() const;
+
+ private:
+
+  // Interface of a lazily parsed singular message extension.
+  class LIBPROTOBUF_EXPORT LazyMessageExtension {
+   public:
+    LazyMessageExtension() {}
+    virtual ~LazyMessageExtension() {}
+
+    virtual LazyMessageExtension* New(::google::protobuf::Arena* arena) const = 0;
+    virtual const MessageLite& GetMessage(
+        const MessageLite& prototype) const = 0;
+    virtual MessageLite* MutableMessage(const MessageLite& prototype) = 0;
+    virtual void SetAllocatedMessage(MessageLite *message) = 0;
+    virtual void UnsafeArenaSetAllocatedMessage(MessageLite *message) = 0;
+    virtual MessageLite* ReleaseMessage(const MessageLite& prototype) = 0;
+    virtual MessageLite* UnsafeArenaReleaseMessage(
+        const MessageLite& prototype) = 0;
+
+    virtual bool IsInitialized() const = 0;
+    virtual int ByteSize() const = 0;
+    virtual size_t SpaceUsedLong() const = 0;
+
+    virtual void MergeFrom(const LazyMessageExtension& other) = 0;
+    virtual void Clear() = 0;
+
+    virtual bool ReadMessage(const MessageLite& prototype,
+                             io::CodedInputStream* input) = 0;
+    virtual void WriteMessage(int number,
+                              io::CodedOutputStream* output) const = 0;
+    virtual uint8* WriteMessageToArray(int number, uint8* target) const = 0;
+    virtual uint8* InternalWriteMessageToArray(int number, bool,
+                                               uint8* target) const {
+      // TODO(gpike): make this pure virtual. This is a placeholder because we
+      // need to update third_party/upb, for example.
+      return WriteMessageToArray(number, target);
+    }
+
+   private:
+    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(LazyMessageExtension);
+  };
+  struct Extension {
+    // The order of these fields packs Extension into 24 bytes when using 8
+    // byte alignment. Consider this when adding or removing fields here.
+    union {
+      int32                 int32_value;
+      int64                 int64_value;
+      uint32                uint32_value;
+      uint64                uint64_value;
+      float                 float_value;
+      double                double_value;
+      bool                  bool_value;
+      int                   enum_value;
+      string*               string_value;
+      MessageLite*          message_value;
+      LazyMessageExtension* lazymessage_value;
+
+      RepeatedField   <int32      >* repeated_int32_value;
+      RepeatedField   <int64      >* repeated_int64_value;
+      RepeatedField   <uint32     >* repeated_uint32_value;
+      RepeatedField   <uint64     >* repeated_uint64_value;
+      RepeatedField   <float      >* repeated_float_value;
+      RepeatedField   <double     >* repeated_double_value;
+      RepeatedField   <bool       >* repeated_bool_value;
+      RepeatedField   <int        >* repeated_enum_value;
+      RepeatedPtrField<string     >* repeated_string_value;
+      RepeatedPtrField<MessageLite>* repeated_message_value;
+    };
+
+    FieldType type;
+    bool is_repeated;
+
+    // For singular types, indicates if the extension is "cleared".  This
+    // happens when an extension is set and then later cleared by the caller.
+    // We want to keep the Extension object around for reuse, so instead of
+    // removing it from the map, we just set is_cleared = true.  This has no
+    // meaning for repeated types; for those, the size of the RepeatedField
+    // simply becomes zero when cleared.
+    bool is_cleared : 4;
+
+    // For singular message types, indicates whether lazy parsing is enabled
+    // for this extension. This field is only valid when type == TYPE_MESSAGE
+    // and !is_repeated because we only support lazy parsing for singular
+    // message types currently. If is_lazy = true, the extension is stored in
+    // lazymessage_value. Otherwise, the extension will be message_value.
+    bool is_lazy : 4;
+
+    // For repeated types, this indicates if the [packed=true] option is set.
+    bool is_packed;
+
+    // For packed fields, the size of the packed data is recorded here when
+    // ByteSize() is called then used during serialization.
+    // TODO(kenton):  Use atomic<int> when C++ supports it.
+    mutable int cached_size;
+
+    // The descriptor for this extension, if one exists and is known.  May be
+    // NULL.  Must not be NULL if the descriptor for the extension does not
+    // live in the same pool as the descriptor for the containing type.
+    const FieldDescriptor* descriptor;
+
+    // Some helper methods for operations on a single Extension.
+    void SerializeFieldWithCachedSizes(
+        int number,
+        io::CodedOutputStream* output) const;
+    uint8* InternalSerializeFieldWithCachedSizesToArray(
+        int number,
+        bool deterministic,
+        uint8* target) const;
+    void SerializeMessageSetItemWithCachedSizes(
+        int number,
+        io::CodedOutputStream* output) const;
+    uint8* InternalSerializeMessageSetItemWithCachedSizesToArray(
+        int number,
+        bool deterministic,
+        uint8* target) const;
+    size_t ByteSize(int number) const;
+    size_t MessageSetItemByteSize(int number) const;
+    void Clear();
+    int GetSize() const;
+    void Free();
+    size_t SpaceUsedExcludingSelfLong() const;
+  };
+  typedef std::map<int, Extension> ExtensionMap;
+
+
+  // Merges existing Extension from other_extension
+  void InternalExtensionMergeFrom(int number, const Extension& other_extension);
+
+  // Returns true and fills field_number and extension if extension is found.
+  // Note to support packed repeated field compatibility, it also fills whether
+  // the tag on wire is packed, which can be different from
+  // extension->is_packed (whether packed=true is specified).
+  bool FindExtensionInfoFromTag(uint32 tag, ExtensionFinder* extension_finder,
+                                int* field_number, ExtensionInfo* extension,
+                                bool* was_packed_on_wire);
+
+  // Returns true and fills extension if extension is found.
+  // Note to support packed repeated field compatibility, it also fills whether
+  // the tag on wire is packed, which can be different from
+  // extension->is_packed (whether packed=true is specified).
+  bool FindExtensionInfoFromFieldNumber(int wire_type, int field_number,
+                                        ExtensionFinder* extension_finder,
+                                        ExtensionInfo* extension,
+                                        bool* was_packed_on_wire);
+
+  // Parses a single extension from the input. The input should start out
+  // positioned immediately after the wire tag. This method is called in
+  // ParseField() after field number and was_packed_on_wire is extracted from
+  // the wire tag and ExtensionInfo is found by the field number.
+  bool ParseFieldWithExtensionInfo(int field_number,
+                                   bool was_packed_on_wire,
+                                   const ExtensionInfo& extension,
+                                   io::CodedInputStream* input,
+                                   FieldSkipper* field_skipper);
+
+  // Like ParseField(), but this method may parse singular message extensions
+  // lazily depending on the value of FLAGS_eagerly_parse_message_sets.
+  bool ParseFieldMaybeLazily(int wire_type, int field_number,
+                             io::CodedInputStream* input,
+                             ExtensionFinder* extension_finder,
+                             MessageSetFieldSkipper* field_skipper);
+
+  // Gets the extension with the given number, creating it if it does not
+  // already exist.  Returns true if the extension did not already exist.
+  bool MaybeNewExtension(int number, const FieldDescriptor* descriptor,
+                         Extension** result);
+
+  // Gets the repeated extension for the given descriptor, creating it if
+  // it does not exist.
+  Extension* MaybeNewRepeatedExtension(const FieldDescriptor* descriptor);
+
+  // Parse a single MessageSet item -- called just after the item group start
+  // tag has been read.
+  bool ParseMessageSetItem(io::CodedInputStream* input,
+                           ExtensionFinder* extension_finder,
+                           MessageSetFieldSkipper* field_skipper);
+
+  // Hack:  RepeatedPtrFieldBase declares ExtensionSet as a friend.  This
+  //   friendship should automatically extend to ExtensionSet::Extension, but
+  //   unfortunately some older compilers (e.g. GCC 3.4.4) do not implement this
+  //   correctly.  So, we must provide helpers for calling methods of that
+  //   class.
+
+  // Defined in extension_set_heavy.cc.
+  static inline size_t RepeatedMessage_SpaceUsedExcludingSelfLong(
+      RepeatedPtrFieldBase* field);
+
+  // The Extension struct is small enough to be passed by value, so we use it
+  // directly as the value type in the map rather than use pointers.  We use
+  // a map rather than hash_map here because we expect most ExtensionSets will
+  // only contain a small number of extensions whereas hash_map is optimized
+  // for 100 elements or more.  Also, we want AppendToList() to order fields
+  // by field number.
+  ExtensionMap extensions_;
+  ::google::protobuf::Arena* arena_;
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ExtensionSet);
+};
+
+// These are just for convenience...
+inline void ExtensionSet::SetString(int number, FieldType type,
+                                    const string& value,
+                                    const FieldDescriptor* descriptor) {
+  MutableString(number, type, descriptor)->assign(value);
+}
+inline void ExtensionSet::SetRepeatedString(int number, int index,
+                                            const string& value) {
+  MutableRepeatedString(number, index)->assign(value);
+}
+inline void ExtensionSet::AddString(int number, FieldType type,
+                                    const string& value,
+                                    const FieldDescriptor* descriptor) {
+  AddString(number, type, descriptor)->assign(value);
+}
+
+// ===================================================================
+// Glue for generated extension accessors
+
+// -------------------------------------------------------------------
+// Template magic
+
+// First we have a set of classes representing "type traits" for different
+// field types.  A type traits class knows how to implement basic accessors
+// for extensions of a particular type given an ExtensionSet.  The signature
+// for a type traits class looks like this:
+//
+//   class TypeTraits {
+//    public:
+//     typedef ? ConstType;
+//     typedef ? MutableType;
+//     // TypeTraits for singular fields and repeated fields will define the
+//     // symbol "Singular" or "Repeated" respectively. These two symbols will
+//     // be used in extension accessors to distinguish between singular
+//     // extensions and repeated extensions. If the TypeTraits for the passed
+//     // in extension doesn't have the expected symbol defined, it means the
+//     // user is passing a repeated extension to a singular accessor, or the
+//     // opposite. In that case the C++ compiler will generate an error
+//     // message "no matching member function" to inform the user.
+//     typedef ? Singular
+//     typedef ? Repeated
+//
+//     static inline ConstType Get(int number, const ExtensionSet& set);
+//     static inline void Set(int number, ConstType value, ExtensionSet* set);
+//     static inline MutableType Mutable(int number, ExtensionSet* set);
+//
+//     // Variants for repeated fields.
+//     static inline ConstType Get(int number, const ExtensionSet& set,
+//                                 int index);
+//     static inline void Set(int number, int index,
+//                            ConstType value, ExtensionSet* set);
+//     static inline MutableType Mutable(int number, int index,
+//                                       ExtensionSet* set);
+//     static inline void Add(int number, ConstType value, ExtensionSet* set);
+//     static inline MutableType Add(int number, ExtensionSet* set);
+//     This is used by the ExtensionIdentifier constructor to register
+//     the extension at dynamic initialization.
+//     template <typename ExtendeeT>
+//     static void Register(int number, FieldType type, bool is_packed);
+//   };
+//
+// Not all of these methods make sense for all field types.  For example, the
+// "Mutable" methods only make sense for strings and messages, and the
+// repeated methods only make sense for repeated types.  So, each type
+// traits class implements only the set of methods from this signature that it
+// actually supports.  This will cause a compiler error if the user tries to
+// access an extension using a method that doesn't make sense for its type.
+// For example, if "foo" is an extension of type "optional int32", then if you
+// try to write code like:
+//   my_message.MutableExtension(foo)
+// you will get a compile error because PrimitiveTypeTraits<int32> does not
+// have a "Mutable()" method.
+
+// -------------------------------------------------------------------
+// PrimitiveTypeTraits
+
+// Since the ExtensionSet has different methods for each primitive type,
+// we must explicitly define the methods of the type traits class for each
+// known type.
+template <typename Type>
+class PrimitiveTypeTraits {
+ public:
+  typedef Type ConstType;
+  typedef Type MutableType;
+  typedef PrimitiveTypeTraits<Type> Singular;
+
+  static inline ConstType Get(int number, const ExtensionSet& set,
+                              ConstType default_value);
+  static inline void Set(int number, FieldType field_type,
+                         ConstType value, ExtensionSet* set);
+  template <typename ExtendeeT>
+  static void Register(int number, FieldType type, bool is_packed) {
+    ExtensionSet::RegisterExtension(&ExtendeeT::default_instance(), number,
+                                    type, false, is_packed);
+  }
+};
+
+template <typename Type>
+class RepeatedPrimitiveTypeTraits {
+ public:
+  typedef Type ConstType;
+  typedef Type MutableType;
+  typedef RepeatedPrimitiveTypeTraits<Type> Repeated;
+
+  typedef RepeatedField<Type> RepeatedFieldType;
+
+  static inline Type Get(int number, const ExtensionSet& set, int index);
+  static inline void Set(int number, int index, Type value, ExtensionSet* set);
+  static inline void Add(int number, FieldType field_type,
+                         bool is_packed, Type value, ExtensionSet* set);
+
+  static inline const RepeatedField<ConstType>&
+      GetRepeated(int number, const ExtensionSet& set);
+  static inline RepeatedField<Type>*
+      MutableRepeated(int number, FieldType field_type,
+                      bool is_packed, ExtensionSet* set);
+
+  static const RepeatedFieldType* GetDefaultRepeatedField();
+  template <typename ExtendeeT>
+  static void Register(int number, FieldType type, bool is_packed) {
+    ExtensionSet::RegisterExtension(&ExtendeeT::default_instance(), number,
+                                    type, true, is_packed);
+  }
+};
+
+LIBPROTOBUF_EXPORT extern ProtobufOnceType repeated_primitive_generic_type_traits_once_init_;
+
+class LIBPROTOBUF_EXPORT RepeatedPrimitiveGenericTypeTraits {
+ private:
+  template<typename Type> friend class RepeatedPrimitiveTypeTraits;
+  static void InitializeDefaultRepeatedFields();
+  static void DestroyDefaultRepeatedFields();
+  static const RepeatedField<int32>* default_repeated_field_int32_;
+  static const RepeatedField<int64>* default_repeated_field_int64_;
+  static const RepeatedField<uint32>* default_repeated_field_uint32_;
+  static const RepeatedField<uint64>* default_repeated_field_uint64_;
+  static const RepeatedField<double>* default_repeated_field_double_;
+  static const RepeatedField<float>* default_repeated_field_float_;
+  static const RepeatedField<bool>* default_repeated_field_bool_;
+};
+
+#define PROTOBUF_DEFINE_PRIMITIVE_TYPE(TYPE, METHOD)                       \
+template<> inline TYPE PrimitiveTypeTraits<TYPE>::Get(                     \
+    int number, const ExtensionSet& set, TYPE default_value) {             \
+  return set.Get##METHOD(number, default_value);                           \
+}                                                                          \
+template<> inline void PrimitiveTypeTraits<TYPE>::Set(                     \
+    int number, FieldType field_type, TYPE value, ExtensionSet* set) {     \
+  set->Set##METHOD(number, field_type, value, NULL);                       \
+}                                                                          \
+                                                                           \
+template<> inline TYPE RepeatedPrimitiveTypeTraits<TYPE>::Get(             \
+    int number, const ExtensionSet& set, int index) {                      \
+  return set.GetRepeated##METHOD(number, index);                           \
+}                                                                          \
+template<> inline void RepeatedPrimitiveTypeTraits<TYPE>::Set(             \
+    int number, int index, TYPE value, ExtensionSet* set) {                \
+  set->SetRepeated##METHOD(number, index, value);                          \
+}                                                                          \
+template<> inline void RepeatedPrimitiveTypeTraits<TYPE>::Add(             \
+    int number, FieldType field_type, bool is_packed,                      \
+    TYPE value, ExtensionSet* set) {                                       \
+  set->Add##METHOD(number, field_type, is_packed, value, NULL);            \
+}                                                                          \
+template<> inline const RepeatedField<TYPE>*                               \
+    RepeatedPrimitiveTypeTraits<TYPE>::GetDefaultRepeatedField() {         \
+  ::google::protobuf::GoogleOnceInit(                                                          \
+      &repeated_primitive_generic_type_traits_once_init_,                  \
+      &RepeatedPrimitiveGenericTypeTraits::InitializeDefaultRepeatedFields); \
+  return RepeatedPrimitiveGenericTypeTraits::                              \
+      default_repeated_field_##TYPE##_;                                    \
+}                                                                          \
+template<> inline const RepeatedField<TYPE>&                               \
+    RepeatedPrimitiveTypeTraits<TYPE>::GetRepeated(int number,             \
+                                               const ExtensionSet& set) {  \
+  return *reinterpret_cast<const RepeatedField<TYPE>*>(                    \
+                            set.GetRawRepeatedField(                       \
+                                number, GetDefaultRepeatedField()));       \
+}                                                                          \
+template<> inline RepeatedField<TYPE>*                                     \
+    RepeatedPrimitiveTypeTraits<TYPE>::MutableRepeated(int number,         \
+                                                   FieldType field_type,   \
+                                                   bool is_packed,         \
+                                                   ExtensionSet* set) {    \
+  return reinterpret_cast<RepeatedField<TYPE>*>(                           \
+      set->MutableRawRepeatedField(number, field_type, is_packed, NULL));  \
+}
+
+PROTOBUF_DEFINE_PRIMITIVE_TYPE( int32,  Int32)
+PROTOBUF_DEFINE_PRIMITIVE_TYPE( int64,  Int64)
+PROTOBUF_DEFINE_PRIMITIVE_TYPE(uint32, UInt32)
+PROTOBUF_DEFINE_PRIMITIVE_TYPE(uint64, UInt64)
+PROTOBUF_DEFINE_PRIMITIVE_TYPE( float,  Float)
+PROTOBUF_DEFINE_PRIMITIVE_TYPE(double, Double)
+PROTOBUF_DEFINE_PRIMITIVE_TYPE(  bool,   Bool)
+
+#undef PROTOBUF_DEFINE_PRIMITIVE_TYPE
+
+// -------------------------------------------------------------------
+// StringTypeTraits
+
+// Strings support both Set() and Mutable().
+class LIBPROTOBUF_EXPORT StringTypeTraits {
+ public:
+  typedef const string& ConstType;
+  typedef string* MutableType;
+  typedef StringTypeTraits Singular;
+
+  static inline const string& Get(int number, const ExtensionSet& set,
+                                  ConstType default_value) {
+    return set.GetString(number, default_value);
+  }
+  static inline void Set(int number, FieldType field_type,
+                         const string& value, ExtensionSet* set) {
+    set->SetString(number, field_type, value, NULL);
+  }
+  static inline string* Mutable(int number, FieldType field_type,
+                                ExtensionSet* set) {
+    return set->MutableString(number, field_type, NULL);
+  }
+  template <typename ExtendeeT>
+  static void Register(int number, FieldType type, bool is_packed) {
+    ExtensionSet::RegisterExtension(&ExtendeeT::default_instance(), number,
+                                    type, false, is_packed);
+  }
+};
+
+LIBPROTOBUF_EXPORT extern ProtobufOnceType repeated_string_type_traits_once_init_;
+
+class LIBPROTOBUF_EXPORT RepeatedStringTypeTraits {
+ public:
+  typedef const string& ConstType;
+  typedef string* MutableType;
+  typedef RepeatedStringTypeTraits Repeated;
+
+  typedef RepeatedPtrField<string> RepeatedFieldType;
+
+  static inline const string& Get(int number, const ExtensionSet& set,
+                                  int index) {
+    return set.GetRepeatedString(number, index);
+  }
+  static inline void Set(int number, int index,
+                         const string& value, ExtensionSet* set) {
+    set->SetRepeatedString(number, index, value);
+  }
+  static inline string* Mutable(int number, int index, ExtensionSet* set) {
+    return set->MutableRepeatedString(number, index);
+  }
+  static inline void Add(int number, FieldType field_type,
+                         bool /*is_packed*/, const string& value,
+                         ExtensionSet* set) {
+    set->AddString(number, field_type, value, NULL);
+  }
+  static inline string* Add(int number, FieldType field_type,
+                            ExtensionSet* set) {
+    return set->AddString(number, field_type, NULL);
+  }
+  static inline const RepeatedPtrField<string>&
+      GetRepeated(int number, const ExtensionSet& set) {
+    return *reinterpret_cast<const RepeatedPtrField<string>*>(
+        set.GetRawRepeatedField(number, GetDefaultRepeatedField()));
+  }
+
+  static inline RepeatedPtrField<string>*
+      MutableRepeated(int number, FieldType field_type,
+                      bool is_packed, ExtensionSet* set) {
+    return reinterpret_cast<RepeatedPtrField<string>*>(
+        set->MutableRawRepeatedField(number, field_type,
+                                     is_packed, NULL));
+  }
+
+  static const RepeatedFieldType* GetDefaultRepeatedField() {
+    ::google::protobuf::GoogleOnceInit(&repeated_string_type_traits_once_init_,
+                   &InitializeDefaultRepeatedFields);
+    return default_repeated_field_;
+  }
+
+  template <typename ExtendeeT>
+  static void Register(int number, FieldType type, bool is_packed) {
+    ExtensionSet::RegisterExtension(&ExtendeeT::default_instance(), number,
+                                    type, true, is_packed);
+  }
+
+ private:
+  static void InitializeDefaultRepeatedFields();
+  static void DestroyDefaultRepeatedFields();
+  static const RepeatedFieldType *default_repeated_field_;
+};
+
+// -------------------------------------------------------------------
+// EnumTypeTraits
+
+// ExtensionSet represents enums using integers internally, so we have to
+// static_cast around.
+template <typename Type, bool IsValid(int)>
+class EnumTypeTraits {
+ public:
+  typedef Type ConstType;
+  typedef Type MutableType;
+  typedef EnumTypeTraits<Type, IsValid> Singular;
+
+  static inline ConstType Get(int number, const ExtensionSet& set,
+                              ConstType default_value) {
+    return static_cast<Type>(set.GetEnum(number, default_value));
+  }
+  static inline void Set(int number, FieldType field_type,
+                         ConstType value, ExtensionSet* set) {
+    GOOGLE_DCHECK(IsValid(value));
+    set->SetEnum(number, field_type, value, NULL);
+  }
+  template <typename ExtendeeT>
+  static void Register(int number, FieldType type, bool is_packed) {
+    ExtensionSet::RegisterEnumExtension(&ExtendeeT::default_instance(), number,
+                                        type, false, is_packed, IsValid);
+  }
+};
+
+template <typename Type, bool IsValid(int)>
+class RepeatedEnumTypeTraits {
+ public:
+  typedef Type ConstType;
+  typedef Type MutableType;
+  typedef RepeatedEnumTypeTraits<Type, IsValid> Repeated;
+
+  typedef RepeatedField<Type> RepeatedFieldType;
+
+  static inline ConstType Get(int number, const ExtensionSet& set, int index) {
+    return static_cast<Type>(set.GetRepeatedEnum(number, index));
+  }
+  static inline void Set(int number, int index,
+                         ConstType value, ExtensionSet* set) {
+    GOOGLE_DCHECK(IsValid(value));
+    set->SetRepeatedEnum(number, index, value);
+  }
+  static inline void Add(int number, FieldType field_type,
+                         bool is_packed, ConstType value, ExtensionSet* set) {
+    GOOGLE_DCHECK(IsValid(value));
+    set->AddEnum(number, field_type, is_packed, value, NULL);
+  }
+  static inline const RepeatedField<Type>& GetRepeated(int number,
+                                                       const ExtensionSet&
+                                                       set) {
+    // Hack: the `Extension` struct stores a RepeatedField<int> for enums.
+    // RepeatedField<int> cannot implicitly convert to RepeatedField<EnumType>
+    // so we need to do some casting magic. See message.h for similar
+    // contortions for non-extension fields.
+    return *reinterpret_cast<const RepeatedField<Type>*>(
+        set.GetRawRepeatedField(number, GetDefaultRepeatedField()));
+  }
+
+  static inline RepeatedField<Type>* MutableRepeated(int number,
+                                                     FieldType field_type,
+                                                     bool is_packed,
+                                                     ExtensionSet* set) {
+    return reinterpret_cast<RepeatedField<Type>*>(
+        set->MutableRawRepeatedField(number, field_type, is_packed, NULL));
+  }
+
+  static const RepeatedFieldType* GetDefaultRepeatedField() {
+    // Hack: as noted above, repeated enum fields are internally stored as a
+    // RepeatedField<int>. We need to be able to instantiate global static
+    // objects to return as default (empty) repeated fields on non-existent
+    // extensions. We would not be able to know a-priori all of the enum types
+    // (values of |Type|) to instantiate all of these, so we just re-use int32's
+    // default repeated field object.
+    return reinterpret_cast<const RepeatedField<Type>*>(
+        RepeatedPrimitiveTypeTraits<int32>::GetDefaultRepeatedField());
+  }
+  template <typename ExtendeeT>
+  static void Register(int number, FieldType type, bool is_packed) {
+    ExtensionSet::RegisterEnumExtension(&ExtendeeT::default_instance(), number,
+                                        type, true, is_packed, IsValid);
+  }
+};
+
+// -------------------------------------------------------------------
+// MessageTypeTraits
+
+// ExtensionSet guarantees that when manipulating extensions with message
+// types, the implementation used will be the compiled-in class representing
+// that type.  So, we can static_cast down to the exact type we expect.
+template <typename Type>
+class MessageTypeTraits {
+ public:
+  typedef const Type& ConstType;
+  typedef Type* MutableType;
+  typedef MessageTypeTraits<Type> Singular;
+
+  static inline ConstType Get(int number, const ExtensionSet& set,
+                              ConstType default_value) {
+    return static_cast<const Type&>(
+        set.GetMessage(number, default_value));
+  }
+  static inline MutableType Mutable(int number, FieldType field_type,
+                                    ExtensionSet* set) {
+    return static_cast<Type*>(
+      set->MutableMessage(number, field_type, Type::default_instance(), NULL));
+  }
+  static inline void SetAllocated(int number, FieldType field_type,
+                                  MutableType message, ExtensionSet* set) {
+    set->SetAllocatedMessage(number, field_type, NULL, message);
+  }
+  static inline void UnsafeArenaSetAllocated(int number, FieldType field_type,
+                                             MutableType message,
+                                             ExtensionSet* set) {
+    set->UnsafeArenaSetAllocatedMessage(number, field_type, NULL, message);
+  }
+  static inline MutableType Release(int number, FieldType /* field_type */,
+                                    ExtensionSet* set) {
+    return static_cast<Type*>(set->ReleaseMessage(
+        number, Type::default_instance()));
+  }
+  static inline MutableType UnsafeArenaRelease(int number,
+                                               FieldType /* field_type */,
+                                               ExtensionSet* set) {
+    return static_cast<Type*>(set->UnsafeArenaReleaseMessage(
+        number, Type::default_instance()));
+  }
+  template <typename ExtendeeT>
+  static void Register(int number, FieldType type, bool is_packed) {
+    ExtensionSet::RegisterMessageExtension(&ExtendeeT::default_instance(),
+                                           number, type, false, is_packed,
+                                           &Type::default_instance());
+  }
+};
+
+// forward declaration
+class RepeatedMessageGenericTypeTraits;
+
+template <typename Type>
+class RepeatedMessageTypeTraits {
+ public:
+  typedef const Type& ConstType;
+  typedef Type* MutableType;
+  typedef RepeatedMessageTypeTraits<Type> Repeated;
+
+  typedef RepeatedPtrField<Type> RepeatedFieldType;
+
+  static inline ConstType Get(int number, const ExtensionSet& set, int index) {
+    return static_cast<const Type&>(set.GetRepeatedMessage(number, index));
+  }
+  static inline MutableType Mutable(int number, int index, ExtensionSet* set) {
+    return static_cast<Type*>(set->MutableRepeatedMessage(number, index));
+  }
+  static inline MutableType Add(int number, FieldType field_type,
+                                ExtensionSet* set) {
+    return static_cast<Type*>(
+        set->AddMessage(number, field_type, Type::default_instance(), NULL));
+  }
+  static inline const RepeatedPtrField<Type>& GetRepeated(int number,
+                                                          const ExtensionSet&
+                                                          set) {
+    // See notes above in RepeatedEnumTypeTraits::GetRepeated(): same
+    // casting hack applies here, because a RepeatedPtrField<MessageLite>
+    // cannot naturally become a RepeatedPtrType<Type> even though Type is
+    // presumably a message. google::protobuf::Message goes through similar contortions
+    // with a reinterpret_cast<>.
+    return *reinterpret_cast<const RepeatedPtrField<Type>*>(
+        set.GetRawRepeatedField(number, GetDefaultRepeatedField()));
+  }
+  static inline RepeatedPtrField<Type>* MutableRepeated(int number,
+                                                        FieldType field_type,
+                                                        bool is_packed,
+                                                        ExtensionSet* set) {
+    return reinterpret_cast<RepeatedPtrField<Type>*>(
+        set->MutableRawRepeatedField(number, field_type, is_packed, NULL));
+  }
+
+  static const RepeatedFieldType* GetDefaultRepeatedField();
+  template <typename ExtendeeT>
+  static void Register(int number, FieldType type, bool is_packed) {
+    ExtensionSet::RegisterMessageExtension(&ExtendeeT::default_instance(),
+                                           number, type, true, is_packed,
+                                           &Type::default_instance());
+  }
+};
+
+LIBPROTOBUF_EXPORT extern ProtobufOnceType repeated_message_generic_type_traits_once_init_;
+
+// This class exists only to hold a generic default empty repeated field for all
+// message-type repeated field extensions.
+class LIBPROTOBUF_EXPORT RepeatedMessageGenericTypeTraits {
+ public:
+  typedef RepeatedPtrField< ::google::protobuf::MessageLite*> RepeatedFieldType;
+ private:
+  template<typename Type> friend class RepeatedMessageTypeTraits;
+  static void InitializeDefaultRepeatedFields();
+  static void DestroyDefaultRepeatedFields();
+  static const RepeatedFieldType* default_repeated_field_;
+};
+
+template<typename Type> inline
+    const typename RepeatedMessageTypeTraits<Type>::RepeatedFieldType*
+    RepeatedMessageTypeTraits<Type>::GetDefaultRepeatedField() {
+  ::google::protobuf::GoogleOnceInit(
+      &repeated_message_generic_type_traits_once_init_,
+      &RepeatedMessageGenericTypeTraits::InitializeDefaultRepeatedFields);
+  return reinterpret_cast<const RepeatedFieldType*>(
+      RepeatedMessageGenericTypeTraits::default_repeated_field_);
+}
+
+// -------------------------------------------------------------------
+// ExtensionIdentifier
+
+// This is the type of actual extension objects.  E.g. if you have:
+//   extends Foo with optional int32 bar = 1234;
+// then "bar" will be defined in C++ as:
+//   ExtensionIdentifier<Foo, PrimitiveTypeTraits<int32>, 1, false> bar(1234);
+//
+// Note that we could, in theory, supply the field number as a template
+// parameter, and thus make an instance of ExtensionIdentifier have no
+// actual contents.  However, if we did that, then using at extension
+// identifier would not necessarily cause the compiler to output any sort
+// of reference to any symbol defined in the extension's .pb.o file.  Some
+// linkers will actually drop object files that are not explicitly referenced,
+// but that would be bad because it would cause this extension to not be
+// registered at static initialization, and therefore using it would crash.
+
+template <typename ExtendeeType, typename TypeTraitsType,
+          FieldType field_type, bool is_packed>
+class ExtensionIdentifier {
+ public:
+  typedef TypeTraitsType TypeTraits;
+  typedef ExtendeeType Extendee;
+
+  ExtensionIdentifier(int number, typename TypeTraits::ConstType default_value)
+      : number_(number), default_value_(default_value) {
+    Register(number);
+  }
+  inline int number() const { return number_; }
+  typename TypeTraits::ConstType default_value() const {
+    return default_value_;
+  }
+
+  static void Register(int number) {
+    TypeTraits::template Register<ExtendeeType>(number, field_type, is_packed);
+  }
+
+ private:
+  const int number_;
+  typename TypeTraits::ConstType default_value_;
+};
+
+// -------------------------------------------------------------------
+// Generated accessors
+
+// This macro should be expanded in the context of a generated type which
+// has extensions.
+//
+// We use "_proto_TypeTraits" as a type name below because "TypeTraits"
+// causes problems if the class has a nested message or enum type with that
+// name and "_TypeTraits" is technically reserved for the C++ library since
+// it starts with an underscore followed by a capital letter.
+//
+// For similar reason, we use "_field_type" and "_is_packed" as parameter names
+// below, so that "field_type" and "is_packed" can be used as field names.
+#define GOOGLE_PROTOBUF_EXTENSION_ACCESSORS(CLASSNAME)                        \
+  /* Has, Size, Clear */                                                      \
+  template <typename _proto_TypeTraits,                                       \
+            ::google::protobuf::internal::FieldType _field_type,                        \
+            bool _is_packed>                                                  \
+  inline bool HasExtension(                                                   \
+      const ::google::protobuf::internal::ExtensionIdentifier<                          \
+        CLASSNAME, _proto_TypeTraits, _field_type, _is_packed>& id) const {   \
+    return _extensions_.Has(id.number());                                     \
+  }                                                                           \
+                                                                              \
+  template <typename _proto_TypeTraits,                                       \
+            ::google::protobuf::internal::FieldType _field_type,                        \
+            bool _is_packed>                                                  \
+  inline void ClearExtension(                                                 \
+      const ::google::protobuf::internal::ExtensionIdentifier<                          \
+        CLASSNAME, _proto_TypeTraits, _field_type, _is_packed>& id) {         \
+    _extensions_.ClearExtension(id.number());                                 \
+  }                                                                           \
+                                                                              \
+  template <typename _proto_TypeTraits,                                       \
+            ::google::protobuf::internal::FieldType _field_type,                        \
+            bool _is_packed>                                                  \
+  inline int ExtensionSize(                                                   \
+      const ::google::protobuf::internal::ExtensionIdentifier<                          \
+        CLASSNAME, _proto_TypeTraits, _field_type, _is_packed>& id) const {   \
+    return _extensions_.ExtensionSize(id.number());                           \
+  }                                                                           \
+                                                                              \
+  /* Singular accessors */                                                    \
+  template <typename _proto_TypeTraits,                                       \
+            ::google::protobuf::internal::FieldType _field_type,                        \
+            bool _is_packed>                                                  \
+  inline typename _proto_TypeTraits::Singular::ConstType GetExtension(        \
+      const ::google::protobuf::internal::ExtensionIdentifier<                          \
+        CLASSNAME, _proto_TypeTraits, _field_type, _is_packed>& id) const {   \
+    return _proto_TypeTraits::Get(id.number(), _extensions_,                  \
+                                  id.default_value());                        \
+  }                                                                           \
+                                                                              \
+  template <typename _proto_TypeTraits,                                       \
+            ::google::protobuf::internal::FieldType _field_type,                        \
+            bool _is_packed>                                                  \
+  inline typename _proto_TypeTraits::Singular::MutableType MutableExtension(  \
+      const ::google::protobuf::internal::ExtensionIdentifier<                          \
+        CLASSNAME, _proto_TypeTraits, _field_type, _is_packed>& id) {         \
+    return _proto_TypeTraits::Mutable(id.number(), _field_type,               \
+                                      &_extensions_);                         \
+  }                                                                           \
+                                                                              \
+  template <typename _proto_TypeTraits,                                       \
+            ::google::protobuf::internal::FieldType _field_type,                        \
+            bool _is_packed>                                                  \
+  inline void SetExtension(                                                   \
+      const ::google::protobuf::internal::ExtensionIdentifier<                          \
+        CLASSNAME, _proto_TypeTraits, _field_type, _is_packed>& id,           \
+      typename _proto_TypeTraits::Singular::ConstType value) {                \
+    _proto_TypeTraits::Set(id.number(), _field_type, value, &_extensions_);   \
+  }                                                                           \
+                                                                              \
+  template <typename _proto_TypeTraits,                                       \
+            ::google::protobuf::internal::FieldType _field_type,                        \
+            bool _is_packed>                                                  \
+  inline void SetAllocatedExtension(                                          \
+      const ::google::protobuf::internal::ExtensionIdentifier<                          \
+        CLASSNAME, _proto_TypeTraits, _field_type, _is_packed>& id,           \
+      typename _proto_TypeTraits::Singular::MutableType value) {              \
+    _proto_TypeTraits::SetAllocated(id.number(), _field_type,                 \
+                                    value, &_extensions_);                    \
+  }                                                                           \
+  template <typename _proto_TypeTraits,                                       \
+            ::google::protobuf::internal::FieldType _field_type,                        \
+            bool _is_packed>                                                  \
+  inline void UnsafeArenaSetAllocatedExtension(                               \
+      const ::google::protobuf::internal::ExtensionIdentifier<                          \
+        CLASSNAME, _proto_TypeTraits, _field_type, _is_packed>& id,           \
+      typename _proto_TypeTraits::Singular::MutableType value) {              \
+    _proto_TypeTraits::UnsafeArenaSetAllocated(id.number(), _field_type,      \
+                                               value, &_extensions_);         \
+  }                                                                           \
+  template <typename _proto_TypeTraits,                                       \
+            ::google::protobuf::internal::FieldType _field_type,                        \
+            bool _is_packed>                                                  \
+  inline typename _proto_TypeTraits::Singular::MutableType ReleaseExtension(  \
+      const ::google::protobuf::internal::ExtensionIdentifier<                          \
+        CLASSNAME, _proto_TypeTraits, _field_type, _is_packed>& id) {         \
+    return _proto_TypeTraits::Release(id.number(), _field_type,               \
+                                      &_extensions_);                         \
+  }                                                                           \
+  template <typename _proto_TypeTraits,                                       \
+            ::google::protobuf::internal::FieldType _field_type,                        \
+            bool _is_packed>                                                  \
+  inline typename _proto_TypeTraits::Singular::MutableType                    \
+      UnsafeArenaReleaseExtension(                                            \
+          const ::google::protobuf::internal::ExtensionIdentifier<                      \
+            CLASSNAME, _proto_TypeTraits, _field_type, _is_packed>& id) {     \
+    return _proto_TypeTraits::UnsafeArenaRelease(id.number(), _field_type,    \
+                                                 &_extensions_);              \
+  }                                                                           \
+                                                                              \
+  /* Repeated accessors */                                                    \
+  template <typename _proto_TypeTraits,                                       \
+            ::google::protobuf::internal::FieldType _field_type,                        \
+            bool _is_packed>                                                  \
+  inline typename _proto_TypeTraits::Repeated::ConstType GetExtension(        \
+      const ::google::protobuf::internal::ExtensionIdentifier<                          \
+        CLASSNAME, _proto_TypeTraits, _field_type, _is_packed>& id,           \
+      int index) const {                                                      \
+    return _proto_TypeTraits::Get(id.number(), _extensions_, index);          \
+  }                                                                           \
+                                                                              \
+  template <typename _proto_TypeTraits,                                       \
+            ::google::protobuf::internal::FieldType _field_type,                        \
+            bool _is_packed>                                                  \
+  inline typename _proto_TypeTraits::Repeated::MutableType MutableExtension(  \
+      const ::google::protobuf::internal::ExtensionIdentifier<                          \
+        CLASSNAME, _proto_TypeTraits, _field_type, _is_packed>& id,           \
+      int index) {                                                            \
+    return _proto_TypeTraits::Mutable(id.number(), index, &_extensions_);     \
+  }                                                                           \
+                                                                              \
+  template <typename _proto_TypeTraits,                                       \
+            ::google::protobuf::internal::FieldType _field_type,                        \
+            bool _is_packed>                                                  \
+  inline void SetExtension(                                                   \
+      const ::google::protobuf::internal::ExtensionIdentifier<                          \
+        CLASSNAME, _proto_TypeTraits, _field_type, _is_packed>& id,           \
+      int index, typename _proto_TypeTraits::Repeated::ConstType value) {     \
+    _proto_TypeTraits::Set(id.number(), index, value, &_extensions_);         \
+  }                                                                           \
+                                                                              \
+  template <typename _proto_TypeTraits,                                       \
+            ::google::protobuf::internal::FieldType _field_type,                        \
+            bool _is_packed>                                                  \
+  inline typename _proto_TypeTraits::Repeated::MutableType AddExtension(      \
+      const ::google::protobuf::internal::ExtensionIdentifier<                          \
+        CLASSNAME, _proto_TypeTraits, _field_type, _is_packed>& id) {         \
+    return _proto_TypeTraits::Add(id.number(), _field_type, &_extensions_);   \
+  }                                                                           \
+                                                                              \
+  template <typename _proto_TypeTraits,                                       \
+            ::google::protobuf::internal::FieldType _field_type,                        \
+            bool _is_packed>                                                  \
+  inline void AddExtension(                                                   \
+      const ::google::protobuf::internal::ExtensionIdentifier<                          \
+        CLASSNAME, _proto_TypeTraits, _field_type, _is_packed>& id,           \
+      typename _proto_TypeTraits::Repeated::ConstType value) {                \
+    _proto_TypeTraits::Add(id.number(), _field_type, _is_packed,              \
+                           value, &_extensions_);                             \
+  }                                                                           \
+                                                                              \
+  template <typename _proto_TypeTraits,                                       \
+            ::google::protobuf::internal::FieldType _field_type,                        \
+            bool _is_packed>                                                  \
+  inline const typename _proto_TypeTraits::Repeated::RepeatedFieldType&       \
+      GetRepeatedExtension(                                                   \
+          const ::google::protobuf::internal::ExtensionIdentifier<                      \
+            CLASSNAME, _proto_TypeTraits, _field_type,                        \
+            _is_packed>& id) const {                                          \
+    return _proto_TypeTraits::GetRepeated(id.number(), _extensions_);         \
+  }                                                                           \
+                                                                              \
+  template <typename _proto_TypeTraits,                                       \
+            ::google::protobuf::internal::FieldType _field_type,                        \
+            bool _is_packed>                                                  \
+  inline typename _proto_TypeTraits::Repeated::RepeatedFieldType*             \
+      MutableRepeatedExtension(                                               \
+          const ::google::protobuf::internal::ExtensionIdentifier<                      \
+              CLASSNAME, _proto_TypeTraits, _field_type,                      \
+              _is_packed>& id) {                                              \
+    return _proto_TypeTraits::MutableRepeated(id.number(), _field_type,       \
+                                              _is_packed, &_extensions_);     \
+  }
+
+}  // namespace internal
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_EXTENSION_SET_H__
diff --git a/kortex_api/include/google/protobuf/field_mask.pb.h b/kortex_api/include/google/protobuf/field_mask.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..d57a449437acefa532a75000694e768c1d1f367b
--- /dev/null
+++ b/kortex_api/include/google/protobuf/field_mask.pb.h
@@ -0,0 +1,267 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: google/protobuf/field_mask.proto
+
+#ifndef PROTOBUF_google_2fprotobuf_2ffield_5fmask_2eproto__INCLUDED
+#define PROTOBUF_google_2fprotobuf_2ffield_5fmask_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 3005000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 3005001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+// @@protoc_insertion_point(includes)
+
+namespace protobuf_google_2fprotobuf_2ffield_5fmask_2eproto {
+// Internal implementation detail -- do not use these members.
+struct LIBPROTOBUF_EXPORT TableStruct {
+  static const ::google::protobuf::internal::ParseTableField entries[];
+  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
+  static const ::google::protobuf::internal::ParseTable schema[1];
+  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
+  static const ::google::protobuf::internal::SerializationTable serialization_table[];
+  static const ::google::protobuf::uint32 offsets[];
+};
+void LIBPROTOBUF_EXPORT AddDescriptors();
+void LIBPROTOBUF_EXPORT InitDefaultsFieldMaskImpl();
+void LIBPROTOBUF_EXPORT InitDefaultsFieldMask();
+inline void LIBPROTOBUF_EXPORT InitDefaults() {
+  InitDefaultsFieldMask();
+}
+}  // namespace protobuf_google_2fprotobuf_2ffield_5fmask_2eproto
+namespace google {
+namespace protobuf {
+class FieldMask;
+class FieldMaskDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern FieldMaskDefaultTypeInternal _FieldMask_default_instance_;
+}  // namespace protobuf
+}  // namespace google
+namespace google {
+namespace protobuf {
+
+// ===================================================================
+
+class LIBPROTOBUF_EXPORT FieldMask : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.FieldMask) */ {
+ public:
+  FieldMask();
+  virtual ~FieldMask();
+
+  FieldMask(const FieldMask& from);
+
+  inline FieldMask& operator=(const FieldMask& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  FieldMask(FieldMask&& from) noexcept
+    : FieldMask() {
+    *this = ::std::move(from);
+  }
+
+  inline FieldMask& operator=(FieldMask&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const FieldMask& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const FieldMask* internal_default_instance() {
+    return reinterpret_cast<const FieldMask*>(
+               &_FieldMask_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    0;
+
+  void Swap(FieldMask* other);
+  friend void swap(FieldMask& a, FieldMask& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline FieldMask* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  FieldMask* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const FieldMask& from);
+  void MergeFrom(const FieldMask& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(FieldMask* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated string paths = 1;
+  int paths_size() const;
+  void clear_paths();
+  static const int kPathsFieldNumber = 1;
+  const ::std::string& paths(int index) const;
+  ::std::string* mutable_paths(int index);
+  void set_paths(int index, const ::std::string& value);
+  #if LANG_CXX11
+  void set_paths(int index, ::std::string&& value);
+  #endif
+  void set_paths(int index, const char* value);
+  void set_paths(int index, const char* value, size_t size);
+  ::std::string* add_paths();
+  void add_paths(const ::std::string& value);
+  #if LANG_CXX11
+  void add_paths(::std::string&& value);
+  #endif
+  void add_paths(const char* value);
+  void add_paths(const char* value, size_t size);
+  const ::google::protobuf::RepeatedPtrField< ::std::string>& paths() const;
+  ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_paths();
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.FieldMask)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::std::string> paths_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_google_2fprotobuf_2ffield_5fmask_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2ffield_5fmask_2eproto::InitDefaultsFieldMaskImpl();
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// FieldMask
+
+// repeated string paths = 1;
+inline int FieldMask::paths_size() const {
+  return paths_.size();
+}
+inline void FieldMask::clear_paths() {
+  paths_.Clear();
+}
+inline const ::std::string& FieldMask::paths(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FieldMask.paths)
+  return paths_.Get(index);
+}
+inline ::std::string* FieldMask::mutable_paths(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.FieldMask.paths)
+  return paths_.Mutable(index);
+}
+inline void FieldMask::set_paths(int index, const ::std::string& value) {
+  // @@protoc_insertion_point(field_set:google.protobuf.FieldMask.paths)
+  paths_.Mutable(index)->assign(value);
+}
+#if LANG_CXX11
+inline void FieldMask::set_paths(int index, ::std::string&& value) {
+  // @@protoc_insertion_point(field_set:google.protobuf.FieldMask.paths)
+  paths_.Mutable(index)->assign(std::move(value));
+}
+#endif
+inline void FieldMask::set_paths(int index, const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  paths_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:google.protobuf.FieldMask.paths)
+}
+inline void FieldMask::set_paths(int index, const char* value, size_t size) {
+  paths_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.FieldMask.paths)
+}
+inline ::std::string* FieldMask::add_paths() {
+  // @@protoc_insertion_point(field_add_mutable:google.protobuf.FieldMask.paths)
+  return paths_.Add();
+}
+inline void FieldMask::add_paths(const ::std::string& value) {
+  paths_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:google.protobuf.FieldMask.paths)
+}
+#if LANG_CXX11
+inline void FieldMask::add_paths(::std::string&& value) {
+  paths_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:google.protobuf.FieldMask.paths)
+}
+#endif
+inline void FieldMask::add_paths(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  paths_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:google.protobuf.FieldMask.paths)
+}
+inline void FieldMask::add_paths(const char* value, size_t size) {
+  paths_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:google.protobuf.FieldMask.paths)
+}
+inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
+FieldMask::paths() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.FieldMask.paths)
+  return paths_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::std::string>*
+FieldMask::mutable_paths() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.FieldMask.paths)
+  return &paths_;
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace protobuf
+}  // namespace google
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_google_2fprotobuf_2ffield_5fmask_2eproto__INCLUDED
diff --git a/kortex_api/include/google/protobuf/generated_enum_reflection.h b/kortex_api/include/google/protobuf/generated_enum_reflection.h
new file mode 100644
index 0000000000000000000000000000000000000000..fdcdc277909eed444ff8d7fd7bc897a9b3cfc745
--- /dev/null
+++ b/kortex_api/include/google/protobuf/generated_enum_reflection.h
@@ -0,0 +1,88 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: jasonh@google.com (Jason Hsueh)
+//
+// This header is logically internal, but is made public because it is used
+// from protocol-compiler-generated code, which may reside in other components.
+// It provides reflection support for generated enums, and is included in
+// generated .pb.h files and should have minimal dependencies. The methods are
+// implemented in generated_message_reflection.cc.
+
+#ifndef GOOGLE_PROTOBUF_GENERATED_ENUM_REFLECTION_H__
+#define GOOGLE_PROTOBUF_GENERATED_ENUM_REFLECTION_H__
+
+#include <string>
+
+#include <google/protobuf/stubs/template_util.h>
+#include <google/protobuf/generated_enum_util.h>
+
+namespace google {
+namespace protobuf {
+  class EnumDescriptor;
+}  // namespace protobuf
+
+namespace protobuf {
+
+// Returns the EnumDescriptor for enum type E, which must be a
+// proto-declared enum type.  Code generated by the protocol compiler
+// will include specializations of this template for each enum type declared.
+template <typename E>
+const EnumDescriptor* GetEnumDescriptor();
+
+namespace internal {
+
+// Helper for EnumType_Parse functions: try to parse the string 'name' as an
+// enum name of the given type, returning true and filling in value on success,
+// or returning false and leaving value unchanged on failure.
+LIBPROTOBUF_EXPORT bool ParseNamedEnum(const EnumDescriptor* descriptor,
+                    const string& name,
+                    int* value);
+
+template<typename EnumType>
+bool ParseNamedEnum(const EnumDescriptor* descriptor,
+                    const string& name,
+                    EnumType* value) {
+  int tmp;
+  if (!ParseNamedEnum(descriptor, name, &tmp)) return false;
+  *value = static_cast<EnumType>(tmp);
+  return true;
+}
+
+// Just a wrapper around printing the name of a value. The main point of this
+// function is not to be inlined, so that you can do this without including
+// descriptor.h.
+LIBPROTOBUF_EXPORT const string& NameOfEnum(const EnumDescriptor* descriptor, int value);
+
+}  // namespace internal
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_GENERATED_ENUM_REFLECTION_H__
diff --git a/kortex_api/include/google/protobuf/generated_enum_util.h b/kortex_api/include/google/protobuf/generated_enum_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..e4242055e991a2f581669c2198ffc909794da9ac
--- /dev/null
+++ b/kortex_api/include/google/protobuf/generated_enum_util.h
@@ -0,0 +1,46 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_GENERATED_ENUM_UTIL_H__
+#define GOOGLE_PROTOBUF_GENERATED_ENUM_UTIL_H__
+
+#include <google/protobuf/stubs/template_util.h>
+
+namespace google {
+namespace protobuf {
+
+// This type trait can be used to cause templates to only match proto2 enum
+// types.
+template <typename T> struct is_proto_enum : ::google::protobuf::internal::false_type {};
+
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_GENERATED_ENUM_UTIL_H__
diff --git a/kortex_api/include/google/protobuf/generated_message_reflection.h b/kortex_api/include/google/protobuf/generated_message_reflection.h
new file mode 100644
index 0000000000000000000000000000000000000000..02ecba6197796a5b5c14b3a50f789778084b7a02
--- /dev/null
+++ b/kortex_api/include/google/protobuf/generated_message_reflection.h
@@ -0,0 +1,728 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// This header is logically internal, but is made public because it is used
+// from protocol-compiler-generated code, which may reside in other components.
+
+#ifndef GOOGLE_PROTOBUF_GENERATED_MESSAGE_REFLECTION_H__
+#define GOOGLE_PROTOBUF_GENERATED_MESSAGE_REFLECTION_H__
+
+#include <string>
+#include <vector>
+#include <google/protobuf/stubs/casts.h>
+#include <google/protobuf/stubs/common.h>
+// TODO(jasonh): Remove this once the compiler change to directly include this
+// is released to components.
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/metadata.h>
+#include <google/protobuf/unknown_field_set.h>
+
+
+namespace google {
+namespace upb {
+namespace google_opensource {
+class GMR_Handlers;
+}  // namespace google_opensource
+}  // namespace upb
+
+namespace protobuf {
+class DescriptorPool;
+class MapKey;
+class MapValueRef;
+}  // namespace protobuf
+
+
+namespace protobuf {
+namespace flat {
+class MetadataBuilder;
+}  // namespace flat
+}  // namespace protobuf
+
+
+namespace protobuf {
+namespace internal {
+class DefaultEmptyOneof;
+
+// Defined in this file.
+class GeneratedMessageReflection;
+
+// Defined in other files.
+class ExtensionSet;             // extension_set.h
+class WeakFieldMap;             // weak_field_map.h
+
+// This struct describes the internal layout of the message, hence this is
+// used to act on the message reflectively.
+//   default_instance:  The default instance of the message.  This is only
+//                  used to obtain pointers to default instances of embedded
+//                  messages, which GetMessage() will return if the particular
+//                  sub-message has not been initialized yet.  (Thus, all
+//                  embedded message fields *must* have non-NULL pointers
+//                  in the default instance.)
+//   offsets:       An array of ints giving the byte offsets.
+//                  For each oneof or weak field, the offset is relative to the
+//                  default_instance. These can be computed at compile time
+//                  using the
+//                  GOOGLE_PROTOBUF_GENERATED_DEFAULT_ONEOF_FIELD_OFFSET()
+//                  macro. For each none oneof field, the offset is related to
+//                  the start of the message object.  These can be computed at
+//                  compile time using the
+//                  GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET() macro.
+//                  Besides offsets for all fields, this array also contains
+//                  offsets for oneof unions. The offset of the i-th oneof union
+//                  is offsets[descriptor->field_count() + i].
+//   has_bit_indices:  Mapping from field indexes to their index in the has
+//                  bit array.
+//   has_bits_offset:  Offset in the message of an array of uint32s of size
+//                  descriptor->field_count()/32, rounded up.  This is a
+//                  bitfield where each bit indicates whether or not the
+//                  corresponding field of the message has been initialized.
+//                  The bit for field index i is obtained by the expression:
+//                    has_bits[i / 32] & (1 << (i % 32))
+//   unknown_fields_offset:  Offset in the message of the UnknownFieldSet for
+//                  the message.
+//   extensions_offset:  Offset in the message of the ExtensionSet for the
+//                  message, or -1 if the message type has no extension
+//                  ranges.
+//   oneof_case_offset:  Offset in the message of an array of uint32s of
+//                  size descriptor->oneof_decl_count().  Each uint32
+//                  indicates what field is set for each oneof.
+//   object_size:   The size of a message object of this type, as measured
+//                  by sizeof().
+//   arena_offset:  If a message doesn't have a unknown_field_set that stores
+//                  the arena, it must have a direct pointer to the arena.
+//   weak_field_map_offset: If the message proto has weak fields, this is the
+//                  offset of _weak_field_map_ in the generated proto. Otherwise
+//                  -1.
+struct ReflectionSchema {
+ public:
+  // Size of a google::protobuf::Message object of this type.
+  uint32 GetObjectSize() const { return static_cast<uint32>(object_size_); }
+
+  // Offset of a non-oneof field.  Getting a field offset is slightly more
+  // efficient when we know statically that it is not a oneof field.
+  uint32 GetFieldOffsetNonOneof(const FieldDescriptor* field) const {
+    GOOGLE_DCHECK(!field->containing_oneof());
+    return offsets_[field->index()];
+  }
+
+  // Offset of any field.
+  uint32 GetFieldOffset(const FieldDescriptor* field) const {
+    if (field->containing_oneof()) {
+      size_t offset =
+          static_cast<size_t>(field->containing_type()->field_count() +
+          field->containing_oneof()->index());
+      return offsets_[offset];
+    } else {
+      return GetFieldOffsetNonOneof(field);
+    }
+  }
+
+  uint32 GetOneofCaseOffset(const OneofDescriptor* oneof_descriptor) const {
+    return static_cast<uint32>(oneof_case_offset_) +
+           static_cast<uint32>(
+               static_cast<size_t>(oneof_descriptor->index()) * sizeof(uint32));
+  }
+
+  bool HasHasbits() const { return has_bits_offset_ != -1; }
+
+  // Bit index within the bit array of hasbits.  Bit order is low-to-high.
+  uint32 HasBitIndex(const FieldDescriptor* field) const {
+    GOOGLE_DCHECK(HasHasbits());
+    return has_bit_indices_[field->index()];
+  }
+
+  // Byte offset of the hasbits array.
+  uint32 HasBitsOffset() const {
+    GOOGLE_DCHECK(HasHasbits());
+    return static_cast<uint32>(has_bits_offset_);
+  }
+
+  // The offset of the InternalMetadataWithArena member.
+  // For Lite this will actually be an InternalMetadataWithArenaLite.
+  // The schema doesn't contain enough information to distinguish between
+  // these two cases.
+  uint32 GetMetadataOffset() const {
+    return static_cast<uint32>(metadata_offset_);
+  }
+
+  // Whether this message has an ExtensionSet.
+  bool HasExtensionSet() const { return extensions_offset_ != -1; }
+
+  // The offset of the ExtensionSet in this message.
+  uint32 GetExtensionSetOffset() const {
+    GOOGLE_DCHECK(HasExtensionSet());
+    return static_cast<uint32>(extensions_offset_);
+  }
+
+  // The off set of WeakFieldMap when the message contains weak fields.
+  // The default is 0 for now.
+  int GetWeakFieldMapOffset() const { return weak_field_map_offset_; }
+
+  bool IsDefaultInstance(const Message& message) const {
+    return &message == default_instance_;
+  }
+
+  // Returns a pointer to the default value for this field.  The size and type
+  // of the underlying data depends on the field's type.
+  const void *GetFieldDefault(const FieldDescriptor* field) const {
+    return reinterpret_cast<const uint8*>(default_instance_) +
+                     offsets_[field->index()];
+  }
+
+
+  bool HasWeakFields() const { return weak_field_map_offset_ > 0; }
+
+  // These members are intended to be private, but we cannot actually make them
+  // private because this prevents us from using aggregate initialization of
+  // them, ie.
+  //
+  //   ReflectionSchema schema = {a, b, c, d, e, ...};
+ // private:
+  const Message* default_instance_;
+  const uint32* offsets_;
+  const uint32* has_bit_indices_;
+  int has_bits_offset_;
+  int metadata_offset_;
+  int extensions_offset_;
+  int oneof_case_offset_;
+  int object_size_;
+  int weak_field_map_offset_;
+};
+
+// Structs that the code generator emits directly to describe a message.
+// These should never used directly except to build a ReflectionSchema
+// object.
+//
+// EXPERIMENTAL: these are changing rapidly, and may completely disappear
+// or merge with ReflectionSchema.
+struct MigrationSchema {
+  int32 offsets_index;
+  int32 has_bit_indices_index;
+  int object_size;
+};
+
+// THIS CLASS IS NOT INTENDED FOR DIRECT USE.  It is intended for use
+// by generated code.  This class is just a big hack that reduces code
+// size.
+//
+// A GeneratedMessageReflection is an implementation of Reflection
+// which expects all fields to be backed by simple variables located in
+// memory.  The locations are given using a base pointer and a set of
+// offsets.
+//
+// It is required that the user represents fields of each type in a standard
+// way, so that GeneratedMessageReflection can cast the void* pointer to
+// the appropriate type.  For primitive fields and string fields, each field
+// should be represented using the obvious C++ primitive type.  Enums and
+// Messages are different:
+//  - Singular Message fields are stored as a pointer to a Message.  These
+//    should start out NULL, except for in the default instance where they
+//    should start out pointing to other default instances.
+//  - Enum fields are stored as an int.  This int must always contain
+//    a valid value, such that EnumDescriptor::FindValueByNumber() would
+//    not return NULL.
+//  - Repeated fields are stored as RepeatedFields or RepeatedPtrFields
+//    of whatever type the individual field would be.  Strings and
+//    Messages use RepeatedPtrFields while everything else uses
+//    RepeatedFields.
+class LIBPROTOBUF_EXPORT GeneratedMessageReflection PROTOBUF_FINAL : public Reflection {
+ public:
+  // Constructs a GeneratedMessageReflection.
+  // Parameters:
+  //   descriptor:    The descriptor for the message type being implemented.
+  //   schema:        The description of the internal guts of the message.
+  //   pool:          DescriptorPool to search for extension definitions.  Only
+  //                  used by FindKnownExtensionByName() and
+  //                  FindKnownExtensionByNumber().
+  //   factory:       MessageFactory to use to construct extension messages.
+  GeneratedMessageReflection(const Descriptor* descriptor,
+                             const ReflectionSchema& schema,
+                             const DescriptorPool* pool,
+                             MessageFactory* factory);
+
+  ~GeneratedMessageReflection();
+
+  // implements Reflection -------------------------------------------
+
+  const UnknownFieldSet& GetUnknownFields(const Message& message) const;
+  UnknownFieldSet* MutableUnknownFields(Message* message) const;
+
+  size_t SpaceUsedLong(const Message& message) const;
+
+  bool HasField(const Message& message, const FieldDescriptor* field) const;
+  int FieldSize(const Message& message, const FieldDescriptor* field) const;
+  void ClearField(Message* message, const FieldDescriptor* field) const;
+  bool HasOneof(const Message& message,
+                const OneofDescriptor* oneof_descriptor) const;
+  void ClearOneof(Message* message, const OneofDescriptor* field) const;
+  void RemoveLast(Message* message, const FieldDescriptor* field) const;
+  Message* ReleaseLast(Message* message, const FieldDescriptor* field) const;
+  void Swap(Message* message1, Message* message2) const;
+  void SwapFields(Message* message1, Message* message2,
+                  const std::vector<const FieldDescriptor*>& fields) const;
+  void SwapElements(Message* message, const FieldDescriptor* field,
+                    int index1, int index2) const;
+  void ListFields(const Message& message,
+                  std::vector<const FieldDescriptor*>* output) const;
+
+  int32  GetInt32 (const Message& message,
+                   const FieldDescriptor* field) const;
+  int64  GetInt64 (const Message& message,
+                   const FieldDescriptor* field) const;
+  uint32 GetUInt32(const Message& message,
+                   const FieldDescriptor* field) const;
+  uint64 GetUInt64(const Message& message,
+                   const FieldDescriptor* field) const;
+  float  GetFloat (const Message& message,
+                   const FieldDescriptor* field) const;
+  double GetDouble(const Message& message,
+                   const FieldDescriptor* field) const;
+  bool   GetBool  (const Message& message,
+                   const FieldDescriptor* field) const;
+  string GetString(const Message& message,
+                   const FieldDescriptor* field) const;
+  const string& GetStringReference(const Message& message,
+                                   const FieldDescriptor* field,
+                                   string* scratch) const;
+  const EnumValueDescriptor* GetEnum(const Message& message,
+                                     const FieldDescriptor* field) const;
+  int GetEnumValue(const Message& message,
+                   const FieldDescriptor* field) const;
+  const Message& GetMessage(const Message& message,
+                            const FieldDescriptor* field,
+                            MessageFactory* factory = NULL) const;
+
+  const FieldDescriptor* GetOneofFieldDescriptor(
+      const Message& message,
+      const OneofDescriptor* oneof_descriptor) const;
+
+ private:
+  bool ContainsMapKey(const Message& message,
+                      const FieldDescriptor* field,
+                      const MapKey& key) const;
+  bool InsertOrLookupMapValue(Message* message,
+                              const FieldDescriptor* field,
+                              const MapKey& key,
+                              MapValueRef* val) const;
+  bool DeleteMapValue(Message* message,
+                      const FieldDescriptor* field,
+                      const MapKey& key) const;
+  MapIterator MapBegin(
+      Message* message,
+      const FieldDescriptor* field) const;
+  MapIterator MapEnd(
+      Message* message,
+      const FieldDescriptor* field) const;
+  int MapSize(const Message& message, const FieldDescriptor* field) const;
+
+ public:
+  void SetInt32 (Message* message,
+                 const FieldDescriptor* field, int32  value) const;
+  void SetInt64 (Message* message,
+                 const FieldDescriptor* field, int64  value) const;
+  void SetUInt32(Message* message,
+                 const FieldDescriptor* field, uint32 value) const;
+  void SetUInt64(Message* message,
+                 const FieldDescriptor* field, uint64 value) const;
+  void SetFloat (Message* message,
+                 const FieldDescriptor* field, float  value) const;
+  void SetDouble(Message* message,
+                 const FieldDescriptor* field, double value) const;
+  void SetBool  (Message* message,
+                 const FieldDescriptor* field, bool   value) const;
+  void SetString(Message* message,
+                 const FieldDescriptor* field,
+                 const string& value) const;
+  void SetEnum  (Message* message, const FieldDescriptor* field,
+                 const EnumValueDescriptor* value) const;
+  void SetEnumValue(Message* message, const FieldDescriptor* field,
+                    int value) const;
+  Message* MutableMessage(Message* message, const FieldDescriptor* field,
+                          MessageFactory* factory = NULL) const;
+  void SetAllocatedMessage(Message* message,
+                           Message* sub_message,
+                           const FieldDescriptor* field) const;
+  Message* ReleaseMessage(Message* message, const FieldDescriptor* field,
+                          MessageFactory* factory = NULL) const;
+
+  int32  GetRepeatedInt32 (const Message& message,
+                           const FieldDescriptor* field, int index) const;
+  int64  GetRepeatedInt64 (const Message& message,
+                           const FieldDescriptor* field, int index) const;
+  uint32 GetRepeatedUInt32(const Message& message,
+                           const FieldDescriptor* field, int index) const;
+  uint64 GetRepeatedUInt64(const Message& message,
+                           const FieldDescriptor* field, int index) const;
+  float  GetRepeatedFloat (const Message& message,
+                           const FieldDescriptor* field, int index) const;
+  double GetRepeatedDouble(const Message& message,
+                           const FieldDescriptor* field, int index) const;
+  bool   GetRepeatedBool  (const Message& message,
+                           const FieldDescriptor* field, int index) const;
+  string GetRepeatedString(const Message& message,
+                           const FieldDescriptor* field, int index) const;
+  const string& GetRepeatedStringReference(const Message& message,
+                                           const FieldDescriptor* field,
+                                           int index, string* scratch) const;
+  const EnumValueDescriptor* GetRepeatedEnum(const Message& message,
+                                             const FieldDescriptor* field,
+                                             int index) const;
+  int GetRepeatedEnumValue(const Message& message,
+                           const FieldDescriptor* field,
+                           int index) const;
+  const Message& GetRepeatedMessage(const Message& message,
+                                    const FieldDescriptor* field,
+                                    int index) const;
+
+  // Set the value of a field.
+  void SetRepeatedInt32 (Message* message,
+                         const FieldDescriptor* field, int index, int32  value) const;
+  void SetRepeatedInt64 (Message* message,
+                         const FieldDescriptor* field, int index, int64  value) const;
+  void SetRepeatedUInt32(Message* message,
+                         const FieldDescriptor* field, int index, uint32 value) const;
+  void SetRepeatedUInt64(Message* message,
+                         const FieldDescriptor* field, int index, uint64 value) const;
+  void SetRepeatedFloat (Message* message,
+                         const FieldDescriptor* field, int index, float  value) const;
+  void SetRepeatedDouble(Message* message,
+                         const FieldDescriptor* field, int index, double value) const;
+  void SetRepeatedBool  (Message* message,
+                         const FieldDescriptor* field, int index, bool   value) const;
+  void SetRepeatedString(Message* message,
+                         const FieldDescriptor* field, int index,
+                         const string& value) const;
+  void SetRepeatedEnum(Message* message, const FieldDescriptor* field,
+                       int index, const EnumValueDescriptor* value) const;
+  void SetRepeatedEnumValue(Message* message, const FieldDescriptor* field,
+                            int index, int value) const;
+  // Get a mutable pointer to a field with a message type.
+  Message* MutableRepeatedMessage(Message* message,
+                                  const FieldDescriptor* field,
+                                  int index) const;
+
+  void AddInt32 (Message* message,
+                 const FieldDescriptor* field, int32  value) const;
+  void AddInt64 (Message* message,
+                 const FieldDescriptor* field, int64  value) const;
+  void AddUInt32(Message* message,
+                 const FieldDescriptor* field, uint32 value) const;
+  void AddUInt64(Message* message,
+                 const FieldDescriptor* field, uint64 value) const;
+  void AddFloat (Message* message,
+                 const FieldDescriptor* field, float  value) const;
+  void AddDouble(Message* message,
+                 const FieldDescriptor* field, double value) const;
+  void AddBool  (Message* message,
+                 const FieldDescriptor* field, bool   value) const;
+  void AddString(Message* message,
+                 const FieldDescriptor* field, const string& value) const;
+  void AddEnum(Message* message,
+               const FieldDescriptor* field,
+               const EnumValueDescriptor* value) const;
+  void AddEnumValue(Message* message,
+                    const FieldDescriptor* field,
+                    int value) const;
+  Message* AddMessage(Message* message, const FieldDescriptor* field,
+                      MessageFactory* factory = NULL) const;
+  void AddAllocatedMessage(
+      Message* message, const FieldDescriptor* field,
+      Message* new_entry) const;
+
+  const FieldDescriptor* FindKnownExtensionByName(const string& name) const;
+  const FieldDescriptor* FindKnownExtensionByNumber(int number) const;
+
+  bool SupportsUnknownEnumValues() const;
+
+  // This value for arena_offset_ indicates that there is no arena pointer in
+  // this message (e.g., old generated code).
+  static const int kNoArenaPointer = -1;
+
+  // This value for unknown_field_offset_ indicates that there is no
+  // UnknownFieldSet in this message, and that instead, we are using the
+  // Zero-Overhead Arena Pointer trick. When this is the case, arena_offset_
+  // actually indexes to an InternalMetadataWithArena instance, which can return
+  // either an arena pointer or an UnknownFieldSet or both. It is never the case
+  // that unknown_field_offset_ == kUnknownFieldSetInMetadata && arena_offset_
+  // == kNoArenaPointer.
+  static const int kUnknownFieldSetInMetadata = -1;
+
+ protected:
+  void* MutableRawRepeatedField(
+      Message* message, const FieldDescriptor* field, FieldDescriptor::CppType,
+      int ctype, const Descriptor* desc) const;
+
+  const void* GetRawRepeatedField(
+      const Message& message, const FieldDescriptor* field,
+      FieldDescriptor::CppType, int ctype,
+      const Descriptor* desc) const;
+
+  virtual MessageFactory* GetMessageFactory() const;
+
+  virtual void* RepeatedFieldData(
+      Message* message, const FieldDescriptor* field,
+      FieldDescriptor::CppType cpp_type,
+      const Descriptor* message_type) const;
+
+ private:
+  friend class google::protobuf::flat::MetadataBuilder;
+  friend class upb::google_opensource::GMR_Handlers;
+
+  const Descriptor* const descriptor_;
+  const ReflectionSchema schema_;
+  const DescriptorPool* const descriptor_pool_;
+  MessageFactory* const message_factory_;
+
+  // Last non weak field index. This is an optimization when most weak fields
+  // are at the end of the containing message. If a message proto doesn't
+  // contain weak fields, then this field equals descriptor_->field_count().
+  int last_non_weak_field_index_;
+
+  template <class T>
+  const T& GetRawNonOneof(const Message& message,
+                          const FieldDescriptor* field) const;
+  template <class T>
+  T* MutableRawNonOneof(Message* message, const FieldDescriptor* field) const;
+
+  template <typename Type>
+  const Type& GetRaw(const Message& message,
+                            const FieldDescriptor* field) const;
+  template <typename Type>
+  inline Type* MutableRaw(Message* message,
+                          const FieldDescriptor* field) const;
+  template <typename Type>
+  inline const Type& DefaultRaw(const FieldDescriptor* field) const;
+
+  inline const uint32* GetHasBits(const Message& message) const;
+  inline uint32* MutableHasBits(Message* message) const;
+  inline uint32 GetOneofCase(
+      const Message& message,
+      const OneofDescriptor* oneof_descriptor) const;
+  inline uint32* MutableOneofCase(
+      Message* message,
+      const OneofDescriptor* oneof_descriptor) const;
+  inline const ExtensionSet& GetExtensionSet(const Message& message) const;
+  inline ExtensionSet* MutableExtensionSet(Message* message) const;
+  inline Arena* GetArena(Message* message) const;
+
+  inline const InternalMetadataWithArena& GetInternalMetadataWithArena(
+      const Message& message) const;
+
+  inline InternalMetadataWithArena*
+      MutableInternalMetadataWithArena(Message* message) const;
+
+  inline bool HasBit(const Message& message,
+                     const FieldDescriptor* field) const;
+  inline void SetBit(Message* message,
+                     const FieldDescriptor* field) const;
+  inline void ClearBit(Message* message,
+                       const FieldDescriptor* field) const;
+  inline void SwapBit(Message* message1,
+                      Message* message2,
+                      const FieldDescriptor* field) const;
+
+  // This function only swaps the field. Should swap corresponding has_bit
+  // before or after using this function.
+  void SwapField(Message* message1,
+                 Message* message2,
+                 const FieldDescriptor* field) const;
+
+  void SwapOneofField(Message* message1,
+                      Message* message2,
+                      const OneofDescriptor* oneof_descriptor) const;
+
+  inline bool HasOneofField(const Message& message,
+                            const FieldDescriptor* field) const;
+  inline void SetOneofCase(Message* message,
+                           const FieldDescriptor* field) const;
+  inline void ClearOneofField(Message* message,
+                              const FieldDescriptor* field) const;
+
+  template <typename Type>
+  inline const Type& GetField(const Message& message,
+                              const FieldDescriptor* field) const;
+  template <typename Type>
+  inline void SetField(Message* message,
+                       const FieldDescriptor* field, const Type& value) const;
+  template <typename Type>
+  inline Type* MutableField(Message* message,
+                            const FieldDescriptor* field) const;
+  template <typename Type>
+  inline const Type& GetRepeatedField(const Message& message,
+                                      const FieldDescriptor* field,
+                                      int index) const;
+  template <typename Type>
+  inline const Type& GetRepeatedPtrField(const Message& message,
+                                         const FieldDescriptor* field,
+                                         int index) const;
+  template <typename Type>
+  inline void SetRepeatedField(Message* message,
+                               const FieldDescriptor* field, int index,
+                               Type value) const;
+  template <typename Type>
+  inline Type* MutableRepeatedField(Message* message,
+                                    const FieldDescriptor* field,
+                                    int index) const;
+  template <typename Type>
+  inline void AddField(Message* message,
+                       const FieldDescriptor* field, const Type& value) const;
+  template <typename Type>
+  inline Type* AddField(Message* message,
+                        const FieldDescriptor* field) const;
+
+  int GetExtensionNumberOrDie(const Descriptor* type) const;
+
+  // Internal versions of EnumValue API perform no checking. Called after checks
+  // by public methods.
+  void SetEnumValueInternal(Message* message,
+                            const FieldDescriptor* field,
+                            int value) const;
+  void SetRepeatedEnumValueInternal(Message* message,
+                                    const FieldDescriptor* field,
+                                    int index,
+                                    int value) const;
+  void AddEnumValueInternal(Message* message,
+                            const FieldDescriptor* field,
+                            int value) const;
+
+
+  Message* UnsafeArenaReleaseMessage(Message* message,
+                                     const FieldDescriptor* field,
+                                     MessageFactory* factory = NULL) const;
+
+  void UnsafeArenaSetAllocatedMessage(Message* message,
+                                      Message* sub_message,
+                                      const FieldDescriptor* field) const;
+
+  internal::MapFieldBase* MapData(
+      Message* message, const FieldDescriptor* field) const;
+
+  friend inline  // inline so nobody can call this function.
+      void
+      RegisterAllTypesInternal(const Metadata* file_level_metadata, int size);
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(GeneratedMessageReflection);
+};
+
+// There are some places in proto2 where dynamic_cast would be useful as an
+// optimization.  For example, take Message::MergeFrom(const Message& other).
+// For a given generated message FooMessage, we generate these two methods:
+//   void MergeFrom(const FooMessage& other);
+//   void MergeFrom(const Message& other);
+// The former method can be implemented directly in terms of FooMessage's
+// inline accessors, but the latter method must work with the reflection
+// interface.  However, if the parameter to the latter method is actually of
+// type FooMessage, then we'd like to be able to just call the other method
+// as an optimization.  So, we use dynamic_cast to check this.
+//
+// That said, dynamic_cast requires RTTI, which many people like to disable
+// for performance and code size reasons.  When RTTI is not available, we
+// still need to produce correct results.  So, in this case we have to fall
+// back to using reflection, which is what we would have done anyway if the
+// objects were not of the exact same class.
+//
+// dynamic_cast_if_available() implements this logic.  If RTTI is
+// enabled, it does a dynamic_cast.  If RTTI is disabled, it just returns
+// NULL.
+//
+// If you need to compile without RTTI, simply #define GOOGLE_PROTOBUF_NO_RTTI.
+// On MSVC, this should be detected automatically.
+template<typename To, typename From>
+inline To dynamic_cast_if_available(From from) {
+#if defined(GOOGLE_PROTOBUF_NO_RTTI) || (defined(_MSC_VER)&&!defined(_CPPRTTI))
+  // Avoid the compiler warning about unused variables.
+  (void)from;
+  return NULL;
+#else
+  return dynamic_cast<To>(from);
+#endif
+}
+
+// Tries to downcast this message to a generated message type.
+// Returns NULL if this class is not an instance of T.
+//
+// This is like dynamic_cast_if_available, except it works even when
+// dynamic_cast is not available by using Reflection.  However it only works
+// with Message objects.
+//
+// TODO(haberman): can we remove dynamic_cast_if_available in favor of this?
+template <typename T>
+T* DynamicCastToGenerated(const Message* from) {
+  // Compile-time assert that T is a generated type that has a
+  // default_instance() accessor, but avoid actually calling it.
+  const T&(*get_default_instance)() = &T::default_instance;
+  (void)get_default_instance;
+
+  // Compile-time assert that T is a subclass of google::protobuf::Message.
+  const Message* unused = static_cast<T*>(NULL);
+  (void)unused;
+
+#if defined(GOOGLE_PROTOBUF_NO_RTTI) || \
+  (defined(_MSC_VER) && !defined(_CPPRTTI))
+  bool ok = &T::default_instance() ==
+            from->GetReflection()->GetMessageFactory()->GetPrototype(
+                from->GetDescriptor());
+  return ok ? down_cast<T*>(from) : NULL;
+#else
+  return dynamic_cast<T*>(from);
+#endif
+}
+
+template <typename T>
+T* DynamicCastToGenerated(Message* from) {
+  const Message* message_const = from;
+  return const_cast<T*>(DynamicCastToGenerated<const T>(message_const));
+}
+
+LIBPROTOBUF_EXPORT void AssignDescriptors(
+    const string& filename, const MigrationSchema* schemas,
+    const Message* const* default_instances_, const uint32* offsets,
+    MessageFactory* factory,
+    // update the following descriptor arrays.
+    Metadata* file_level_metadata,
+    const EnumDescriptor** file_level_enum_descriptors,
+    const ServiceDescriptor** file_level_service_descriptors);
+
+LIBPROTOBUF_EXPORT void RegisterAllTypes(const Metadata* file_level_metadata, int size);
+
+// These cannot be in lite so we put them in the reflection.
+LIBPROTOBUF_EXPORT void UnknownFieldSetSerializer(const uint8* base, uint32 offset, uint32 tag,
+                               uint32 has_offset,
+                               ::google::protobuf::io::CodedOutputStream* output);
+
+}  // namespace internal
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_GENERATED_MESSAGE_REFLECTION_H__
diff --git a/kortex_api/include/google/protobuf/generated_message_table_driven.h b/kortex_api/include/google/protobuf/generated_message_table_driven.h
new file mode 100644
index 0000000000000000000000000000000000000000..6f3fe66609897e90c6ec615c65088556a6a930ee
--- /dev/null
+++ b/kortex_api/include/google/protobuf/generated_message_table_driven.h
@@ -0,0 +1,219 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_GENERATED_MESSAGE_TABLE_DRIVEN_H__
+#define GOOGLE_PROTOBUF_GENERATED_MESSAGE_TABLE_DRIVEN_H__
+
+#include <google/protobuf/map.h>
+#include <google/protobuf/map_entry_lite.h>
+#include <google/protobuf/map_field_lite.h>
+#include <google/protobuf/message_lite.h>
+#include <google/protobuf/wire_format_lite.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+
+#if LANG_CXX11
+#define PROTOBUF_CONSTEXPR constexpr
+
+// We require C++11 and Clang to use constexpr for variables, as GCC 4.8
+// requires constexpr to be consistent between declarations of variables
+// unnecessarily (see https://gcc.gnu.org/bugzilla/show_bug.cgi?id=58541).
+// VS 2017 Update 3 also supports this usage of constexpr.
+#if defined(__clang__) || (defined(_MSC_VER) && _MSC_VER >= 1911)
+#define PROTOBUF_CONSTEXPR_VAR constexpr
+#else  // !__clang__
+#define PROTOBUF_CONSTEXPR_VAR
+#endif  // !_clang
+
+#else
+#define PROTOBUF_CONSTEXPR
+#define PROTOBUF_CONSTEXPR_VAR
+#endif
+
+namespace google {
+namespace protobuf {
+namespace internal {
+
+// Processing-type masks.
+static PROTOBUF_CONSTEXPR const unsigned char kOneofMask = 0x40;
+static PROTOBUF_CONSTEXPR const unsigned char kRepeatedMask = 0x20;
+// Mask for the raw type: either a WireFormatLite::FieldType or one of the
+// ProcessingTypes below, without the oneof or repeated flag.
+static PROTOBUF_CONSTEXPR const unsigned char kTypeMask = 0x1f;
+
+// Wire type masks.
+static PROTOBUF_CONSTEXPR const unsigned char kNotPackedMask = 0x10;
+static PROTOBUF_CONSTEXPR const unsigned char kInvalidMask = 0x20;
+
+enum ProcessingTypes {
+  TYPE_STRING_CORD = 19,
+  TYPE_STRING_STRING_PIECE = 20,
+  TYPE_BYTES_CORD = 21,
+  TYPE_BYTES_STRING_PIECE = 22,
+  TYPE_MAP = 23,
+};
+
+#if LANG_CXX11
+static_assert(TYPE_MAP < kRepeatedMask, "Invalid enum");
+#endif
+
+// TODO(ckennelly):  Add a static assertion to ensure that these masks do not
+// conflict with wiretypes.
+
+// ParseTableField is kept small to help simplify instructions for computing
+// offsets, as we will always need this information to parse a field.
+// Additional data, needed for some types, is stored in
+// AuxillaryParseTableField.
+struct ParseTableField {
+  uint32 offset;
+  // The presence_index ordinarily represents a has_bit index, but for fields
+  // inside a oneof it represents the index in _oneof_case_.
+  uint32 presence_index;
+  unsigned char normal_wiretype;
+  unsigned char packed_wiretype;
+
+  // processing_type is given by:
+  //   (FieldDescriptor->type() << 1) | FieldDescriptor->is_packed()
+  unsigned char processing_type;
+
+  unsigned char tag_size;
+};
+
+struct ParseTable;
+
+union AuxillaryParseTableField {
+  typedef bool (*EnumValidator)(int);
+
+  // Enums
+  struct enum_aux {
+    EnumValidator validator;
+  };
+  enum_aux enums;
+  // Group, messages
+  struct message_aux {
+    // ExplicitlyInitialized<T> -> T requires a reinterpret_cast, which prevents
+    // the tables from being constructed as a constexpr.  We use void to avoid
+    // the cast.
+    const void* default_message_void;
+    const MessageLite* default_message() const {
+      return static_cast<const MessageLite*>(default_message_void);
+    }
+    const ParseTable* parse_table;
+  };
+  message_aux messages;
+  // Strings
+  struct string_aux {
+    const void* default_ptr;
+    const char* field_name;
+  };
+  string_aux strings;
+
+  struct map_aux {
+    bool (*parse_map)(io::CodedInputStream*, void*);
+  };
+  map_aux maps;
+
+#if LANG_CXX11
+  AuxillaryParseTableField() = default;
+#else
+  AuxillaryParseTableField() { }
+#endif
+  PROTOBUF_CONSTEXPR AuxillaryParseTableField(
+      AuxillaryParseTableField::enum_aux e) : enums(e) {}
+  PROTOBUF_CONSTEXPR AuxillaryParseTableField(
+      AuxillaryParseTableField::message_aux m) : messages(m) {}
+  PROTOBUF_CONSTEXPR AuxillaryParseTableField(
+      AuxillaryParseTableField::string_aux s) : strings(s) {}
+  PROTOBUF_CONSTEXPR AuxillaryParseTableField(
+      AuxillaryParseTableField::map_aux m)
+      : maps(m) {}
+};
+
+struct ParseTable {
+  const ParseTableField* fields;
+  const AuxillaryParseTableField* aux;
+  int max_field_number;
+  // TODO(ckennelly): Do something with this padding.
+
+  // TODO(ckennelly): Vet these for sign extension.
+  int64 has_bits_offset;
+  int64 oneof_case_offset;
+  int64 extension_offset;
+  int64 arena_offset;
+
+  // ExplicitlyInitialized<T> -> T requires a reinterpret_cast, which prevents
+  // the tables from being constructed as a constexpr.  We use void to avoid
+  // the cast.
+  const void* default_instance_void;
+  const MessageLite* default_instance() const {
+    return static_cast<const MessageLite*>(default_instance_void);
+  }
+
+  bool unknown_field_set;
+};
+
+// TODO(jhen): Remove the __NVCC__ check when we get a version of nvcc that
+// supports these checks.
+#if LANG_CXX11 && !defined(__NVCC__)
+static_assert(sizeof(ParseTableField) <= 16, "ParseTableField is too large");
+// The tables must be composed of POD components to ensure link-time
+// initialization.
+static_assert(std::is_pod<ParseTableField>::value, "");
+static_assert(std::is_pod<AuxillaryParseTableField>::value, "");
+static_assert(std::is_pod<AuxillaryParseTableField::enum_aux>::value, "");
+static_assert(std::is_pod<AuxillaryParseTableField::message_aux>::value, "");
+static_assert(std::is_pod<AuxillaryParseTableField::string_aux>::value, "");
+static_assert(std::is_pod<ParseTable>::value, "");
+#endif
+
+// TODO(ckennelly): Consolidate these implementations into a single one, using
+// dynamic dispatch to the appropriate unknown field handler.
+bool MergePartialFromCodedStream(MessageLite* msg, const ParseTable& table,
+                                 io::CodedInputStream* input);
+bool MergePartialFromCodedStreamLite(MessageLite* msg, const ParseTable& table,
+                                 io::CodedInputStream* input);
+
+template <typename Entry>
+bool ParseMap(io::CodedInputStream* input, void* map_field) {
+  typedef typename MapEntryToMapField<Entry>::MapFieldType MapFieldType;
+  typedef google::protobuf::Map<typename Entry::EntryKeyType,
+                      typename Entry::EntryValueType>
+      MapType;
+  typedef typename Entry::template Parser<MapFieldType, MapType> ParserType;
+
+  ParserType parser(static_cast<MapFieldType*>(map_field));
+  return ::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(input,
+                                                                  &parser);
+}
+
+}  // namespace internal
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_GENERATED_MESSAGE_TABLE_DRIVEN_H__
diff --git a/kortex_api/include/google/protobuf/generated_message_util.h b/kortex_api/include/google/protobuf/generated_message_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..8ebfc13b893f9170275a49469cd807473ba18cf0
--- /dev/null
+++ b/kortex_api/include/google/protobuf/generated_message_util.h
@@ -0,0 +1,320 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// This file contains miscellaneous helper code used by generated code --
+// including lite types -- but which should not be used directly by users.
+
+#ifndef GOOGLE_PROTOBUF_GENERATED_MESSAGE_UTIL_H__
+#define GOOGLE_PROTOBUF_GENERATED_MESSAGE_UTIL_H__
+
+#include <assert.h>
+#include <climits>
+#include <string>
+#include <vector>
+
+#include <google/protobuf/stubs/logging.h>
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/has_bits.h>
+#include <google/protobuf/map_entry_lite.h>
+#include <google/protobuf/message_lite.h>
+#include <google/protobuf/wire_format_lite.h>
+
+namespace google {
+
+namespace protobuf {
+
+class Arena;
+
+namespace io { class CodedInputStream; }
+
+namespace internal {
+
+
+// Annotation for the compiler to emit a deprecation message if a field marked
+// with option 'deprecated=true' is used in the code, or for other things in
+// generated code which are deprecated.
+//
+// For internal use in the pb.cc files, deprecation warnings are suppressed
+// there.
+#undef DEPRECATED_PROTOBUF_FIELD
+#define PROTOBUF_DEPRECATED
+
+#define GOOGLE_PROTOBUF_DEPRECATED_ATTR
+
+
+// Returns the offset of the given field within the given aggregate type.
+// This is equivalent to the ANSI C offsetof() macro.  However, according
+// to the C++ standard, offsetof() only works on POD types, and GCC
+// enforces this requirement with a warning.  In practice, this rule is
+// unnecessarily strict; there is probably no compiler or platform on
+// which the offsets of the direct fields of a class are non-constant.
+// Fields inherited from superclasses *can* have non-constant offsets,
+// but that's not what this macro will be used for.
+#if defined(__clang__)
+// For Clang we use __builtin_offsetof() and suppress the warning,
+// to avoid Control Flow Integrity and UBSan vptr sanitizers from
+// crashing while trying to validate the invalid reinterpet_casts.
+#define GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TYPE, FIELD)  \
+  _Pragma("clang diagnostic push")                                   \
+  _Pragma("clang diagnostic ignored \"-Winvalid-offsetof\"")         \
+  __builtin_offsetof(TYPE, FIELD)                                    \
+  _Pragma("clang diagnostic pop")
+#else
+// Note that we calculate relative to the pointer value 16 here since if we
+// just use zero, GCC complains about dereferencing a NULL pointer.  We
+// choose 16 rather than some other number just in case the compiler would
+// be confused by an unaligned pointer.
+#define GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TYPE, FIELD)  \
+  static_cast< ::google::protobuf::uint32>(                           \
+      reinterpret_cast<const char*>(                                 \
+          &reinterpret_cast<const TYPE*>(16)->FIELD) -               \
+      reinterpret_cast<const char*>(16))
+#endif
+
+// Constants for special floating point values.
+LIBPROTOBUF_EXPORT double Infinity();
+LIBPROTOBUF_EXPORT double NaN();
+
+
+// True if IsInitialized() is true for all elements of t.  Type is expected
+// to be a RepeatedPtrField<some message type>.  It's useful to have this
+// helper here to keep the protobuf compiler from ever having to emit loops in
+// IsInitialized() methods.  We want the C++ compiler to inline this or not
+// as it sees fit.
+template <class Type> bool AllAreInitialized(const Type& t) {
+  for (int i = t.size(); --i >= 0; ) {
+    if (!t.Get(i).IsInitialized()) return false;
+  }
+  return true;
+}
+
+LIBPROTOBUF_EXPORT void InitProtobufDefaults();
+
+struct LIBPROTOBUF_EXPORT FieldMetadata {
+  uint32 offset;  // offset of this field in the struct
+  uint32 tag;     // field * 8 + wire_type
+  // byte offset * 8 + bit_offset;
+  // if the high bit is set then this is the byte offset of the oneof_case
+  // for this field.
+  uint32 has_offset;
+  uint32 type;      // the type of this field.
+  const void* ptr;  // auxiliary data
+
+  // From the serializer point of view each fundamental type can occur in
+  // 4 different ways. For simplicity we treat all combinations as a cartesion
+  // product although not all combinations are allowed.
+  enum FieldTypeClass {
+    kPresence,
+    kNoPresence,
+    kRepeated,
+    kPacked,
+    kOneOf,
+    kNumTypeClasses  // must be last enum
+  };
+  // C++ protobuf has 20 fundamental types, were we added Cord and StringPiece
+  // and also distinquish the same types if they have different wire format.
+  enum {
+    kCordType = 19,
+    kStringPieceType = 20,
+    kNumTypes = 20,
+    kSpecial = kNumTypes * kNumTypeClasses,
+  };
+
+  static int CalculateType(int fundamental_type, FieldTypeClass type_class);
+};
+
+inline bool IsPresent(const void* base, uint32 hasbit) {
+  const uint32* has_bits_array = static_cast<const uint32*>(base);
+  return has_bits_array[hasbit / 32] & (1u << (hasbit & 31));
+}
+
+inline bool IsOneofPresent(const void* base, uint32 offset, uint32 tag) {
+  const uint32* oneof =
+      reinterpret_cast<const uint32*>(static_cast<const uint8*>(base) + offset);
+  return *oneof == tag >> 3;
+}
+
+typedef void (*SpecialSerializer)(const uint8* base, uint32 offset, uint32 tag,
+                                  uint32 has_offset,
+                                  ::google::protobuf::io::CodedOutputStream* output);
+
+LIBPROTOBUF_EXPORT void ExtensionSerializer(const uint8* base, uint32 offset, uint32 tag,
+                         uint32 has_offset,
+                         ::google::protobuf::io::CodedOutputStream* output);
+LIBPROTOBUF_EXPORT void UnknownFieldSerializerLite(const uint8* base, uint32 offset, uint32 tag,
+                                uint32 has_offset,
+                                ::google::protobuf::io::CodedOutputStream* output);
+
+struct SerializationTable {
+  int num_fields;
+  const FieldMetadata* field_table;
+};
+
+LIBPROTOBUF_EXPORT void SerializeInternal(const uint8* base, const FieldMetadata* table,
+                       int num_fields, ::google::protobuf::io::CodedOutputStream* output);
+
+inline void TableSerialize(const ::google::protobuf::MessageLite& msg,
+                           const SerializationTable* table,
+                           ::google::protobuf::io::CodedOutputStream* output) {
+  const FieldMetadata* field_table = table->field_table;
+  int num_fields = table->num_fields - 1;
+  const uint8* base = reinterpret_cast<const uint8*>(&msg);
+  // TODO(gerbens) This skips the first test if we could use the fast
+  // array serialization path, we should make this
+  // int cached_size =
+  //    *reinterpret_cast<const int32*>(base + field_table->offset);
+  // SerializeWithCachedSize(msg, field_table + 1, num_fields, cached_size, ...)
+  // But we keep conformance with the old way for now.
+  SerializeInternal(base, field_table + 1, num_fields, output);
+}
+
+uint8* SerializeInternalToArray(const uint8* base, const FieldMetadata* table,
+                                int num_fields, bool is_deterministic,
+                                uint8* buffer);
+
+inline uint8* TableSerializeToArray(const ::google::protobuf::MessageLite& msg,
+                                    const SerializationTable* table,
+                                    bool is_deterministic, uint8* buffer) {
+  const uint8* base = reinterpret_cast<const uint8*>(&msg);
+  const FieldMetadata* field_table = table->field_table + 1;
+  int num_fields = table->num_fields - 1;
+  return SerializeInternalToArray(base, field_table, num_fields,
+                                  is_deterministic, buffer);
+}
+
+template <typename T>
+struct CompareHelper {
+  bool operator()(const T& a, const T& b) { return a < b; }
+};
+
+template <>
+struct CompareHelper<ArenaStringPtr> {
+  bool operator()(const ArenaStringPtr& a, const ArenaStringPtr& b) {
+    return a.Get() < b.Get();
+  }
+};
+
+struct CompareMapKey {
+  template <typename T>
+  bool operator()(const MapEntryHelper<T>& a, const MapEntryHelper<T>& b) {
+    return Compare(a.key_, b.key_);
+  }
+  template <typename T>
+  bool Compare(const T& a, const T& b) {
+    return CompareHelper<T>()(a, b);
+  }
+};
+
+template <typename MapFieldType, const SerializationTable* table>
+void MapFieldSerializer(const uint8* base, uint32 offset, uint32 tag,
+                        uint32 has_offset,
+                        ::google::protobuf::io::CodedOutputStream* output) {
+  typedef MapEntryHelper<typename MapFieldType::EntryTypeTrait> Entry;
+  typedef typename MapFieldType::MapType::const_iterator Iter;
+
+  const MapFieldType& map_field =
+      *reinterpret_cast<const MapFieldType*>(base + offset);
+  const SerializationTable* t =
+      table +
+      has_offset;  // has_offset is overloaded for maps to mean table offset
+  if (!output->IsSerializationDeterministic()) {
+    for (Iter it = map_field.GetMap().begin(); it != map_field.GetMap().end();
+         ++it) {
+      Entry map_entry(*it);
+      output->WriteVarint32(tag);
+      output->WriteVarint32(map_entry._cached_size_);
+      SerializeInternal(reinterpret_cast<const uint8*>(&map_entry),
+                        t->field_table, t->num_fields, output);
+    }
+  } else {
+    std::vector<Entry> v;
+    for (Iter it = map_field.GetMap().begin(); it != map_field.GetMap().end();
+         ++it) {
+      v.push_back(Entry(*it));
+    }
+    std::sort(v.begin(), v.end(), CompareMapKey());
+    for (int i = 0; i < v.size(); i++) {
+      output->WriteVarint32(tag);
+      output->WriteVarint32(v[i]._cached_size_);
+      SerializeInternal(reinterpret_cast<const uint8*>(&v[i]), t->field_table,
+                        t->num_fields, output);
+    }
+  }
+}
+
+LIBPROTOBUF_EXPORT MessageLite* DuplicateIfNonNullInternal(MessageLite* message, Arena* arena);
+LIBPROTOBUF_EXPORT MessageLite* GetOwnedMessageInternal(Arena* message_arena,
+                                     MessageLite* submessage,
+                                     Arena* submessage_arena);
+
+template <typename T>
+T* DuplicateIfNonNull(T* message, Arena* arena) {
+  // The casts must be reinterpret_cast<> because T might be a forward-declared
+  // type that the compiler doesn't know is related to MessageLite.
+  return reinterpret_cast<T*>(DuplicateIfNonNullInternal(
+      reinterpret_cast<MessageLite*>(message), arena));
+}
+
+template <typename T>
+T* GetOwnedMessage(Arena* message_arena, T* submessage,
+                   Arena* submessage_arena) {
+  // The casts must be reinterpret_cast<> because T might be a forward-declared
+  // type that the compiler doesn't know is related to MessageLite.
+  return reinterpret_cast<T*>(GetOwnedMessageInternal(
+      message_arena, reinterpret_cast<MessageLite*>(submessage),
+      submessage_arena));
+}
+
+// Returns a message owned by this Arena.  This may require Own()ing or
+// duplicating the message.
+template <typename T>
+T* GetOwnedMessage(T* message, Arena* arena) {
+  GOOGLE_DCHECK(message);
+  Arena* message_arena = google::protobuf::Arena::GetArena(message);
+  if (message_arena == arena) {
+    return message;
+  } else if (arena != NULL && message_arena == NULL) {
+    arena->Own(message);
+    return message;
+  } else {
+    return DuplicateIfNonNull(message, arena);
+  }
+}
+
+}  // namespace internal
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_GENERATED_MESSAGE_UTIL_H__
diff --git a/kortex_api/include/google/protobuf/has_bits.h b/kortex_api/include/google/protobuf/has_bits.h
new file mode 100644
index 0000000000000000000000000000000000000000..e3a0149a47598e2919a027e19f4ca491d46fc75c
--- /dev/null
+++ b/kortex_api/include/google/protobuf/has_bits.h
@@ -0,0 +1,105 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_HAS_BITS_H__
+#define GOOGLE_PROTOBUF_HAS_BITS_H__
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/port.h>
+
+namespace google {
+namespace protobuf {
+namespace internal {
+
+template<size_t doublewords>
+class HasBits {
+ public:
+  HasBits() GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE { Clear(); }
+
+  void Clear() GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE {
+    memset(has_bits_, 0, sizeof(has_bits_));
+  }
+
+  ::google::protobuf::uint32& operator[](int index) GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE {
+    return has_bits_[index];
+  }
+
+  const ::google::protobuf::uint32& operator[](int index) const
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE {
+    return has_bits_[index];
+  }
+
+  bool operator==(const HasBits<doublewords>& rhs) const {
+    return memcmp(has_bits_, rhs.has_bits_, sizeof(has_bits_)) == 0;
+  }
+
+  bool operator!=(const HasBits<doublewords>& rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool empty() const;
+
+ private:
+  ::google::protobuf::uint32 has_bits_[doublewords];
+};
+
+template <>
+inline bool HasBits<1>::empty() const {
+  return !has_bits_[0];
+}
+
+template <>
+inline bool HasBits<2>::empty() const {
+  return !(has_bits_[0] | has_bits_[1]);
+}
+
+template <>
+inline bool HasBits<3>::empty() const {
+  return !(has_bits_[0] | has_bits_[1] | has_bits_[2]);
+}
+
+template <>
+inline bool HasBits<4>::empty() const {
+  return !(has_bits_[0] | has_bits_[1] | has_bits_[2] | has_bits_[3]);
+}
+
+template <size_t doublewords>
+inline bool HasBits<doublewords>::empty() const {
+  for (size_t i = 0; i < doublewords; ++i) {
+    if (has_bits_[i]) return false;
+  }
+  return true;
+}
+
+}  // namespace internal
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_HAS_BITS_H__
diff --git a/kortex_api/include/google/protobuf/io/coded_stream.h b/kortex_api/include/google/protobuf/io/coded_stream.h
new file mode 100644
index 0000000000000000000000000000000000000000..02d87ea42825dc2a1841d25335cf7c6dc4794012
--- /dev/null
+++ b/kortex_api/include/google/protobuf/io/coded_stream.h
@@ -0,0 +1,1422 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// This file contains the CodedInputStream and CodedOutputStream classes,
+// which wrap a ZeroCopyInputStream or ZeroCopyOutputStream, respectively,
+// and allow you to read or write individual pieces of data in various
+// formats.  In particular, these implement the varint encoding for
+// integers, a simple variable-length encoding in which smaller numbers
+// take fewer bytes.
+//
+// Typically these classes will only be used internally by the protocol
+// buffer library in order to encode and decode protocol buffers.  Clients
+// of the library only need to know about this class if they wish to write
+// custom message parsing or serialization procedures.
+//
+// CodedOutputStream example:
+//   // Write some data to "myfile".  First we write a 4-byte "magic number"
+//   // to identify the file type, then write a length-delimited string.  The
+//   // string is composed of a varint giving the length followed by the raw
+//   // bytes.
+//   int fd = open("myfile", O_CREAT | O_WRONLY);
+//   ZeroCopyOutputStream* raw_output = new FileOutputStream(fd);
+//   CodedOutputStream* coded_output = new CodedOutputStream(raw_output);
+//
+//   int magic_number = 1234;
+//   char text[] = "Hello world!";
+//   coded_output->WriteLittleEndian32(magic_number);
+//   coded_output->WriteVarint32(strlen(text));
+//   coded_output->WriteRaw(text, strlen(text));
+//
+//   delete coded_output;
+//   delete raw_output;
+//   close(fd);
+//
+// CodedInputStream example:
+//   // Read a file created by the above code.
+//   int fd = open("myfile", O_RDONLY);
+//   ZeroCopyInputStream* raw_input = new FileInputStream(fd);
+//   CodedInputStream coded_input = new CodedInputStream(raw_input);
+//
+//   coded_input->ReadLittleEndian32(&magic_number);
+//   if (magic_number != 1234) {
+//     cerr << "File not in expected format." << endl;
+//     return;
+//   }
+//
+//   uint32 size;
+//   coded_input->ReadVarint32(&size);
+//
+//   char* text = new char[size + 1];
+//   coded_input->ReadRaw(buffer, size);
+//   text[size] = '\0';
+//
+//   delete coded_input;
+//   delete raw_input;
+//   close(fd);
+//
+//   cout << "Text is: " << text << endl;
+//   delete [] text;
+//
+// For those who are interested, varint encoding is defined as follows:
+//
+// The encoding operates on unsigned integers of up to 64 bits in length.
+// Each byte of the encoded value has the format:
+// * bits 0-6: Seven bits of the number being encoded.
+// * bit 7: Zero if this is the last byte in the encoding (in which
+//   case all remaining bits of the number are zero) or 1 if
+//   more bytes follow.
+// The first byte contains the least-significant 7 bits of the number, the
+// second byte (if present) contains the next-least-significant 7 bits,
+// and so on.  So, the binary number 1011000101011 would be encoded in two
+// bytes as "10101011 00101100".
+//
+// In theory, varint could be used to encode integers of any length.
+// However, for practicality we set a limit at 64 bits.  The maximum encoded
+// length of a number is thus 10 bytes.
+
+#ifndef GOOGLE_PROTOBUF_IO_CODED_STREAM_H__
+#define GOOGLE_PROTOBUF_IO_CODED_STREAM_H__
+
+#include <assert.h>
+#include <climits>
+#include <string>
+#include <utility>
+#ifdef _MSC_VER
+  // Assuming windows is always little-endian.
+  #if !defined(PROTOBUF_DISABLE_LITTLE_ENDIAN_OPT_FOR_TEST)
+    #define PROTOBUF_LITTLE_ENDIAN 1
+  #endif
+  #if _MSC_VER >= 1300 && !defined(__INTEL_COMPILER)
+    // If MSVC has "/RTCc" set, it will complain about truncating casts at
+    // runtime.  This file contains some intentional truncating casts.
+    #pragma runtime_checks("c", off)
+  #endif
+#else
+  #include <sys/param.h>   // __BYTE_ORDER
+  #if ((defined(__LITTLE_ENDIAN__) && !defined(__BIG_ENDIAN__)) || \
+         (defined(__BYTE_ORDER) && __BYTE_ORDER == __LITTLE_ENDIAN)) && \
+      !defined(PROTOBUF_DISABLE_LITTLE_ENDIAN_OPT_FOR_TEST)
+    #define PROTOBUF_LITTLE_ENDIAN 1
+  #endif
+#endif
+#include <google/protobuf/stubs/atomicops.h>
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/port.h>
+#include <google/protobuf/stubs/port.h>
+
+namespace google {
+
+namespace protobuf {
+
+class DescriptorPool;
+class MessageFactory;
+
+namespace internal { void MapTestForceDeterministic(); }
+
+namespace io {
+
+// Defined in this file.
+class CodedInputStream;
+class CodedOutputStream;
+
+// Defined in other files.
+class ZeroCopyInputStream;           // zero_copy_stream.h
+class ZeroCopyOutputStream;          // zero_copy_stream.h
+
+// Class which reads and decodes binary data which is composed of varint-
+// encoded integers and fixed-width pieces.  Wraps a ZeroCopyInputStream.
+// Most users will not need to deal with CodedInputStream.
+//
+// Most methods of CodedInputStream that return a bool return false if an
+// underlying I/O error occurs or if the data is malformed.  Once such a
+// failure occurs, the CodedInputStream is broken and is no longer useful.
+class LIBPROTOBUF_EXPORT CodedInputStream {
+ public:
+  // Create a CodedInputStream that reads from the given ZeroCopyInputStream.
+  explicit CodedInputStream(ZeroCopyInputStream* input);
+
+  // Create a CodedInputStream that reads from the given flat array.  This is
+  // faster than using an ArrayInputStream.  PushLimit(size) is implied by
+  // this constructor.
+  explicit CodedInputStream(const uint8* buffer, int size);
+
+  // Destroy the CodedInputStream and position the underlying
+  // ZeroCopyInputStream at the first unread byte.  If an error occurred while
+  // reading (causing a method to return false), then the exact position of
+  // the input stream may be anywhere between the last value that was read
+  // successfully and the stream's byte limit.
+  ~CodedInputStream();
+
+  // Return true if this CodedInputStream reads from a flat array instead of
+  // a ZeroCopyInputStream.
+  inline bool IsFlat() const;
+
+  // Skips a number of bytes.  Returns false if an underlying read error
+  // occurs.
+  inline bool Skip(int count);
+
+  // Sets *data to point directly at the unread part of the CodedInputStream's
+  // underlying buffer, and *size to the size of that buffer, but does not
+  // advance the stream's current position.  This will always either produce
+  // a non-empty buffer or return false.  If the caller consumes any of
+  // this data, it should then call Skip() to skip over the consumed bytes.
+  // This may be useful for implementing external fast parsing routines for
+  // types of data not covered by the CodedInputStream interface.
+  bool GetDirectBufferPointer(const void** data, int* size);
+
+  // Like GetDirectBufferPointer, but this method is inlined, and does not
+  // attempt to Refresh() if the buffer is currently empty.
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  void GetDirectBufferPointerInline(const void** data, int* size);
+
+  // Read raw bytes, copying them into the given buffer.
+  bool ReadRaw(void* buffer, int size);
+
+  // Like the above, with inlined optimizations. This should only be used
+  // by the protobuf implementation.
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  bool InternalReadRawInline(void* buffer, int size);
+
+  // Like ReadRaw, but reads into a string.
+  bool ReadString(string* buffer, int size);
+  // Like the above, with inlined optimizations. This should only be used
+  // by the protobuf implementation.
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  bool InternalReadStringInline(string* buffer, int size);
+
+
+  // Read a 32-bit little-endian integer.
+  bool ReadLittleEndian32(uint32* value);
+  // Read a 64-bit little-endian integer.
+  bool ReadLittleEndian64(uint64* value);
+
+  // These methods read from an externally provided buffer. The caller is
+  // responsible for ensuring that the buffer has sufficient space.
+  // Read a 32-bit little-endian integer.
+  static const uint8* ReadLittleEndian32FromArray(const uint8* buffer,
+                                                   uint32* value);
+  // Read a 64-bit little-endian integer.
+  static const uint8* ReadLittleEndian64FromArray(const uint8* buffer,
+                                                   uint64* value);
+
+  // Read an unsigned integer with Varint encoding, truncating to 32 bits.
+  // Reading a 32-bit value is equivalent to reading a 64-bit one and casting
+  // it to uint32, but may be more efficient.
+  bool ReadVarint32(uint32* value);
+  // Read an unsigned integer with Varint encoding.
+  bool ReadVarint64(uint64* value);
+
+  // Reads a varint off the wire into an "int". This should be used for reading
+  // sizes off the wire (sizes of strings, submessages, bytes fields, etc).
+  //
+  // The value from the wire is interpreted as unsigned.  If its value exceeds
+  // the representable value of an integer on this platform, instead of
+  // truncating we return false. Truncating (as performed by ReadVarint32()
+  // above) is an acceptable approach for fields representing an integer, but
+  // when we are parsing a size from the wire, truncating the value would result
+  // in us misparsing the payload.
+  bool ReadVarintSizeAsInt(int* value);
+
+  // Read a tag.  This calls ReadVarint32() and returns the result, or returns
+  // zero (which is not a valid tag) if ReadVarint32() fails.  Also, ReadTag
+  // (but not ReadTagNoLastTag) updates the last tag value, which can be checked
+  // with LastTagWas().
+  //
+  // Always inline because this is only called in one place per parse loop
+  // but it is called for every iteration of said loop, so it should be fast.
+  // GCC doesn't want to inline this by default.
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE uint32 ReadTag() {
+    return last_tag_ = ReadTagNoLastTag();
+  }
+
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE uint32 ReadTagNoLastTag();
+
+
+  // This usually a faster alternative to ReadTag() when cutoff is a manifest
+  // constant.  It does particularly well for cutoff >= 127.  The first part
+  // of the return value is the tag that was read, though it can also be 0 in
+  // the cases where ReadTag() would return 0.  If the second part is true
+  // then the tag is known to be in [0, cutoff].  If not, the tag either is
+  // above cutoff or is 0.  (There's intentional wiggle room when tag is 0,
+  // because that can arise in several ways, and for best performance we want
+  // to avoid an extra "is tag == 0?" check here.)
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  std::pair<uint32, bool> ReadTagWithCutoff(uint32 cutoff) {
+    std::pair<uint32, bool> result = ReadTagWithCutoffNoLastTag(cutoff);
+    last_tag_ = result.first;
+    return result;
+  }
+
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  std::pair<uint32, bool> ReadTagWithCutoffNoLastTag(uint32 cutoff);
+
+  // Usually returns true if calling ReadVarint32() now would produce the given
+  // value.  Will always return false if ReadVarint32() would not return the
+  // given value.  If ExpectTag() returns true, it also advances past
+  // the varint.  For best performance, use a compile-time constant as the
+  // parameter.
+  // Always inline because this collapses to a small number of instructions
+  // when given a constant parameter, but GCC doesn't want to inline by default.
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE bool ExpectTag(uint32 expected);
+
+  // Like above, except this reads from the specified buffer. The caller is
+  // responsible for ensuring that the buffer is large enough to read a varint
+  // of the expected size. For best performance, use a compile-time constant as
+  // the expected tag parameter.
+  //
+  // Returns a pointer beyond the expected tag if it was found, or NULL if it
+  // was not.
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  static const uint8* ExpectTagFromArray(const uint8* buffer, uint32 expected);
+
+  // Usually returns true if no more bytes can be read.  Always returns false
+  // if more bytes can be read.  If ExpectAtEnd() returns true, a subsequent
+  // call to LastTagWas() will act as if ReadTag() had been called and returned
+  // zero, and ConsumedEntireMessage() will return true.
+  bool ExpectAtEnd();
+
+  // If the last call to ReadTag() or ReadTagWithCutoff() returned the given
+  // value, returns true.  Otherwise, returns false.
+  // ReadTagNoLastTag/ReadTagWithCutoffNoLastTag do not preserve the last
+  // returned value.
+  //
+  // This is needed because parsers for some types of embedded messages
+  // (with field type TYPE_GROUP) don't actually know that they've reached the
+  // end of a message until they see an ENDGROUP tag, which was actually part
+  // of the enclosing message.  The enclosing message would like to check that
+  // tag to make sure it had the right number, so it calls LastTagWas() on
+  // return from the embedded parser to check.
+  bool LastTagWas(uint32 expected);
+  void SetLastTag(uint32 tag) { last_tag_ = tag; }
+
+  // When parsing message (but NOT a group), this method must be called
+  // immediately after MergeFromCodedStream() returns (if it returns true)
+  // to further verify that the message ended in a legitimate way.  For
+  // example, this verifies that parsing did not end on an end-group tag.
+  // It also checks for some cases where, due to optimizations,
+  // MergeFromCodedStream() can incorrectly return true.
+  bool ConsumedEntireMessage();
+
+  // Limits ----------------------------------------------------------
+  // Limits are used when parsing length-delimited embedded messages.
+  // After the message's length is read, PushLimit() is used to prevent
+  // the CodedInputStream from reading beyond that length.  Once the
+  // embedded message has been parsed, PopLimit() is called to undo the
+  // limit.
+
+  // Opaque type used with PushLimit() and PopLimit().  Do not modify
+  // values of this type yourself.  The only reason that this isn't a
+  // struct with private internals is for efficiency.
+  typedef int Limit;
+
+  // Places a limit on the number of bytes that the stream may read,
+  // starting from the current position.  Once the stream hits this limit,
+  // it will act like the end of the input has been reached until PopLimit()
+  // is called.
+  //
+  // As the names imply, the stream conceptually has a stack of limits.  The
+  // shortest limit on the stack is always enforced, even if it is not the
+  // top limit.
+  //
+  // The value returned by PushLimit() is opaque to the caller, and must
+  // be passed unchanged to the corresponding call to PopLimit().
+  Limit PushLimit(int byte_limit);
+
+  // Pops the last limit pushed by PushLimit().  The input must be the value
+  // returned by that call to PushLimit().
+  void PopLimit(Limit limit);
+
+  // Returns the number of bytes left until the nearest limit on the
+  // stack is hit, or -1 if no limits are in place.
+  int BytesUntilLimit() const;
+
+  // Returns current position relative to the beginning of the input stream.
+  int CurrentPosition() const;
+
+  // Total Bytes Limit -----------------------------------------------
+  // To prevent malicious users from sending excessively large messages
+  // and causing integer overflows or memory exhaustion, CodedInputStream
+  // imposes a hard limit on the total number of bytes it will read.
+
+  // Sets the maximum number of bytes that this CodedInputStream will read
+  // before refusing to continue.  To prevent integer overflows in the
+  // protocol buffers implementation, as well as to prevent servers from
+  // allocating enormous amounts of memory to hold parsed messages, the
+  // maximum message length should be limited to the shortest length that
+  // will not harm usability.  The theoretical shortest message that could
+  // cause integer overflows is 512MB.  The default limit is 64MB.  Apps
+  // should set shorter limits if possible.  For backwards compatibility all
+  // negative values get squashed to -1, as other negative values might have
+  // special internal meanings.  An error will always be printed to stderr if
+  // the limit is reached.
+  //
+  // This is unrelated to PushLimit()/PopLimit().
+  //
+  // Hint:  If you are reading this because your program is printing a
+  //   warning about dangerously large protocol messages, you may be
+  //   confused about what to do next.  The best option is to change your
+  //   design such that excessively large messages are not necessary.
+  //   For example, try to design file formats to consist of many small
+  //   messages rather than a single large one.  If this is infeasible,
+  //   you will need to increase the limit.  Chances are, though, that
+  //   your code never constructs a CodedInputStream on which the limit
+  //   can be set.  You probably parse messages by calling things like
+  //   Message::ParseFromString().  In this case, you will need to change
+  //   your code to instead construct some sort of ZeroCopyInputStream
+  //   (e.g. an ArrayInputStream), construct a CodedInputStream around
+  //   that, then you can adjust the limit. Then call
+  //   Message::ParseFromCodedStream() instead. Yes, it's more work, but
+  //   you're doing something unusual.
+  void SetTotalBytesLimit(int total_bytes_limit, int warning_threshold);
+
+  // The Total Bytes Limit minus the Current Position, or -1 if there
+  // is no Total Bytes Limit.
+  int BytesUntilTotalBytesLimit() const;
+
+  // Recursion Limit -------------------------------------------------
+  // To prevent corrupt or malicious messages from causing stack overflows,
+  // we must keep track of the depth of recursion when parsing embedded
+  // messages and groups.  CodedInputStream keeps track of this because it
+  // is the only object that is passed down the stack during parsing.
+
+  // Sets the maximum recursion depth.  The default is 100.
+  void SetRecursionLimit(int limit);
+
+
+  // Increments the current recursion depth.  Returns true if the depth is
+  // under the limit, false if it has gone over.
+  bool IncrementRecursionDepth();
+
+  // Decrements the recursion depth if possible.
+  void DecrementRecursionDepth();
+
+  // Decrements the recursion depth blindly.  This is faster than
+  // DecrementRecursionDepth().  It should be used only if all previous
+  // increments to recursion depth were successful.
+  void UnsafeDecrementRecursionDepth();
+
+  // Shorthand for make_pair(PushLimit(byte_limit), --recursion_budget_).
+  // Using this can reduce code size and complexity in some cases.  The caller
+  // is expected to check that the second part of the result is non-negative (to
+  // bail out if the depth of recursion is too high) and, if all is well, to
+  // later pass the first part of the result to PopLimit() or similar.
+  std::pair<CodedInputStream::Limit, int> IncrementRecursionDepthAndPushLimit(
+      int byte_limit);
+
+  // Shorthand for PushLimit(ReadVarint32(&length) ? length : 0).
+  Limit ReadLengthAndPushLimit();
+
+  // Helper that is equivalent to: {
+  //  bool result = ConsumedEntireMessage();
+  //  PopLimit(limit);
+  //  UnsafeDecrementRecursionDepth();
+  //  return result; }
+  // Using this can reduce code size and complexity in some cases.
+  // Do not use unless the current recursion depth is greater than zero.
+  bool DecrementRecursionDepthAndPopLimit(Limit limit);
+
+  // Helper that is equivalent to: {
+  //  bool result = ConsumedEntireMessage();
+  //  PopLimit(limit);
+  //  return result; }
+  // Using this can reduce code size and complexity in some cases.
+  bool CheckEntireMessageConsumedAndPopLimit(Limit limit);
+
+  // Extension Registry ----------------------------------------------
+  // ADVANCED USAGE:  99.9% of people can ignore this section.
+  //
+  // By default, when parsing extensions, the parser looks for extension
+  // definitions in the pool which owns the outer message's Descriptor.
+  // However, you may call SetExtensionRegistry() to provide an alternative
+  // pool instead.  This makes it possible, for example, to parse a message
+  // using a generated class, but represent some extensions using
+  // DynamicMessage.
+
+  // Set the pool used to look up extensions.  Most users do not need to call
+  // this as the correct pool will be chosen automatically.
+  //
+  // WARNING:  It is very easy to misuse this.  Carefully read the requirements
+  //   below.  Do not use this unless you are sure you need it.  Almost no one
+  //   does.
+  //
+  // Let's say you are parsing a message into message object m, and you want
+  // to take advantage of SetExtensionRegistry().  You must follow these
+  // requirements:
+  //
+  // The given DescriptorPool must contain m->GetDescriptor().  It is not
+  // sufficient for it to simply contain a descriptor that has the same name
+  // and content -- it must be the *exact object*.  In other words:
+  //   assert(pool->FindMessageTypeByName(m->GetDescriptor()->full_name()) ==
+  //          m->GetDescriptor());
+  // There are two ways to satisfy this requirement:
+  // 1) Use m->GetDescriptor()->pool() as the pool.  This is generally useless
+  //    because this is the pool that would be used anyway if you didn't call
+  //    SetExtensionRegistry() at all.
+  // 2) Use a DescriptorPool which has m->GetDescriptor()->pool() as an
+  //    "underlay".  Read the documentation for DescriptorPool for more
+  //    information about underlays.
+  //
+  // You must also provide a MessageFactory.  This factory will be used to
+  // construct Message objects representing extensions.  The factory's
+  // GetPrototype() MUST return non-NULL for any Descriptor which can be found
+  // through the provided pool.
+  //
+  // If the provided factory might return instances of protocol-compiler-
+  // generated (i.e. compiled-in) types, or if the outer message object m is
+  // a generated type, then the given factory MUST have this property:  If
+  // GetPrototype() is given a Descriptor which resides in
+  // DescriptorPool::generated_pool(), the factory MUST return the same
+  // prototype which MessageFactory::generated_factory() would return.  That
+  // is, given a descriptor for a generated type, the factory must return an
+  // instance of the generated class (NOT DynamicMessage).  However, when
+  // given a descriptor for a type that is NOT in generated_pool, the factory
+  // is free to return any implementation.
+  //
+  // The reason for this requirement is that generated sub-objects may be
+  // accessed via the standard (non-reflection) extension accessor methods,
+  // and these methods will down-cast the object to the generated class type.
+  // If the object is not actually of that type, the results would be undefined.
+  // On the other hand, if an extension is not compiled in, then there is no
+  // way the code could end up accessing it via the standard accessors -- the
+  // only way to access the extension is via reflection.  When using reflection,
+  // DynamicMessage and generated messages are indistinguishable, so it's fine
+  // if these objects are represented using DynamicMessage.
+  //
+  // Using DynamicMessageFactory on which you have called
+  // SetDelegateToGeneratedFactory(true) should be sufficient to satisfy the
+  // above requirement.
+  //
+  // If either pool or factory is NULL, both must be NULL.
+  //
+  // Note that this feature is ignored when parsing "lite" messages as they do
+  // not have descriptors.
+  void SetExtensionRegistry(const DescriptorPool* pool,
+                            MessageFactory* factory);
+
+  // Get the DescriptorPool set via SetExtensionRegistry(), or NULL if no pool
+  // has been provided.
+  const DescriptorPool* GetExtensionPool();
+
+  // Get the MessageFactory set via SetExtensionRegistry(), or NULL if no
+  // factory has been provided.
+  MessageFactory* GetExtensionFactory();
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CodedInputStream);
+
+  const uint8* buffer_;
+  const uint8* buffer_end_;     // pointer to the end of the buffer.
+  ZeroCopyInputStream* input_;
+  int total_bytes_read_;  // total bytes read from input_, including
+                          // the current buffer
+
+  // If total_bytes_read_ surpasses INT_MAX, we record the extra bytes here
+  // so that we can BackUp() on destruction.
+  int overflow_bytes_;
+
+  // LastTagWas() stuff.
+  uint32 last_tag_;         // result of last ReadTag() or ReadTagWithCutoff().
+
+  // This is set true by ReadTag{Fallback/Slow}() if it is called when exactly
+  // at EOF, or by ExpectAtEnd() when it returns true.  This happens when we
+  // reach the end of a message and attempt to read another tag.
+  bool legitimate_message_end_;
+
+  // See EnableAliasing().
+  bool aliasing_enabled_;
+
+  // Limits
+  Limit current_limit_;   // if position = -1, no limit is applied
+
+  // For simplicity, if the current buffer crosses a limit (either a normal
+  // limit created by PushLimit() or the total bytes limit), buffer_size_
+  // only tracks the number of bytes before that limit.  This field
+  // contains the number of bytes after it.  Note that this implies that if
+  // buffer_size_ == 0 and buffer_size_after_limit_ > 0, we know we've
+  // hit a limit.  However, if both are zero, it doesn't necessarily mean
+  // we aren't at a limit -- the buffer may have ended exactly at the limit.
+  int buffer_size_after_limit_;
+
+  // Maximum number of bytes to read, period.  This is unrelated to
+  // current_limit_.  Set using SetTotalBytesLimit().
+  int total_bytes_limit_;
+
+  // Current recursion budget, controlled by IncrementRecursionDepth() and
+  // similar.  Starts at recursion_limit_ and goes down: if this reaches
+  // -1 we are over budget.
+  int recursion_budget_;
+  // Recursion depth limit, set by SetRecursionLimit().
+  int recursion_limit_;
+
+  bool disable_strict_correctness_enforcement_;
+
+  // See SetExtensionRegistry().
+  const DescriptorPool* extension_pool_;
+  MessageFactory* extension_factory_;
+
+  // Private member functions.
+
+  // Fallback when Skip() goes past the end of the current buffer.
+  bool SkipFallback(int count, int original_buffer_size);
+
+  // Advance the buffer by a given number of bytes.
+  void Advance(int amount);
+
+  // Back up input_ to the current buffer position.
+  void BackUpInputToCurrentPosition();
+
+  // Recomputes the value of buffer_size_after_limit_.  Must be called after
+  // current_limit_ or total_bytes_limit_ changes.
+  void RecomputeBufferLimits();
+
+  // Writes an error message saying that we hit total_bytes_limit_.
+  void PrintTotalBytesLimitError();
+
+  // Called when the buffer runs out to request more data.  Implies an
+  // Advance(BufferSize()).
+  bool Refresh();
+
+  // When parsing varints, we optimize for the common case of small values, and
+  // then optimize for the case when the varint fits within the current buffer
+  // piece. The Fallback method is used when we can't use the one-byte
+  // optimization. The Slow method is yet another fallback when the buffer is
+  // not large enough. Making the slow path out-of-line speeds up the common
+  // case by 10-15%. The slow path is fairly uncommon: it only triggers when a
+  // message crosses multiple buffers.  Note: ReadVarint32Fallback() and
+  // ReadVarint64Fallback() are called frequently and generally not inlined, so
+  // they have been optimized to avoid "out" parameters.  The former returns -1
+  // if it fails and the uint32 it read otherwise.  The latter has a bool
+  // indicating success or failure as part of its return type.
+  int64 ReadVarint32Fallback(uint32 first_byte_or_zero);
+  int ReadVarintSizeAsIntFallback();
+  std::pair<uint64, bool> ReadVarint64Fallback();
+  bool ReadVarint32Slow(uint32* value);
+  bool ReadVarint64Slow(uint64* value);
+  int ReadVarintSizeAsIntSlow();
+  bool ReadLittleEndian32Fallback(uint32* value);
+  bool ReadLittleEndian64Fallback(uint64* value);
+
+  // Fallback/slow methods for reading tags. These do not update last_tag_,
+  // but will set legitimate_message_end_ if we are at the end of the input
+  // stream.
+  uint32 ReadTagFallback(uint32 first_byte_or_zero);
+  uint32 ReadTagSlow();
+  bool ReadStringFallback(string* buffer, int size);
+
+  // Return the size of the buffer.
+  int BufferSize() const;
+
+  static const int kDefaultTotalBytesLimit = INT_MAX;
+
+  static int default_recursion_limit_;  // 100 by default.
+};
+
+// Class which encodes and writes binary data which is composed of varint-
+// encoded integers and fixed-width pieces.  Wraps a ZeroCopyOutputStream.
+// Most users will not need to deal with CodedOutputStream.
+//
+// Most methods of CodedOutputStream which return a bool return false if an
+// underlying I/O error occurs.  Once such a failure occurs, the
+// CodedOutputStream is broken and is no longer useful. The Write* methods do
+// not return the stream status, but will invalidate the stream if an error
+// occurs. The client can probe HadError() to determine the status.
+//
+// Note that every method of CodedOutputStream which writes some data has
+// a corresponding static "ToArray" version. These versions write directly
+// to the provided buffer, returning a pointer past the last written byte.
+// They require that the buffer has sufficient capacity for the encoded data.
+// This allows an optimization where we check if an output stream has enough
+// space for an entire message before we start writing and, if there is, we
+// call only the ToArray methods to avoid doing bound checks for each
+// individual value.
+// i.e., in the example above:
+//
+//   CodedOutputStream coded_output = new CodedOutputStream(raw_output);
+//   int magic_number = 1234;
+//   char text[] = "Hello world!";
+//
+//   int coded_size = sizeof(magic_number) +
+//                    CodedOutputStream::VarintSize32(strlen(text)) +
+//                    strlen(text);
+//
+//   uint8* buffer =
+//       coded_output->GetDirectBufferForNBytesAndAdvance(coded_size);
+//   if (buffer != NULL) {
+//     // The output stream has enough space in the buffer: write directly to
+//     // the array.
+//     buffer = CodedOutputStream::WriteLittleEndian32ToArray(magic_number,
+//                                                            buffer);
+//     buffer = CodedOutputStream::WriteVarint32ToArray(strlen(text), buffer);
+//     buffer = CodedOutputStream::WriteRawToArray(text, strlen(text), buffer);
+//   } else {
+//     // Make bound-checked writes, which will ask the underlying stream for
+//     // more space as needed.
+//     coded_output->WriteLittleEndian32(magic_number);
+//     coded_output->WriteVarint32(strlen(text));
+//     coded_output->WriteRaw(text, strlen(text));
+//   }
+//
+//   delete coded_output;
+class LIBPROTOBUF_EXPORT CodedOutputStream {
+ public:
+  // Create an CodedOutputStream that writes to the given ZeroCopyOutputStream.
+  explicit CodedOutputStream(ZeroCopyOutputStream* output);
+  CodedOutputStream(ZeroCopyOutputStream* output, bool do_eager_refresh);
+
+  // Destroy the CodedOutputStream and position the underlying
+  // ZeroCopyOutputStream immediately after the last byte written.
+  ~CodedOutputStream();
+
+  // Trims any unused space in the underlying buffer so that its size matches
+  // the number of bytes written by this stream. The underlying buffer will
+  // automatically be trimmed when this stream is destroyed; this call is only
+  // necessary if the underlying buffer is accessed *before* the stream is
+  // destroyed.
+  void Trim();
+
+  // Skips a number of bytes, leaving the bytes unmodified in the underlying
+  // buffer.  Returns false if an underlying write error occurs.  This is
+  // mainly useful with GetDirectBufferPointer().
+  bool Skip(int count);
+
+  // Sets *data to point directly at the unwritten part of the
+  // CodedOutputStream's underlying buffer, and *size to the size of that
+  // buffer, but does not advance the stream's current position.  This will
+  // always either produce a non-empty buffer or return false.  If the caller
+  // writes any data to this buffer, it should then call Skip() to skip over
+  // the consumed bytes.  This may be useful for implementing external fast
+  // serialization routines for types of data not covered by the
+  // CodedOutputStream interface.
+  bool GetDirectBufferPointer(void** data, int* size);
+
+  // If there are at least "size" bytes available in the current buffer,
+  // returns a pointer directly into the buffer and advances over these bytes.
+  // The caller may then write directly into this buffer (e.g. using the
+  // *ToArray static methods) rather than go through CodedOutputStream.  If
+  // there are not enough bytes available, returns NULL.  The return pointer is
+  // invalidated as soon as any other non-const method of CodedOutputStream
+  // is called.
+  inline uint8* GetDirectBufferForNBytesAndAdvance(int size);
+
+  // Write raw bytes, copying them from the given buffer.
+  void WriteRaw(const void* buffer, int size);
+  // Like WriteRaw()  but will try to write aliased data if aliasing is
+  // turned on.
+  void WriteRawMaybeAliased(const void* data, int size);
+  // Like WriteRaw()  but writing directly to the target array.
+  // This is _not_ inlined, as the compiler often optimizes memcpy into inline
+  // copy loops. Since this gets called by every field with string or bytes
+  // type, inlining may lead to a significant amount of code bloat, with only a
+  // minor performance gain.
+  static uint8* WriteRawToArray(const void* buffer, int size, uint8* target);
+
+  // Equivalent to WriteRaw(str.data(), str.size()).
+  void WriteString(const string& str);
+  // Like WriteString()  but writing directly to the target array.
+  static uint8* WriteStringToArray(const string& str, uint8* target);
+  // Write the varint-encoded size of str followed by str.
+  static uint8* WriteStringWithSizeToArray(const string& str, uint8* target);
+
+
+  // Instructs the CodedOutputStream to allow the underlying
+  // ZeroCopyOutputStream to hold pointers to the original structure instead of
+  // copying, if it supports it (i.e. output->AllowsAliasing() is true).  If the
+  // underlying stream does not support aliasing, then enabling it has no
+  // affect.  For now, this only affects the behavior of
+  // WriteRawMaybeAliased().
+  //
+  // NOTE: It is caller's responsibility to ensure that the chunk of memory
+  // remains live until all of the data has been consumed from the stream.
+  void EnableAliasing(bool enabled);
+
+  // Write a 32-bit little-endian integer.
+  void WriteLittleEndian32(uint32 value);
+  // Like WriteLittleEndian32()  but writing directly to the target array.
+  static uint8* WriteLittleEndian32ToArray(uint32 value, uint8* target);
+  // Write a 64-bit little-endian integer.
+  void WriteLittleEndian64(uint64 value);
+  // Like WriteLittleEndian64()  but writing directly to the target array.
+  static uint8* WriteLittleEndian64ToArray(uint64 value, uint8* target);
+
+  // Write an unsigned integer with Varint encoding.  Writing a 32-bit value
+  // is equivalent to casting it to uint64 and writing it as a 64-bit value,
+  // but may be more efficient.
+  void WriteVarint32(uint32 value);
+  // Like WriteVarint32()  but writing directly to the target array.
+  static uint8* WriteVarint32ToArray(uint32 value, uint8* target);
+  // Write an unsigned integer with Varint encoding.
+  void WriteVarint64(uint64 value);
+  // Like WriteVarint64()  but writing directly to the target array.
+  static uint8* WriteVarint64ToArray(uint64 value, uint8* target);
+
+  // Equivalent to WriteVarint32() except when the value is negative,
+  // in which case it must be sign-extended to a full 10 bytes.
+  void WriteVarint32SignExtended(int32 value);
+  // Like WriteVarint32SignExtended()  but writing directly to the target array.
+  static uint8* WriteVarint32SignExtendedToArray(int32 value, uint8* target);
+
+  // This is identical to WriteVarint32(), but optimized for writing tags.
+  // In particular, if the input is a compile-time constant, this method
+  // compiles down to a couple instructions.
+  // Always inline because otherwise the aformentioned optimization can't work,
+  // but GCC by default doesn't want to inline this.
+  void WriteTag(uint32 value);
+  // Like WriteTag()  but writing directly to the target array.
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  static uint8* WriteTagToArray(uint32 value, uint8* target);
+
+  // Returns the number of bytes needed to encode the given value as a varint.
+  static size_t VarintSize32(uint32 value);
+  // Returns the number of bytes needed to encode the given value as a varint.
+  static size_t VarintSize64(uint64 value);
+
+  // If negative, 10 bytes.  Otheriwse, same as VarintSize32().
+  static size_t VarintSize32SignExtended(int32 value);
+
+  // Compile-time equivalent of VarintSize32().
+  template <uint32 Value>
+  struct StaticVarintSize32 {
+    static const size_t value =
+        (Value < (1 << 7))
+            ? 1
+            : (Value < (1 << 14))
+                ? 2
+                : (Value < (1 << 21))
+                    ? 3
+                    : (Value < (1 << 28))
+                        ? 4
+                        : 5;
+  };
+
+  // Returns the total number of bytes written since this object was created.
+  inline int ByteCount() const;
+
+  // Returns true if there was an underlying I/O error since this object was
+  // created.
+  bool HadError() const { return had_error_; }
+
+  // Deterministic serialization, if requested, guarantees that for a given
+  // binary, equal messages will always be serialized to the same bytes. This
+  // implies:
+  //   . repeated serialization of a message will return the same bytes
+  //   . different processes of the same binary (which may be executing on
+  //     different machines) will serialize equal messages to the same bytes.
+  //
+  // Note the deterministic serialization is NOT canonical across languages; it
+  // is also unstable across different builds with schema changes due to unknown
+  // fields. Users who need canonical serialization, e.g., persistent storage in
+  // a canonical form, fingerprinting, etc., should define their own
+  // canonicalization specification and implement the serializer using
+  // reflection APIs rather than relying on this API.
+  //
+  // If determinisitc serialization is requested, the serializer will
+  // sort map entries by keys in lexicographical order or numerical order.
+  // (This is an implementation detail and may subject to change.)
+  //
+  // There are two ways to determine whether serialization should be
+  // deterministic for this CodedOutputStream.  If SetSerializationDeterministic
+  // has not yet been called, then the default comes from the global default,
+  // which is false, until SetDefaultSerializationDeterministic has been called.
+  // Otherwise, SetSerializationDeterministic has been called, and the last
+  // value passed to it is all that matters.
+  void SetSerializationDeterministic(bool value) {
+    serialization_deterministic_is_overridden_ = true;
+    serialization_deterministic_override_ = value;
+  }
+  // See above.  Also, note that users of this CodedOutputStream may need to
+  // call IsSerializationDeterministic() to serialize in the intended way.  This
+  // CodedOutputStream cannot enforce a desire for deterministic serialization
+  // by itself.
+  bool IsSerializationDeterministic() const {
+    return serialization_deterministic_is_overridden_ ?
+        serialization_deterministic_override_ :
+        IsDefaultSerializationDeterministic();
+  }
+
+  static bool IsDefaultSerializationDeterministic() {
+    return google::protobuf::internal::NoBarrier_Load(&default_serialization_deterministic_);
+  }
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CodedOutputStream);
+
+  ZeroCopyOutputStream* output_;
+  uint8* buffer_;
+  int buffer_size_;
+  int total_bytes_;  // Sum of sizes of all buffers seen so far.
+  bool had_error_;   // Whether an error occurred during output.
+  bool aliasing_enabled_;  // See EnableAliasing().
+  // See SetSerializationDeterministic() regarding these three fields.
+  bool serialization_deterministic_is_overridden_;
+  bool serialization_deterministic_override_;
+  // Conceptually, default_serialization_deterministic_ is an atomic bool.
+  // TODO(haberman): replace with std::atomic<bool> when we move to C++11.
+  static google::protobuf::internal::AtomicWord default_serialization_deterministic_;
+
+  // Advance the buffer by a given number of bytes.
+  void Advance(int amount);
+
+  // Called when the buffer runs out to request more data.  Implies an
+  // Advance(buffer_size_).
+  bool Refresh();
+
+  // Like WriteRaw() but may avoid copying if the underlying
+  // ZeroCopyOutputStream supports it.
+  void WriteAliasedRaw(const void* buffer, int size);
+
+  // If this write might cross the end of the buffer, we compose the bytes first
+  // then use WriteRaw().
+  void WriteVarint32SlowPath(uint32 value);
+  void WriteVarint64SlowPath(uint64 value);
+
+  // See above.  Other projects may use "friend" to allow them to call this.
+  // After SetDefaultSerializationDeterministic() completes, all protocol
+  // buffer serializations will be deterministic by default.  Thread safe.
+  // However, the meaning of "after" is subtle here: to be safe, each thread
+  // that wants deterministic serialization by default needs to call
+  // SetDefaultSerializationDeterministic() or ensure on its own that another
+  // thread has done so.
+  friend void ::google::protobuf::internal::MapTestForceDeterministic();
+  static void SetDefaultSerializationDeterministic() {
+    google::protobuf::internal::NoBarrier_Store(&default_serialization_deterministic_, 1);
+  }
+};
+
+// inline methods ====================================================
+// The vast majority of varints are only one byte.  These inline
+// methods optimize for that case.
+
+inline bool CodedInputStream::ReadVarint32(uint32* value) {
+  uint32 v = 0;
+  if (GOOGLE_PREDICT_TRUE(buffer_ < buffer_end_)) {
+    v = *buffer_;
+    if (v < 0x80) {
+      *value = v;
+      Advance(1);
+      return true;
+    }
+  }
+  int64 result = ReadVarint32Fallback(v);
+  *value = static_cast<uint32>(result);
+  return result >= 0;
+}
+
+inline bool CodedInputStream::ReadVarint64(uint64* value) {
+  if (GOOGLE_PREDICT_TRUE(buffer_ < buffer_end_) && *buffer_ < 0x80) {
+    *value = *buffer_;
+    Advance(1);
+    return true;
+  }
+  std::pair<uint64, bool> p = ReadVarint64Fallback();
+  *value = p.first;
+  return p.second;
+}
+
+inline bool CodedInputStream::ReadVarintSizeAsInt(int* value) {
+  if (GOOGLE_PREDICT_TRUE(buffer_ < buffer_end_)) {
+    int v = *buffer_;
+    if (v < 0x80) {
+      *value = v;
+      Advance(1);
+      return true;
+    }
+  }
+  *value = ReadVarintSizeAsIntFallback();
+  return *value >= 0;
+}
+
+// static
+inline const uint8* CodedInputStream::ReadLittleEndian32FromArray(
+    const uint8* buffer,
+    uint32* value) {
+#if defined(PROTOBUF_LITTLE_ENDIAN)
+  memcpy(value, buffer, sizeof(*value));
+  return buffer + sizeof(*value);
+#else
+  *value = (static_cast<uint32>(buffer[0])      ) |
+           (static_cast<uint32>(buffer[1]) <<  8) |
+           (static_cast<uint32>(buffer[2]) << 16) |
+           (static_cast<uint32>(buffer[3]) << 24);
+  return buffer + sizeof(*value);
+#endif
+}
+// static
+inline const uint8* CodedInputStream::ReadLittleEndian64FromArray(
+    const uint8* buffer,
+    uint64* value) {
+#if defined(PROTOBUF_LITTLE_ENDIAN)
+  memcpy(value, buffer, sizeof(*value));
+  return buffer + sizeof(*value);
+#else
+  uint32 part0 = (static_cast<uint32>(buffer[0])      ) |
+                 (static_cast<uint32>(buffer[1]) <<  8) |
+                 (static_cast<uint32>(buffer[2]) << 16) |
+                 (static_cast<uint32>(buffer[3]) << 24);
+  uint32 part1 = (static_cast<uint32>(buffer[4])      ) |
+                 (static_cast<uint32>(buffer[5]) <<  8) |
+                 (static_cast<uint32>(buffer[6]) << 16) |
+                 (static_cast<uint32>(buffer[7]) << 24);
+  *value = static_cast<uint64>(part0) |
+          (static_cast<uint64>(part1) << 32);
+  return buffer + sizeof(*value);
+#endif
+}
+
+inline bool CodedInputStream::ReadLittleEndian32(uint32* value) {
+#if defined(PROTOBUF_LITTLE_ENDIAN)
+  if (GOOGLE_PREDICT_TRUE(BufferSize() >= static_cast<int>(sizeof(*value)))) {
+    buffer_ = ReadLittleEndian32FromArray(buffer_, value);
+    return true;
+  } else {
+    return ReadLittleEndian32Fallback(value);
+  }
+#else
+  return ReadLittleEndian32Fallback(value);
+#endif
+}
+
+inline bool CodedInputStream::ReadLittleEndian64(uint64* value) {
+#if defined(PROTOBUF_LITTLE_ENDIAN)
+  if (GOOGLE_PREDICT_TRUE(BufferSize() >= static_cast<int>(sizeof(*value)))) {
+    buffer_ = ReadLittleEndian64FromArray(buffer_, value);
+    return true;
+  } else {
+    return ReadLittleEndian64Fallback(value);
+  }
+#else
+  return ReadLittleEndian64Fallback(value);
+#endif
+}
+
+inline uint32 CodedInputStream::ReadTagNoLastTag() {
+  uint32 v = 0;
+  if (GOOGLE_PREDICT_TRUE(buffer_ < buffer_end_)) {
+    v = *buffer_;
+    if (v < 0x80) {
+      Advance(1);
+      return v;
+    }
+  }
+  v = ReadTagFallback(v);
+  return v;
+}
+
+inline std::pair<uint32, bool> CodedInputStream::ReadTagWithCutoffNoLastTag(
+    uint32 cutoff) {
+  // In performance-sensitive code we can expect cutoff to be a compile-time
+  // constant, and things like "cutoff >= kMax1ByteVarint" to be evaluated at
+  // compile time.
+  uint32 first_byte_or_zero = 0;
+  if (GOOGLE_PREDICT_TRUE(buffer_ < buffer_end_)) {
+    // Hot case: buffer_ non_empty, buffer_[0] in [1, 128).
+    // TODO(gpike): Is it worth rearranging this? E.g., if the number of fields
+    // is large enough then is it better to check for the two-byte case first?
+    first_byte_or_zero = buffer_[0];
+    if (static_cast<int8>(buffer_[0]) > 0) {
+      const uint32 kMax1ByteVarint = 0x7f;
+      uint32 tag = buffer_[0];
+      Advance(1);
+      return std::make_pair(tag, cutoff >= kMax1ByteVarint || tag <= cutoff);
+    }
+    // Other hot case: cutoff >= 0x80, buffer_ has at least two bytes available,
+    // and tag is two bytes.  The latter is tested by bitwise-and-not of the
+    // first byte and the second byte.
+    if (cutoff >= 0x80 &&
+        GOOGLE_PREDICT_TRUE(buffer_ + 1 < buffer_end_) &&
+        GOOGLE_PREDICT_TRUE((buffer_[0] & ~buffer_[1]) >= 0x80)) {
+      const uint32 kMax2ByteVarint = (0x7f << 7) + 0x7f;
+      uint32 tag = (1u << 7) * buffer_[1] + (buffer_[0] - 0x80);
+      Advance(2);
+      // It might make sense to test for tag == 0 now, but it is so rare that
+      // that we don't bother.  A varint-encoded 0 should be one byte unless
+      // the encoder lost its mind.  The second part of the return value of
+      // this function is allowed to be either true or false if the tag is 0,
+      // so we don't have to check for tag == 0.  We may need to check whether
+      // it exceeds cutoff.
+      bool at_or_below_cutoff = cutoff >= kMax2ByteVarint || tag <= cutoff;
+      return std::make_pair(tag, at_or_below_cutoff);
+    }
+  }
+  // Slow path
+  const uint32 tag = ReadTagFallback(first_byte_or_zero);
+  return std::make_pair(tag, static_cast<uint32>(tag - 1) < cutoff);
+}
+
+inline bool CodedInputStream::LastTagWas(uint32 expected) {
+  return last_tag_ == expected;
+}
+
+inline bool CodedInputStream::ConsumedEntireMessage() {
+  return legitimate_message_end_;
+}
+
+inline bool CodedInputStream::ExpectTag(uint32 expected) {
+  if (expected < (1 << 7)) {
+    if (GOOGLE_PREDICT_TRUE(buffer_ < buffer_end_) && buffer_[0] == expected) {
+      Advance(1);
+      return true;
+    } else {
+      return false;
+    }
+  } else if (expected < (1 << 14)) {
+    if (GOOGLE_PREDICT_TRUE(BufferSize() >= 2) &&
+        buffer_[0] == static_cast<uint8>(expected | 0x80) &&
+        buffer_[1] == static_cast<uint8>(expected >> 7)) {
+      Advance(2);
+      return true;
+    } else {
+      return false;
+    }
+  } else {
+    // Don't bother optimizing for larger values.
+    return false;
+  }
+}
+
+inline const uint8* CodedInputStream::ExpectTagFromArray(
+    const uint8* buffer, uint32 expected) {
+  if (expected < (1 << 7)) {
+    if (buffer[0] == expected) {
+      return buffer + 1;
+    }
+  } else if (expected < (1 << 14)) {
+    if (buffer[0] == static_cast<uint8>(expected | 0x80) &&
+        buffer[1] == static_cast<uint8>(expected >> 7)) {
+      return buffer + 2;
+    }
+  }
+  return NULL;
+}
+
+inline void CodedInputStream::GetDirectBufferPointerInline(const void** data,
+                                                           int* size) {
+  *data = buffer_;
+  *size = static_cast<int>(buffer_end_ - buffer_);
+}
+
+inline bool CodedInputStream::ExpectAtEnd() {
+  // If we are at a limit we know no more bytes can be read.  Otherwise, it's
+  // hard to say without calling Refresh(), and we'd rather not do that.
+
+  if (buffer_ == buffer_end_ &&
+      ((buffer_size_after_limit_ != 0) ||
+       (total_bytes_read_ == current_limit_))) {
+    last_tag_ = 0;                   // Pretend we called ReadTag()...
+    legitimate_message_end_ = true;  // ... and it hit EOF.
+    return true;
+  } else {
+    return false;
+  }
+}
+
+inline int CodedInputStream::CurrentPosition() const {
+  return total_bytes_read_ - (BufferSize() + buffer_size_after_limit_);
+}
+
+inline uint8* CodedOutputStream::GetDirectBufferForNBytesAndAdvance(int size) {
+  if (buffer_size_ < size) {
+    return NULL;
+  } else {
+    uint8* result = buffer_;
+    Advance(size);
+    return result;
+  }
+}
+
+inline uint8* CodedOutputStream::WriteVarint32ToArray(uint32 value,
+                                                      uint8* target) {
+  while (value >= 0x80) {
+    *target = static_cast<uint8>(value | 0x80);
+    value >>= 7;
+    ++target;
+  }
+  *target = static_cast<uint8>(value);
+  return target + 1;
+}
+
+inline uint8* CodedOutputStream::WriteVarint64ToArray(uint64 value,
+                                                      uint8* target) {
+  while (value >= 0x80) {
+    *target = static_cast<uint8>(value | 0x80);
+    value >>= 7;
+    ++target;
+  }
+  *target = static_cast<uint8>(value);
+  return target + 1;
+}
+
+inline void CodedOutputStream::WriteVarint32SignExtended(int32 value) {
+  WriteVarint64(static_cast<uint64>(value));
+}
+
+inline uint8* CodedOutputStream::WriteVarint32SignExtendedToArray(
+    int32 value, uint8* target) {
+  return WriteVarint64ToArray(static_cast<uint64>(value), target);
+}
+
+inline uint8* CodedOutputStream::WriteLittleEndian32ToArray(uint32 value,
+                                                            uint8* target) {
+#if defined(PROTOBUF_LITTLE_ENDIAN)
+  memcpy(target, &value, sizeof(value));
+#else
+  target[0] = static_cast<uint8>(value);
+  target[1] = static_cast<uint8>(value >>  8);
+  target[2] = static_cast<uint8>(value >> 16);
+  target[3] = static_cast<uint8>(value >> 24);
+#endif
+  return target + sizeof(value);
+}
+
+inline uint8* CodedOutputStream::WriteLittleEndian64ToArray(uint64 value,
+                                                            uint8* target) {
+#if defined(PROTOBUF_LITTLE_ENDIAN)
+  memcpy(target, &value, sizeof(value));
+#else
+  uint32 part0 = static_cast<uint32>(value);
+  uint32 part1 = static_cast<uint32>(value >> 32);
+
+  target[0] = static_cast<uint8>(part0);
+  target[1] = static_cast<uint8>(part0 >>  8);
+  target[2] = static_cast<uint8>(part0 >> 16);
+  target[3] = static_cast<uint8>(part0 >> 24);
+  target[4] = static_cast<uint8>(part1);
+  target[5] = static_cast<uint8>(part1 >>  8);
+  target[6] = static_cast<uint8>(part1 >> 16);
+  target[7] = static_cast<uint8>(part1 >> 24);
+#endif
+  return target + sizeof(value);
+}
+
+inline void CodedOutputStream::WriteVarint32(uint32 value) {
+  if (buffer_size_ >= 5) {
+    // Fast path:  We have enough bytes left in the buffer to guarantee that
+    // this write won't cross the end, so we can skip the checks.
+    uint8* target = buffer_;
+    uint8* end = WriteVarint32ToArray(value, target);
+    int size = static_cast<int>(end - target);
+    Advance(size);
+  } else {
+    WriteVarint32SlowPath(value);
+  }
+}
+
+inline void CodedOutputStream::WriteVarint64(uint64 value) {
+  if (buffer_size_ >= 10) {
+    // Fast path:  We have enough bytes left in the buffer to guarantee that
+    // this write won't cross the end, so we can skip the checks.
+    uint8* target = buffer_;
+    uint8* end = WriteVarint64ToArray(value, target);
+    int size = static_cast<int>(end - target);
+    Advance(size);
+  } else {
+    WriteVarint64SlowPath(value);
+  }
+}
+
+inline void CodedOutputStream::WriteTag(uint32 value) {
+  WriteVarint32(value);
+}
+
+inline uint8* CodedOutputStream::WriteTagToArray(
+    uint32 value, uint8* target) {
+  return WriteVarint32ToArray(value, target);
+}
+
+inline size_t CodedOutputStream::VarintSize32(uint32 value) {
+  // This computes value == 0 ? 1 : floor(log2(value)) / 7 + 1
+  // Use an explicit multiplication to implement the divide of
+  // a number in the 1..31 range.
+  // Explicit OR 0x1 to avoid calling Bits::Log2FloorNonZero(0), which is
+  // undefined.
+  uint32 log2value = Bits::Log2FloorNonZero(value | 0x1);
+  return static_cast<size_t>((log2value * 9 + 73) / 64);
+}
+
+inline size_t CodedOutputStream::VarintSize64(uint64 value) {
+  // This computes value == 0 ? 1 : floor(log2(value)) / 7 + 1
+  // Use an explicit multiplication to implement the divide of
+  // a number in the 1..63 range.
+  // Explicit OR 0x1 to avoid calling Bits::Log2FloorNonZero(0), which is
+  // undefined.
+  uint32 log2value = Bits::Log2FloorNonZero64(value | 0x1);
+  return static_cast<size_t>((log2value * 9 + 73) / 64);
+}
+
+inline size_t CodedOutputStream::VarintSize32SignExtended(int32 value) {
+  if (value < 0) {
+    return 10;     // TODO(kenton):  Make this a symbolic constant.
+  } else {
+    return VarintSize32(static_cast<uint32>(value));
+  }
+}
+
+inline void CodedOutputStream::WriteString(const string& str) {
+  WriteRaw(str.data(), static_cast<int>(str.size()));
+}
+
+inline void CodedOutputStream::WriteRawMaybeAliased(
+    const void* data, int size) {
+  if (aliasing_enabled_) {
+    WriteAliasedRaw(data, size);
+  } else {
+    WriteRaw(data, size);
+  }
+}
+
+inline uint8* CodedOutputStream::WriteStringToArray(
+    const string& str, uint8* target) {
+  return WriteRawToArray(str.data(), static_cast<int>(str.size()), target);
+}
+
+inline int CodedOutputStream::ByteCount() const {
+  return total_bytes_ - buffer_size_;
+}
+
+inline void CodedInputStream::Advance(int amount) {
+  buffer_ += amount;
+}
+
+inline void CodedOutputStream::Advance(int amount) {
+  buffer_ += amount;
+  buffer_size_ -= amount;
+}
+
+inline void CodedInputStream::SetRecursionLimit(int limit) {
+  recursion_budget_ += limit - recursion_limit_;
+  recursion_limit_ = limit;
+}
+
+inline bool CodedInputStream::IncrementRecursionDepth() {
+  --recursion_budget_;
+  return recursion_budget_ >= 0;
+}
+
+inline void CodedInputStream::DecrementRecursionDepth() {
+  if (recursion_budget_ < recursion_limit_) ++recursion_budget_;
+}
+
+inline void CodedInputStream::UnsafeDecrementRecursionDepth() {
+  assert(recursion_budget_ < recursion_limit_);
+  ++recursion_budget_;
+}
+
+inline void CodedInputStream::SetExtensionRegistry(const DescriptorPool* pool,
+                                                   MessageFactory* factory) {
+  extension_pool_ = pool;
+  extension_factory_ = factory;
+}
+
+inline const DescriptorPool* CodedInputStream::GetExtensionPool() {
+  return extension_pool_;
+}
+
+inline MessageFactory* CodedInputStream::GetExtensionFactory() {
+  return extension_factory_;
+}
+
+inline int CodedInputStream::BufferSize() const {
+  return static_cast<int>(buffer_end_ - buffer_);
+}
+
+inline CodedInputStream::CodedInputStream(ZeroCopyInputStream* input)
+  : buffer_(NULL),
+    buffer_end_(NULL),
+    input_(input),
+    total_bytes_read_(0),
+    overflow_bytes_(0),
+    last_tag_(0),
+    legitimate_message_end_(false),
+    aliasing_enabled_(false),
+    current_limit_(kint32max),
+    buffer_size_after_limit_(0),
+    total_bytes_limit_(kDefaultTotalBytesLimit),
+    recursion_budget_(default_recursion_limit_),
+    recursion_limit_(default_recursion_limit_),
+    disable_strict_correctness_enforcement_(true),
+    extension_pool_(NULL),
+    extension_factory_(NULL) {
+  // Eagerly Refresh() so buffer space is immediately available.
+  Refresh();
+}
+
+inline CodedInputStream::CodedInputStream(const uint8* buffer, int size)
+  : buffer_(buffer),
+    buffer_end_(buffer + size),
+    input_(NULL),
+    total_bytes_read_(size),
+    overflow_bytes_(0),
+    last_tag_(0),
+    legitimate_message_end_(false),
+    aliasing_enabled_(false),
+    current_limit_(size),
+    buffer_size_after_limit_(0),
+    total_bytes_limit_(kDefaultTotalBytesLimit),
+    recursion_budget_(default_recursion_limit_),
+    recursion_limit_(default_recursion_limit_),
+    disable_strict_correctness_enforcement_(true),
+    extension_pool_(NULL),
+    extension_factory_(NULL) {
+  // Note that setting current_limit_ == size is important to prevent some
+  // code paths from trying to access input_ and segfaulting.
+}
+
+inline bool CodedInputStream::IsFlat() const {
+  return input_ == NULL;
+}
+
+inline bool CodedInputStream::Skip(int count) {
+  if (count < 0) return false;  // security: count is often user-supplied
+
+  const int original_buffer_size = BufferSize();
+
+  if (count <= original_buffer_size) {
+    // Just skipping within the current buffer.  Easy.
+    Advance(count);
+    return true;
+  }
+
+  return SkipFallback(count, original_buffer_size);
+}
+
+}  // namespace io
+}  // namespace protobuf
+
+
+#if defined(_MSC_VER) && _MSC_VER >= 1300 && !defined(__INTEL_COMPILER)
+  #pragma runtime_checks("c", restore)
+#endif  // _MSC_VER && !defined(__INTEL_COMPILER)
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_IO_CODED_STREAM_H__
diff --git a/kortex_api/include/google/protobuf/io/gzip_stream.h b/kortex_api/include/google/protobuf/io/gzip_stream.h
new file mode 100644
index 0000000000000000000000000000000000000000..15b02fe3d7dc7fdf97c27bfa198d0c380ecc495f
--- /dev/null
+++ b/kortex_api/include/google/protobuf/io/gzip_stream.h
@@ -0,0 +1,209 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: brianolson@google.com (Brian Olson)
+//
+// This file contains the definition for classes GzipInputStream and
+// GzipOutputStream.
+//
+// GzipInputStream decompresses data from an underlying
+// ZeroCopyInputStream and provides the decompressed data as a
+// ZeroCopyInputStream.
+//
+// GzipOutputStream is an ZeroCopyOutputStream that compresses data to
+// an underlying ZeroCopyOutputStream.
+
+#ifndef GOOGLE_PROTOBUF_IO_GZIP_STREAM_H__
+#define GOOGLE_PROTOBUF_IO_GZIP_STREAM_H__
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/io/zero_copy_stream.h>
+#include <zlib.h>
+
+namespace google {
+namespace protobuf {
+namespace io {
+
+// A ZeroCopyInputStream that reads compressed data through zlib
+class LIBPROTOBUF_EXPORT GzipInputStream : public ZeroCopyInputStream {
+ public:
+  // Format key for constructor
+  enum Format {
+    // zlib will autodetect gzip header or deflate stream
+    AUTO = 0,
+
+    // GZIP streams have some extra header data for file attributes.
+    GZIP = 1,
+
+    // Simpler zlib stream format.
+    ZLIB = 2,
+  };
+
+  // buffer_size and format may be -1 for default of 64kB and GZIP format
+  explicit GzipInputStream(
+      ZeroCopyInputStream* sub_stream,
+      Format format = AUTO,
+      int buffer_size = -1);
+  virtual ~GzipInputStream();
+
+  // Return last error message or NULL if no error.
+  inline const char* ZlibErrorMessage() const {
+    return zcontext_.msg;
+  }
+  inline int ZlibErrorCode() const {
+    return zerror_;
+  }
+
+  // implements ZeroCopyInputStream ----------------------------------
+  bool Next(const void** data, int* size);
+  void BackUp(int count);
+  bool Skip(int count);
+  int64 ByteCount() const;
+
+ private:
+  Format format_;
+
+  ZeroCopyInputStream* sub_stream_;
+
+  z_stream zcontext_;
+  int zerror_;
+
+  void* output_buffer_;
+  void* output_position_;
+  size_t output_buffer_length_;
+  int64 byte_count_;
+
+  int Inflate(int flush);
+  void DoNextOutput(const void** data, int* size);
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(GzipInputStream);
+};
+
+
+class LIBPROTOBUF_EXPORT GzipOutputStream : public ZeroCopyOutputStream {
+ public:
+  // Format key for constructor
+  enum Format {
+    // GZIP streams have some extra header data for file attributes.
+    GZIP = 1,
+
+    // Simpler zlib stream format.
+    ZLIB = 2,
+  };
+
+  struct Options {
+    // Defaults to GZIP.
+    Format format;
+
+    // What size buffer to use internally.  Defaults to 64kB.
+    int buffer_size;
+
+    // A number between 0 and 9, where 0 is no compression and 9 is best
+    // compression.  Defaults to Z_DEFAULT_COMPRESSION (see zlib.h).
+    int compression_level;
+
+    // Defaults to Z_DEFAULT_STRATEGY.  Can also be set to Z_FILTERED,
+    // Z_HUFFMAN_ONLY, or Z_RLE.  See the documentation for deflateInit2 in
+    // zlib.h for definitions of these constants.
+    int compression_strategy;
+
+    Options();  // Initializes with default values.
+  };
+
+  // Create a GzipOutputStream with default options.
+  explicit GzipOutputStream(ZeroCopyOutputStream* sub_stream);
+
+  // Create a GzipOutputStream with the given options.
+  GzipOutputStream(
+      ZeroCopyOutputStream* sub_stream,
+      const Options& options);
+
+  virtual ~GzipOutputStream();
+
+  // Return last error message or NULL if no error.
+  inline const char* ZlibErrorMessage() const {
+    return zcontext_.msg;
+  }
+  inline int ZlibErrorCode() const {
+    return zerror_;
+  }
+
+  // Flushes data written so far to zipped data in the underlying stream.
+  // It is the caller's responsibility to flush the underlying stream if
+  // necessary.
+  // Compression may be less efficient stopping and starting around flushes.
+  // Returns true if no error.
+  //
+  // Please ensure that block size is > 6. Here is an excerpt from the zlib
+  // doc that explains why:
+  //
+  // In the case of a Z_FULL_FLUSH or Z_SYNC_FLUSH, make sure that avail_out
+  // is greater than six to avoid repeated flush markers due to
+  // avail_out == 0 on return.
+  bool Flush();
+
+  // Writes out all data and closes the gzip stream.
+  // It is the caller's responsibility to close the underlying stream if
+  // necessary.
+  // Returns true if no error.
+  bool Close();
+
+  // implements ZeroCopyOutputStream ---------------------------------
+  bool Next(void** data, int* size);
+  void BackUp(int count);
+  int64 ByteCount() const;
+
+ private:
+  ZeroCopyOutputStream* sub_stream_;
+  // Result from calling Next() on sub_stream_
+  void* sub_data_;
+  int sub_data_size_;
+
+  z_stream zcontext_;
+  int zerror_;
+  void* input_buffer_;
+  size_t input_buffer_length_;
+
+  // Shared constructor code.
+  void Init(ZeroCopyOutputStream* sub_stream, const Options& options);
+
+  // Do some compression.
+  // Takes zlib flush mode.
+  // Returns zlib error code.
+  int Deflate(int flush);
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(GzipOutputStream);
+};
+
+}  // namespace io
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_IO_GZIP_STREAM_H__
diff --git a/kortex_api/include/google/protobuf/io/printer.h b/kortex_api/include/google/protobuf/io/printer.h
new file mode 100644
index 0000000000000000000000000000000000000000..d11745ce97ae166b83f0a6dbe03d14d28d0af887
--- /dev/null
+++ b/kortex_api/include/google/protobuf/io/printer.h
@@ -0,0 +1,363 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// Utility class for writing text to a ZeroCopyOutputStream.
+
+#ifndef GOOGLE_PROTOBUF_IO_PRINTER_H__
+#define GOOGLE_PROTOBUF_IO_PRINTER_H__
+
+#include <string>
+#include <map>
+#include <vector>
+#include <google/protobuf/stubs/common.h>
+
+namespace google {
+namespace protobuf {
+namespace io {
+
+class ZeroCopyOutputStream;     // zero_copy_stream.h
+
+// Records annotations about a Printer's output.
+class LIBPROTOBUF_EXPORT AnnotationCollector {
+ public:
+  // Records that the bytes in file_path beginning with begin_offset and ending
+  // before end_offset are associated with the SourceCodeInfo-style path.
+  virtual void AddAnnotation(size_t begin_offset, size_t end_offset,
+                             const string& file_path,
+                             const std::vector<int>& path) = 0;
+
+  virtual ~AnnotationCollector() {}
+};
+
+// Records annotations about a Printer's output to the given protocol buffer,
+// assuming that the buffer has an ::Annotation message exposing path,
+// source_file, begin and end fields.
+template <typename AnnotationProto>
+class AnnotationProtoCollector : public AnnotationCollector {
+ public:
+  // annotation_proto is the protocol buffer to which new Annotations should be
+  // added. It is not owned by the AnnotationProtoCollector.
+  explicit AnnotationProtoCollector(AnnotationProto* annotation_proto)
+      : annotation_proto_(annotation_proto) {}
+
+  // Override for AnnotationCollector::AddAnnotation.
+  virtual void AddAnnotation(size_t begin_offset, size_t end_offset,
+                             const string& file_path,
+                             const std::vector<int>& path) {
+    typename AnnotationProto::Annotation* annotation =
+        annotation_proto_->add_annotation();
+    for (int i = 0; i < path.size(); ++i) {
+      annotation->add_path(path[i]);
+    }
+    annotation->set_source_file(file_path);
+    annotation->set_begin(begin_offset);
+    annotation->set_end(end_offset);
+  }
+
+ private:
+  // The protocol buffer to which new annotations should be added.
+  AnnotationProto* const annotation_proto_;
+};
+
+// This simple utility class assists in code generation.  It basically
+// allows the caller to define a set of variables and then output some
+// text with variable substitutions.  Example usage:
+//
+//   Printer printer(output, '$');
+//   map<string, string> vars;
+//   vars["name"] = "Bob";
+//   printer.Print(vars, "My name is $name$.");
+//
+// The above writes "My name is Bob." to the output stream.
+//
+// Printer aggressively enforces correct usage, crashing (with assert failures)
+// in the case of undefined variables in debug builds. This helps greatly in
+// debugging code which uses it.
+//
+// If a Printer is constructed with an AnnotationCollector, it will provide it
+// with annotations that connect the Printer's output to paths that can identify
+// various descriptors.  In the above example, if person_ is a descriptor that
+// identifies Bob, we can associate the output string "My name is Bob." with
+// a source path pointing to that descriptor with:
+//
+//   printer.Annotate("name", person_);
+//
+// The AnnotationCollector will be sent an annotation linking the output range
+// covering "Bob" to the logical path provided by person_.  Tools may use
+// this association to (for example) link "Bob" in the output back to the
+// source file that defined the person_ descriptor identifying Bob.
+//
+// Annotate can only examine variables substituted during the last call to
+// Print.  It is invalid to refer to a variable that was used multiple times
+// in a single Print call.
+//
+// In full generality, one may specify a range of output text using a beginning
+// substitution variable and an ending variable.  The resulting annotation will
+// span from the first character of the substituted value for the beginning
+// variable to the last character of the substituted value for the ending
+// variable.  For example, the Annotate call above is equivalent to this one:
+//
+//   printer.Annotate("name", "name", person_);
+//
+// This is useful if multiple variables combine to form a single span of output
+// that should be annotated with the same source path.  For example:
+//
+//   Printer printer(output, '$');
+//   map<string, string> vars;
+//   vars["first"] = "Alice";
+//   vars["last"] = "Smith";
+//   printer.Print(vars, "My name is $first$ $last$.");
+//   printer.Annotate("first", "last", person_);
+//
+// This code would associate the span covering "Alice Smith" in the output with
+// the person_ descriptor.
+//
+// Note that the beginning variable must come before (or overlap with, in the
+// case of zero-sized substitution values) the ending variable.
+//
+// It is also sometimes useful to use variables with zero-sized values as
+// markers.  This avoids issues with multiple references to the same variable
+// and also allows annotation ranges to span literal text from the Print
+// templates:
+//
+//   Printer printer(output, '$');
+//   map<string, string> vars;
+//   vars["foo"] = "bar";
+//   vars["function"] = "call";
+//   vars["mark"] = "";
+//   printer.Print(vars, "$function$($foo$,$foo$)$mark$");
+//   printer.Annotate("function", "mark", call_);
+//
+// This code associates the span covering "call(bar,bar)" in the output with the
+// call_ descriptor.
+
+class LIBPROTOBUF_EXPORT Printer {
+ public:
+  // Create a printer that writes text to the given output stream.  Use the
+  // given character as the delimiter for variables.
+  Printer(ZeroCopyOutputStream* output, char variable_delimiter);
+
+  // Create a printer that writes text to the given output stream.  Use the
+  // given character as the delimiter for variables.  If annotation_collector
+  // is not null, Printer will provide it with annotations about code written
+  // to the stream.  annotation_collector is not owned by Printer.
+  Printer(ZeroCopyOutputStream* output, char variable_delimiter,
+          AnnotationCollector* annotation_collector);
+
+  ~Printer();
+
+  // Link a subsitution variable emitted by the last call to Print to the object
+  // described by descriptor.
+  template <typename SomeDescriptor>
+  void Annotate(const char* varname, const SomeDescriptor* descriptor) {
+    Annotate(varname, varname, descriptor);
+  }
+
+  // Link the output range defined by the substitution variables as emitted by
+  // the last call to Print to the object described by descriptor. The range
+  // begins at begin_varname's value and ends after the last character of the
+  // value substituted for end_varname.
+  template <typename SomeDescriptor>
+  void Annotate(const char* begin_varname, const char* end_varname,
+                const SomeDescriptor* descriptor) {
+    if (annotation_collector_ == NULL) {
+      // Annotations aren't turned on for this Printer, so don't pay the cost
+      // of building the location path.
+      return;
+    }
+    std::vector<int> path;
+    descriptor->GetLocationPath(&path);
+    Annotate(begin_varname, end_varname, descriptor->file()->name(), path);
+  }
+
+  // Link a subsitution variable emitted by the last call to Print to the file
+  // with path file_name.
+  void Annotate(const char* varname, const string& file_name) {
+    Annotate(varname, varname, file_name);
+  }
+
+  // Link the output range defined by the substitution variables as emitted by
+  // the last call to Print to the file with path file_name. The range begins
+  // at begin_varname's value and ends after the last character of the value
+  // substituted for end_varname.
+  void Annotate(const char* begin_varname, const char* end_varname,
+                const string& file_name) {
+    if (annotation_collector_ == NULL) {
+      // Annotations aren't turned on for this Printer.
+      return;
+    }
+    std::vector<int> empty_path;
+    Annotate(begin_varname, end_varname, file_name, empty_path);
+  }
+
+  // Print some text after applying variable substitutions.  If a particular
+  // variable in the text is not defined, this will crash.  Variables to be
+  // substituted are identified by their names surrounded by delimiter
+  // characters (as given to the constructor).  The variable bindings are
+  // defined by the given map.
+  void Print(const std::map<string, string>& variables, const char* text);
+
+  // Like the first Print(), except the substitutions are given as parameters.
+  void Print(const char* text);
+  // Like the first Print(), except the substitutions are given as parameters.
+  void Print(const char* text, const char* variable, const string& value);
+  // Like the first Print(), except the substitutions are given as parameters.
+  void Print(const char* text, const char* variable1, const string& value1,
+                               const char* variable2, const string& value2);
+  // Like the first Print(), except the substitutions are given as parameters.
+  void Print(const char* text, const char* variable1, const string& value1,
+                               const char* variable2, const string& value2,
+                               const char* variable3, const string& value3);
+  // Like the first Print(), except the substitutions are given as parameters.
+  void Print(const char* text, const char* variable1, const string& value1,
+                               const char* variable2, const string& value2,
+                               const char* variable3, const string& value3,
+                               const char* variable4, const string& value4);
+  // Like the first Print(), except the substitutions are given as parameters.
+  void Print(const char* text, const char* variable1, const string& value1,
+                               const char* variable2, const string& value2,
+                               const char* variable3, const string& value3,
+                               const char* variable4, const string& value4,
+                               const char* variable5, const string& value5);
+  // Like the first Print(), except the substitutions are given as parameters.
+  void Print(const char* text, const char* variable1, const string& value1,
+                               const char* variable2, const string& value2,
+                               const char* variable3, const string& value3,
+                               const char* variable4, const string& value4,
+                               const char* variable5, const string& value5,
+                               const char* variable6, const string& value6);
+  // Like the first Print(), except the substitutions are given as parameters.
+  void Print(const char* text, const char* variable1, const string& value1,
+                               const char* variable2, const string& value2,
+                               const char* variable3, const string& value3,
+                               const char* variable4, const string& value4,
+                               const char* variable5, const string& value5,
+                               const char* variable6, const string& value6,
+                               const char* variable7, const string& value7);
+  // Like the first Print(), except the substitutions are given as parameters.
+  void Print(const char* text, const char* variable1, const string& value1,
+                               const char* variable2, const string& value2,
+                               const char* variable3, const string& value3,
+                               const char* variable4, const string& value4,
+                               const char* variable5, const string& value5,
+                               const char* variable6, const string& value6,
+                               const char* variable7, const string& value7,
+                               const char* variable8, const string& value8);
+
+  // Indent text by two spaces.  After calling Indent(), two spaces will be
+  // inserted at the beginning of each line of text.  Indent() may be called
+  // multiple times to produce deeper indents.
+  void Indent();
+
+  // Reduces the current indent level by two spaces, or crashes if the indent
+  // level is zero.
+  void Outdent();
+
+  // Write a string to the output buffer.
+  // This method does not look for newlines to add indentation.
+  void PrintRaw(const string& data);
+
+  // Write a zero-delimited string to output buffer.
+  // This method does not look for newlines to add indentation.
+  void PrintRaw(const char* data);
+
+  // Write some bytes to the output buffer.
+  // This method does not look for newlines to add indentation.
+  void WriteRaw(const char* data, int size);
+
+  // True if any write to the underlying stream failed.  (We don't just
+  // crash in this case because this is an I/O failure, not a programming
+  // error.)
+  bool failed() const { return failed_; }
+
+ private:
+  // Link the output range defined by the substitution variables as emitted by
+  // the last call to Print to the object found at the SourceCodeInfo-style path
+  // in a file with path file_path. The range begins at the start of
+  // begin_varname's value and ends after the last character of the value
+  // substituted for end_varname. Note that begin_varname and end_varname
+  // may refer to the same variable.
+  void Annotate(const char* begin_varname, const char* end_varname,
+                const string& file_path, const std::vector<int>& path);
+
+  // Copy size worth of bytes from data to buffer_.
+  void CopyToBuffer(const char* data, int size);
+
+  const char variable_delimiter_;
+
+  ZeroCopyOutputStream* const output_;
+  char* buffer_;
+  int buffer_size_;
+  // The current position, in bytes, in the output stream.  This is equivalent
+  // to the total number of bytes that have been written so far.  This value is
+  // used to calculate annotation ranges in the substitutions_ map below.
+  size_t offset_;
+
+  string indent_;
+  bool at_start_of_line_;
+  bool failed_;
+
+  // A map from variable name to [start, end) offsets in the output buffer.
+  // These refer to the offsets used for a variable after the last call to
+  // Print.  If a variable was used more than once, the entry used in
+  // this map is set to a negative-length span.  For singly-used variables, the
+  // start offset is the beginning of the substitution; the end offset is the
+  // last byte of the substitution plus one (such that (end - start) is the
+  // length of the substituted string).
+  std::map<string, std::pair<size_t, size_t> > substitutions_;
+
+  // Keeps track of the keys in substitutions_ that need to be updated when
+  // indents are inserted. These are keys that refer to the beginning of the
+  // current line.
+  std::vector<string> line_start_variables_;
+
+  // Returns true and sets range to the substitution range in the output for
+  // varname if varname was used once in the last call to Print. If varname
+  // was not used, or if it was used multiple times, returns false (and
+  // fails a debug assertion).
+  bool GetSubstitutionRange(const char* varname,
+                            std::pair<size_t, size_t>* range);
+
+  // If non-null, annotation_collector_ is used to store annotations about
+  // generated code.
+  AnnotationCollector* const annotation_collector_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Printer);
+};
+
+}  // namespace io
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_IO_PRINTER_H__
diff --git a/kortex_api/include/google/protobuf/io/strtod.h b/kortex_api/include/google/protobuf/io/strtod.h
new file mode 100644
index 0000000000000000000000000000000000000000..f56e41c8403087316fea469a5803509a452a787a
--- /dev/null
+++ b/kortex_api/include/google/protobuf/io/strtod.h
@@ -0,0 +1,55 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// A locale-independent version of strtod(), used to parse floating
+// point default values in .proto files, where the decimal separator
+// is always a dot.
+
+#ifndef GOOGLE_PROTOBUF_IO_STRTOD_H__
+#define GOOGLE_PROTOBUF_IO_STRTOD_H__
+
+namespace google {
+namespace protobuf {
+namespace io {
+
+// A locale-independent version of the standard strtod(), which always
+// uses a dot as the decimal separator.
+double NoLocaleStrtod(const char* str, char** endptr);
+
+// Casts a double value to a float value. If the value is outside of the
+// representable range of float, it will be converted to positive or negative
+// infinity.
+float SafeDoubleToFloat(double value);
+
+}  // namespace io
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_IO_STRTOD_H__
diff --git a/kortex_api/include/google/protobuf/io/tokenizer.h b/kortex_api/include/google/protobuf/io/tokenizer.h
new file mode 100644
index 0000000000000000000000000000000000000000..e80d564cd5e8f477a4cfdbee3c6cfb93ab95900f
--- /dev/null
+++ b/kortex_api/include/google/protobuf/io/tokenizer.h
@@ -0,0 +1,411 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// Class for parsing tokenized text from a ZeroCopyInputStream.
+
+#ifndef GOOGLE_PROTOBUF_IO_TOKENIZER_H__
+#define GOOGLE_PROTOBUF_IO_TOKENIZER_H__
+
+#include <string>
+#include <vector>
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/logging.h>
+
+namespace google {
+namespace protobuf {
+namespace io {
+
+class ZeroCopyInputStream;     // zero_copy_stream.h
+
+// Defined in this file.
+class ErrorCollector;
+class Tokenizer;
+
+// By "column number", the proto compiler refers to a count of the number
+// of bytes before a given byte, except that a tab character advances to
+// the next multiple of 8 bytes.  Note in particular that column numbers
+// are zero-based, while many user interfaces use one-based column numbers.
+typedef int ColumnNumber;
+
+// Abstract interface for an object which collects the errors that occur
+// during parsing.  A typical implementation might simply print the errors
+// to stdout.
+class LIBPROTOBUF_EXPORT ErrorCollector {
+ public:
+  inline ErrorCollector() {}
+  virtual ~ErrorCollector();
+
+  // Indicates that there was an error in the input at the given line and
+  // column numbers.  The numbers are zero-based, so you may want to add
+  // 1 to each before printing them.
+  virtual void AddError(int line, ColumnNumber column,
+                        const string& message) = 0;
+
+  // Indicates that there was a warning in the input at the given line and
+  // column numbers.  The numbers are zero-based, so you may want to add
+  // 1 to each before printing them.
+  virtual void AddWarning(int line, ColumnNumber column,
+                          const string& message) { }
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ErrorCollector);
+};
+
+// This class converts a stream of raw text into a stream of tokens for
+// the protocol definition parser to parse.  The tokens recognized are
+// similar to those that make up the C language; see the TokenType enum for
+// precise descriptions.  Whitespace and comments are skipped.  By default,
+// C- and C++-style comments are recognized, but other styles can be used by
+// calling set_comment_style().
+class LIBPROTOBUF_EXPORT Tokenizer {
+ public:
+  // Construct a Tokenizer that reads and tokenizes text from the given
+  // input stream and writes errors to the given error_collector.
+  // The caller keeps ownership of input and error_collector.
+  Tokenizer(ZeroCopyInputStream* input, ErrorCollector* error_collector);
+  ~Tokenizer();
+
+  enum TokenType {
+    TYPE_START,       // Next() has not yet been called.
+    TYPE_END,         // End of input reached.  "text" is empty.
+
+    TYPE_IDENTIFIER,  // A sequence of letters, digits, and underscores, not
+                      // starting with a digit.  It is an error for a number
+                      // to be followed by an identifier with no space in
+                      // between.
+    TYPE_INTEGER,     // A sequence of digits representing an integer.  Normally
+                      // the digits are decimal, but a prefix of "0x" indicates
+                      // a hex number and a leading zero indicates octal, just
+                      // like with C numeric literals.  A leading negative sign
+                      // is NOT included in the token; it's up to the parser to
+                      // interpret the unary minus operator on its own.
+    TYPE_FLOAT,       // A floating point literal, with a fractional part and/or
+                      // an exponent.  Always in decimal.  Again, never
+                      // negative.
+    TYPE_STRING,      // A quoted sequence of escaped characters.  Either single
+                      // or double quotes can be used, but they must match.
+                      // A string literal cannot cross a line break.
+    TYPE_SYMBOL,      // Any other printable character, like '!' or '+'.
+                      // Symbols are always a single character, so "!+$%" is
+                      // four tokens.
+  };
+
+  // Structure representing a token read from the token stream.
+  struct Token {
+    TokenType type;
+    string text;       // The exact text of the token as it appeared in
+                       // the input.  e.g. tokens of TYPE_STRING will still
+                       // be escaped and in quotes.
+
+    // "line" and "column" specify the position of the first character of
+    // the token within the input stream.  They are zero-based.
+    int line;
+    ColumnNumber column;
+    ColumnNumber end_column;
+  };
+
+  // Get the current token.  This is updated when Next() is called.  Before
+  // the first call to Next(), current() has type TYPE_START and no contents.
+  const Token& current();
+
+  // Return the previous token -- i.e. what current() returned before the
+  // previous call to Next().
+  const Token& previous();
+
+  // Advance to the next token.  Returns false if the end of the input is
+  // reached.
+  bool Next();
+
+  // Like Next(), but also collects comments which appear between the previous
+  // and next tokens.
+  //
+  // Comments which appear to be attached to the previous token are stored
+  // in *prev_tailing_comments.  Comments which appear to be attached to the
+  // next token are stored in *next_leading_comments.  Comments appearing in
+  // between which do not appear to be attached to either will be added to
+  // detached_comments.  Any of these parameters can be NULL to simply discard
+  // the comments.
+  //
+  // A series of line comments appearing on consecutive lines, with no other
+  // tokens appearing on those lines, will be treated as a single comment.
+  //
+  // Only the comment content is returned; comment markers (e.g. //) are
+  // stripped out.  For block comments, leading whitespace and an asterisk will
+  // be stripped from the beginning of each line other than the first.  Newlines
+  // are included in the output.
+  //
+  // Examples:
+  //
+  //   optional int32 foo = 1;  // Comment attached to foo.
+  //   // Comment attached to bar.
+  //   optional int32 bar = 2;
+  //
+  //   optional string baz = 3;
+  //   // Comment attached to baz.
+  //   // Another line attached to baz.
+  //
+  //   // Comment attached to qux.
+  //   //
+  //   // Another line attached to qux.
+  //   optional double qux = 4;
+  //
+  //   // Detached comment.  This is not attached to qux or corge
+  //   // because there are blank lines separating it from both.
+  //
+  //   optional string corge = 5;
+  //   /* Block comment attached
+  //    * to corge.  Leading asterisks
+  //    * will be removed. */
+  //   /* Block comment attached to
+  //    * grault. */
+  //   optional int32 grault = 6;
+  bool NextWithComments(string* prev_trailing_comments,
+                        std::vector<string>* detached_comments,
+                        string* next_leading_comments);
+
+  // Parse helpers ---------------------------------------------------
+
+  // Parses a TYPE_FLOAT token.  This never fails, so long as the text actually
+  // comes from a TYPE_FLOAT token parsed by Tokenizer.  If it doesn't, the
+  // result is undefined (possibly an assert failure).
+  static double ParseFloat(const string& text);
+
+  // Parses a TYPE_STRING token.  This never fails, so long as the text actually
+  // comes from a TYPE_STRING token parsed by Tokenizer.  If it doesn't, the
+  // result is undefined (possibly an assert failure).
+  static void ParseString(const string& text, string* output);
+
+  // Identical to ParseString, but appends to output.
+  static void ParseStringAppend(const string& text, string* output);
+
+  // Parses a TYPE_INTEGER token.  Returns false if the result would be
+  // greater than max_value.  Otherwise, returns true and sets *output to the
+  // result.  If the text is not from a Token of type TYPE_INTEGER originally
+  // parsed by a Tokenizer, the result is undefined (possibly an assert
+  // failure).
+  static bool ParseInteger(const string& text, uint64 max_value,
+                           uint64* output);
+
+  // Options ---------------------------------------------------------
+
+  // Set true to allow floats to be suffixed with the letter 'f'.  Tokens
+  // which would otherwise be integers but which have the 'f' suffix will be
+  // forced to be interpreted as floats.  For all other purposes, the 'f' is
+  // ignored.
+  void set_allow_f_after_float(bool value) { allow_f_after_float_ = value; }
+
+  // Valid values for set_comment_style().
+  enum CommentStyle {
+    // Line comments begin with "//", block comments are delimited by "/*" and
+    // "*/".
+    CPP_COMMENT_STYLE,
+    // Line comments begin with "#".  No way to write block comments.
+    SH_COMMENT_STYLE
+  };
+
+  // Sets the comment style.
+  void set_comment_style(CommentStyle style) { comment_style_ = style; }
+
+  // Whether to require whitespace between a number and a field name.
+  // Default is true. Do not use this; for Google-internal cleanup only.
+  void set_require_space_after_number(bool require) {
+    require_space_after_number_ = require;
+  }
+
+  // Whether to allow string literals to span multiple lines. Default is false.
+  // Do not use this; for Google-internal cleanup only.
+  void set_allow_multiline_strings(bool allow) {
+    allow_multiline_strings_ = allow;
+  }
+
+  // External helper: validate an identifier.
+  static bool IsIdentifier(const string& text);
+
+  // -----------------------------------------------------------------
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Tokenizer);
+
+  Token current_;           // Returned by current().
+  Token previous_;          // Returned by previous().
+
+  ZeroCopyInputStream* input_;
+  ErrorCollector* error_collector_;
+
+  char current_char_;       // == buffer_[buffer_pos_], updated by NextChar().
+  const char* buffer_;      // Current buffer returned from input_.
+  int buffer_size_;         // Size of buffer_.
+  int buffer_pos_;          // Current position within the buffer.
+  bool read_error_;         // Did we previously encounter a read error?
+
+  // Line and column number of current_char_ within the whole input stream.
+  int line_;
+  ColumnNumber column_;
+
+  // String to which text should be appended as we advance through it.
+  // Call RecordTo(&str) to start recording and StopRecording() to stop.
+  // E.g. StartToken() calls RecordTo(&current_.text).  record_start_ is the
+  // position within the current buffer where recording started.
+  string* record_target_;
+  int record_start_;
+
+  // Options.
+  bool allow_f_after_float_;
+  CommentStyle comment_style_;
+  bool require_space_after_number_;
+  bool allow_multiline_strings_;
+
+  // Since we count columns we need to interpret tabs somehow.  We'll take
+  // the standard 8-character definition for lack of any way to do better.
+  // This must match the documentation of ColumnNumber.
+  static const int kTabWidth = 8;
+
+  // -----------------------------------------------------------------
+  // Helper methods.
+
+  // Consume this character and advance to the next one.
+  void NextChar();
+
+  // Read a new buffer from the input.
+  void Refresh();
+
+  inline void RecordTo(string* target);
+  inline void StopRecording();
+
+  // Called when the current character is the first character of a new
+  // token (not including whitespace or comments).
+  inline void StartToken();
+  // Called when the current character is the first character after the
+  // end of the last token.  After this returns, current_.text will
+  // contain all text consumed since StartToken() was called.
+  inline void EndToken();
+
+  // Convenience method to add an error at the current line and column.
+  void AddError(const string& message) {
+    error_collector_->AddError(line_, column_, message);
+  }
+
+  // -----------------------------------------------------------------
+  // The following four methods are used to consume tokens of specific
+  // types.  They are actually used to consume all characters *after*
+  // the first, since the calling function consumes the first character
+  // in order to decide what kind of token is being read.
+
+  // Read and consume a string, ending when the given delimiter is
+  // consumed.
+  void ConsumeString(char delimiter);
+
+  // Read and consume a number, returning TYPE_FLOAT or TYPE_INTEGER
+  // depending on what was read.  This needs to know if the first
+  // character was a zero in order to correctly recognize hex and octal
+  // numbers.
+  // It also needs to know if the first character was a . to parse floating
+  // point correctly.
+  TokenType ConsumeNumber(bool started_with_zero, bool started_with_dot);
+
+  // Consume the rest of a line.
+  void ConsumeLineComment(string* content);
+  // Consume until "*/".
+  void ConsumeBlockComment(string* content);
+
+  enum NextCommentStatus {
+    // Started a line comment.
+    LINE_COMMENT,
+
+    // Started a block comment.
+    BLOCK_COMMENT,
+
+    // Consumed a slash, then realized it wasn't a comment.  current_ has
+    // been filled in with a slash token.  The caller should return it.
+    SLASH_NOT_COMMENT,
+
+    // We do not appear to be starting a comment here.
+    NO_COMMENT
+  };
+
+  // If we're at the start of a new comment, consume it and return what kind
+  // of comment it is.
+  NextCommentStatus TryConsumeCommentStart();
+
+  // -----------------------------------------------------------------
+  // These helper methods make the parsing code more readable.  The
+  // "character classes" referred to are defined at the top of the .cc file.
+  // Basically it is a C++ class with one method:
+  //   static bool InClass(char c);
+  // The method returns true if c is a member of this "class", like "Letter"
+  // or "Digit".
+
+  // Returns true if the current character is of the given character
+  // class, but does not consume anything.
+  template<typename CharacterClass>
+  inline bool LookingAt();
+
+  // If the current character is in the given class, consume it and return
+  // true.  Otherwise return false.
+  // e.g. TryConsumeOne<Letter>()
+  template<typename CharacterClass>
+  inline bool TryConsumeOne();
+
+  // Like above, but try to consume the specific character indicated.
+  inline bool TryConsume(char c);
+
+  // Consume zero or more of the given character class.
+  template<typename CharacterClass>
+  inline void ConsumeZeroOrMore();
+
+  // Consume one or more of the given character class or log the given
+  // error message.
+  // e.g. ConsumeOneOrMore<Digit>("Expected digits.");
+  template<typename CharacterClass>
+  inline void ConsumeOneOrMore(const char* error);
+};
+
+// inline methods ====================================================
+inline const Tokenizer::Token& Tokenizer::current() {
+  return current_;
+}
+
+inline const Tokenizer::Token& Tokenizer::previous() {
+  return previous_;
+}
+
+inline void Tokenizer::ParseString(const string& text, string* output) {
+  output->clear();
+  ParseStringAppend(text, output);
+}
+
+}  // namespace io
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_IO_TOKENIZER_H__
diff --git a/kortex_api/include/google/protobuf/io/zero_copy_stream.h b/kortex_api/include/google/protobuf/io/zero_copy_stream.h
new file mode 100644
index 0000000000000000000000000000000000000000..62ace7ae33f302db34a006ca70f16d633615cef9
--- /dev/null
+++ b/kortex_api/include/google/protobuf/io/zero_copy_stream.h
@@ -0,0 +1,248 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// This file contains the ZeroCopyInputStream and ZeroCopyOutputStream
+// interfaces, which represent abstract I/O streams to and from which
+// protocol buffers can be read and written.  For a few simple
+// implementations of these interfaces, see zero_copy_stream_impl.h.
+//
+// These interfaces are different from classic I/O streams in that they
+// try to minimize the amount of data copying that needs to be done.
+// To accomplish this, responsibility for allocating buffers is moved to
+// the stream object, rather than being the responsibility of the caller.
+// So, the stream can return a buffer which actually points directly into
+// the final data structure where the bytes are to be stored, and the caller
+// can interact directly with that buffer, eliminating an intermediate copy
+// operation.
+//
+// As an example, consider the common case in which you are reading bytes
+// from an array that is already in memory (or perhaps an mmap()ed file).
+// With classic I/O streams, you would do something like:
+//   char buffer[BUFFER_SIZE];
+//   input->Read(buffer, BUFFER_SIZE);
+//   DoSomething(buffer, BUFFER_SIZE);
+// Then, the stream basically just calls memcpy() to copy the data from
+// the array into your buffer.  With a ZeroCopyInputStream, you would do
+// this instead:
+//   const void* buffer;
+//   int size;
+//   input->Next(&buffer, &size);
+//   DoSomething(buffer, size);
+// Here, no copy is performed.  The input stream returns a pointer directly
+// into the backing array, and the caller ends up reading directly from it.
+//
+// If you want to be able to read the old-fashion way, you can create
+// a CodedInputStream or CodedOutputStream wrapping these objects and use
+// their ReadRaw()/WriteRaw() methods.  These will, of course, add a copy
+// step, but Coded*Stream will handle buffering so at least it will be
+// reasonably efficient.
+//
+// ZeroCopyInputStream example:
+//   // Read in a file and print its contents to stdout.
+//   int fd = open("myfile", O_RDONLY);
+//   ZeroCopyInputStream* input = new FileInputStream(fd);
+//
+//   const void* buffer;
+//   int size;
+//   while (input->Next(&buffer, &size)) {
+//     cout.write(buffer, size);
+//   }
+//
+//   delete input;
+//   close(fd);
+//
+// ZeroCopyOutputStream example:
+//   // Copy the contents of "infile" to "outfile", using plain read() for
+//   // "infile" but a ZeroCopyOutputStream for "outfile".
+//   int infd = open("infile", O_RDONLY);
+//   int outfd = open("outfile", O_WRONLY);
+//   ZeroCopyOutputStream* output = new FileOutputStream(outfd);
+//
+//   void* buffer;
+//   int size;
+//   while (output->Next(&buffer, &size)) {
+//     int bytes = read(infd, buffer, size);
+//     if (bytes < size) {
+//       // Reached EOF.
+//       output->BackUp(size - bytes);
+//       break;
+//     }
+//   }
+//
+//   delete output;
+//   close(infd);
+//   close(outfd);
+
+#ifndef GOOGLE_PROTOBUF_IO_ZERO_COPY_STREAM_H__
+#define GOOGLE_PROTOBUF_IO_ZERO_COPY_STREAM_H__
+
+#include <string>
+#include <google/protobuf/stubs/common.h>
+
+namespace google {
+
+namespace protobuf {
+namespace io {
+
+// Defined in this file.
+class ZeroCopyInputStream;
+class ZeroCopyOutputStream;
+
+// Abstract interface similar to an input stream but designed to minimize
+// copying.
+class LIBPROTOBUF_EXPORT ZeroCopyInputStream {
+ public:
+  ZeroCopyInputStream() {}
+  virtual ~ZeroCopyInputStream() {}
+
+  // Obtains a chunk of data from the stream.
+  //
+  // Preconditions:
+  // * "size" and "data" are not NULL.
+  //
+  // Postconditions:
+  // * If the returned value is false, there is no more data to return or
+  //   an error occurred.  All errors are permanent.
+  // * Otherwise, "size" points to the actual number of bytes read and "data"
+  //   points to a pointer to a buffer containing these bytes.
+  // * Ownership of this buffer remains with the stream, and the buffer
+  //   remains valid only until some other method of the stream is called
+  //   or the stream is destroyed.
+  // * It is legal for the returned buffer to have zero size, as long
+  //   as repeatedly calling Next() eventually yields a buffer with non-zero
+  //   size.
+  virtual bool Next(const void** data, int* size) = 0;
+
+  // Backs up a number of bytes, so that the next call to Next() returns
+  // data again that was already returned by the last call to Next().  This
+  // is useful when writing procedures that are only supposed to read up
+  // to a certain point in the input, then return.  If Next() returns a
+  // buffer that goes beyond what you wanted to read, you can use BackUp()
+  // to return to the point where you intended to finish.
+  //
+  // Preconditions:
+  // * The last method called must have been Next().
+  // * count must be less than or equal to the size of the last buffer
+  //   returned by Next().
+  //
+  // Postconditions:
+  // * The last "count" bytes of the last buffer returned by Next() will be
+  //   pushed back into the stream.  Subsequent calls to Next() will return
+  //   the same data again before producing new data.
+  virtual void BackUp(int count) = 0;
+
+  // Skips a number of bytes.  Returns false if the end of the stream is
+  // reached or some input error occurred.  In the end-of-stream case, the
+  // stream is advanced to the end of the stream (so ByteCount() will return
+  // the total size of the stream).
+  virtual bool Skip(int count) = 0;
+
+  // Returns the total number of bytes read since this object was created.
+  virtual int64 ByteCount() const = 0;
+
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ZeroCopyInputStream);
+};
+
+// Abstract interface similar to an output stream but designed to minimize
+// copying.
+class LIBPROTOBUF_EXPORT ZeroCopyOutputStream {
+ public:
+  ZeroCopyOutputStream() {}
+  virtual ~ZeroCopyOutputStream() {}
+
+  // Obtains a buffer into which data can be written.  Any data written
+  // into this buffer will eventually (maybe instantly, maybe later on)
+  // be written to the output.
+  //
+  // Preconditions:
+  // * "size" and "data" are not NULL.
+  //
+  // Postconditions:
+  // * If the returned value is false, an error occurred.  All errors are
+  //   permanent.
+  // * Otherwise, "size" points to the actual number of bytes in the buffer
+  //   and "data" points to the buffer.
+  // * Ownership of this buffer remains with the stream, and the buffer
+  //   remains valid only until some other method of the stream is called
+  //   or the stream is destroyed.
+  // * Any data which the caller stores in this buffer will eventually be
+  //   written to the output (unless BackUp() is called).
+  // * It is legal for the returned buffer to have zero size, as long
+  //   as repeatedly calling Next() eventually yields a buffer with non-zero
+  //   size.
+  virtual bool Next(void** data, int* size) = 0;
+
+  // Backs up a number of bytes, so that the end of the last buffer returned
+  // by Next() is not actually written.  This is needed when you finish
+  // writing all the data you want to write, but the last buffer was bigger
+  // than you needed.  You don't want to write a bunch of garbage after the
+  // end of your data, so you use BackUp() to back up.
+  //
+  // Preconditions:
+  // * The last method called must have been Next().
+  // * count must be less than or equal to the size of the last buffer
+  //   returned by Next().
+  // * The caller must not have written anything to the last "count" bytes
+  //   of that buffer.
+  //
+  // Postconditions:
+  // * The last "count" bytes of the last buffer returned by Next() will be
+  //   ignored.
+  virtual void BackUp(int count) = 0;
+
+  // Returns the total number of bytes written since this object was created.
+  virtual int64 ByteCount() const = 0;
+
+  // Write a given chunk of data to the output.  Some output streams may
+  // implement this in a way that avoids copying. Check AllowsAliasing() before
+  // calling WriteAliasedRaw(). It will GOOGLE_CHECK fail if WriteAliasedRaw() is
+  // called on a stream that does not allow aliasing.
+  //
+  // NOTE: It is caller's responsibility to ensure that the chunk of memory
+  // remains live until all of the data has been consumed from the stream.
+  virtual bool WriteAliasedRaw(const void* data, int size);
+  virtual bool AllowsAliasing() const { return false; }
+
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ZeroCopyOutputStream);
+};
+
+}  // namespace io
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_IO_ZERO_COPY_STREAM_H__
diff --git a/kortex_api/include/google/protobuf/io/zero_copy_stream_impl.h b/kortex_api/include/google/protobuf/io/zero_copy_stream_impl.h
new file mode 100644
index 0000000000000000000000000000000000000000..ea978bfbb7086aeb0b5e1e28e760a43048bcd43e
--- /dev/null
+++ b/kortex_api/include/google/protobuf/io/zero_copy_stream_impl.h
@@ -0,0 +1,355 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// This file contains common implementations of the interfaces defined in
+// zero_copy_stream.h which are only included in the full (non-lite)
+// protobuf library.  These implementations include Unix file descriptors
+// and C++ iostreams.  See also:  zero_copy_stream_impl_lite.h
+
+#ifndef GOOGLE_PROTOBUF_IO_ZERO_COPY_STREAM_IMPL_H__
+#define GOOGLE_PROTOBUF_IO_ZERO_COPY_STREAM_IMPL_H__
+
+#include <string>
+#include <iosfwd>
+#include <google/protobuf/io/zero_copy_stream.h>
+#include <google/protobuf/io/zero_copy_stream_impl_lite.h>
+#include <google/protobuf/stubs/common.h>
+
+
+namespace google {
+namespace protobuf {
+namespace io {
+
+
+// ===================================================================
+
+// A ZeroCopyInputStream which reads from a file descriptor.
+//
+// FileInputStream is preferred over using an ifstream with IstreamInputStream.
+// The latter will introduce an extra layer of buffering, harming performance.
+// Also, it's conceivable that FileInputStream could someday be enhanced
+// to use zero-copy file descriptors on OSs which support them.
+class LIBPROTOBUF_EXPORT FileInputStream : public ZeroCopyInputStream {
+ public:
+  // Creates a stream that reads from the given Unix file descriptor.
+  // If a block_size is given, it specifies the number of bytes that
+  // should be read and returned with each call to Next().  Otherwise,
+  // a reasonable default is used.
+  explicit FileInputStream(int file_descriptor, int block_size = -1);
+
+  // Flushes any buffers and closes the underlying file.  Returns false if
+  // an error occurs during the process; use GetErrno() to examine the error.
+  // Even if an error occurs, the file descriptor is closed when this returns.
+  bool Close();
+
+  // By default, the file descriptor is not closed when the stream is
+  // destroyed.  Call SetCloseOnDelete(true) to change that.  WARNING:
+  // This leaves no way for the caller to detect if close() fails.  If
+  // detecting close() errors is important to you, you should arrange
+  // to close the descriptor yourself.
+  void SetCloseOnDelete(bool value) { copying_input_.SetCloseOnDelete(value); }
+
+  // If an I/O error has occurred on this file descriptor, this is the
+  // errno from that error.  Otherwise, this is zero.  Once an error
+  // occurs, the stream is broken and all subsequent operations will
+  // fail.
+  int GetErrno() { return copying_input_.GetErrno(); }
+
+  // implements ZeroCopyInputStream ----------------------------------
+  bool Next(const void** data, int* size);
+  void BackUp(int count);
+  bool Skip(int count);
+  int64 ByteCount() const;
+
+ private:
+  class LIBPROTOBUF_EXPORT CopyingFileInputStream : public CopyingInputStream {
+   public:
+    CopyingFileInputStream(int file_descriptor);
+    ~CopyingFileInputStream();
+
+    bool Close();
+    void SetCloseOnDelete(bool value) { close_on_delete_ = value; }
+    int GetErrno() { return errno_; }
+
+    // implements CopyingInputStream ---------------------------------
+    int Read(void* buffer, int size);
+    int Skip(int count);
+
+   private:
+    // The file descriptor.
+    const int file_;
+    bool close_on_delete_;
+    bool is_closed_;
+
+    // The errno of the I/O error, if one has occurred.  Otherwise, zero.
+    int errno_;
+
+    // Did we try to seek once and fail?  If so, we assume this file descriptor
+    // doesn't support seeking and won't try again.
+    bool previous_seek_failed_;
+
+    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CopyingFileInputStream);
+  };
+
+  CopyingFileInputStream copying_input_;
+  CopyingInputStreamAdaptor impl_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(FileInputStream);
+};
+
+// ===================================================================
+
+// A ZeroCopyOutputStream which writes to a file descriptor.
+//
+// FileOutputStream is preferred over using an ofstream with
+// OstreamOutputStream.  The latter will introduce an extra layer of buffering,
+// harming performance.  Also, it's conceivable that FileOutputStream could
+// someday be enhanced to use zero-copy file descriptors on OSs which
+// support them.
+class LIBPROTOBUF_EXPORT FileOutputStream : public ZeroCopyOutputStream {
+ public:
+  // Creates a stream that writes to the given Unix file descriptor.
+  // If a block_size is given, it specifies the size of the buffers
+  // that should be returned by Next().  Otherwise, a reasonable default
+  // is used.
+  explicit FileOutputStream(int file_descriptor, int block_size = -1);
+  ~FileOutputStream();
+
+  // Flushes any buffers and closes the underlying file.  Returns false if
+  // an error occurs during the process; use GetErrno() to examine the error.
+  // Even if an error occurs, the file descriptor is closed when this returns.
+  bool Close();
+
+  // Flushes FileOutputStream's buffers but does not close the
+  // underlying file. No special measures are taken to ensure that
+  // underlying operating system file object is synchronized to disk.
+  bool Flush();
+
+  // By default, the file descriptor is not closed when the stream is
+  // destroyed.  Call SetCloseOnDelete(true) to change that.  WARNING:
+  // This leaves no way for the caller to detect if close() fails.  If
+  // detecting close() errors is important to you, you should arrange
+  // to close the descriptor yourself.
+  void SetCloseOnDelete(bool value) { copying_output_.SetCloseOnDelete(value); }
+
+  // If an I/O error has occurred on this file descriptor, this is the
+  // errno from that error.  Otherwise, this is zero.  Once an error
+  // occurs, the stream is broken and all subsequent operations will
+  // fail.
+  int GetErrno() { return copying_output_.GetErrno(); }
+
+  // implements ZeroCopyOutputStream ---------------------------------
+  bool Next(void** data, int* size);
+  void BackUp(int count);
+  int64 ByteCount() const;
+
+ private:
+  class LIBPROTOBUF_EXPORT CopyingFileOutputStream : public CopyingOutputStream {
+   public:
+    CopyingFileOutputStream(int file_descriptor);
+    ~CopyingFileOutputStream();
+
+    bool Close();
+    void SetCloseOnDelete(bool value) { close_on_delete_ = value; }
+    int GetErrno() { return errno_; }
+
+    // implements CopyingOutputStream --------------------------------
+    bool Write(const void* buffer, int size);
+
+   private:
+    // The file descriptor.
+    const int file_;
+    bool close_on_delete_;
+    bool is_closed_;
+
+    // The errno of the I/O error, if one has occurred.  Otherwise, zero.
+    int errno_;
+
+    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CopyingFileOutputStream);
+  };
+
+  CopyingFileOutputStream copying_output_;
+  CopyingOutputStreamAdaptor impl_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(FileOutputStream);
+};
+
+// ===================================================================
+
+// A ZeroCopyInputStream which reads from a C++ istream.
+//
+// Note that for reading files (or anything represented by a file descriptor),
+// FileInputStream is more efficient.
+class LIBPROTOBUF_EXPORT IstreamInputStream : public ZeroCopyInputStream {
+ public:
+  // Creates a stream that reads from the given C++ istream.
+  // If a block_size is given, it specifies the number of bytes that
+  // should be read and returned with each call to Next().  Otherwise,
+  // a reasonable default is used.
+  explicit IstreamInputStream(std::istream* stream, int block_size = -1);
+
+  // implements ZeroCopyInputStream ----------------------------------
+  bool Next(const void** data, int* size);
+  void BackUp(int count);
+  bool Skip(int count);
+  int64 ByteCount() const;
+
+ private:
+  class LIBPROTOBUF_EXPORT CopyingIstreamInputStream : public CopyingInputStream {
+   public:
+    CopyingIstreamInputStream(std::istream* input);
+    ~CopyingIstreamInputStream();
+
+    // implements CopyingInputStream ---------------------------------
+    int Read(void* buffer, int size);
+    // (We use the default implementation of Skip().)
+
+   private:
+    // The stream.
+    std::istream* input_;
+
+    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CopyingIstreamInputStream);
+  };
+
+  CopyingIstreamInputStream copying_input_;
+  CopyingInputStreamAdaptor impl_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(IstreamInputStream);
+};
+
+// ===================================================================
+
+// A ZeroCopyOutputStream which writes to a C++ ostream.
+//
+// Note that for writing files (or anything represented by a file descriptor),
+// FileOutputStream is more efficient.
+class LIBPROTOBUF_EXPORT OstreamOutputStream : public ZeroCopyOutputStream {
+ public:
+  // Creates a stream that writes to the given C++ ostream.
+  // If a block_size is given, it specifies the size of the buffers
+  // that should be returned by Next().  Otherwise, a reasonable default
+  // is used.
+  explicit OstreamOutputStream(std::ostream* stream, int block_size = -1);
+  ~OstreamOutputStream();
+
+  // implements ZeroCopyOutputStream ---------------------------------
+  bool Next(void** data, int* size);
+  void BackUp(int count);
+  int64 ByteCount() const;
+
+ private:
+  class LIBPROTOBUF_EXPORT CopyingOstreamOutputStream : public CopyingOutputStream {
+   public:
+    CopyingOstreamOutputStream(std::ostream* output);
+    ~CopyingOstreamOutputStream();
+
+    // implements CopyingOutputStream --------------------------------
+    bool Write(const void* buffer, int size);
+
+   private:
+    // The stream.
+    std::ostream* output_;
+
+    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CopyingOstreamOutputStream);
+  };
+
+  CopyingOstreamOutputStream copying_output_;
+  CopyingOutputStreamAdaptor impl_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(OstreamOutputStream);
+};
+
+// ===================================================================
+
+// A ZeroCopyInputStream which reads from several other streams in sequence.
+// ConcatenatingInputStream is unable to distinguish between end-of-stream
+// and read errors in the underlying streams, so it assumes any errors mean
+// end-of-stream.  So, if the underlying streams fail for any other reason,
+// ConcatenatingInputStream may do odd things.  It is suggested that you do
+// not use ConcatenatingInputStream on streams that might produce read errors
+// other than end-of-stream.
+class LIBPROTOBUF_EXPORT ConcatenatingInputStream : public ZeroCopyInputStream {
+ public:
+  // All streams passed in as well as the array itself must remain valid
+  // until the ConcatenatingInputStream is destroyed.
+  ConcatenatingInputStream(ZeroCopyInputStream* const streams[], int count);
+
+  // implements ZeroCopyInputStream ----------------------------------
+  bool Next(const void** data, int* size);
+  void BackUp(int count);
+  bool Skip(int count);
+  int64 ByteCount() const;
+
+
+ private:
+  // As streams are retired, streams_ is incremented and count_ is
+  // decremented.
+  ZeroCopyInputStream* const* streams_;
+  int stream_count_;
+  int64 bytes_retired_;  // Bytes read from previous streams.
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ConcatenatingInputStream);
+};
+
+// ===================================================================
+
+// A ZeroCopyInputStream which wraps some other stream and limits it to
+// a particular byte count.
+class LIBPROTOBUF_EXPORT LimitingInputStream : public ZeroCopyInputStream {
+ public:
+  LimitingInputStream(ZeroCopyInputStream* input, int64 limit);
+  ~LimitingInputStream();
+
+  // implements ZeroCopyInputStream ----------------------------------
+  bool Next(const void** data, int* size);
+  void BackUp(int count);
+  bool Skip(int count);
+  int64 ByteCount() const;
+
+
+ private:
+  ZeroCopyInputStream* input_;
+  int64 limit_;  // Decreases as we go, becomes negative if we overshoot.
+  int64 prior_bytes_read_;  // Bytes read on underlying stream at construction
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(LimitingInputStream);
+};
+
+// ===================================================================
+
+}  // namespace io
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_IO_ZERO_COPY_STREAM_IMPL_H__
diff --git a/kortex_api/include/google/protobuf/io/zero_copy_stream_impl_lite.h b/kortex_api/include/google/protobuf/io/zero_copy_stream_impl_lite.h
new file mode 100644
index 0000000000000000000000000000000000000000..ab0fd5ac24e22a31cab146e50e2f72797cf197c6
--- /dev/null
+++ b/kortex_api/include/google/protobuf/io/zero_copy_stream_impl_lite.h
@@ -0,0 +1,386 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// This file contains common implementations of the interfaces defined in
+// zero_copy_stream.h which are included in the "lite" protobuf library.
+// These implementations cover I/O on raw arrays and strings, as well as
+// adaptors which make it easy to implement streams based on traditional
+// streams.  Of course, many users will probably want to write their own
+// implementations of these interfaces specific to the particular I/O
+// abstractions they prefer to use, but these should cover the most common
+// cases.
+
+#ifndef GOOGLE_PROTOBUF_IO_ZERO_COPY_STREAM_IMPL_LITE_H__
+#define GOOGLE_PROTOBUF_IO_ZERO_COPY_STREAM_IMPL_LITE_H__
+
+#include <memory>
+#ifndef _SHARED_PTR_H
+#include <google/protobuf/stubs/shared_ptr.h>
+#endif
+#include <string>
+#include <iosfwd>
+#include <google/protobuf/io/zero_copy_stream.h>
+#include <google/protobuf/stubs/callback.h>
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/stl_util.h>
+
+
+namespace google {
+namespace protobuf {
+namespace io {
+
+// ===================================================================
+
+// A ZeroCopyInputStream backed by an in-memory array of bytes.
+class LIBPROTOBUF_EXPORT ArrayInputStream : public ZeroCopyInputStream {
+ public:
+  // Create an InputStream that returns the bytes pointed to by "data".
+  // "data" remains the property of the caller but must remain valid until
+  // the stream is destroyed.  If a block_size is given, calls to Next()
+  // will return data blocks no larger than the given size.  Otherwise, the
+  // first call to Next() returns the entire array.  block_size is mainly
+  // useful for testing; in production you would probably never want to set
+  // it.
+  ArrayInputStream(const void* data, int size, int block_size = -1);
+
+  // implements ZeroCopyInputStream ----------------------------------
+  bool Next(const void** data, int* size);
+  void BackUp(int count);
+  bool Skip(int count);
+  int64 ByteCount() const;
+
+
+ private:
+  const uint8* const data_;  // The byte array.
+  const int size_;           // Total size of the array.
+  const int block_size_;     // How many bytes to return at a time.
+
+  int position_;
+  int last_returned_size_;   // How many bytes we returned last time Next()
+                             // was called (used for error checking only).
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ArrayInputStream);
+};
+
+// ===================================================================
+
+// A ZeroCopyOutputStream backed by an in-memory array of bytes.
+class LIBPROTOBUF_EXPORT ArrayOutputStream : public ZeroCopyOutputStream {
+ public:
+  // Create an OutputStream that writes to the bytes pointed to by "data".
+  // "data" remains the property of the caller but must remain valid until
+  // the stream is destroyed.  If a block_size is given, calls to Next()
+  // will return data blocks no larger than the given size.  Otherwise, the
+  // first call to Next() returns the entire array.  block_size is mainly
+  // useful for testing; in production you would probably never want to set
+  // it.
+  ArrayOutputStream(void* data, int size, int block_size = -1);
+
+  // implements ZeroCopyOutputStream ---------------------------------
+  bool Next(void** data, int* size);
+  void BackUp(int count);
+  int64 ByteCount() const;
+
+ private:
+  uint8* const data_;        // The byte array.
+  const int size_;           // Total size of the array.
+  const int block_size_;     // How many bytes to return at a time.
+
+  int position_;
+  int last_returned_size_;   // How many bytes we returned last time Next()
+                             // was called (used for error checking only).
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ArrayOutputStream);
+};
+
+// ===================================================================
+
+// A ZeroCopyOutputStream which appends bytes to a string.
+class LIBPROTOBUF_EXPORT StringOutputStream : public ZeroCopyOutputStream {
+ public:
+  // Create a StringOutputStream which appends bytes to the given string.
+  // The string remains property of the caller, but it is mutated in arbitrary
+  // ways and MUST NOT be accessed in any way until you're done with the
+  // stream. Either be sure there's no further usage, or (safest) destroy the
+  // stream before using the contents.
+  //
+  // Hint:  If you call target->reserve(n) before creating the stream,
+  //   the first call to Next() will return at least n bytes of buffer
+  //   space.
+  explicit StringOutputStream(string* target);
+
+  // implements ZeroCopyOutputStream ---------------------------------
+  bool Next(void** data, int* size);
+  void BackUp(int count);
+  int64 ByteCount() const;
+
+ protected:
+  void SetString(string* target);
+
+ private:
+  static const int kMinimumSize = 16;
+
+  string* target_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(StringOutputStream);
+};
+
+// Note:  There is no StringInputStream.  Instead, just create an
+// ArrayInputStream as follows:
+//   ArrayInputStream input(str.data(), str.size());
+
+// ===================================================================
+
+// A generic traditional input stream interface.
+//
+// Lots of traditional input streams (e.g. file descriptors, C stdio
+// streams, and C++ iostreams) expose an interface where every read
+// involves copying bytes into a buffer.  If you want to take such an
+// interface and make a ZeroCopyInputStream based on it, simply implement
+// CopyingInputStream and then use CopyingInputStreamAdaptor.
+//
+// CopyingInputStream implementations should avoid buffering if possible.
+// CopyingInputStreamAdaptor does its own buffering and will read data
+// in large blocks.
+class LIBPROTOBUF_EXPORT CopyingInputStream {
+ public:
+  virtual ~CopyingInputStream() {}
+
+  // Reads up to "size" bytes into the given buffer.  Returns the number of
+  // bytes read.  Read() waits until at least one byte is available, or
+  // returns zero if no bytes will ever become available (EOF), or -1 if a
+  // permanent read error occurred.
+  virtual int Read(void* buffer, int size) = 0;
+
+  // Skips the next "count" bytes of input.  Returns the number of bytes
+  // actually skipped.  This will always be exactly equal to "count" unless
+  // EOF was reached or a permanent read error occurred.
+  //
+  // The default implementation just repeatedly calls Read() into a scratch
+  // buffer.
+  virtual int Skip(int count);
+};
+
+// A ZeroCopyInputStream which reads from a CopyingInputStream.  This is
+// useful for implementing ZeroCopyInputStreams that read from traditional
+// streams.  Note that this class is not really zero-copy.
+//
+// If you want to read from file descriptors or C++ istreams, this is
+// already implemented for you:  use FileInputStream or IstreamInputStream
+// respectively.
+class LIBPROTOBUF_EXPORT CopyingInputStreamAdaptor : public ZeroCopyInputStream {
+ public:
+  // Creates a stream that reads from the given CopyingInputStream.
+  // If a block_size is given, it specifies the number of bytes that
+  // should be read and returned with each call to Next().  Otherwise,
+  // a reasonable default is used.  The caller retains ownership of
+  // copying_stream unless SetOwnsCopyingStream(true) is called.
+  explicit CopyingInputStreamAdaptor(CopyingInputStream* copying_stream,
+                                     int block_size = -1);
+  ~CopyingInputStreamAdaptor();
+
+  // Call SetOwnsCopyingStream(true) to tell the CopyingInputStreamAdaptor to
+  // delete the underlying CopyingInputStream when it is destroyed.
+  void SetOwnsCopyingStream(bool value) { owns_copying_stream_ = value; }
+
+  // implements ZeroCopyInputStream ----------------------------------
+  bool Next(const void** data, int* size);
+  void BackUp(int count);
+  bool Skip(int count);
+  int64 ByteCount() const;
+
+ private:
+  // Insures that buffer_ is not NULL.
+  void AllocateBufferIfNeeded();
+  // Frees the buffer and resets buffer_used_.
+  void FreeBuffer();
+
+  // The underlying copying stream.
+  CopyingInputStream* copying_stream_;
+  bool owns_copying_stream_;
+
+  // True if we have seen a permenant error from the underlying stream.
+  bool failed_;
+
+  // The current position of copying_stream_, relative to the point where
+  // we started reading.
+  int64 position_;
+
+  // Data is read into this buffer.  It may be NULL if no buffer is currently
+  // in use.  Otherwise, it points to an array of size buffer_size_.
+  google::protobuf::scoped_array<uint8> buffer_;
+  const int buffer_size_;
+
+  // Number of valid bytes currently in the buffer (i.e. the size last
+  // returned by Next()).  0 <= buffer_used_ <= buffer_size_.
+  int buffer_used_;
+
+  // Number of bytes in the buffer which were backed up over by a call to
+  // BackUp().  These need to be returned again.
+  // 0 <= backup_bytes_ <= buffer_used_
+  int backup_bytes_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CopyingInputStreamAdaptor);
+};
+
+// ===================================================================
+
+// A generic traditional output stream interface.
+//
+// Lots of traditional output streams (e.g. file descriptors, C stdio
+// streams, and C++ iostreams) expose an interface where every write
+// involves copying bytes from a buffer.  If you want to take such an
+// interface and make a ZeroCopyOutputStream based on it, simply implement
+// CopyingOutputStream and then use CopyingOutputStreamAdaptor.
+//
+// CopyingOutputStream implementations should avoid buffering if possible.
+// CopyingOutputStreamAdaptor does its own buffering and will write data
+// in large blocks.
+class LIBPROTOBUF_EXPORT CopyingOutputStream {
+ public:
+  virtual ~CopyingOutputStream() {}
+
+  // Writes "size" bytes from the given buffer to the output.  Returns true
+  // if successful, false on a write error.
+  virtual bool Write(const void* buffer, int size) = 0;
+};
+
+// A ZeroCopyOutputStream which writes to a CopyingOutputStream.  This is
+// useful for implementing ZeroCopyOutputStreams that write to traditional
+// streams.  Note that this class is not really zero-copy.
+//
+// If you want to write to file descriptors or C++ ostreams, this is
+// already implemented for you:  use FileOutputStream or OstreamOutputStream
+// respectively.
+class LIBPROTOBUF_EXPORT CopyingOutputStreamAdaptor : public ZeroCopyOutputStream {
+ public:
+  // Creates a stream that writes to the given Unix file descriptor.
+  // If a block_size is given, it specifies the size of the buffers
+  // that should be returned by Next().  Otherwise, a reasonable default
+  // is used.
+  explicit CopyingOutputStreamAdaptor(CopyingOutputStream* copying_stream,
+                                      int block_size = -1);
+  ~CopyingOutputStreamAdaptor();
+
+  // Writes all pending data to the underlying stream.  Returns false if a
+  // write error occurred on the underlying stream.  (The underlying
+  // stream itself is not necessarily flushed.)
+  bool Flush();
+
+  // Call SetOwnsCopyingStream(true) to tell the CopyingOutputStreamAdaptor to
+  // delete the underlying CopyingOutputStream when it is destroyed.
+  void SetOwnsCopyingStream(bool value) { owns_copying_stream_ = value; }
+
+  // implements ZeroCopyOutputStream ---------------------------------
+  bool Next(void** data, int* size);
+  void BackUp(int count);
+  int64 ByteCount() const;
+
+ private:
+  // Write the current buffer, if it is present.
+  bool WriteBuffer();
+  // Insures that buffer_ is not NULL.
+  void AllocateBufferIfNeeded();
+  // Frees the buffer.
+  void FreeBuffer();
+
+  // The underlying copying stream.
+  CopyingOutputStream* copying_stream_;
+  bool owns_copying_stream_;
+
+  // True if we have seen a permenant error from the underlying stream.
+  bool failed_;
+
+  // The current position of copying_stream_, relative to the point where
+  // we started writing.
+  int64 position_;
+
+  // Data is written from this buffer.  It may be NULL if no buffer is
+  // currently in use.  Otherwise, it points to an array of size buffer_size_.
+  google::protobuf::scoped_array<uint8> buffer_;
+  const int buffer_size_;
+
+  // Number of valid bytes currently in the buffer (i.e. the size last
+  // returned by Next()).  When BackUp() is called, we just reduce this.
+  // 0 <= buffer_used_ <= buffer_size_.
+  int buffer_used_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CopyingOutputStreamAdaptor);
+};
+
+// ===================================================================
+
+// mutable_string_data() and as_string_data() are workarounds to improve
+// the performance of writing new data to an existing string.  Unfortunately
+// the methods provided by the string class are suboptimal, and using memcpy()
+// is mildly annoying because it requires its pointer args to be non-NULL even
+// if we ask it to copy 0 bytes.  Furthermore, string_as_array() has the
+// property that it always returns NULL if its arg is the empty string, exactly
+// what we want to avoid if we're using it in conjunction with memcpy()!
+// With C++11, the desired memcpy() boils down to memcpy(..., &(*s)[0], size),
+// where s is a string*.  Without C++11, &(*s)[0] is not guaranteed to be safe,
+// so we use string_as_array(), and live with the extra logic that tests whether
+// *s is empty.
+
+// Return a pointer to mutable characters underlying the given string.  The
+// return value is valid until the next time the string is resized.  We
+// trust the caller to treat the return value as an array of length s->size().
+inline char* mutable_string_data(string* s) {
+#ifdef LANG_CXX11
+  // This should be simpler & faster than string_as_array() because the latter
+  // is guaranteed to return NULL when *s is empty, so it has to check for that.
+  return &(*s)[0];
+#else
+  return string_as_array(s);
+#endif
+}
+
+// as_string_data(s) is equivalent to
+//  ({ char* p = mutable_string_data(s); make_pair(p, p != NULL); })
+// Sometimes it's faster: in some scenarios p cannot be NULL, and then the
+// code can avoid that check.
+inline std::pair<char*, bool> as_string_data(string* s) {
+  char *p = mutable_string_data(s);
+#ifdef LANG_CXX11
+  return std::make_pair(p, true);
+#else
+  return std::make_pair(p, p != NULL);
+#endif
+}
+
+}  // namespace io
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_IO_ZERO_COPY_STREAM_IMPL_LITE_H__
diff --git a/kortex_api/include/google/protobuf/map.h b/kortex_api/include/google/protobuf/map.h
new file mode 100644
index 0000000000000000000000000000000000000000..7d9cc5c5927b54774862d7043a6a69e044750042
--- /dev/null
+++ b/kortex_api/include/google/protobuf/map.h
@@ -0,0 +1,1217 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// This file defines the map container and its helpers to support protobuf maps.
+//
+// The Map and MapIterator types are provided by this header file.
+// Please avoid using other types defined here, unless they are public
+// types within Map or MapIterator, such as Map::value_type.
+
+#ifndef GOOGLE_PROTOBUF_MAP_H__
+#define GOOGLE_PROTOBUF_MAP_H__
+
+#include <iterator>
+#include <limits>  // To support Visual Studio 2008
+#include <set>
+#include <utility>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/generated_enum_util.h>
+#include <google/protobuf/map_type_handler.h>
+#include <google/protobuf/stubs/hash.h>
+
+namespace google {
+namespace protobuf {
+
+template <typename Key, typename T>
+class Map;
+
+class MapIterator;
+
+template <typename Enum> struct is_proto_enum;
+
+namespace internal {
+template <typename Derived, typename Key, typename T,
+          WireFormatLite::FieldType key_wire_type,
+          WireFormatLite::FieldType value_wire_type, int default_enum_value>
+class MapFieldLite;
+
+template <typename Derived, typename Key, typename T,
+          WireFormatLite::FieldType key_wire_type,
+          WireFormatLite::FieldType value_wire_type, int default_enum_value>
+class MapField;
+
+template <typename Key, typename T>
+class TypeDefinedMapFieldBase;
+
+class DynamicMapField;
+
+class GeneratedMessageReflection;
+}  // namespace internal
+
+// This is the class for google::protobuf::Map's internal value_type. Instead of using
+// std::pair as value_type, we use this class which provides us more control of
+// its process of construction and destruction.
+template <typename Key, typename T>
+class MapPair {
+ public:
+  typedef const Key first_type;
+  typedef T second_type;
+
+  MapPair(const Key& other_first, const T& other_second)
+      : first(other_first), second(other_second) {}
+  explicit MapPair(const Key& other_first) : first(other_first), second() {}
+  MapPair(const MapPair& other)
+      : first(other.first), second(other.second) {}
+
+  ~MapPair() {}
+
+  // Implicitly convertible to std::pair of compatible types.
+  template <typename T1, typename T2>
+  operator std::pair<T1, T2>() const {
+    return std::pair<T1, T2>(first, second);
+  }
+
+  const Key first;
+  T second;
+
+ private:
+  friend class ::google::protobuf::Arena;
+  friend class Map<Key, T>;
+};
+
+// google::protobuf::Map is an associative container type used to store protobuf map
+// fields.  Each Map instance may or may not use a different hash function, a
+// different iteration order, and so on.  E.g., please don't examine
+// implementation details to decide if the following would work:
+//  Map<int, int> m0, m1;
+//  m0[0] = m1[0] = m0[1] = m1[1] = 0;
+//  assert(m0.begin()->first == m1.begin()->first);  // Bug!
+//
+// Map's interface is similar to std::unordered_map, except that Map is not
+// designed to play well with exceptions.
+template <typename Key, typename T>
+class Map {
+ public:
+  typedef Key key_type;
+  typedef T mapped_type;
+  typedef MapPair<Key, T> value_type;
+
+  typedef value_type* pointer;
+  typedef const value_type* const_pointer;
+  typedef value_type& reference;
+  typedef const value_type& const_reference;
+
+  typedef size_t size_type;
+  typedef hash<Key> hasher;
+
+  Map() : arena_(NULL), default_enum_value_(0) { Init(); }
+  explicit Map(Arena* arena) : arena_(arena), default_enum_value_(0) { Init(); }
+
+  Map(const Map& other)
+      : arena_(NULL), default_enum_value_(other.default_enum_value_) {
+    Init();
+    insert(other.begin(), other.end());
+  }
+
+#if LANG_CXX11
+  Map(Map&& other) noexcept : Map() {
+    if (other.arena_) {
+      *this = other;
+    } else {
+      swap(other);
+    }
+  }
+  Map& operator=(Map&& other) noexcept {
+    if (this != &other) {
+      if (arena_ != other.arena_) {
+        *this = other;
+      } else {
+        swap(other);
+      }
+    }
+    return *this;
+  }
+#endif
+
+  template <class InputIt>
+  Map(const InputIt& first, const InputIt& last)
+      : arena_(NULL), default_enum_value_(0) {
+    Init();
+    insert(first, last);
+  }
+
+  ~Map() {
+    clear();
+    if (arena_ == NULL) {
+      delete elements_;
+    }
+  }
+
+ private:
+  void Init() {
+    elements_ = Arena::Create<InnerMap>(arena_, 0u, hasher(), Allocator(arena_));
+  }
+
+  // re-implement std::allocator to use arena allocator for memory allocation.
+  // Used for google::protobuf::Map implementation. Users should not use this class
+  // directly.
+  template <typename U>
+  class MapAllocator {
+   public:
+    typedef U value_type;
+    typedef value_type* pointer;
+    typedef const value_type* const_pointer;
+    typedef value_type& reference;
+    typedef const value_type& const_reference;
+    typedef size_t size_type;
+    typedef ptrdiff_t difference_type;
+
+    MapAllocator() : arena_(NULL) {}
+    explicit MapAllocator(Arena* arena) : arena_(arena) {}
+    template <typename X>
+    MapAllocator(const MapAllocator<X>& allocator)
+        : arena_(allocator.arena()) {}
+
+    pointer allocate(size_type n, const void* /* hint */ = 0) {
+      // If arena is not given, malloc needs to be called which doesn't
+      // construct element object.
+      if (arena_ == NULL) {
+        return static_cast<pointer>(::operator new(n * sizeof(value_type)));
+      } else {
+        return reinterpret_cast<pointer>(
+            Arena::CreateArray<uint8>(arena_, n * sizeof(value_type)));
+      }
+    }
+
+    void deallocate(pointer p, size_type n) {
+      if (arena_ == NULL) {
+#if defined(__GXX_DELETE_WITH_SIZE__) || defined(__cpp_sized_deallocation)
+        ::operator delete(p, n * sizeof(value_type));
+#else
+        (void)n;
+        ::operator delete(p);
+#endif
+      }
+    }
+
+#if __cplusplus >= 201103L && !defined(GOOGLE_PROTOBUF_OS_APPLE) && \
+    !defined(GOOGLE_PROTOBUF_OS_NACL) &&                            \
+    !defined(GOOGLE_PROTOBUF_OS_EMSCRIPTEN)
+    template<class NodeType, class... Args>
+    void construct(NodeType* p, Args&&... args) {
+      // Clang 3.6 doesn't compile static casting to void* directly. (Issue
+      // #1266) According C++ standard 5.2.9/1: "The static_cast operator shall
+      // not cast away constness". So first the maybe const pointer is casted to
+      // const void* and after the const void* is const casted.
+      new (const_cast<void*>(static_cast<const void*>(p)))
+          NodeType(std::forward<Args>(args)...);
+    }
+
+    template<class NodeType>
+    void destroy(NodeType* p) {
+      p->~NodeType();
+    }
+#else
+    void construct(pointer p, const_reference t) { new (p) value_type(t); }
+
+    void destroy(pointer p) { p->~value_type(); }
+#endif
+
+    template <typename X>
+    struct rebind {
+      typedef MapAllocator<X> other;
+    };
+
+    template <typename X>
+    bool operator==(const MapAllocator<X>& other) const {
+      return arena_ == other.arena_;
+    }
+
+    template <typename X>
+    bool operator!=(const MapAllocator<X>& other) const {
+      return arena_ != other.arena_;
+    }
+
+    // To support Visual Studio 2008
+    size_type max_size() const {
+      // parentheses around (std::...:max) prevents macro warning of max()
+      return (std::numeric_limits<size_type>::max)();
+    }
+
+    // To support gcc-4.4, which does not properly
+    // support templated friend classes
+    Arena* arena() const {
+      return arena_;
+    }
+
+   private:
+    typedef void DestructorSkippable_;
+    Arena* const arena_;
+  };
+
+  // InnerMap's key type is Key and its value type is value_type*.  We use a
+  // custom class here and for Node, below, to ensure that k_ is at offset 0,
+  // allowing safe conversion from pointer to Node to pointer to Key, and vice
+  // versa when appropriate.
+  class KeyValuePair {
+   public:
+    KeyValuePair(const Key& k, value_type* v) : k_(k), v_(v) {}
+
+    const Key& key() const { return k_; }
+    Key& key() { return k_; }
+    value_type* value() const { return v_; }
+    value_type*& value() { return v_; }
+
+   private:
+    Key k_;
+    value_type* v_;
+  };
+
+  typedef MapAllocator<KeyValuePair> Allocator;
+
+  // InnerMap is a generic hash-based map.  It doesn't contain any
+  // protocol-buffer-specific logic.  It is a chaining hash map with the
+  // additional feature that some buckets can be converted to use an ordered
+  // container.  This ensures O(lg n) bounds on find, insert, and erase, while
+  // avoiding the overheads of ordered containers most of the time.
+  //
+  // The implementation doesn't need the full generality of unordered_map,
+  // and it doesn't have it.  More bells and whistles can be added as needed.
+  // Some implementation details:
+  // 1. The hash function has type hasher and the equality function
+  //    equal_to<Key>.  We inherit from hasher to save space
+  //    (empty-base-class optimization).
+  // 2. The number of buckets is a power of two.
+  // 3. Buckets are converted to trees in pairs: if we convert bucket b then
+  //    buckets b and b^1 will share a tree.  Invariant: buckets b and b^1 have
+  //    the same non-NULL value iff they are sharing a tree.  (An alternative
+  //    implementation strategy would be to have a tag bit per bucket.)
+  // 4. As is typical for hash_map and such, the Keys and Values are always
+  //    stored in linked list nodes.  Pointers to elements are never invalidated
+  //    until the element is deleted.
+  // 5. The trees' payload type is pointer to linked-list node.  Tree-converting
+  //    a bucket doesn't copy Key-Value pairs.
+  // 6. Once we've tree-converted a bucket, it is never converted back. However,
+  //    the items a tree contains may wind up assigned to trees or lists upon a
+  //    rehash.
+  // 7. The code requires no C++ features from C++11 or later.
+  // 8. Mutations to a map do not invalidate the map's iterators, pointers to
+  //    elements, or references to elements.
+  // 9. Except for erase(iterator), any non-const method can reorder iterators.
+  class InnerMap : private hasher {
+   public:
+    typedef value_type* Value;
+
+    InnerMap(size_type n, hasher h, Allocator alloc)
+        : hasher(h),
+          num_elements_(0),
+          seed_(Seed()),
+          table_(NULL),
+          alloc_(alloc) {
+      n = TableSize(n);
+      table_ = CreateEmptyTable(n);
+      num_buckets_ = index_of_first_non_null_ = n;
+    }
+
+    ~InnerMap() {
+      if (table_ != NULL) {
+        clear();
+        Dealloc<void*>(table_, num_buckets_);
+      }
+    }
+
+   private:
+    enum { kMinTableSize = 8 };
+
+    // Linked-list nodes, as one would expect for a chaining hash table.
+    struct Node {
+      KeyValuePair kv;
+      Node* next;
+    };
+
+    // This is safe only if the given pointer is known to point to a Key that is
+    // part of a Node.
+    static Node* NodePtrFromKeyPtr(Key* k) {
+      return reinterpret_cast<Node*>(k);
+    }
+
+    static Key* KeyPtrFromNodePtr(Node* node) { return &node->kv.key(); }
+
+    // Trees.  The payload type is pointer to Key, so that we can query the tree
+    // with Keys that are not in any particular data structure.  When we insert,
+    // though, the pointer is always pointing to a Key that is inside a Node.
+    struct KeyCompare {
+      bool operator()(const Key* n0, const Key* n1) const { return *n0 < *n1; }
+    };
+    typedef typename Allocator::template rebind<Key*>::other KeyPtrAllocator;
+    typedef std::set<Key*, KeyCompare, KeyPtrAllocator> Tree;
+    typedef typename Tree::iterator TreeIterator;
+
+    // iterator and const_iterator are instantiations of iterator_base.
+    template <typename KeyValueType>
+    struct iterator_base {
+      typedef KeyValueType& reference;
+      typedef KeyValueType* pointer;
+
+      // Invariants:
+      // node_ is always correct. This is handy because the most common
+      // operations are operator* and operator-> and they only use node_.
+      // When node_ is set to a non-NULL value, all the other non-const fields
+      // are updated to be correct also, but those fields can become stale
+      // if the underlying map is modified.  When those fields are needed they
+      // are rechecked, and updated if necessary.
+      iterator_base() : node_(NULL), m_(NULL), bucket_index_(0) {}
+
+      explicit iterator_base(const InnerMap* m) : m_(m) {
+        SearchFrom(m->index_of_first_non_null_);
+      }
+
+      // Any iterator_base can convert to any other.  This is overkill, and we
+      // rely on the enclosing class to use it wisely.  The standard "iterator
+      // can convert to const_iterator" is OK but the reverse direction is not.
+      template <typename U>
+      explicit iterator_base(const iterator_base<U>& it)
+          : node_(it.node_), m_(it.m_), bucket_index_(it.bucket_index_) {}
+
+      iterator_base(Node* n, const InnerMap* m, size_type index)
+          : node_(n), m_(m), bucket_index_(index) {}
+
+      iterator_base(TreeIterator tree_it, const InnerMap* m, size_type index)
+          : node_(NodePtrFromKeyPtr(*tree_it)), m_(m), bucket_index_(index) {
+        // Invariant: iterators that use buckets with trees have an even
+        // bucket_index_.
+        GOOGLE_DCHECK_EQ(bucket_index_ % 2, 0);
+      }
+
+      // Advance through buckets, looking for the first that isn't empty.
+      // If nothing non-empty is found then leave node_ == NULL.
+      void SearchFrom(size_type start_bucket) {
+        GOOGLE_DCHECK(m_->index_of_first_non_null_ == m_->num_buckets_ ||
+               m_->table_[m_->index_of_first_non_null_] != NULL);
+        node_ = NULL;
+        for (bucket_index_ = start_bucket; bucket_index_ < m_->num_buckets_;
+             bucket_index_++) {
+          if (m_->TableEntryIsNonEmptyList(bucket_index_)) {
+            node_ = static_cast<Node*>(m_->table_[bucket_index_]);
+            break;
+          } else if (m_->TableEntryIsTree(bucket_index_)) {
+            Tree* tree = static_cast<Tree*>(m_->table_[bucket_index_]);
+            GOOGLE_DCHECK(!tree->empty());
+            node_ = NodePtrFromKeyPtr(*tree->begin());
+            break;
+          }
+        }
+      }
+
+      reference operator*() const { return node_->kv; }
+      pointer operator->() const { return &(operator*()); }
+
+      friend bool operator==(const iterator_base& a, const iterator_base& b) {
+        return a.node_ == b.node_;
+      }
+      friend bool operator!=(const iterator_base& a, const iterator_base& b) {
+        return a.node_ != b.node_;
+      }
+
+      iterator_base& operator++() {
+        if (node_->next == NULL) {
+          TreeIterator tree_it;
+          const bool is_list = revalidate_if_necessary(&tree_it);
+          if (is_list) {
+            SearchFrom(bucket_index_ + 1);
+          } else {
+            GOOGLE_DCHECK_EQ(bucket_index_ & 1, 0);
+            Tree* tree = static_cast<Tree*>(m_->table_[bucket_index_]);
+            if (++tree_it == tree->end()) {
+              SearchFrom(bucket_index_ + 2);
+            } else {
+              node_ = NodePtrFromKeyPtr(*tree_it);
+            }
+          }
+        } else {
+          node_ = node_->next;
+        }
+        return *this;
+      }
+
+      iterator_base operator++(int /* unused */) {
+        iterator_base tmp = *this;
+        ++*this;
+        return tmp;
+      }
+
+      // Assumes node_ and m_ are correct and non-NULL, but other fields may be
+      // stale.  Fix them as needed.  Then return true iff node_ points to a
+      // Node in a list.  If false is returned then *it is modified to be
+      // a valid iterator for node_.
+      bool revalidate_if_necessary(TreeIterator* it) {
+        GOOGLE_DCHECK(node_ != NULL && m_ != NULL);
+        // Force bucket_index_ to be in range.
+        bucket_index_ &= (m_->num_buckets_ - 1);
+        // Common case: the bucket we think is relevant points to node_.
+        if (m_->table_[bucket_index_] == static_cast<void*>(node_))
+          return true;
+        // Less common: the bucket is a linked list with node_ somewhere in it,
+        // but not at the head.
+        if (m_->TableEntryIsNonEmptyList(bucket_index_)) {
+          Node* l = static_cast<Node*>(m_->table_[bucket_index_]);
+          while ((l = l->next) != NULL) {
+            if (l == node_) {
+              return true;
+            }
+          }
+        }
+        // Well, bucket_index_ still might be correct, but probably
+        // not.  Revalidate just to be sure.  This case is rare enough that we
+        // don't worry about potential optimizations, such as having a custom
+        // find-like method that compares Node* instead of const Key&.
+        iterator_base i(m_->find(*KeyPtrFromNodePtr(node_), it));
+        bucket_index_ = i.bucket_index_;
+        return m_->TableEntryIsList(bucket_index_);
+      }
+
+      Node* node_;
+      const InnerMap* m_;
+      size_type bucket_index_;
+    };
+
+   public:
+    typedef iterator_base<KeyValuePair> iterator;
+    typedef iterator_base<const KeyValuePair> const_iterator;
+
+    iterator begin() { return iterator(this); }
+    iterator end() { return iterator(); }
+    const_iterator begin() const { return const_iterator(this); }
+    const_iterator end() const { return const_iterator(); }
+
+    void clear() {
+      for (size_type b = 0; b < num_buckets_; b++) {
+        if (TableEntryIsNonEmptyList(b)) {
+          Node* node = static_cast<Node*>(table_[b]);
+          table_[b] = NULL;
+          do {
+            Node* next = node->next;
+            DestroyNode(node);
+            node = next;
+          } while (node != NULL);
+        } else if (TableEntryIsTree(b)) {
+          Tree* tree = static_cast<Tree*>(table_[b]);
+          GOOGLE_DCHECK(table_[b] == table_[b + 1] && (b & 1) == 0);
+          table_[b] = table_[b + 1] = NULL;
+          typename Tree::iterator tree_it = tree->begin();
+          do {
+            Node* node = NodePtrFromKeyPtr(*tree_it);
+            typename Tree::iterator next = tree_it;
+            ++next;
+            tree->erase(tree_it);
+            DestroyNode(node);
+            tree_it = next;
+          } while (tree_it != tree->end());
+          DestroyTree(tree);
+          b++;
+        }
+      }
+      num_elements_ = 0;
+      index_of_first_non_null_ = num_buckets_;
+    }
+
+    const hasher& hash_function() const { return *this; }
+
+    static size_type max_size() {
+      return static_cast<size_type>(1) << (sizeof(void**) >= 8 ? 60 : 28);
+    }
+    size_type size() const { return num_elements_; }
+    bool empty() const { return size() == 0; }
+
+    iterator find(const Key& k) { return iterator(FindHelper(k).first); }
+    const_iterator find(const Key& k) const { return find(k, NULL); }
+
+    // In traditional C++ style, this performs "insert if not present."
+    std::pair<iterator, bool> insert(const KeyValuePair& kv) {
+      std::pair<const_iterator, size_type> p = FindHelper(kv.key());
+      // Case 1: key was already present.
+      if (p.first.node_ != NULL)
+        return std::make_pair(iterator(p.first), false);
+      // Case 2: insert.
+      if (ResizeIfLoadIsOutOfRange(num_elements_ + 1)) {
+        p = FindHelper(kv.key());
+      }
+      const size_type b = p.second;  // bucket number
+      Node* node = Alloc<Node>(1);
+      alloc_.construct(&node->kv, kv);
+      iterator result = InsertUnique(b, node);
+      ++num_elements_;
+      return std::make_pair(result, true);
+    }
+
+    // The same, but if an insertion is necessary then the value portion of the
+    // inserted key-value pair is left uninitialized.
+    std::pair<iterator, bool> insert(const Key& k) {
+      std::pair<const_iterator, size_type> p = FindHelper(k);
+      // Case 1: key was already present.
+      if (p.first.node_ != NULL)
+        return std::make_pair(iterator(p.first), false);
+      // Case 2: insert.
+      if (ResizeIfLoadIsOutOfRange(num_elements_ + 1)) {
+        p = FindHelper(k);
+      }
+      const size_type b = p.second;  // bucket number
+      Node* node = Alloc<Node>(1);
+      typedef typename Allocator::template rebind<Key>::other KeyAllocator;
+      KeyAllocator(alloc_).construct(&node->kv.key(), k);
+      iterator result = InsertUnique(b, node);
+      ++num_elements_;
+      return std::make_pair(result, true);
+    }
+
+    Value& operator[](const Key& k) {
+      KeyValuePair kv(k, Value());
+      return insert(kv).first->value();
+    }
+
+    void erase(iterator it) {
+      GOOGLE_DCHECK_EQ(it.m_, this);
+      typename Tree::iterator tree_it;
+      const bool is_list = it.revalidate_if_necessary(&tree_it);
+      size_type b = it.bucket_index_;
+      Node* const item = it.node_;
+      if (is_list) {
+        GOOGLE_DCHECK(TableEntryIsNonEmptyList(b));
+        Node* head = static_cast<Node*>(table_[b]);
+        head = EraseFromLinkedList(item, head);
+        table_[b] = static_cast<void*>(head);
+      } else {
+        GOOGLE_DCHECK(TableEntryIsTree(b));
+        Tree* tree = static_cast<Tree*>(table_[b]);
+        tree->erase(*tree_it);
+        if (tree->empty()) {
+          // Force b to be the minimum of b and b ^ 1.  This is important
+          // only because we want index_of_first_non_null_ to be correct.
+          b &= ~static_cast<size_type>(1);
+          DestroyTree(tree);
+          table_[b] = table_[b + 1] = NULL;
+        }
+      }
+      DestroyNode(item);
+      --num_elements_;
+      if (GOOGLE_PREDICT_FALSE(b == index_of_first_non_null_)) {
+        while (index_of_first_non_null_ < num_buckets_ &&
+               table_[index_of_first_non_null_] == NULL) {
+          ++index_of_first_non_null_;
+        }
+      }
+    }
+
+   private:
+    const_iterator find(const Key& k, TreeIterator* it) const {
+      return FindHelper(k, it).first;
+    }
+    std::pair<const_iterator, size_type> FindHelper(const Key& k) const {
+      return FindHelper(k, NULL);
+    }
+    std::pair<const_iterator, size_type> FindHelper(const Key& k,
+                                                    TreeIterator* it) const {
+      size_type b = BucketNumber(k);
+      if (TableEntryIsNonEmptyList(b)) {
+        Node* node = static_cast<Node*>(table_[b]);
+        do {
+          if (IsMatch(*KeyPtrFromNodePtr(node), k)) {
+            return std::make_pair(const_iterator(node, this, b), b);
+          } else {
+            node = node->next;
+          }
+        } while (node != NULL);
+      } else if (TableEntryIsTree(b)) {
+        GOOGLE_DCHECK_EQ(table_[b], table_[b ^ 1]);
+        b &= ~static_cast<size_t>(1);
+        Tree* tree = static_cast<Tree*>(table_[b]);
+        Key* key = const_cast<Key*>(&k);
+        typename Tree::iterator tree_it = tree->find(key);
+        if (tree_it != tree->end()) {
+          if (it != NULL) *it = tree_it;
+          return std::make_pair(const_iterator(tree_it, this, b), b);
+        }
+      }
+      return std::make_pair(end(), b);
+    }
+
+    // Insert the given Node in bucket b.  If that would make bucket b too big,
+    // and bucket b is not a tree, create a tree for buckets b and b^1 to share.
+    // Requires count(*KeyPtrFromNodePtr(node)) == 0 and that b is the correct
+    // bucket.  num_elements_ is not modified.
+    iterator InsertUnique(size_type b, Node* node) {
+      GOOGLE_DCHECK(index_of_first_non_null_ == num_buckets_ ||
+             table_[index_of_first_non_null_] != NULL);
+      // In practice, the code that led to this point may have already
+      // determined whether we are inserting into an empty list, a short list,
+      // or whatever.  But it's probably cheap enough to recompute that here;
+      // it's likely that we're inserting into an empty or short list.
+      iterator result;
+      GOOGLE_DCHECK(find(*KeyPtrFromNodePtr(node)) == end());
+      if (TableEntryIsEmpty(b)) {
+        result = InsertUniqueInList(b, node);
+      } else if (TableEntryIsNonEmptyList(b)) {
+        if (GOOGLE_PREDICT_FALSE(TableEntryIsTooLong(b))) {
+          TreeConvert(b);
+          result = InsertUniqueInTree(b, node);
+          GOOGLE_DCHECK_EQ(result.bucket_index_, b & ~static_cast<size_type>(1));
+        } else {
+          // Insert into a pre-existing list.  This case cannot modify
+          // index_of_first_non_null_, so we skip the code to update it.
+          return InsertUniqueInList(b, node);
+        }
+      } else {
+        // Insert into a pre-existing tree.  This case cannot modify
+        // index_of_first_non_null_, so we skip the code to update it.
+        return InsertUniqueInTree(b, node);
+      }
+      // parentheses around (std::min) prevents macro expansion of min(...)
+      index_of_first_non_null_ =
+          (std::min)(index_of_first_non_null_, result.bucket_index_);
+      return result;
+    }
+
+    // Helper for InsertUnique.  Handles the case where bucket b is a
+    // not-too-long linked list.
+    iterator InsertUniqueInList(size_type b, Node* node) {
+      node->next = static_cast<Node*>(table_[b]);
+      table_[b] = static_cast<void*>(node);
+      return iterator(node, this, b);
+    }
+
+    // Helper for InsertUnique.  Handles the case where bucket b points to a
+    // Tree.
+    iterator InsertUniqueInTree(size_type b, Node* node) {
+      GOOGLE_DCHECK_EQ(table_[b], table_[b ^ 1]);
+      // Maintain the invariant that node->next is NULL for all Nodes in Trees.
+      node->next = NULL;
+      return iterator(static_cast<Tree*>(table_[b])
+                      ->insert(KeyPtrFromNodePtr(node))
+                      .first,
+                      this, b & ~static_cast<size_t>(1));
+    }
+
+    // Returns whether it did resize.  Currently this is only used when
+    // num_elements_ increases, though it could be used in other situations.
+    // It checks for load too low as well as load too high: because any number
+    // of erases can occur between inserts, the load could be as low as 0 here.
+    // Resizing to a lower size is not always helpful, but failing to do so can
+    // destroy the expected big-O bounds for some operations. By having the
+    // policy that sometimes we resize down as well as up, clients can easily
+    // keep O(size()) = O(number of buckets) if they want that.
+    bool ResizeIfLoadIsOutOfRange(size_type new_size) {
+      const size_type kMaxMapLoadTimes16 = 12;  // controls RAM vs CPU tradeoff
+      const size_type hi_cutoff = num_buckets_ * kMaxMapLoadTimes16 / 16;
+      const size_type lo_cutoff = hi_cutoff / 4;
+      // We don't care how many elements are in trees.  If a lot are,
+      // we may resize even though there are many empty buckets.  In
+      // practice, this seems fine.
+      if (GOOGLE_PREDICT_FALSE(new_size >= hi_cutoff)) {
+        if (num_buckets_ <= max_size() / 2) {
+          Resize(num_buckets_ * 2);
+          return true;
+        }
+      } else if (GOOGLE_PREDICT_FALSE(new_size <= lo_cutoff &&
+                               num_buckets_ > kMinTableSize)) {
+        size_type lg2_of_size_reduction_factor = 1;
+        // It's possible we want to shrink a lot here... size() could even be 0.
+        // So, estimate how much to shrink by making sure we don't shrink so
+        // much that we would need to grow the table after a few inserts.
+        const size_type hypothetical_size = new_size * 5 / 4 + 1;
+        while ((hypothetical_size << lg2_of_size_reduction_factor) <
+               hi_cutoff) {
+          ++lg2_of_size_reduction_factor;
+        }
+        size_type new_num_buckets = std::max<size_type>(
+            kMinTableSize, num_buckets_ >> lg2_of_size_reduction_factor);
+        if (new_num_buckets != num_buckets_) {
+          Resize(new_num_buckets);
+          return true;
+        }
+      }
+      return false;
+    }
+
+    // Resize to the given number of buckets.
+    void Resize(size_t new_num_buckets) {
+      GOOGLE_DCHECK_GE(new_num_buckets, kMinTableSize);
+      void** const old_table = table_;
+      const size_type old_table_size = num_buckets_;
+      num_buckets_ = new_num_buckets;
+      table_ = CreateEmptyTable(num_buckets_);
+      const size_type start = index_of_first_non_null_;
+      index_of_first_non_null_ = num_buckets_;
+      for (size_type i = start; i < old_table_size; i++) {
+        if (TableEntryIsNonEmptyList(old_table, i)) {
+          TransferList(old_table, i);
+        } else if (TableEntryIsTree(old_table, i)) {
+          TransferTree(old_table, i++);
+        }
+      }
+      Dealloc<void*>(old_table, old_table_size);
+    }
+
+    void TransferList(void* const* table, size_type index) {
+      Node* node = static_cast<Node*>(table[index]);
+      do {
+        Node* next = node->next;
+        InsertUnique(BucketNumber(*KeyPtrFromNodePtr(node)), node);
+        node = next;
+      } while (node != NULL);
+    }
+
+    void TransferTree(void* const* table, size_type index) {
+      Tree* tree = static_cast<Tree*>(table[index]);
+      typename Tree::iterator tree_it = tree->begin();
+      do {
+        Node* node = NodePtrFromKeyPtr(*tree_it);
+        InsertUnique(BucketNumber(**tree_it), node);
+      } while (++tree_it != tree->end());
+      DestroyTree(tree);
+    }
+
+    Node* EraseFromLinkedList(Node* item, Node* head) {
+      if (head == item) {
+        return head->next;
+      } else {
+        head->next = EraseFromLinkedList(item, head->next);
+        return head;
+      }
+    }
+
+    bool TableEntryIsEmpty(size_type b) const {
+      return TableEntryIsEmpty(table_, b);
+    }
+    bool TableEntryIsNonEmptyList(size_type b) const {
+      return TableEntryIsNonEmptyList(table_, b);
+    }
+    bool TableEntryIsTree(size_type b) const {
+      return TableEntryIsTree(table_, b);
+    }
+    bool TableEntryIsList(size_type b) const {
+      return TableEntryIsList(table_, b);
+    }
+    static bool TableEntryIsEmpty(void* const* table, size_type b) {
+      return table[b] == NULL;
+    }
+    static bool TableEntryIsNonEmptyList(void* const* table, size_type b) {
+      return table[b] != NULL && table[b] != table[b ^ 1];
+    }
+    static bool TableEntryIsTree(void* const* table, size_type b) {
+      return !TableEntryIsEmpty(table, b) &&
+          !TableEntryIsNonEmptyList(table, b);
+    }
+    static bool TableEntryIsList(void* const* table, size_type b) {
+      return !TableEntryIsTree(table, b);
+    }
+
+    void TreeConvert(size_type b) {
+      GOOGLE_DCHECK(!TableEntryIsTree(b) && !TableEntryIsTree(b ^ 1));
+      typename Allocator::template rebind<Tree>::other tree_allocator(alloc_);
+      Tree* tree = tree_allocator.allocate(1);
+      // We want to use the three-arg form of construct, if it exists, but we
+      // create a temporary and use the two-arg construct that's known to exist.
+      // It's clunky, but the compiler should be able to generate more-or-less
+      // the same code.
+      tree_allocator.construct(tree,
+                               Tree(KeyCompare(), KeyPtrAllocator(alloc_)));
+      // Now the tree is ready to use.
+      size_type count = CopyListToTree(b, tree) + CopyListToTree(b ^ 1, tree);
+      GOOGLE_DCHECK_EQ(count, tree->size());
+      table_[b] = table_[b ^ 1] = static_cast<void*>(tree);
+    }
+
+    // Copy a linked list in the given bucket to a tree.
+    // Returns the number of things it copied.
+    size_type CopyListToTree(size_type b, Tree* tree) {
+      size_type count = 0;
+      Node* node = static_cast<Node*>(table_[b]);
+      while (node != NULL) {
+        tree->insert(KeyPtrFromNodePtr(node));
+        ++count;
+        Node* next = node->next;
+        node->next = NULL;
+        node = next;
+      }
+      return count;
+    }
+
+    // Return whether table_[b] is a linked list that seems awfully long.
+    // Requires table_[b] to point to a non-empty linked list.
+    bool TableEntryIsTooLong(size_type b) {
+      const size_type kMaxLength = 8;
+      size_type count = 0;
+      Node* node = static_cast<Node*>(table_[b]);
+      do {
+        ++count;
+        node = node->next;
+      } while (node != NULL);
+      // Invariant: no linked list ever is more than kMaxLength in length.
+      GOOGLE_DCHECK_LE(count, kMaxLength);
+      return count >= kMaxLength;
+    }
+
+    size_type BucketNumber(const Key& k) const {
+      // We inherit from hasher, so one-arg operator() provides a hash function.
+      size_type h = (*const_cast<InnerMap*>(this))(k);
+      return (h + seed_) & (num_buckets_ - 1);
+    }
+
+    bool IsMatch(const Key& k0, const Key& k1) const {
+      return std::equal_to<Key>()(k0, k1);
+    }
+
+    // Return a power of two no less than max(kMinTableSize, n).
+    // Assumes either n < kMinTableSize or n is a power of two.
+    size_type TableSize(size_type n) {
+      return n < static_cast<size_type>(kMinTableSize)
+                 ? static_cast<size_type>(kMinTableSize)
+                 : n;
+    }
+
+    // Use alloc_ to allocate an array of n objects of type U.
+    template <typename U>
+    U* Alloc(size_type n) {
+      typedef typename Allocator::template rebind<U>::other alloc_type;
+      return alloc_type(alloc_).allocate(n);
+    }
+
+    // Use alloc_ to deallocate an array of n objects of type U.
+    template <typename U>
+    void Dealloc(U* t, size_type n) {
+      typedef typename Allocator::template rebind<U>::other alloc_type;
+      alloc_type(alloc_).deallocate(t, n);
+    }
+
+    void DestroyNode(Node* node) {
+      alloc_.destroy(&node->kv);
+      Dealloc<Node>(node, 1);
+    }
+
+    void DestroyTree(Tree* tree) {
+      typename Allocator::template rebind<Tree>::other tree_allocator(alloc_);
+      tree_allocator.destroy(tree);
+      tree_allocator.deallocate(tree, 1);
+    }
+
+    void** CreateEmptyTable(size_type n) {
+      GOOGLE_DCHECK(n >= kMinTableSize);
+      GOOGLE_DCHECK_EQ(n & (n - 1), 0);
+      void** result = Alloc<void*>(n);
+      memset(result, 0, n * sizeof(result[0]));
+      return result;
+    }
+
+    // Return a randomish value.
+    size_type Seed() const {
+      size_type s = static_cast<size_type>(reinterpret_cast<uintptr_t>(this));
+#if defined(__x86_64__) && defined(__GNUC__)
+      uint32 hi, lo;
+      asm("rdtsc" : "=a" (lo), "=d" (hi));
+      s += ((static_cast<uint64>(hi) << 32) | lo);
+#endif
+      return s;
+    }
+
+    size_type num_elements_;
+    size_type num_buckets_;
+    size_type seed_;
+    size_type index_of_first_non_null_;
+    void** table_;  // an array with num_buckets_ entries
+    Allocator alloc_;
+    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(InnerMap);
+  };  // end of class InnerMap
+
+ public:
+  // Iterators
+  class const_iterator {
+    typedef typename InnerMap::const_iterator InnerIt;
+
+   public:
+    typedef std::forward_iterator_tag iterator_category;
+    typedef typename Map::value_type value_type;
+    typedef ptrdiff_t difference_type;
+    typedef const value_type* pointer;
+    typedef const value_type& reference;
+
+    const_iterator() {}
+    explicit const_iterator(const InnerIt& it) : it_(it) {}
+
+    const_reference operator*() const {
+      return *it_->value();
+    }
+    const_pointer operator->() const { return &(operator*()); }
+
+    const_iterator& operator++() {
+      ++it_;
+      return *this;
+    }
+    const_iterator operator++(int) { return const_iterator(it_++); }
+
+    friend bool operator==(const const_iterator& a, const const_iterator& b) {
+      return a.it_ == b.it_;
+    }
+    friend bool operator!=(const const_iterator& a, const const_iterator& b) {
+      return !(a == b);
+    }
+
+   private:
+    InnerIt it_;
+  };
+
+  class iterator {
+    typedef typename InnerMap::iterator InnerIt;
+
+   public:
+    typedef std::forward_iterator_tag iterator_category;
+    typedef typename Map::value_type value_type;
+    typedef ptrdiff_t difference_type;
+    typedef value_type* pointer;
+    typedef value_type& reference;
+
+    iterator() {}
+    explicit iterator(const InnerIt& it) : it_(it) {}
+
+    reference operator*() const { return *it_->value(); }
+    pointer operator->() const { return &(operator*()); }
+
+    iterator& operator++() {
+      ++it_;
+      return *this;
+    }
+    iterator operator++(int) { return iterator(it_++); }
+
+    // Allow implicit conversion to const_iterator.
+    operator const_iterator() const {
+      return const_iterator(typename InnerMap::const_iterator(it_));
+    }
+
+    friend bool operator==(const iterator& a, const iterator& b) {
+      return a.it_ == b.it_;
+    }
+    friend bool operator!=(const iterator& a, const iterator& b) {
+      return !(a == b);
+    }
+
+   private:
+    friend class Map;
+
+    InnerIt it_;
+  };
+
+  iterator begin() { return iterator(elements_->begin()); }
+  iterator end() { return iterator(elements_->end()); }
+  const_iterator begin() const {
+    return const_iterator(iterator(elements_->begin()));
+  }
+  const_iterator end() const {
+    return const_iterator(iterator(elements_->end()));
+  }
+  const_iterator cbegin() const { return begin(); }
+  const_iterator cend() const { return end(); }
+
+  // Capacity
+  size_type size() const { return elements_->size(); }
+  bool empty() const { return size() == 0; }
+
+  // Element access
+  T& operator[](const key_type& key) {
+    value_type** value =  &(*elements_)[key];
+    if (*value == NULL) {
+      *value = CreateValueTypeInternal(key);
+      internal::MapValueInitializer<google::protobuf::is_proto_enum<T>::value,
+                                    T>::Initialize((*value)->second,
+                                                   default_enum_value_);
+    }
+    return (*value)->second;
+  }
+  const T& at(const key_type& key) const {
+    const_iterator it = find(key);
+    GOOGLE_CHECK(it != end()) << "key not found: " << key;
+    return it->second;
+  }
+  T& at(const key_type& key) {
+    iterator it = find(key);
+    GOOGLE_CHECK(it != end()) << "key not found: " << key;
+    return it->second;
+  }
+
+  // Lookup
+  size_type count(const key_type& key) const {
+    const_iterator it = find(key);
+    GOOGLE_DCHECK(it == end() || key == it->first);
+    return it == end() ? 0 : 1;
+  }
+  const_iterator find(const key_type& key) const {
+    return const_iterator(iterator(elements_->find(key)));
+  }
+  iterator find(const key_type& key) { return iterator(elements_->find(key)); }
+  std::pair<const_iterator, const_iterator> equal_range(
+      const key_type& key) const {
+    const_iterator it = find(key);
+    if (it == end()) {
+      return std::pair<const_iterator, const_iterator>(it, it);
+    } else {
+      const_iterator begin = it++;
+      return std::pair<const_iterator, const_iterator>(begin, it);
+    }
+  }
+  std::pair<iterator, iterator> equal_range(const key_type& key) {
+    iterator it = find(key);
+    if (it == end()) {
+      return std::pair<iterator, iterator>(it, it);
+    } else {
+      iterator begin = it++;
+      return std::pair<iterator, iterator>(begin, it);
+    }
+  }
+
+  // insert
+  std::pair<iterator, bool> insert(const value_type& value) {
+    std::pair<typename InnerMap::iterator, bool> p =
+        elements_->insert(value.first);
+    if (p.second) {
+      p.first->value() = CreateValueTypeInternal(value);
+    }
+    return std::pair<iterator, bool>(iterator(p.first), p.second);
+  }
+  template <class InputIt>
+  void insert(InputIt first, InputIt last) {
+    for (InputIt it = first; it != last; ++it) {
+      iterator exist_it = find(it->first);
+      if (exist_it == end()) {
+        operator[](it->first) = it->second;
+      }
+    }
+  }
+
+  // Erase and clear
+  size_type erase(const key_type& key) {
+    iterator it = find(key);
+    if (it == end()) {
+      return 0;
+    } else {
+      erase(it);
+      return 1;
+    }
+  }
+  iterator erase(iterator pos) {
+    if (arena_ == NULL) delete pos.operator->();
+    iterator i = pos++;
+    elements_->erase(i.it_);
+    return pos;
+  }
+  void erase(iterator first, iterator last) {
+    while (first != last) {
+      first = erase(first);
+    }
+  }
+  void clear() { erase(begin(), end()); }
+
+  // Assign
+  Map& operator=(const Map& other) {
+    if (this != &other) {
+      clear();
+      insert(other.begin(), other.end());
+    }
+    return *this;
+  }
+
+  void swap(Map& other) {
+    if (arena_ == other.arena_) {
+      std::swap(default_enum_value_, other.default_enum_value_);
+      std::swap(elements_, other.elements_);
+    } else {
+      // TODO(zuguang): optimize this. The temporary copy can be allocated
+      // in the same arena as the other message, and the "other = copy" can
+      // be replaced with the fast-path swap above.
+      Map copy = *this;
+      *this = other;
+      other = copy;
+    }
+  }
+
+  // Access to hasher.  Currently this returns a copy, but it may
+  // be modified to return a const reference in the future.
+  hasher hash_function() const { return elements_->hash_function(); }
+
+ private:
+  // Set default enum value only for proto2 map field whose value is enum type.
+  void SetDefaultEnumValue(int default_enum_value) {
+    default_enum_value_ = default_enum_value;
+  }
+
+  value_type* CreateValueTypeInternal(const Key& key) {
+    if (arena_ == NULL) {
+      return new value_type(key);
+    } else {
+      value_type* value = reinterpret_cast<value_type*>(
+          Arena::CreateArray<uint8>(arena_, sizeof(value_type)));
+      Arena::CreateInArenaStorage(const_cast<Key*>(&value->first), arena_);
+      Arena::CreateInArenaStorage(&value->second, arena_);
+      const_cast<Key&>(value->first) = key;
+      return value;
+    }
+  }
+
+  value_type* CreateValueTypeInternal(const value_type& value) {
+    if (arena_ == NULL) {
+      return new value_type(value);
+    } else {
+      value_type* p = reinterpret_cast<value_type*>(
+          Arena::CreateArray<uint8>(arena_, sizeof(value_type)));
+      Arena::CreateInArenaStorage(const_cast<Key*>(&p->first), arena_);
+      Arena::CreateInArenaStorage(&p->second, arena_);
+      const_cast<Key&>(p->first) = value.first;
+      p->second = value.second;
+      return p;
+    }
+  }
+
+  Arena* arena_;
+  int default_enum_value_;
+  InnerMap* elements_;
+
+  friend class ::google::protobuf::Arena;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  template <typename Derived, typename K, typename V,
+            internal::WireFormatLite::FieldType key_wire_type,
+            internal::WireFormatLite::FieldType value_wire_type,
+            int default_enum_value>
+  friend class internal::MapFieldLite;
+};
+
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_MAP_H__
diff --git a/kortex_api/include/google/protobuf/map_entry.h b/kortex_api/include/google/protobuf/map_entry.h
new file mode 100644
index 0000000000000000000000000000000000000000..801def97840d95953c7e1481ceedc9331858c84a
--- /dev/null
+++ b/kortex_api/include/google/protobuf/map_entry.h
@@ -0,0 +1,140 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_MAP_ENTRY_H__
+#define GOOGLE_PROTOBUF_MAP_ENTRY_H__
+
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/map_entry_lite.h>
+#include <google/protobuf/map_type_handler.h>
+#include <google/protobuf/metadata.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/unknown_field_set.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+
+namespace google {
+namespace protobuf {
+class Arena;
+namespace internal {
+template <typename Derived, typename Key, typename Value,
+          WireFormatLite::FieldType kKeyFieldType,
+          WireFormatLite::FieldType kValueFieldType, int default_enum_value>
+class MapField;
+}
+}
+
+namespace protobuf {
+namespace internal {
+
+// MapEntry is the returned google::protobuf::Message when calling AddMessage of
+// google::protobuf::Reflection. In order to let it work with generated message
+// reflection, its in-memory type is the same as generated message with the same
+// fields. However, in order to decide the in-memory type of key/value, we need
+// to know both their cpp type in generated api and proto type. In
+// implementation, all in-memory types have related wire format functions to
+// support except ArenaStringPtr. Therefore, we need to define another type with
+// supporting wire format functions. Since this type is only used as return type
+// of MapEntry accessors, it's named MapEntry accessor type.
+//
+// cpp type:               the type visible to users in public API.
+// proto type:             WireFormatLite::FieldType of the field.
+// in-memory type:         type of the data member used to stored this field.
+// MapEntry accessor type: type used in MapEntry getters/mutators to access the
+//                         field.
+//
+// cpp type | proto type  | in-memory type | MapEntry accessor type
+// int32      TYPE_INT32    int32            int32
+// int32      TYPE_FIXED32  int32            int32
+// string     TYPE_STRING   ArenaStringPtr   string
+// FooEnum    TYPE_ENUM     int              int
+// FooMessage TYPE_MESSAGE  FooMessage*      FooMessage
+//
+// The in-memory types of primitive types can be inferred from its proto type,
+// while we need to explicitly specify the cpp type if proto type is
+// TYPE_MESSAGE to infer the in-memory type.  Moreover, default_enum_value is
+// used to initialize enum field in proto2.
+template <typename Derived, typename Key, typename Value,
+          WireFormatLite::FieldType kKeyFieldType,
+          WireFormatLite::FieldType kValueFieldType, int default_enum_value>
+class MapEntry
+    : public MapEntryImpl<Derived, Message, Key, Value, kKeyFieldType,
+                          kValueFieldType, default_enum_value> {
+ public:
+  MapEntry() : _internal_metadata_(NULL) {}
+  explicit MapEntry(Arena* arena)
+      : MapEntryImpl<Derived, Message, Key, Value, kKeyFieldType,
+                     kValueFieldType, default_enum_value>(arena),
+        _internal_metadata_(arena) {}
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+
+  InternalMetadataWithArena _internal_metadata_;
+
+ private:
+  friend class ::google::protobuf::Arena;
+  template <typename C, typename K, typename V,
+            WireFormatLite::FieldType k_wire_type, WireFormatLite::FieldType,
+            int default_enum>
+  friend class internal::MapField;
+  friend class internal::GeneratedMessageReflection;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MapEntry);
+};
+
+// Specialization for the full runtime
+template <typename Derived, typename Key, typename Value,
+          WireFormatLite::FieldType kKeyFieldType,
+          WireFormatLite::FieldType kValueFieldType, int default_enum_value>
+struct MapEntryHelper<MapEntry<Derived, Key, Value, kKeyFieldType,
+                               kValueFieldType, default_enum_value> >
+    : MapEntryHelper<MapEntryLite<Derived, Key, Value, kKeyFieldType,
+                                  kValueFieldType, default_enum_value> > {
+  explicit MapEntryHelper(const MapPair<Key, Value>& map_pair)
+      : MapEntryHelper<MapEntryLite<Derived, Key, Value, kKeyFieldType,
+                                    kValueFieldType, default_enum_value> >(
+            map_pair) {}
+};
+
+template <typename Derived, typename K, typename V,
+          WireFormatLite::FieldType key, WireFormatLite::FieldType value,
+          int default_enum>
+struct DeconstructMapEntry<MapEntry<Derived, K, V, key, value, default_enum> > {
+  typedef K Key;
+  typedef V Value;
+  static const WireFormatLite::FieldType kKeyFieldType = key;
+  static const WireFormatLite::FieldType kValueFieldType = value;
+  static const int default_enum_value = default_enum;
+};
+
+}  // namespace internal
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_MAP_ENTRY_H__
diff --git a/kortex_api/include/google/protobuf/map_entry_lite.h b/kortex_api/include/google/protobuf/map_entry_lite.h
new file mode 100644
index 0000000000000000000000000000000000000000..7c477c56ec314215d8086900c644066f14dc390a
--- /dev/null
+++ b/kortex_api/include/google/protobuf/map_entry_lite.h
@@ -0,0 +1,666 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_MAP_ENTRY_LITE_H__
+#define GOOGLE_PROTOBUF_MAP_ENTRY_LITE_H__
+
+#include <assert.h>
+
+#include <google/protobuf/arena.h>
+#include <google/protobuf/map.h>
+#include <google/protobuf/map_type_handler.h>
+#include <google/protobuf/stubs/port.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+
+namespace google {
+namespace protobuf {
+namespace internal {
+template <typename Derived, typename Key, typename Value,
+          WireFormatLite::FieldType kKeyFieldType,
+          WireFormatLite::FieldType kValueFieldType, int default_enum_value>
+class MapEntry;
+template <typename Derived, typename Key, typename Value,
+          WireFormatLite::FieldType kKeyFieldType,
+          WireFormatLite::FieldType kValueFieldType, int default_enum_value>
+class MapFieldLite;
+}  // namespace internal
+}  // namespace protobuf
+
+namespace protobuf {
+namespace internal {
+
+// MoveHelper::Move is used to set *dest.  It copies *src, or moves it (in
+// the C++11 sense), or swaps it. *src is left in a sane state for
+// subsequent destruction, but shouldn't be used for anything.
+template <bool is_enum, bool is_message, bool is_stringlike, typename T>
+struct MoveHelper {  // primitives
+  static void Move(T* src, T* dest) { *dest = *src; }
+};
+
+template <bool is_message, bool is_stringlike, typename T>
+struct MoveHelper<true, is_message, is_stringlike, T> {  // enums
+  static void Move(T* src, T* dest) { *dest = *src; }
+  // T is an enum here, so allow conversions to and from int.
+  static void Move(T* src, int* dest) { *dest = static_cast<int>(*src); }
+  static void Move(int* src, T* dest) { *dest = static_cast<T>(*src); }
+};
+
+template <bool is_stringlike, typename T>
+struct MoveHelper<false, true, is_stringlike, T> {  // messages
+  static void Move(T* src, T* dest) { dest->Swap(src); }
+};
+
+template <typename T>
+struct MoveHelper<false, false, true, T> {  // strings and similar
+  static void Move(T* src, T* dest) {
+#if __cplusplus >= 201103L
+    *dest = std::move(*src);
+#else
+    dest->swap(*src);
+#endif
+  }
+};
+
+// MapEntryImpl is used to implement parsing and serialization of map entries.
+// It uses Curious Recursive Template Pattern (CRTP) to provide the type of
+// the eventual code to the template code.
+template <typename Derived, typename Base, typename Key, typename Value,
+          WireFormatLite::FieldType kKeyFieldType,
+          WireFormatLite::FieldType kValueFieldType, int default_enum_value>
+class MapEntryImpl : public Base {
+ protected:
+  // Provide utilities to parse/serialize key/value.  Provide utilities to
+  // manipulate internal stored type.
+  typedef MapTypeHandler<kKeyFieldType, Key> KeyTypeHandler;
+  typedef MapTypeHandler<kValueFieldType, Value> ValueTypeHandler;
+
+  // Define internal memory layout. Strings and messages are stored as
+  // pointers, while other types are stored as values.
+  typedef typename KeyTypeHandler::TypeOnMemory KeyOnMemory;
+  typedef typename ValueTypeHandler::TypeOnMemory ValueOnMemory;
+
+  // Enum type cannot be used for MapTypeHandler::Read. Define a type
+  // which will replace Enum with int.
+  typedef typename KeyTypeHandler::MapEntryAccessorType KeyMapEntryAccessorType;
+  typedef typename ValueTypeHandler::MapEntryAccessorType
+      ValueMapEntryAccessorType;
+
+  // Constants for field number.
+  static const int kKeyFieldNumber = 1;
+  static const int kValueFieldNumber = 2;
+
+  // Constants for field tag.
+  static const uint8 kKeyTag = GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(
+      kKeyFieldNumber, KeyTypeHandler::kWireType);
+  static const uint8 kValueTag = GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(
+      kValueFieldNumber, ValueTypeHandler::kWireType);
+  static const size_t kTagSize = 1;
+
+ public:
+  // Work-around for a compiler bug (see repeated_field.h).
+  typedef void MapEntryHasMergeTypeTrait;
+  typedef Derived EntryType;
+  typedef Key EntryKeyType;
+  typedef Value EntryValueType;
+  static const WireFormatLite::FieldType kEntryKeyFieldType = kKeyFieldType;
+  static const WireFormatLite::FieldType kEntryValueFieldType = kValueFieldType;
+  static const int kEntryDefaultEnumValue = default_enum_value;
+
+  MapEntryImpl() : arena_(NULL) {
+    KeyTypeHandler::Initialize(&key_, NULL);
+    ValueTypeHandler::InitializeMaybeByDefaultEnum(&value_, default_enum_value,
+                                                   NULL);
+    _has_bits_[0] = 0;
+  }
+
+  explicit MapEntryImpl(Arena* arena) : arena_(arena) {
+    KeyTypeHandler::Initialize(&key_, arena);
+    ValueTypeHandler::InitializeMaybeByDefaultEnum(&value_, default_enum_value,
+                                                   arena);
+    _has_bits_[0] = 0;
+  }
+
+  ~MapEntryImpl() {
+    if (GetArenaNoVirtual() != NULL) return;
+    KeyTypeHandler::DeleteNoArena(key_);
+    ValueTypeHandler::DeleteNoArena(value_);
+  }
+
+  // accessors ======================================================
+
+  virtual inline const KeyMapEntryAccessorType& key() const {
+    return KeyTypeHandler::GetExternalReference(key_);
+  }
+  virtual inline const ValueMapEntryAccessorType& value() const {
+    return ValueTypeHandler::DefaultIfNotInitialized(
+        value_, Derived::internal_default_instance()->value_);
+  }
+  inline KeyMapEntryAccessorType* mutable_key() {
+    set_has_key();
+    return KeyTypeHandler::EnsureMutable(&key_, GetArenaNoVirtual());
+  }
+  inline ValueMapEntryAccessorType* mutable_value() {
+    set_has_value();
+    return ValueTypeHandler::EnsureMutable(&value_, GetArenaNoVirtual());
+  }
+
+  // implements MessageLite =========================================
+
+  // MapEntryImpl is for implementation only and this function isn't called
+  // anywhere. Just provide a fake implementation here for MessageLite.
+  string GetTypeName() const { return ""; }
+
+  void CheckTypeAndMergeFrom(const MessageLite& other) {
+    MergeFromInternal(*::google::protobuf::down_cast<const Derived*>(&other));
+  }
+
+  bool MergePartialFromCodedStream(::google::protobuf::io::CodedInputStream* input) {
+    uint32 tag;
+
+    for (;;) {
+      // 1) corrupted data: return false;
+      // 2) unknown field: skip without putting into unknown field set;
+      // 3) unknown enum value: keep it in parsing. In proto2, caller should
+      // check the value and put this entry into containing message's unknown
+      // field set if the value is an unknown enum. In proto3, caller doesn't
+      // need to care whether the value is unknown enum;
+      // 4) missing key/value: missed key/value will have default value. caller
+      // should take this entry as if key/value is set to default value.
+      tag = input->ReadTagNoLastTag();
+      switch (tag) {
+        case kKeyTag:
+          if (!KeyTypeHandler::Read(input, mutable_key())) {
+            return false;
+          }
+          set_has_key();
+          if (!input->ExpectTag(kValueTag)) break;
+          GOOGLE_FALLTHROUGH_INTENDED;
+
+        case kValueTag:
+          if (!ValueTypeHandler::Read(input, mutable_value())) {
+            return false;
+          }
+          set_has_value();
+          if (input->ExpectAtEnd()) return true;
+          break;
+
+        default:
+          if (tag == 0 ||
+              WireFormatLite::GetTagWireType(tag) ==
+              WireFormatLite::WIRETYPE_END_GROUP) {
+            return true;
+          }
+          if (!WireFormatLite::SkipField(input, tag)) return false;
+          break;
+      }
+    }
+  }
+
+  size_t ByteSizeLong() const {
+    size_t size = 0;
+    size += has_key() ?
+        kTagSize + static_cast<size_t>(KeyTypeHandler::ByteSize(key())) : 0;
+    size += has_value() ?
+        kTagSize + static_cast<size_t>(ValueTypeHandler::ByteSize(value())) : 0;
+    return size;
+  }
+
+  void SerializeWithCachedSizes(::google::protobuf::io::CodedOutputStream* output) const {
+    KeyTypeHandler::Write(kKeyFieldNumber, key(), output);
+    ValueTypeHandler::Write(kValueFieldNumber, value(), output);
+  }
+
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(bool deterministic,
+                                                   ::google::protobuf::uint8* output) const {
+    output = KeyTypeHandler::InternalWriteToArray(kKeyFieldNumber, key(),
+                                                  deterministic, output);
+    output = ValueTypeHandler::InternalWriteToArray(kValueFieldNumber, value(),
+                                                    deterministic, output);
+    return output;
+  }
+
+  // Don't override SerializeWithCachedSizesToArray.  Use MessageLite's.
+
+  int GetCachedSize() const {
+    int size = 0;
+    size += has_key()
+        ? static_cast<int>(kTagSize) + KeyTypeHandler::GetCachedSize(key())
+        : 0;
+    size += has_value()
+        ? static_cast<int>(kTagSize) + ValueTypeHandler::GetCachedSize(value())
+        : 0;
+    return size;
+  }
+
+  bool IsInitialized() const { return ValueTypeHandler::IsInitialized(value_); }
+
+  Base* New() const {
+    Derived* entry = new Derived;
+    return entry;
+  }
+
+  Base* New(Arena* arena) const {
+    Derived* entry = Arena::CreateMessage<Derived>(arena);
+    return entry;
+  }
+
+  size_t SpaceUsedLong() const {
+    size_t size = sizeof(Derived);
+    size += KeyTypeHandler::SpaceUsedInMapEntryLong(key_);
+    size += ValueTypeHandler::SpaceUsedInMapEntryLong(value_);
+    return size;
+  }
+
+ protected:
+  // We can't declare this function directly here as it would hide the other
+  // overload (const Message&).
+  void MergeFromInternal(const MapEntryImpl& from) {
+    if (from._has_bits_[0]) {
+      if (from.has_key()) {
+        KeyTypeHandler::EnsureMutable(&key_, GetArenaNoVirtual());
+        KeyTypeHandler::Merge(from.key(), &key_, GetArenaNoVirtual());
+        set_has_key();
+      }
+      if (from.has_value()) {
+        ValueTypeHandler::EnsureMutable(&value_, GetArenaNoVirtual());
+        ValueTypeHandler::Merge(from.value(), &value_, GetArenaNoVirtual());
+        set_has_value();
+      }
+    }
+  }
+
+ public:
+  void Clear() {
+    KeyTypeHandler::Clear(&key_, GetArenaNoVirtual());
+    ValueTypeHandler::ClearMaybeByDefaultEnum(
+        &value_, GetArenaNoVirtual(), default_enum_value);
+    clear_has_key();
+    clear_has_value();
+  }
+
+  static void InitAsDefaultInstance() {
+    Derived* d = const_cast<Derived*>(Derived::internal_default_instance());
+    KeyTypeHandler::AssignDefaultValue(&d->key_);
+    ValueTypeHandler::AssignDefaultValue(&d->value_);
+  }
+
+  Arena* GetArena() const {
+    return GetArenaNoVirtual();
+  }
+
+  // Create a MapEntryImpl for given key and value from google::protobuf::Map in
+  // serialization. This function is only called when value is enum. Enum is
+  // treated differently because its type in MapEntry is int and its type in
+  // google::protobuf::Map is enum. We cannot create a reference to int from an enum.
+  static Derived* EnumWrap(const Key& key, const Value value, Arena* arena) {
+    return Arena::CreateMessage<MapEnumEntryWrapper>(arena, key, value);
+  }
+
+  // Like above, but for all the other types. This avoids value copy to create
+  // MapEntryImpl from google::protobuf::Map in serialization.
+  static Derived* Wrap(const Key& key, const Value& value, Arena* arena) {
+    return Arena::CreateMessage<MapEntryWrapper>(arena, key, value);
+  }
+
+  // Parsing using MergePartialFromCodedStream, above, is not as
+  // efficient as it could be.  This helper class provides a speedier way.
+  template <typename MapField, typename Map>
+  class Parser {
+   public:
+    explicit Parser(MapField* mf) : mf_(mf), map_(mf->MutableMap()) {}
+
+    // This does what the typical MergePartialFromCodedStream() is expected to
+    // do, with the additional side-effect that if successful (i.e., if true is
+    // going to be its return value) it inserts the key-value pair into map_.
+    bool MergePartialFromCodedStream(::google::protobuf::io::CodedInputStream* input) {
+      // Look for the expected thing: a key and then a value.  If it fails,
+      // invoke the enclosing class's MergePartialFromCodedStream, or return
+      // false if that would be pointless.
+      if (input->ExpectTag(kKeyTag)) {
+        if (!KeyTypeHandler::Read(input, &key_)) {
+          return false;
+        }
+        // Peek at the next byte to see if it is kValueTag.  If not, bail out.
+        const void* data;
+        int size;
+        input->GetDirectBufferPointerInline(&data, &size);
+        // We could use memcmp here, but we don't bother. The tag is one byte.
+        GOOGLE_COMPILE_ASSERT(kTagSize == 1, tag_size_error);
+        if (size > 0 && *reinterpret_cast<const char*>(data) == kValueTag) {
+          typename Map::size_type size = map_->size();
+          value_ptr_ = &(*map_)[key_];
+          if (GOOGLE_PREDICT_TRUE(size != map_->size())) {
+            // We created a new key-value pair.  Fill in the value.
+            typedef
+                typename MapIf<ValueTypeHandler::kIsEnum, int*, Value*>::type T;
+            input->Skip(kTagSize);  // Skip kValueTag.
+            if (!ValueTypeHandler::Read(input,
+                                        reinterpret_cast<T>(value_ptr_))) {
+              map_->erase(key_);  // Failure! Undo insertion.
+              return false;
+            }
+            if (input->ExpectAtEnd()) return true;
+            return ReadBeyondKeyValuePair(input);
+          }
+        }
+      } else {
+        key_ = Key();
+      }
+
+      entry_.reset(mf_->NewEntry());
+      *entry_->mutable_key() = key_;
+      const bool result = entry_->MergePartialFromCodedStream(input);
+      if (result) UseKeyAndValueFromEntry();
+      if (entry_->GetArena() != NULL) entry_.release();
+      return result;
+    }
+
+    const Key& key() const { return key_; }
+    const Value& value() const { return *value_ptr_; }
+
+   private:
+    void UseKeyAndValueFromEntry() GOOGLE_PROTOBUF_ATTRIBUTE_COLD {
+      // Update key_ in case we need it later (because key() is called).
+      // This is potentially inefficient, especially if the key is
+      // expensive to copy (e.g., a long string), but this is a cold
+      // path, so it's not a big deal.
+      key_ = entry_->key();
+      value_ptr_ = &(*map_)[key_];
+      MoveHelper<ValueTypeHandler::kIsEnum,
+                 ValueTypeHandler::kIsMessage,
+                 ValueTypeHandler::kWireType ==
+                 WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
+                 Value>::Move(entry_->mutable_value(), value_ptr_);
+    }
+
+    // After reading a key and value successfully, and inserting that data
+    // into map_, we are not at the end of the input.  This is unusual, but
+    // allowed by the spec.
+    bool ReadBeyondKeyValuePair(::google::protobuf::io::CodedInputStream* input)
+        GOOGLE_PROTOBUF_ATTRIBUTE_COLD {
+      typedef MoveHelper<KeyTypeHandler::kIsEnum,
+                         KeyTypeHandler::kIsMessage,
+                         KeyTypeHandler::kWireType ==
+                         WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
+                         Key> KeyMover;
+      typedef MoveHelper<ValueTypeHandler::kIsEnum,
+                         ValueTypeHandler::kIsMessage,
+                         ValueTypeHandler::kWireType ==
+                         WireFormatLite::WIRETYPE_LENGTH_DELIMITED,
+                         Value> ValueMover;
+      entry_.reset(mf_->NewEntry());
+      ValueMover::Move(value_ptr_, entry_->mutable_value());
+      map_->erase(key_);
+      KeyMover::Move(&key_, entry_->mutable_key());
+      const bool result = entry_->MergePartialFromCodedStream(input);
+      if (result) UseKeyAndValueFromEntry();
+      if (entry_->GetArena() != NULL) entry_.release();
+      return result;
+    }
+
+    MapField* const mf_;
+    Map* const map_;
+    Key key_;
+    Value* value_ptr_;
+    // On the fast path entry_ is not used.  And, when entry_ is used, it's set
+    // to mf_->NewEntry(), so in the arena case we must call entry_.release.
+    google::protobuf::scoped_ptr<MapEntryImpl> entry_;
+  };
+
+ protected:
+  void set_has_key() { _has_bits_[0] |= 0x00000001u; }
+  bool has_key() const { return (_has_bits_[0] & 0x00000001u) != 0; }
+  void clear_has_key() { _has_bits_[0] &= ~0x00000001u; }
+  void set_has_value() { _has_bits_[0] |= 0x00000002u; }
+  bool has_value() const { return (_has_bits_[0] & 0x00000002u) != 0; }
+  void clear_has_value() { _has_bits_[0] &= ~0x00000002u; }
+
+ private:
+  // Serializing a generated message containing map field involves serializing
+  // key-value pairs from google::protobuf::Map. The wire format of each key-value pair
+  // after serialization should be the same as that of a MapEntry message
+  // containing the same key and value inside it.  However, google::protobuf::Map doesn't
+  // store key and value as MapEntry message, which disables us to use existing
+  // code to serialize message. In order to use existing code to serialize
+  // message, we need to construct a MapEntry from key-value pair. But it
+  // involves copy of key and value to construct a MapEntry. In order to avoid
+  // this copy in constructing a MapEntry, we need the following class which
+  // only takes references of given key and value.
+  class MapEntryWrapper : public Derived {
+    typedef Derived BaseClass;
+    typedef typename BaseClass::KeyMapEntryAccessorType KeyMapEntryAccessorType;
+    typedef
+        typename BaseClass::ValueMapEntryAccessorType ValueMapEntryAccessorType;
+
+   public:
+    MapEntryWrapper(Arena* arena, const Key& key, const Value& value)
+        : Derived(arena), key_(key), value_(value) {
+      BaseClass::set_has_key();
+      BaseClass::set_has_value();
+    }
+    inline const KeyMapEntryAccessorType& key() const { return key_; }
+    inline const ValueMapEntryAccessorType& value() const { return value_; }
+
+   private:
+    const Key& key_;
+    const Value& value_;
+
+    friend class ::google::protobuf::Arena;
+    typedef void InternalArenaConstructable_;
+    typedef void DestructorSkippable_;
+  };
+
+  // Like above, but for enum value only, which stores value instead of
+  // reference of value field inside. This is needed because the type of value
+  // field in constructor is an enum, while we need to store it as an int. If we
+  // initialize a reference to int with a reference to enum, compiler will
+  // generate a temporary int from enum and initialize the reference to int with
+  // the temporary.
+  class MapEnumEntryWrapper : public Derived {
+    typedef Derived BaseClass;
+    typedef typename BaseClass::KeyMapEntryAccessorType KeyMapEntryAccessorType;
+    typedef
+        typename BaseClass::ValueMapEntryAccessorType ValueMapEntryAccessorType;
+
+   public:
+    MapEnumEntryWrapper(Arena* arena, const Key& key, const Value& value)
+        : Derived(arena), key_(key), value_(value) {
+      BaseClass::set_has_key();
+      BaseClass::set_has_value();
+    }
+    inline const KeyMapEntryAccessorType& key() const { return key_; }
+    inline const ValueMapEntryAccessorType& value() const { return value_; }
+
+   private:
+    const KeyMapEntryAccessorType& key_;
+    const ValueMapEntryAccessorType value_;
+
+    friend class google::protobuf::Arena;
+    typedef void DestructorSkippable_;
+  };
+
+  inline Arena* GetArenaNoVirtual() const {
+    return arena_;
+  }
+
+ public:  // Needed for constructing tables
+  KeyOnMemory key_;
+  ValueOnMemory value_;
+  Arena* arena_;
+  uint32 _has_bits_[1];
+
+ private:
+  friend class ::google::protobuf::Arena;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  template <typename C, typename K, typename V, WireFormatLite::FieldType,
+            WireFormatLite::FieldType, int>
+  friend class internal::MapEntry;
+  template <typename C, typename K, typename V, WireFormatLite::FieldType,
+            WireFormatLite::FieldType, int>
+  friend class internal::MapFieldLite;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MapEntryImpl);
+};
+
+template <typename T, typename Key, typename Value,
+          WireFormatLite::FieldType kKeyFieldType,
+          WireFormatLite::FieldType kValueFieldType, int default_enum_value>
+class MapEntryLite
+    : public MapEntryImpl<T, MessageLite, Key, Value, kKeyFieldType,
+                          kValueFieldType, default_enum_value> {
+ public:
+  typedef MapEntryImpl<T, MessageLite, Key, Value, kKeyFieldType,
+                       kValueFieldType, default_enum_value>
+      SuperType;
+  MapEntryLite() {}
+  explicit MapEntryLite(Arena* arena) : SuperType(arena) {}
+  void MergeFrom(const MapEntryLite& other) { MergeFromInternal(other); }
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MapEntryLite);
+};
+// The completely unprincipled and unwieldy use of template parameters in
+// the map code necessitates wrappers to make the code a little bit more
+// manageable.
+template <typename Derived>
+struct DeconstructMapEntry;
+
+template <typename T, typename K, typename V, WireFormatLite::FieldType key,
+          WireFormatLite::FieldType value, int default_enum>
+struct DeconstructMapEntry<MapEntryLite<T, K, V, key, value, default_enum> > {
+  typedef K Key;
+  typedef V Value;
+  static const WireFormatLite::FieldType kKeyFieldType = key;
+  static const WireFormatLite::FieldType kValueFieldType = value;
+  static const int default_enum_value = default_enum;
+};
+
+// Helpers for deterministic serialization =============================
+
+// This struct can be used with any generic sorting algorithm.  If the Key
+// type is relatively small and easy to copy then copying Keys into an
+// array of SortItems can be beneficial.  Then all the data the sorting
+// algorithm needs to touch is in that one array.
+template <typename Key, typename PtrToKeyValuePair> struct SortItem {
+  SortItem() {}
+  explicit SortItem(PtrToKeyValuePair p) : first(p->first), second(p) {}
+
+  Key first;
+  PtrToKeyValuePair second;
+};
+
+template <typename T> struct CompareByFirstField {
+  bool operator()(const T& a, const T& b) const {
+    return a.first < b.first;
+  }
+};
+
+template <typename T> struct CompareByDerefFirst {
+  bool operator()(const T& a, const T& b) const {
+    return a->first < b->first;
+  }
+};
+
+// Helper for table driven serialization
+
+template <WireFormatLite::FieldType FieldType>
+struct FromHelper {
+  template <typename T>
+  static const T& From(const T& x) {
+    return x;
+  }
+};
+
+template <>
+struct FromHelper<WireFormatLite::TYPE_STRING> {
+  static ArenaStringPtr From(const string& x) {
+    ArenaStringPtr res;
+    *res.UnsafeRawStringPointer() = const_cast<string*>(&x);
+    return res;
+  }
+};
+template <>
+struct FromHelper<WireFormatLite::TYPE_BYTES> {
+  static ArenaStringPtr From(const string& x) {
+    ArenaStringPtr res;
+    *res.UnsafeRawStringPointer() = const_cast<string*>(&x);
+    return res;
+  }
+};
+template <>
+struct FromHelper<WireFormatLite::TYPE_MESSAGE> {
+  template <typename T>
+  static T* From(const T& x) {
+    return const_cast<T*>(&x);
+  }
+};
+
+template <typename MapEntryType>
+struct MapEntryHelper;
+
+template <typename T, typename Key, typename Value,
+          WireFormatLite::FieldType kKeyFieldType,
+          WireFormatLite::FieldType kValueFieldType, int default_enum_value>
+struct MapEntryHelper<MapEntryLite<T, Key, Value, kKeyFieldType,
+                                   kValueFieldType, default_enum_value> > {
+  // Provide utilities to parse/serialize key/value.  Provide utilities to
+  // manipulate internal stored type.
+  typedef MapTypeHandler<kKeyFieldType, Key> KeyTypeHandler;
+  typedef MapTypeHandler<kValueFieldType, Value> ValueTypeHandler;
+
+  // Define internal memory layout. Strings and messages are stored as
+  // pointers, while other types are stored as values.
+  typedef typename KeyTypeHandler::TypeOnMemory KeyOnMemory;
+  typedef typename ValueTypeHandler::TypeOnMemory ValueOnMemory;
+
+  explicit MapEntryHelper(const MapPair<Key, Value>& map_pair)
+      : _has_bits_(3),
+        _cached_size_(2 + KeyTypeHandler::GetCachedSize(map_pair.first) +
+                      ValueTypeHandler::GetCachedSize(map_pair.second)),
+        key_(FromHelper<kKeyFieldType>::From(map_pair.first)),
+        value_(FromHelper<kValueFieldType>::From(map_pair.second)) {}
+
+  // Purposely not folowing the style guide naming. These are the names
+  // the proto compiler would generate given the map entry descriptor.
+  // The proto compiler generates the offsets in this struct as if this was
+  // a regular message. This way the table driven code barely notices it's
+  // dealing with a map field.
+  uint32 _has_bits_;     // NOLINT
+  uint32 _cached_size_;  // NOLINT
+  KeyOnMemory key_;      // NOLINT
+  ValueOnMemory value_;  // NOLINT
+};
+
+}  // namespace internal
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_MAP_ENTRY_LITE_H__
diff --git a/kortex_api/include/google/protobuf/map_field.h b/kortex_api/include/google/protobuf/map_field.h
new file mode 100644
index 0000000000000000000000000000000000000000..6c75a6da40feef761ed6c745dbee61cbe344d4f2
--- /dev/null
+++ b/kortex_api/include/google/protobuf/map_field.h
@@ -0,0 +1,838 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_MAP_FIELD_H__
+#define GOOGLE_PROTOBUF_MAP_FIELD_H__
+
+#include <google/protobuf/stubs/atomicops.h>
+#include <google/protobuf/stubs/mutex.h>
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/map_entry.h>
+#include <google/protobuf/map_field_lite.h>
+#include <google/protobuf/map_type_handler.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>
+#include <google/protobuf/unknown_field_set.h>
+
+
+namespace google {
+namespace protobuf {
+class DynamicMessage;
+class MapKey;
+namespace internal {
+
+class ContendedMapCleanTest;
+class GeneratedMessageReflection;
+class MapFieldAccessor;
+
+// This class provides access to map field using reflection, which is the same
+// as those provided for RepeatedPtrField<Message>. It is used for internal
+// reflection implentation only. Users should never use this directly.
+class LIBPROTOBUF_EXPORT MapFieldBase {
+ public:
+  MapFieldBase()
+      : arena_(NULL),
+        repeated_field_(NULL),
+        state_(STATE_MODIFIED_MAP) {}
+  explicit MapFieldBase(Arena* arena)
+      : arena_(arena),
+        repeated_field_(NULL),
+        state_(STATE_MODIFIED_MAP) {
+    // Mutex's destructor needs to be called explicitly to release resources
+    // acquired in its constructor.
+    arena->OwnDestructor(&mutex_);
+  }
+  virtual ~MapFieldBase();
+
+  // Returns reference to internal repeated field. Data written using
+  // google::protobuf::Map's api prior to calling this function is guarantted to be
+  // included in repeated field.
+  const RepeatedPtrFieldBase& GetRepeatedField() const;
+
+  // Like above. Returns mutable pointer to the internal repeated field.
+  RepeatedPtrFieldBase* MutableRepeatedField();
+
+  // Pure virtual map APIs for Map Reflection.
+  virtual bool ContainsMapKey(const MapKey& map_key) const = 0;
+  virtual bool InsertOrLookupMapValue(
+      const MapKey& map_key, MapValueRef* val) = 0;
+  // Insures operations after won't get executed before calling this.
+  bool IsMapValid() const;
+  virtual bool DeleteMapValue(const MapKey& map_key) = 0;
+  virtual bool EqualIterator(const MapIterator& a,
+                             const MapIterator& b) const = 0;
+  virtual void MapBegin(MapIterator* map_iter) const = 0;
+  virtual void MapEnd(MapIterator* map_iter) const = 0;
+  // Sync Map with repeated field and returns the size of map.
+  virtual int size() const = 0;
+
+  // Returns the number of bytes used by the repeated field, excluding
+  // sizeof(*this)
+  size_t SpaceUsedExcludingSelfLong() const;
+
+  int SpaceUsedExcludingSelf() const {
+    return internal::ToIntSize(SpaceUsedExcludingSelfLong());
+  }
+
+ protected:
+  // Gets the size of space used by map field.
+  virtual size_t SpaceUsedExcludingSelfNoLock() const;
+
+  // Synchronizes the content in Map to RepeatedPtrField if there is any change
+  // to Map after last synchronization.
+  void SyncRepeatedFieldWithMap() const;
+  virtual void SyncRepeatedFieldWithMapNoLock() const;
+
+  // Synchronizes the content in RepeatedPtrField to Map if there is any change
+  // to RepeatedPtrField after last synchronization.
+  void SyncMapWithRepeatedField() const;
+  virtual void SyncMapWithRepeatedFieldNoLock() const {}
+
+  // Tells MapFieldBase that there is new change to Map.
+  void SetMapDirty();
+
+  // Tells MapFieldBase that there is new change to RepeatedPTrField.
+  void SetRepeatedDirty();
+
+  // Provides derived class the access to repeated field.
+  void* MutableRepeatedPtrField() const;
+
+  enum State {
+    STATE_MODIFIED_MAP = 0,       // map has newly added data that has not been
+                                  // synchronized to repeated field
+    STATE_MODIFIED_REPEATED = 1,  // repeated field has newly added data that
+                                  // has not been synchronized to map
+    CLEAN = 2,  // data in map and repeated field are same
+  };
+
+  Arena* arena_;
+  mutable RepeatedPtrField<Message>* repeated_field_;
+
+  mutable Mutex mutex_;  // The thread to synchronize map and repeated field
+                         // needs to get lock first;
+  mutable volatile Atomic32 state_;  // 0: STATE_MODIFIED_MAP
+                                     // 1: STATE_MODIFIED_REPEATED
+                                     // 2: CLEAN
+
+ private:
+  friend class ContendedMapCleanTest;
+  friend class GeneratedMessageReflection;
+  friend class MapFieldAccessor;
+  friend class ::google::protobuf::DynamicMessage;
+
+  // Virtual helper methods for MapIterator. MapIterator doesn't have the
+  // type helper for key and value. Call these help methods to deal with
+  // different types. Real helper methods are implemented in
+  // TypeDefinedMapFieldBase.
+  friend class ::google::protobuf::MapIterator;
+  // Allocate map<...>::iterator for MapIterator.
+  virtual void InitializeIterator(MapIterator* map_iter) const = 0;
+
+  // DeleteIterator() is called by the destructor of MapIterator only.
+  // It deletes map<...>::iterator for MapIterator.
+  virtual void DeleteIterator(MapIterator* map_iter) const = 0;
+
+  // Copy the map<...>::iterator from other_iterator to
+  // this_iterator.
+  virtual void CopyIterator(MapIterator* this_iterator,
+                            const MapIterator& other_iterator) const = 0;
+
+  // IncreaseIterator() is called by operator++() of MapIterator only.
+  // It implements the ++ operator of MapIterator.
+  virtual void IncreaseIterator(MapIterator* map_iter) const = 0;
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MapFieldBase);
+};
+
+// This class provides common Map Reflection implementations for generated
+// message and dynamic message.
+template<typename Key, typename T>
+class TypeDefinedMapFieldBase : public MapFieldBase {
+ public:
+  TypeDefinedMapFieldBase() {}
+  explicit TypeDefinedMapFieldBase(Arena* arena) : MapFieldBase(arena) {}
+  ~TypeDefinedMapFieldBase() {}
+  void MapBegin(MapIterator* map_iter) const;
+  void MapEnd(MapIterator* map_iter) const;
+  bool EqualIterator(const MapIterator& a, const MapIterator& b) const;
+
+  virtual const Map<Key, T>& GetMap() const = 0;
+  virtual Map<Key, T>* MutableMap() = 0;
+
+ protected:
+  typename Map<Key, T>::const_iterator& InternalGetIterator(
+      const MapIterator* map_iter) const;
+
+ private:
+  void InitializeIterator(MapIterator* map_iter) const;
+  void DeleteIterator(MapIterator* map_iter) const;
+  void CopyIterator(MapIterator* this_iteratorm,
+                    const MapIterator& that_iterator) const;
+  void IncreaseIterator(MapIterator* map_iter) const;
+
+  virtual void SetMapIteratorValue(MapIterator* map_iter) const = 0;
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(TypeDefinedMapFieldBase);
+};
+
+// This class provides access to map field using generated api. It is used for
+// internal generated message implentation only. Users should never use this
+// directly.
+template <typename Derived, typename Key, typename T,
+          WireFormatLite::FieldType kKeyFieldType,
+          WireFormatLite::FieldType kValueFieldType, int default_enum_value = 0>
+class MapField : public TypeDefinedMapFieldBase<Key, T> {
+  // Provide utilities to parse/serialize key/value.  Provide utilities to
+  // manipulate internal stored type.
+  typedef MapTypeHandler<kKeyFieldType, Key> KeyTypeHandler;
+  typedef MapTypeHandler<kValueFieldType, T> ValueTypeHandler;
+
+  // Define message type for internal repeated field.
+  typedef Derived EntryType;
+  typedef MapEntryLite<Derived, Key, T, kKeyFieldType, kValueFieldType,
+                       default_enum_value>
+      EntryLiteType;
+
+  // Define abbreviation for parent MapFieldLite
+  typedef MapFieldLite<Derived, Key, T, kKeyFieldType, kValueFieldType,
+                       default_enum_value>
+      MapFieldLiteType;
+
+  // Enum needs to be handled differently from other types because it has
+  // different exposed type in google::protobuf::Map's api and repeated field's api. For
+  // details see the comment in the implementation of
+  // SyncMapWithRepeatedFieldNoLock.
+  static const bool kIsValueEnum = ValueTypeHandler::kIsEnum;
+  typedef typename MapIf<kIsValueEnum, T, const T&>::type CastValueType;
+
+ public:
+  typedef typename Derived::SuperType EntryTypeTrait;
+  typedef Map<Key, T> MapType;
+
+  MapField() {}
+  explicit MapField(Arena* arena)
+      : TypeDefinedMapFieldBase<Key, T>(arena), impl_(arena) {}
+
+  // Implement MapFieldBase
+  bool ContainsMapKey(const MapKey& map_key) const;
+  bool InsertOrLookupMapValue(const MapKey& map_key, MapValueRef* val);
+  bool DeleteMapValue(const MapKey& map_key);
+
+  const Map<Key, T>& GetMap() const {
+    MapFieldBase::SyncMapWithRepeatedField();
+    return impl_.GetMap();
+  }
+
+  Map<Key, T>* MutableMap() {
+    MapFieldBase::SyncMapWithRepeatedField();
+    Map<Key, T>* result = impl_.MutableMap();
+    MapFieldBase::SetMapDirty();
+    return result;
+  }
+
+  // Convenient methods for generated message implementation.
+  int size() const;
+  void Clear();
+  void MergeFrom(const MapField& other);
+  void Swap(MapField* other);
+
+  // Used in the implementation of parsing. Caller should take the ownership iff
+  // arena_ is NULL.
+  EntryType* NewEntry() const { return impl_.NewEntry(); }
+  // Used in the implementation of serializing enum value type. Caller should
+  // take the ownership iff arena_ is NULL.
+  EntryType* NewEnumEntryWrapper(const Key& key, const T t) const {
+    return impl_.NewEnumEntryWrapper(key, t);
+  }
+  // Used in the implementation of serializing other value types. Caller should
+  // take the ownership iff arena_ is NULL.
+  EntryType* NewEntryWrapper(const Key& key, const T& t) const {
+    return impl_.NewEntryWrapper(key, t);
+  }
+
+ private:
+  MapFieldLiteType impl_;
+
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+
+  // Implements MapFieldBase
+  void SyncRepeatedFieldWithMapNoLock() const;
+  void SyncMapWithRepeatedFieldNoLock() const;
+  size_t SpaceUsedExcludingSelfNoLock() const;
+
+  void SetMapIteratorValue(MapIterator* map_iter) const;
+
+  friend class ::google::protobuf::Arena;
+  friend class MapFieldStateTest;  // For testing, it needs raw access to impl_
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MapField);
+};
+
+template <typename T, typename Key, typename Value,
+          WireFormatLite::FieldType kKeyFieldType,
+          WireFormatLite::FieldType kValueFieldType, int default_enum_value>
+struct MapEntryToMapField<MapEntry<T, Key, Value, kKeyFieldType,
+                                   kValueFieldType, default_enum_value> > {
+  typedef MapField<T, Key, Value, kKeyFieldType, kValueFieldType,
+                   default_enum_value>
+      MapFieldType;
+};
+
+class LIBPROTOBUF_EXPORT DynamicMapField: public TypeDefinedMapFieldBase<MapKey, MapValueRef> {
+ public:
+  explicit DynamicMapField(const Message* default_entry);
+  DynamicMapField(const Message* default_entry, Arena* arena);
+  ~DynamicMapField();
+
+  // Implement MapFieldBase
+  bool ContainsMapKey(const MapKey& map_key) const;
+  bool InsertOrLookupMapValue(const MapKey& map_key, MapValueRef* val);
+  bool DeleteMapValue(const MapKey& map_key);
+
+  const Map<MapKey, MapValueRef>& GetMap() const;
+  Map<MapKey, MapValueRef>* MutableMap();
+
+  int size() const;
+
+ private:
+  Map<MapKey, MapValueRef> map_;
+  const Message* default_entry_;
+
+  // Implements MapFieldBase
+  void SyncRepeatedFieldWithMapNoLock() const;
+  void SyncMapWithRepeatedFieldNoLock() const;
+  size_t SpaceUsedExcludingSelfNoLock() const;
+  void SetMapIteratorValue(MapIterator* map_iter) const;
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(DynamicMapField);
+};
+
+}  // namespace internal
+
+#define TYPE_CHECK(EXPECTEDTYPE, METHOD)                        \
+  if (type() != EXPECTEDTYPE) {                                 \
+    GOOGLE_LOG(FATAL)                                                  \
+        << "Protocol Buffer map usage error:\n"                 \
+        << METHOD << " type does not match\n"                   \
+        << "  Expected : "                                      \
+        << FieldDescriptor::CppTypeName(EXPECTEDTYPE) << "\n"   \
+        << "  Actual   : "                                      \
+        << FieldDescriptor::CppTypeName(type());                \
+  }
+
+// MapKey is an union type for representing any possible
+// map key.
+class LIBPROTOBUF_EXPORT MapKey {
+ public:
+  MapKey() : type_(0) {
+  }
+  MapKey(const MapKey& other) : type_(0) {
+    CopyFrom(other);
+  }
+  MapKey& operator=(const MapKey& other) {
+    CopyFrom(other);
+    return *this;
+  }
+
+  ~MapKey() {
+    if (type_ == FieldDescriptor::CPPTYPE_STRING) {
+      delete val_.string_value_;
+    }
+  }
+
+  FieldDescriptor::CppType type() const {
+    if (type_ == 0) {
+      GOOGLE_LOG(FATAL)
+          << "Protocol Buffer map usage error:\n"
+          << "MapKey::type MapKey is not initialized. "
+          << "Call set methods to initialize MapKey.";
+    }
+    return (FieldDescriptor::CppType)type_;
+  }
+
+  void SetInt64Value(int64 value) {
+    SetType(FieldDescriptor::CPPTYPE_INT64);
+    val_.int64_value_ = value;
+  }
+  void SetUInt64Value(uint64 value) {
+    SetType(FieldDescriptor::CPPTYPE_UINT64);
+    val_.uint64_value_ = value;
+  }
+  void SetInt32Value(int32 value) {
+    SetType(FieldDescriptor::CPPTYPE_INT32);
+    val_.int32_value_ = value;
+  }
+  void SetUInt32Value(uint32 value) {
+    SetType(FieldDescriptor::CPPTYPE_UINT32);
+    val_.uint32_value_ = value;
+  }
+  void SetBoolValue(bool value) {
+    SetType(FieldDescriptor::CPPTYPE_BOOL);
+    val_.bool_value_ = value;
+  }
+  void SetStringValue(const string& val) {
+    SetType(FieldDescriptor::CPPTYPE_STRING);
+    *val_.string_value_ = val;
+  }
+
+  int64 GetInt64Value() const {
+    TYPE_CHECK(FieldDescriptor::CPPTYPE_INT64,
+               "MapKey::GetInt64Value");
+    return val_.int64_value_;
+  }
+  uint64 GetUInt64Value() const {
+    TYPE_CHECK(FieldDescriptor::CPPTYPE_UINT64,
+               "MapKey::GetUInt64Value");
+    return val_.uint64_value_;
+  }
+  int32 GetInt32Value() const {
+    TYPE_CHECK(FieldDescriptor::CPPTYPE_INT32,
+               "MapKey::GetInt32Value");
+    return val_.int32_value_;
+  }
+  uint32 GetUInt32Value() const {
+    TYPE_CHECK(FieldDescriptor::CPPTYPE_UINT32,
+               "MapKey::GetUInt32Value");
+    return val_.uint32_value_;
+  }
+  bool GetBoolValue() const {
+    TYPE_CHECK(FieldDescriptor::CPPTYPE_BOOL,
+               "MapKey::GetBoolValue");
+    return val_.bool_value_;
+  }
+  const string& GetStringValue() const {
+    TYPE_CHECK(FieldDescriptor::CPPTYPE_STRING,
+               "MapKey::GetStringValue");
+    return *val_.string_value_;
+  }
+
+  bool operator<(const MapKey& other) const {
+    if (type_ != other.type_) {
+      // We could define a total order that handles this case, but
+      // there currently no need.  So, for now, fail.
+      GOOGLE_LOG(FATAL) << "Unsupported: type mismatch";
+    }
+    switch (type()) {
+      case FieldDescriptor::CPPTYPE_DOUBLE:
+      case FieldDescriptor::CPPTYPE_FLOAT:
+      case FieldDescriptor::CPPTYPE_ENUM:
+      case FieldDescriptor::CPPTYPE_MESSAGE:
+        GOOGLE_LOG(FATAL) << "Unsupported";
+        return false;
+      case FieldDescriptor::CPPTYPE_STRING:
+        return *val_.string_value_ < *other.val_.string_value_;
+      case FieldDescriptor::CPPTYPE_INT64:
+        return val_.int64_value_ < other.val_.int64_value_;
+      case FieldDescriptor::CPPTYPE_INT32:
+        return val_.int32_value_ < other.val_.int32_value_;
+      case FieldDescriptor::CPPTYPE_UINT64:
+        return val_.uint64_value_ < other.val_.uint64_value_;
+      case FieldDescriptor::CPPTYPE_UINT32:
+        return val_.uint32_value_ < other.val_.uint32_value_;
+      case FieldDescriptor::CPPTYPE_BOOL:
+        return val_.bool_value_ < other.val_.bool_value_;
+    }
+    return false;
+  }
+
+  bool operator==(const MapKey& other) const {
+    if (type_ != other.type_) {
+      // To be consistent with operator<, we don't allow this either.
+      GOOGLE_LOG(FATAL) << "Unsupported: type mismatch";
+    }
+    switch (type()) {
+      case FieldDescriptor::CPPTYPE_DOUBLE:
+      case FieldDescriptor::CPPTYPE_FLOAT:
+      case FieldDescriptor::CPPTYPE_ENUM:
+      case FieldDescriptor::CPPTYPE_MESSAGE:
+        GOOGLE_LOG(FATAL) << "Unsupported";
+        break;
+      case FieldDescriptor::CPPTYPE_STRING:
+        return *val_.string_value_ == *other.val_.string_value_;
+      case FieldDescriptor::CPPTYPE_INT64:
+        return val_.int64_value_ == other.val_.int64_value_;
+      case FieldDescriptor::CPPTYPE_INT32:
+        return val_.int32_value_ == other.val_.int32_value_;
+      case FieldDescriptor::CPPTYPE_UINT64:
+        return val_.uint64_value_ == other.val_.uint64_value_;
+      case FieldDescriptor::CPPTYPE_UINT32:
+        return val_.uint32_value_ == other.val_.uint32_value_;
+      case FieldDescriptor::CPPTYPE_BOOL:
+        return val_.bool_value_ == other.val_.bool_value_;
+    }
+    GOOGLE_LOG(FATAL) << "Can't get here.";
+    return false;
+  }
+
+  void CopyFrom(const MapKey& other) {
+    SetType(other.type());
+    switch (type_) {
+      case FieldDescriptor::CPPTYPE_DOUBLE:
+      case FieldDescriptor::CPPTYPE_FLOAT:
+      case FieldDescriptor::CPPTYPE_ENUM:
+      case FieldDescriptor::CPPTYPE_MESSAGE:
+        GOOGLE_LOG(FATAL) << "Unsupported";
+        break;
+      case FieldDescriptor::CPPTYPE_STRING:
+        *val_.string_value_ = *other.val_.string_value_;
+        break;
+      case FieldDescriptor::CPPTYPE_INT64:
+        val_.int64_value_ = other.val_.int64_value_;
+        break;
+      case FieldDescriptor::CPPTYPE_INT32:
+        val_.int32_value_ = other.val_.int32_value_;
+        break;
+      case FieldDescriptor::CPPTYPE_UINT64:
+        val_.uint64_value_ = other.val_.uint64_value_;
+        break;
+      case FieldDescriptor::CPPTYPE_UINT32:
+        val_.uint32_value_ = other.val_.uint32_value_;
+        break;
+      case FieldDescriptor::CPPTYPE_BOOL:
+        val_.bool_value_ = other.val_.bool_value_;
+        break;
+    }
+  }
+
+ private:
+  template <typename K, typename V>
+  friend class internal::TypeDefinedMapFieldBase;
+  friend class MapIterator;
+  friend class internal::DynamicMapField;
+
+  union KeyValue {
+    KeyValue() {}
+    string* string_value_;
+    int64 int64_value_;
+    int32 int32_value_;
+    uint64 uint64_value_;
+    uint32 uint32_value_;
+    bool bool_value_;
+  } val_;
+
+  void SetType(FieldDescriptor::CppType type) {
+    if (type_ == type) return;
+    if (type_ == FieldDescriptor::CPPTYPE_STRING) {
+      delete val_.string_value_;
+    }
+    type_ = type;
+    if (type_ == FieldDescriptor::CPPTYPE_STRING) {
+      val_.string_value_ = new string;
+    }
+  }
+
+  // type_ is 0 or a valid FieldDescriptor::CppType.
+  int type_;
+};
+
+// MapValueRef points to a map value.
+class LIBPROTOBUF_EXPORT MapValueRef {
+ public:
+  MapValueRef() : data_(NULL), type_(0) {}
+
+  void SetInt64Value(int64 value) {
+    TYPE_CHECK(FieldDescriptor::CPPTYPE_INT64,
+               "MapValueRef::SetInt64Value");
+    *reinterpret_cast<int64*>(data_) = value;
+  }
+  void SetUInt64Value(uint64 value) {
+    TYPE_CHECK(FieldDescriptor::CPPTYPE_UINT64,
+               "MapValueRef::SetUInt64Value");
+    *reinterpret_cast<uint64*>(data_) = value;
+  }
+  void SetInt32Value(int32 value) {
+    TYPE_CHECK(FieldDescriptor::CPPTYPE_INT32,
+               "MapValueRef::SetInt32Value");
+    *reinterpret_cast<int32*>(data_) = value;
+  }
+  void SetUInt32Value(uint32 value) {
+    TYPE_CHECK(FieldDescriptor::CPPTYPE_UINT32,
+               "MapValueRef::SetUInt32Value");
+    *reinterpret_cast<uint32*>(data_) = value;
+  }
+  void SetBoolValue(bool value) {
+    TYPE_CHECK(FieldDescriptor::CPPTYPE_BOOL,
+               "MapValueRef::SetBoolValue");
+    *reinterpret_cast<bool*>(data_) = value;
+  }
+  // TODO(jieluo) - Checks that enum is member.
+  void SetEnumValue(int value) {
+    TYPE_CHECK(FieldDescriptor::CPPTYPE_ENUM,
+               "MapValueRef::SetEnumValue");
+    *reinterpret_cast<int*>(data_) = value;
+  }
+  void SetStringValue(const string& value) {
+    TYPE_CHECK(FieldDescriptor::CPPTYPE_STRING,
+               "MapValueRef::SetStringValue");
+    *reinterpret_cast<string*>(data_) = value;
+  }
+  void SetFloatValue(float value) {
+    TYPE_CHECK(FieldDescriptor::CPPTYPE_FLOAT,
+               "MapValueRef::SetFloatValue");
+    *reinterpret_cast<float*>(data_) = value;
+  }
+  void SetDoubleValue(double value) {
+    TYPE_CHECK(FieldDescriptor::CPPTYPE_DOUBLE,
+               "MapValueRef::SetDoubleValue");
+    *reinterpret_cast<double*>(data_) = value;
+  }
+
+  int64 GetInt64Value() const {
+    TYPE_CHECK(FieldDescriptor::CPPTYPE_INT64,
+               "MapValueRef::GetInt64Value");
+    return *reinterpret_cast<int64*>(data_);
+  }
+  uint64 GetUInt64Value() const {
+    TYPE_CHECK(FieldDescriptor::CPPTYPE_UINT64,
+               "MapValueRef::GetUInt64Value");
+    return *reinterpret_cast<uint64*>(data_);
+  }
+  int32 GetInt32Value() const {
+    TYPE_CHECK(FieldDescriptor::CPPTYPE_INT32,
+               "MapValueRef::GetInt32Value");
+    return *reinterpret_cast<int32*>(data_);
+  }
+  uint32 GetUInt32Value() const {
+    TYPE_CHECK(FieldDescriptor::CPPTYPE_UINT32,
+               "MapValueRef::GetUInt32Value");
+    return *reinterpret_cast<uint32*>(data_);
+  }
+  bool GetBoolValue() const {
+    TYPE_CHECK(FieldDescriptor::CPPTYPE_BOOL,
+               "MapValueRef::GetBoolValue");
+    return *reinterpret_cast<bool*>(data_);
+  }
+  int GetEnumValue() const {
+    TYPE_CHECK(FieldDescriptor::CPPTYPE_ENUM,
+               "MapValueRef::GetEnumValue");
+    return *reinterpret_cast<int*>(data_);
+  }
+  const string& GetStringValue() const {
+    TYPE_CHECK(FieldDescriptor::CPPTYPE_STRING,
+               "MapValueRef::GetStringValue");
+    return *reinterpret_cast<string*>(data_);
+  }
+  float GetFloatValue() const {
+    TYPE_CHECK(FieldDescriptor::CPPTYPE_FLOAT,
+               "MapValueRef::GetFloatValue");
+    return *reinterpret_cast<float*>(data_);
+  }
+  double GetDoubleValue() const {
+    TYPE_CHECK(FieldDescriptor::CPPTYPE_DOUBLE,
+               "MapValueRef::GetDoubleValue");
+    return *reinterpret_cast<double*>(data_);
+  }
+
+  const Message& GetMessageValue() const {
+    TYPE_CHECK(FieldDescriptor::CPPTYPE_MESSAGE,
+               "MapValueRef::GetMessageValue");
+    return *reinterpret_cast<Message*>(data_);
+  }
+
+  Message* MutableMessageValue() {
+    TYPE_CHECK(FieldDescriptor::CPPTYPE_MESSAGE,
+               "MapValueRef::MutableMessageValue");
+    return reinterpret_cast<Message*>(data_);
+  }
+
+ private:
+  template <typename Derived, typename K, typename V,
+            internal::WireFormatLite::FieldType key_wire_type,
+            internal::WireFormatLite::FieldType value_wire_type,
+            int default_enum_value>
+  friend class internal::MapField;
+  template <typename K, typename V>
+  friend class internal::TypeDefinedMapFieldBase;
+  friend class MapIterator;
+  friend class internal::GeneratedMessageReflection;
+  friend class internal::DynamicMapField;
+
+  void SetType(FieldDescriptor::CppType type) {
+    type_ = type;
+  }
+
+  FieldDescriptor::CppType type() const {
+    if (type_ == 0 || data_ == NULL) {
+      GOOGLE_LOG(FATAL)
+          << "Protocol Buffer map usage error:\n"
+          << "MapValueRef::type MapValueRef is not initialized.";
+    }
+    return (FieldDescriptor::CppType)type_;
+  }
+  void SetValue(const void* val) {
+    data_ = const_cast<void*>(val);
+  }
+  void CopyFrom(const MapValueRef& other) {
+    type_ = other.type_;
+    data_ = other.data_;
+  }
+  // Only used in DynamicMapField
+  void DeleteData() {
+    switch (type_) {
+#define HANDLE_TYPE(CPPTYPE, TYPE)                              \
+      case google::protobuf::FieldDescriptor::CPPTYPE_##CPPTYPE: {        \
+        delete reinterpret_cast<TYPE*>(data_);                  \
+        break;                                                  \
+      }
+      HANDLE_TYPE(INT32, int32);
+      HANDLE_TYPE(INT64, int64);
+      HANDLE_TYPE(UINT32, uint32);
+      HANDLE_TYPE(UINT64, uint64);
+      HANDLE_TYPE(DOUBLE, double);
+      HANDLE_TYPE(FLOAT, float);
+      HANDLE_TYPE(BOOL, bool);
+      HANDLE_TYPE(STRING, string);
+      HANDLE_TYPE(ENUM, int32);
+      HANDLE_TYPE(MESSAGE, Message);
+#undef HANDLE_TYPE
+    }
+  }
+  // data_ point to a map value. MapValueRef does not
+  // own this value.
+  void* data_;
+  // type_ is 0 or a valid FieldDescriptor::CppType.
+  int type_;
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MapValueRef);
+};
+
+#undef TYPE_CHECK
+
+class LIBPROTOBUF_EXPORT MapIterator {
+ public:
+  MapIterator(Message* message, const FieldDescriptor* field) {
+    const Reflection* reflection = message->GetReflection();
+    map_ = reflection->MapData(message, field);
+    key_.SetType(field->message_type()->FindFieldByName("key")->cpp_type());
+    value_.SetType(field->message_type()->FindFieldByName("value")->cpp_type());
+    map_->InitializeIterator(this);
+  }
+  MapIterator(const MapIterator& other) {
+    map_ = other.map_;
+    map_->InitializeIterator(this);
+    map_->CopyIterator(this, other);
+  }
+  ~MapIterator() {
+    map_->DeleteIterator(this);
+  }
+  MapIterator& operator=(const MapIterator& other) {
+    map_ = other.map_;
+    map_->CopyIterator(this, other);
+    return *this;
+  }
+  friend bool operator==(const MapIterator& a, const MapIterator& b) {
+    return a.map_->EqualIterator(a, b);
+  }
+  friend bool operator!=(const MapIterator& a, const MapIterator& b) {
+    return !a.map_->EqualIterator(a, b);
+  }
+  MapIterator& operator++() {
+    map_->IncreaseIterator(this);
+    return *this;
+  }
+  MapIterator operator++(int) {
+    // iter_ is copied from Map<...>::iterator, no need to
+    // copy from its self again. Use the same implementation
+    // with operator++()
+    map_->IncreaseIterator(this);
+    return *this;
+  }
+  const MapKey& GetKey() {
+    return key_;
+  }
+  const MapValueRef& GetValueRef() {
+    return value_;
+  }
+  MapValueRef* MutableValueRef() {
+    map_->SetMapDirty();
+    return &value_;
+  }
+
+ private:
+  template <typename Key, typename T>
+  friend class internal::TypeDefinedMapFieldBase;
+  friend class internal::DynamicMapField;
+  template <typename Derived, typename Key, typename T,
+            internal::WireFormatLite::FieldType kKeyFieldType,
+            internal::WireFormatLite::FieldType kValueFieldType,
+            int default_enum_value>
+  friend class internal::MapField;
+
+  // reinterpret_cast from heap-allocated Map<...>::iterator*. MapIterator owns
+  // the iterator. It is allocated by MapField<...>::InitializeIterator() called
+  // in constructor and deleted by MapField<...>::DeleteIterator() called in
+  // destructor.
+  void* iter_;
+  // Point to a MapField to call helper methods implemented in MapField.
+  // MapIterator does not own this object.
+  internal::MapFieldBase* map_;
+  MapKey key_;
+  MapValueRef value_;
+};
+
+}  // namespace protobuf
+}  // namespace google
+
+GOOGLE_PROTOBUF_HASH_NAMESPACE_DECLARATION_START
+template<>
+struct hash<google::protobuf::MapKey> {
+  size_t
+  operator()(const google::protobuf::MapKey& map_key) const {
+    switch (map_key.type()) {
+      case google::protobuf::FieldDescriptor::CPPTYPE_DOUBLE:
+      case google::protobuf::FieldDescriptor::CPPTYPE_FLOAT:
+      case google::protobuf::FieldDescriptor::CPPTYPE_ENUM:
+      case google::protobuf::FieldDescriptor::CPPTYPE_MESSAGE:
+        GOOGLE_LOG(FATAL) << "Unsupported";
+        break;
+      case google::protobuf::FieldDescriptor::CPPTYPE_STRING:
+        return hash<string>()(map_key.GetStringValue());
+      case google::protobuf::FieldDescriptor::CPPTYPE_INT64:
+        return hash< ::google::protobuf::int64>()(map_key.GetInt64Value());
+      case google::protobuf::FieldDescriptor::CPPTYPE_INT32:
+        return hash< ::google::protobuf::int32>()(map_key.GetInt32Value());
+      case google::protobuf::FieldDescriptor::CPPTYPE_UINT64:
+        return hash< ::google::protobuf::uint64>()(map_key.GetUInt64Value());
+      case google::protobuf::FieldDescriptor::CPPTYPE_UINT32:
+        return hash< ::google::protobuf::uint32>()(map_key.GetUInt32Value());
+      case google::protobuf::FieldDescriptor::CPPTYPE_BOOL:
+        return hash<bool>()(map_key.GetBoolValue());
+    }
+    GOOGLE_LOG(FATAL) << "Can't get here.";
+    return 0;
+  }
+  bool
+  operator()(const google::protobuf::MapKey& map_key1,
+             const google::protobuf::MapKey& map_key2) const {
+    return map_key1 < map_key2;
+  }
+};
+GOOGLE_PROTOBUF_HASH_NAMESPACE_DECLARATION_END
+
+#endif  // GOOGLE_PROTOBUF_MAP_FIELD_H__
diff --git a/kortex_api/include/google/protobuf/map_field_inl.h b/kortex_api/include/google/protobuf/map_field_inl.h
new file mode 100644
index 0000000000000000000000000000000000000000..e317b5ed428acd280ffbcc35a26b4045157f0e9e
--- /dev/null
+++ b/kortex_api/include/google/protobuf/map_field_inl.h
@@ -0,0 +1,341 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_MAP_FIELD_INL_H__
+#define GOOGLE_PROTOBUF_MAP_FIELD_INL_H__
+
+#include <memory>
+#ifndef _SHARED_PTR_H
+#include <google/protobuf/stubs/shared_ptr.h>
+#endif
+
+#include <google/protobuf/map.h>
+#include <google/protobuf/map_field.h>
+#include <google/protobuf/map_type_handler.h>
+
+namespace google {
+namespace protobuf {
+namespace internal {
+// UnwrapMapKey template
+template<typename T>
+T UnwrapMapKey(const MapKey& map_key);
+template<>
+inline int32 UnwrapMapKey<int32>(const MapKey& map_key) {
+  return map_key.GetInt32Value();
+}
+template<>
+inline uint32 UnwrapMapKey<uint32>(const MapKey& map_key) {
+  return map_key.GetUInt32Value();
+}
+template<>
+inline int64 UnwrapMapKey<int64>(const MapKey& map_key) {
+  return map_key.GetInt64Value();
+}
+template<>
+inline uint64 UnwrapMapKey<uint64>(const MapKey& map_key) {
+  return map_key.GetUInt64Value();
+}
+template<>
+inline bool UnwrapMapKey<bool>(const MapKey& map_key) {
+  return map_key.GetBoolValue();
+}
+template<>
+inline string UnwrapMapKey<string>(const MapKey& map_key) {
+  return map_key.GetStringValue();
+}
+
+// SetMapKey template
+template<typename T>
+inline void SetMapKey(MapKey* map_key, const T& value);
+template<>
+inline void SetMapKey<int32>(MapKey* map_key, const int32& value) {
+  map_key->SetInt32Value(value);
+}
+template<>
+inline void SetMapKey<uint32>(MapKey* map_key, const uint32& value) {
+  map_key->SetUInt32Value(value);
+}
+template<>
+inline void SetMapKey<int64>(MapKey* map_key, const int64& value) {
+  map_key->SetInt64Value(value);
+}
+template<>
+inline void SetMapKey<uint64>(MapKey* map_key, const uint64& value) {
+  map_key->SetUInt64Value(value);
+}
+template<>
+inline void SetMapKey<bool>(MapKey* map_key, const bool& value) {
+  map_key->SetBoolValue(value);
+}
+template<>
+inline void SetMapKey<string>(MapKey* map_key, const string& value) {
+  map_key->SetStringValue(value);
+}
+
+// ------------------------TypeDefinedMapFieldBase---------------
+template <typename Key, typename T>
+typename Map<Key, T>::const_iterator&
+TypeDefinedMapFieldBase<Key, T>::InternalGetIterator(
+    const MapIterator* map_iter) const {
+  return *reinterpret_cast<typename Map<Key, T>::const_iterator *>(
+      map_iter->iter_);
+}
+
+template <typename Key, typename T>
+void TypeDefinedMapFieldBase<Key, T>::MapBegin(MapIterator* map_iter) const {
+  InternalGetIterator(map_iter) = GetMap().begin();
+  SetMapIteratorValue(map_iter);
+}
+
+template <typename Key, typename T>
+void TypeDefinedMapFieldBase<Key, T>::MapEnd(MapIterator* map_iter) const {
+  InternalGetIterator(map_iter) = GetMap().end();
+}
+
+template <typename Key, typename T>
+bool TypeDefinedMapFieldBase<Key, T>::EqualIterator(const MapIterator& a,
+                                                    const MapIterator& b)
+    const {
+  return InternalGetIterator(&a) == InternalGetIterator(&b);
+}
+
+template <typename Key, typename T>
+void TypeDefinedMapFieldBase<Key, T>::IncreaseIterator(MapIterator* map_iter)
+    const {
+  ++InternalGetIterator(map_iter);
+  SetMapIteratorValue(map_iter);
+}
+
+template <typename Key, typename T>
+void TypeDefinedMapFieldBase<Key, T>::InitializeIterator(
+    MapIterator* map_iter) const {
+  map_iter->iter_ = new typename Map<Key, T>::const_iterator;
+  GOOGLE_CHECK(map_iter->iter_ != NULL);
+}
+
+template <typename Key, typename T>
+void TypeDefinedMapFieldBase<Key, T>::DeleteIterator(MapIterator* map_iter)
+    const {
+  delete reinterpret_cast<typename Map<Key, T>::const_iterator *>(
+      map_iter->iter_);
+}
+
+template <typename Key, typename T>
+void TypeDefinedMapFieldBase<Key, T>::CopyIterator(
+    MapIterator* this_iter,
+    const MapIterator& that_iter) const {
+  InternalGetIterator(this_iter) = InternalGetIterator(&that_iter);
+  this_iter->key_.SetType(that_iter.key_.type());
+  // MapValueRef::type() fails when containing data is null. However, if
+  // this_iter points to MapEnd, data can be null.
+  this_iter->value_.SetType(
+      static_cast<FieldDescriptor::CppType>(that_iter.value_.type_));
+  SetMapIteratorValue(this_iter);
+}
+
+// ----------------------------------------------------------------------
+
+template <typename Derived, typename Key, typename T,
+          WireFormatLite::FieldType kKeyFieldType,
+          WireFormatLite::FieldType kValueFieldType, int default_enum_value>
+int MapField<Derived, Key, T, kKeyFieldType, kValueFieldType,
+             default_enum_value>::size() const {
+  MapFieldBase::SyncMapWithRepeatedField();
+  return static_cast<int>(impl_.GetMap().size());
+}
+
+template <typename Derived, typename Key, typename T,
+          WireFormatLite::FieldType kKeyFieldType,
+          WireFormatLite::FieldType kValueFieldType, int default_enum_value>
+void MapField<Derived, Key, T, kKeyFieldType, kValueFieldType,
+              default_enum_value>::Clear() {
+  MapFieldBase::SyncMapWithRepeatedField();
+  impl_.MutableMap()->clear();
+  MapFieldBase::SetMapDirty();
+}
+
+template <typename Derived, typename Key, typename T,
+          WireFormatLite::FieldType kKeyFieldType,
+          WireFormatLite::FieldType kValueFieldType, int default_enum_value>
+void MapField<Derived, Key, T, kKeyFieldType, kValueFieldType,
+              default_enum_value>::SetMapIteratorValue(MapIterator* map_iter)
+    const {
+  const Map<Key, T>& map = impl_.GetMap();
+  typename Map<Key, T>::const_iterator iter =
+      TypeDefinedMapFieldBase<Key, T>::InternalGetIterator(map_iter);
+  if (iter == map.end()) return;
+  SetMapKey(&map_iter->key_, iter->first);
+  map_iter->value_.SetValue(&iter->second);
+}
+
+template <typename Derived, typename Key, typename T,
+          WireFormatLite::FieldType kKeyFieldType,
+          WireFormatLite::FieldType kValueFieldType, int default_enum_value>
+bool MapField<Derived, Key, T, kKeyFieldType, kValueFieldType,
+              default_enum_value>::ContainsMapKey(const MapKey& map_key) const {
+  const Map<Key, T>& map = impl_.GetMap();
+  const Key& key = UnwrapMapKey<Key>(map_key);
+  typename Map<Key, T>::const_iterator iter = map.find(key);
+  return iter != map.end();
+}
+
+template <typename Derived, typename Key, typename T,
+          WireFormatLite::FieldType kKeyFieldType,
+          WireFormatLite::FieldType kValueFieldType, int default_enum_value>
+bool MapField<Derived, Key, T, kKeyFieldType, kValueFieldType,
+              default_enum_value>::InsertOrLookupMapValue(const MapKey& map_key,
+                                                          MapValueRef* val) {
+  // Always use mutable map because users may change the map value by
+  // MapValueRef.
+  Map<Key, T>* map = MutableMap();
+  const Key& key = UnwrapMapKey<Key>(map_key);
+  typename Map<Key, T>::iterator iter = map->find(key);
+  if (map->end() == iter) {
+    val->SetValue(&((*map)[key]));
+    return true;
+  }
+  // Key is already in the map. Make sure (*map)[key] is not called.
+  // [] may reorder the map and iterators.
+  val->SetValue(&(iter->second));
+  return false;
+}
+
+template <typename Derived, typename Key, typename T,
+          WireFormatLite::FieldType kKeyFieldType,
+          WireFormatLite::FieldType kValueFieldType, int default_enum_value>
+bool MapField<Derived, Key, T, kKeyFieldType, kValueFieldType,
+              default_enum_value>::DeleteMapValue(const MapKey& map_key) {
+  const Key& key = UnwrapMapKey<Key>(map_key);
+  return MutableMap()->erase(key);
+}
+
+template <typename Derived, typename Key, typename T,
+          WireFormatLite::FieldType kKeyFieldType,
+          WireFormatLite::FieldType kValueFieldType, int default_enum_value>
+void MapField<Derived, Key, T, kKeyFieldType, kValueFieldType,
+              default_enum_value>::MergeFrom(const MapField& other) {
+  MapFieldBase::SyncMapWithRepeatedField();
+  other.SyncMapWithRepeatedField();
+  impl_.MergeFrom(other.impl_);
+  MapFieldBase::SetMapDirty();
+}
+
+template <typename Derived, typename Key, typename T,
+          WireFormatLite::FieldType kKeyFieldType,
+          WireFormatLite::FieldType kValueFieldType, int default_enum_value>
+void MapField<Derived, Key, T, kKeyFieldType, kValueFieldType,
+              default_enum_value>::Swap(MapField* other) {
+  std::swap(this->MapFieldBase::repeated_field_, other->repeated_field_);
+  impl_.Swap(&other->impl_);
+  std::swap(this->MapFieldBase::state_, other->state_);
+}
+
+template <typename Derived, typename Key, typename T,
+          WireFormatLite::FieldType kKeyFieldType,
+          WireFormatLite::FieldType kValueFieldType, int default_enum_value>
+void MapField<Derived, Key, T, kKeyFieldType, kValueFieldType,
+              default_enum_value>::SyncRepeatedFieldWithMapNoLock() const {
+  if (this->MapFieldBase::repeated_field_ == NULL) {
+    if (this->MapFieldBase::arena_ == NULL) {
+      this->MapFieldBase::repeated_field_ = new RepeatedPtrField<Message>();
+    } else {
+      this->MapFieldBase::repeated_field_ =
+          Arena::CreateMessage<RepeatedPtrField<Message> >(
+              this->MapFieldBase::arena_);
+    }
+  }
+  const Map<Key, T>& map = impl_.GetMap();
+  RepeatedPtrField<EntryType>* repeated_field =
+      reinterpret_cast<RepeatedPtrField<EntryType>*>(
+          this->MapFieldBase::repeated_field_);
+
+  repeated_field->Clear();
+
+  // The only way we can get at this point is through reflection and the
+  // only way we can get the reflection object is by having called GetReflection
+  // on the encompassing field. So that type must have existed and hence we
+  // know that this MapEntry default_type has also already been constructed.
+  // So it's safe to just call internal_default_instance().
+  const Message* default_entry = Derived::internal_default_instance();
+  for (typename Map<Key, T>::const_iterator it = map.begin();
+       it != map.end(); ++it) {
+    EntryType* new_entry =
+        down_cast<EntryType*>(default_entry->New(this->MapFieldBase::arena_));
+    repeated_field->AddAllocated(new_entry);
+    (*new_entry->mutable_key()) = it->first;
+    (*new_entry->mutable_value()) = it->second;
+  }
+}
+
+template <typename Derived, typename Key, typename T,
+          WireFormatLite::FieldType kKeyFieldType,
+          WireFormatLite::FieldType kValueFieldType, int default_enum_value>
+void MapField<Derived, Key, T, kKeyFieldType, kValueFieldType,
+              default_enum_value>::SyncMapWithRepeatedFieldNoLock() const {
+  Map<Key, T>* map = const_cast<MapField*>(this)->impl_.MutableMap();
+  RepeatedPtrField<EntryType>* repeated_field =
+      reinterpret_cast<RepeatedPtrField<EntryType>*>(
+          this->MapFieldBase::repeated_field_);
+  GOOGLE_CHECK(this->MapFieldBase::repeated_field_ != NULL);
+  map->clear();
+  for (typename RepeatedPtrField<EntryType>::iterator it =
+           repeated_field->begin(); it != repeated_field->end(); ++it) {
+    // Cast is needed because Map's api and internal storage is different when
+    // value is enum. For enum, we cannot cast an int to enum. Thus, we have to
+    // copy value. For other types, they have same exposed api type and internal
+    // stored type. We should not introduce value copy for them. We achieve this
+    // by casting to value for enum while casting to reference for other types.
+    (*map)[it->key()] = static_cast<CastValueType>(it->value());
+  }
+}
+
+template <typename Derived, typename Key, typename T,
+          WireFormatLite::FieldType kKeyFieldType,
+          WireFormatLite::FieldType kValueFieldType, int default_enum_value>
+size_t MapField<Derived, Key, T, kKeyFieldType, kValueFieldType,
+                default_enum_value>::SpaceUsedExcludingSelfNoLock() const {
+  size_t size = 0;
+  if (this->MapFieldBase::repeated_field_ != NULL) {
+    size += this->MapFieldBase::repeated_field_->SpaceUsedExcludingSelfLong();
+  }
+  Map<Key, T>* map = const_cast<MapField*>(this)->impl_.MutableMap();
+  size += sizeof(*map);
+  for (typename Map<Key, T>::iterator it = map->begin(); it != map->end();
+       ++it) {
+    size += KeyTypeHandler::SpaceUsedInMapLong(it->first);
+    size += ValueTypeHandler::SpaceUsedInMapLong(it->second);
+  }
+  return size;
+}
+}  // namespace internal
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_MAP_FIELD_INL_H__
diff --git a/kortex_api/include/google/protobuf/map_field_lite.h b/kortex_api/include/google/protobuf/map_field_lite.h
new file mode 100644
index 0000000000000000000000000000000000000000..f648b43034f6f1aae741ac89cb0773814b782f17
--- /dev/null
+++ b/kortex_api/include/google/protobuf/map_field_lite.h
@@ -0,0 +1,143 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_MAP_FIELD_LITE_H__
+#define GOOGLE_PROTOBUF_MAP_FIELD_LITE_H__
+
+#include <google/protobuf/map.h>
+#include <google/protobuf/map_entry_lite.h>
+#include <google/protobuf/wire_format_lite.h>
+
+namespace google {
+namespace protobuf {
+namespace internal {
+
+// This class provides access to map field using generated api. It is used for
+// internal generated message implentation only. Users should never use this
+// directly.
+template <typename Derived, typename Key, typename T,
+          WireFormatLite::FieldType key_wire_type,
+          WireFormatLite::FieldType value_wire_type, int default_enum_value = 0>
+class MapFieldLite {
+  // Define message type for internal repeated field.
+  typedef Derived EntryType;
+
+ public:
+  typedef Map<Key, T> MapType;
+  typedef EntryType EntryTypeTrait;
+
+  MapFieldLite() : arena_(NULL) { SetDefaultEnumValue(); }
+
+  explicit MapFieldLite(Arena* arena) : arena_(arena), map_(arena) {
+    SetDefaultEnumValue();
+  }
+
+  // Accessors
+  const Map<Key, T>& GetMap() const { return map_; }
+  Map<Key, T>* MutableMap() { return &map_; }
+
+  // Convenient methods for generated message implementation.
+  int size() const { return static_cast<int>(map_.size()); }
+  void Clear() { return map_.clear(); }
+  void MergeFrom(const MapFieldLite& other) {
+    for (typename Map<Key, T>::const_iterator it = other.map_.begin();
+         it != other.map_.end(); ++it) {
+      map_[it->first] = it->second;
+    }
+  }
+  void Swap(MapFieldLite* other) { map_.swap(other->map_); }
+
+  // Set default enum value only for proto2 map field whose value is enum type.
+  void SetDefaultEnumValue() {
+    MutableMap()->SetDefaultEnumValue(default_enum_value);
+  }
+
+  // Used in the implementation of parsing. Caller should take the ownership iff
+  // arena_ is NULL.
+  EntryType* NewEntry() const {
+    if (arena_ == NULL) {
+      return new EntryType();
+    } else {
+      return Arena::CreateMessage<EntryType>(arena_);
+    }
+  }
+  // Used in the implementation of serializing enum value type. Caller should
+  // take the ownership iff arena_ is NULL.
+  EntryType* NewEnumEntryWrapper(const Key& key, const T t) const {
+    return EntryType::EnumWrap(key, t, arena_);
+  }
+  // Used in the implementation of serializing other value types. Caller should
+  // take the ownership iff arena_ is NULL.
+  EntryType* NewEntryWrapper(const Key& key, const T& t) const {
+    return EntryType::Wrap(key, t, arena_);
+  }
+
+ private:
+  typedef void DestructorSkippable_;
+
+  Arena* arena_;
+  Map<Key, T> map_;
+
+  friend class ::google::protobuf::Arena;
+};
+
+// True if IsInitialized() is true for value field in all elements of t. T is
+// expected to be message.  It's useful to have this helper here to keep the
+// protobuf compiler from ever having to emit loops in IsInitialized() methods.
+// We want the C++ compiler to inline this or not as it sees fit.
+template <typename Key, typename T>
+bool AllAreInitialized(const Map<Key, T>& t) {
+  for (typename Map<Key, T>::const_iterator it = t.begin(); it != t.end();
+       ++it) {
+    if (!it->second.IsInitialized()) return false;
+  }
+  return true;
+}
+
+template <typename MEntry>
+struct MapEntryToMapField : MapEntryToMapField<typename MEntry::SuperType> {};
+
+template <typename T, typename Key, typename Value,
+          WireFormatLite::FieldType kKeyFieldType,
+          WireFormatLite::FieldType kValueFieldType, int default_enum_value>
+struct MapEntryToMapField<MapEntryLite<T, Key, Value, kKeyFieldType,
+                                       kValueFieldType, default_enum_value> > {
+  typedef MapFieldLite<MapEntryLite<T, Key, Value, kKeyFieldType,
+                                    kValueFieldType, default_enum_value>,
+                       Key, Value, kKeyFieldType, kValueFieldType,
+                       default_enum_value>
+      MapFieldType;
+};
+
+}  // namespace internal
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_MAP_FIELD_LITE_H__
diff --git a/kortex_api/include/google/protobuf/map_type_handler.h b/kortex_api/include/google/protobuf/map_type_handler.h
new file mode 100644
index 0000000000000000000000000000000000000000..7f7b1e0e1d007f32f06c0c28f46f2308d53f94c0
--- /dev/null
+++ b/kortex_api/include/google/protobuf/map_type_handler.h
@@ -0,0 +1,739 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_TYPE_HANDLER_H__
+#define GOOGLE_PROTOBUF_TYPE_HANDLER_H__
+
+#include <google/protobuf/arena.h>
+#include <google/protobuf/wire_format_lite_inl.h>
+
+namespace google {
+namespace protobuf {
+namespace internal {
+
+// Used for compile time type selection. MapIf::type will be TrueType if Flag is
+// true and FalseType otherwise.
+template<bool Flag, typename TrueType, typename FalseType>
+struct MapIf;
+
+template<typename TrueType, typename FalseType>
+struct MapIf<true, TrueType, FalseType> {
+  typedef TrueType type;
+};
+
+template<typename TrueType, typename FalseType>
+struct MapIf<false, TrueType, FalseType> {
+  typedef FalseType type;
+};
+
+// In proto2 Map, enum needs to be initialized to given default value, while
+// other types' default value can be inferred from the type.
+template <bool IsEnum, typename Type>
+class MapValueInitializer {
+ public:
+  static inline void Initialize(Type& type, int default_enum_value);
+};
+
+template <typename Type>
+class MapValueInitializer<true, Type> {
+ public:
+  static inline void Initialize(Type& value, int default_enum_value) {
+    value = static_cast<Type>(default_enum_value);
+  }
+};
+
+template <typename Type>
+class MapValueInitializer<false, Type> {
+ public:
+  static inline void Initialize(Type& /* value */, int /* default_enum_value */) {}
+};
+
+template <typename Type, bool is_arena_constructable>
+class MapArenaMessageCreator {
+ public:
+  // Use arena to create message if Type is arena constructable. Otherwise,
+  // create the message on heap.
+  static inline Type* CreateMessage(Arena* arena);
+};
+template <typename Type>
+class MapArenaMessageCreator<Type, true> {
+ public:
+  static inline Type* CreateMessage(Arena* arena) {
+    return Arena::CreateMessage<Type>(arena);
+  }
+};
+template <typename Type>
+class MapArenaMessageCreator<Type, false> {
+ public:
+  static inline Type* CreateMessage(Arena* arena) {
+    return Arena::Create<Type>(arena);
+  }
+};
+
+// Define constants for given wire field type
+template <WireFormatLite::FieldType field_type, typename Type>
+class MapWireFieldTypeTraits {};
+
+#define TYPE_TRAITS(FieldType, CType, WireFormatType, IsMessage, IsEnum)   \
+  template <typename Type>                                                 \
+  class MapWireFieldTypeTraits<WireFormatLite::TYPE_##FieldType, Type> {   \
+   public:                                                                 \
+    static const bool kIsMessage = IsMessage;                              \
+    static const bool kIsEnum = IsEnum;                                    \
+    typedef typename MapIf<kIsMessage, Type*, CType>::type TypeOnMemory;   \
+    typedef typename MapIf<kIsEnum, int, Type>::type MapEntryAccessorType; \
+    static const WireFormatLite::WireType kWireType =                      \
+        WireFormatLite::WIRETYPE_##WireFormatType;                         \
+  };
+
+TYPE_TRAITS(MESSAGE , Type, LENGTH_DELIMITED, true, false)
+TYPE_TRAITS(STRING  , ArenaStringPtr, LENGTH_DELIMITED, false, false)
+TYPE_TRAITS(BYTES   , ArenaStringPtr ,  LENGTH_DELIMITED, false, false)
+TYPE_TRAITS(INT64   , int64  ,  VARINT , false, false)
+TYPE_TRAITS(UINT64  , uint64 ,  VARINT , false, false)
+TYPE_TRAITS(INT32   , int32  ,  VARINT , false, false)
+TYPE_TRAITS(UINT32  , uint32 ,  VARINT , false, false)
+TYPE_TRAITS(SINT64  , int64  ,  VARINT , false, false)
+TYPE_TRAITS(SINT32  , int32  ,  VARINT , false, false)
+TYPE_TRAITS(ENUM    , int    ,  VARINT , false, true )
+TYPE_TRAITS(DOUBLE  , double ,  FIXED64, false, false)
+TYPE_TRAITS(FLOAT   , float  ,  FIXED32, false, false)
+TYPE_TRAITS(FIXED64 , uint64 ,  FIXED64, false, false)
+TYPE_TRAITS(FIXED32 , uint32 ,  FIXED32, false, false)
+TYPE_TRAITS(SFIXED64, int64  ,  FIXED64, false, false)
+TYPE_TRAITS(SFIXED32, int32  ,  FIXED32, false, false)
+TYPE_TRAITS(BOOL    , bool   ,  VARINT , false, false)
+
+#undef TYPE_TRAITS
+
+template <WireFormatLite::FieldType field_type, typename Type>
+class MapTypeHandler {};
+
+template <typename Type>
+class MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type> {
+ public:
+  // Enum type cannot be used for MapTypeHandler::Read. Define a type which will
+  // replace Enum with int.
+  typedef typename MapWireFieldTypeTraits<WireFormatLite::TYPE_MESSAGE,
+      Type>::MapEntryAccessorType MapEntryAccessorType;
+  // Internal stored type in MapEntryLite for given wire field type.
+  typedef typename MapWireFieldTypeTraits<WireFormatLite::TYPE_MESSAGE,
+                                          Type>::TypeOnMemory TypeOnMemory;
+  // Corresponding wire type for field type.
+  static const WireFormatLite::WireType kWireType =
+      MapWireFieldTypeTraits<WireFormatLite::TYPE_MESSAGE, Type>::kWireType;
+  // Whether wire type is for message.
+  static const bool kIsMessage =
+      MapWireFieldTypeTraits<WireFormatLite::TYPE_MESSAGE, Type>::kIsMessage;
+  // Whether wire type is for enum.
+  static const bool kIsEnum =
+      MapWireFieldTypeTraits<WireFormatLite::TYPE_MESSAGE, Type>::kIsEnum;
+
+  // Functions used in parsing and serialization. ===================
+  static inline size_t ByteSize(const MapEntryAccessorType& value);
+  static inline int GetCachedSize(const MapEntryAccessorType& value);
+  static inline bool Read(io::CodedInputStream* input,
+                          MapEntryAccessorType* value);
+  static inline void Write(int field, const MapEntryAccessorType& value,
+                           io::CodedOutputStream* output);
+  static inline uint8* InternalWriteToArray(int field,
+                                            const MapEntryAccessorType& value,
+                                            bool deterministic, uint8* target);
+  static inline uint8* WriteToArray(int field,
+                                    const MapEntryAccessorType& value,
+                                    uint8* target);
+
+  // Functions to manipulate data on memory. ========================
+  static inline const Type& GetExternalReference(const Type* value);
+  static inline void DeleteNoArena(const Type* x);
+  static inline void Merge(const Type& from, Type** to, Arena* arena);
+  static inline void Clear(Type** value, Arena* arena);
+  static inline void ClearMaybeByDefaultEnum(Type** value, Arena* arena,
+                                             int default_enum_value);
+  static inline void Initialize(Type** x, Arena* arena);
+
+  static inline void InitializeMaybeByDefaultEnum(Type** x,
+                                                  int default_enum_value,
+                                                  Arena* arena);
+  static inline Type* EnsureMutable(Type** value, Arena* arena);
+  // SpaceUsedInMapEntry: Return bytes used by value in MapEntry, excluding
+  // those already calculate in sizeof(MapField).
+  static inline size_t SpaceUsedInMapEntryLong(const Type* value);
+  // Return bytes used by value in Map.
+  static inline size_t SpaceUsedInMapLong(const Type& value);
+  // Assign default value to given instance.
+  static inline void AssignDefaultValue(Type** value);
+  // Return default instance if value is not initialized when calling const
+  // reference accessor.
+  static inline const Type& DefaultIfNotInitialized(
+      const Type* value, const Type* default_value);
+  // Check if all required fields have values set.
+  static inline bool IsInitialized(Type* value);
+};
+
+#define MAP_HANDLER(FieldType)                                                \
+  template <typename Type>                                                    \
+  class MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type> {              \
+   public:                                                                    \
+    typedef typename MapWireFieldTypeTraits<WireFormatLite::TYPE_##FieldType, \
+                                            Type>::MapEntryAccessorType       \
+        MapEntryAccessorType;                                                 \
+    typedef typename MapWireFieldTypeTraits<WireFormatLite::TYPE_##FieldType, \
+                                            Type>::TypeOnMemory TypeOnMemory; \
+    static const WireFormatLite::WireType kWireType =                         \
+        MapWireFieldTypeTraits<WireFormatLite::TYPE_##FieldType,              \
+                               Type>::kWireType;                              \
+    static const bool kIsMessage =                                            \
+        MapWireFieldTypeTraits<WireFormatLite::TYPE_##FieldType,              \
+                               Type>::kIsMessage;                             \
+    static const bool kIsEnum =                                               \
+        MapWireFieldTypeTraits<WireFormatLite::TYPE_##FieldType,              \
+                               Type>::kIsEnum;                                \
+    static inline int ByteSize(const MapEntryAccessorType& value);            \
+    static inline int GetCachedSize(const MapEntryAccessorType& value);       \
+    static inline bool Read(io::CodedInputStream* input,                      \
+                            MapEntryAccessorType* value);                     \
+    static inline void Write(int field, const MapEntryAccessorType& value,    \
+                             io::CodedOutputStream* output);                  \
+    static inline uint8* InternalWriteToArray(                                \
+        int field, const MapEntryAccessorType& value, bool deterministic,     \
+        uint8* target);                                                       \
+    static inline uint8* WriteToArray(int field,                              \
+                                      const MapEntryAccessorType& value,      \
+                                      uint8* target) {                        \
+      return InternalWriteToArray(field, value, false, target);               \
+    }                                                                         \
+    static inline const MapEntryAccessorType& GetExternalReference(           \
+        const TypeOnMemory& value);                                           \
+    static inline void DeleteNoArena(const TypeOnMemory& x);                  \
+    static inline void Merge(const MapEntryAccessorType& from,                \
+                             TypeOnMemory* to, Arena* arena);                 \
+    static inline void Clear(TypeOnMemory* value, Arena* arena);              \
+    static inline void ClearMaybeByDefaultEnum(TypeOnMemory* value,           \
+                                               Arena* arena,                  \
+                                               int default_enum);             \
+    static inline size_t SpaceUsedInMapEntryLong(const TypeOnMemory& value);  \
+    static inline size_t SpaceUsedInMapLong(const TypeOnMemory& value);       \
+    static inline size_t SpaceUsedInMapLong(const string& value);             \
+    static inline void AssignDefaultValue(TypeOnMemory* value);               \
+    static inline const MapEntryAccessorType& DefaultIfNotInitialized(        \
+        const TypeOnMemory& value, const TypeOnMemory& default_value);        \
+    static inline bool IsInitialized(const TypeOnMemory& value);              \
+    static void DeleteNoArena(TypeOnMemory& value);                           \
+    static inline void Initialize(TypeOnMemory* value, Arena* arena);         \
+    static inline void InitializeMaybeByDefaultEnum(TypeOnMemory* value,      \
+                                                    int default_enum_value,   \
+                                                    Arena* arena);            \
+    static inline MapEntryAccessorType* EnsureMutable(TypeOnMemory* value,    \
+                                                      Arena* arena);          \
+  };
+MAP_HANDLER(STRING)
+MAP_HANDLER(BYTES)
+MAP_HANDLER(INT64)
+MAP_HANDLER(UINT64)
+MAP_HANDLER(INT32)
+MAP_HANDLER(UINT32)
+MAP_HANDLER(SINT64)
+MAP_HANDLER(SINT32)
+MAP_HANDLER(ENUM)
+MAP_HANDLER(DOUBLE)
+MAP_HANDLER(FLOAT)
+MAP_HANDLER(FIXED64)
+MAP_HANDLER(FIXED32)
+MAP_HANDLER(SFIXED64)
+MAP_HANDLER(SFIXED32)
+MAP_HANDLER(BOOL)
+#undef MAP_HANDLER
+
+template <typename Type>
+inline size_t
+MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::ByteSize(
+    const MapEntryAccessorType& value) {
+  return WireFormatLite::MessageSizeNoVirtual(value);
+}
+
+#define GOOGLE_PROTOBUF_BYTE_SIZE(FieldType, DeclaredType)                     \
+  template <typename Type>                                                     \
+  inline int MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::ByteSize( \
+      const MapEntryAccessorType& value) {                                     \
+    return static_cast<int>(WireFormatLite::DeclaredType##Size(value));        \
+  }
+
+GOOGLE_PROTOBUF_BYTE_SIZE(STRING, String)
+GOOGLE_PROTOBUF_BYTE_SIZE(BYTES , Bytes)
+GOOGLE_PROTOBUF_BYTE_SIZE(INT64 , Int64)
+GOOGLE_PROTOBUF_BYTE_SIZE(UINT64, UInt64)
+GOOGLE_PROTOBUF_BYTE_SIZE(INT32 , Int32)
+GOOGLE_PROTOBUF_BYTE_SIZE(UINT32, UInt32)
+GOOGLE_PROTOBUF_BYTE_SIZE(SINT64, SInt64)
+GOOGLE_PROTOBUF_BYTE_SIZE(SINT32, SInt32)
+GOOGLE_PROTOBUF_BYTE_SIZE(ENUM  , Enum)
+
+#undef GOOGLE_PROTOBUF_BYTE_SIZE
+
+#define FIXED_BYTE_SIZE(FieldType, DeclaredType)                               \
+  template <typename Type>                                                     \
+  inline int MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::ByteSize( \
+      const MapEntryAccessorType& /* value */) {                               \
+    return WireFormatLite::k##DeclaredType##Size;                              \
+  }
+
+FIXED_BYTE_SIZE(DOUBLE  , Double)
+FIXED_BYTE_SIZE(FLOAT   , Float)
+FIXED_BYTE_SIZE(FIXED64 , Fixed64)
+FIXED_BYTE_SIZE(FIXED32 , Fixed32)
+FIXED_BYTE_SIZE(SFIXED64, SFixed64)
+FIXED_BYTE_SIZE(SFIXED32, SFixed32)
+FIXED_BYTE_SIZE(BOOL    , Bool)
+
+#undef FIXED_BYTE_SIZE
+
+template <typename Type>
+inline int
+MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::GetCachedSize(
+    const MapEntryAccessorType& value) {
+  return static_cast<int>(
+      WireFormatLite::LengthDelimitedSize(
+          static_cast<size_t>(value.GetCachedSize())));
+}
+
+#define GET_CACHED_SIZE(FieldType, DeclaredType)                         \
+  template <typename Type>                                               \
+  inline int                                                             \
+  MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::GetCachedSize( \
+      const MapEntryAccessorType& value) {                               \
+    return static_cast<int>(WireFormatLite::DeclaredType##Size(value));  \
+  }
+
+GET_CACHED_SIZE(STRING, String)
+GET_CACHED_SIZE(BYTES , Bytes)
+GET_CACHED_SIZE(INT64 , Int64)
+GET_CACHED_SIZE(UINT64, UInt64)
+GET_CACHED_SIZE(INT32 , Int32)
+GET_CACHED_SIZE(UINT32, UInt32)
+GET_CACHED_SIZE(SINT64, SInt64)
+GET_CACHED_SIZE(SINT32, SInt32)
+GET_CACHED_SIZE(ENUM  , Enum)
+
+#undef GET_CACHED_SIZE
+
+#define GET_FIXED_CACHED_SIZE(FieldType, DeclaredType)                   \
+  template <typename Type>                                               \
+  inline int                                                             \
+  MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::GetCachedSize( \
+      const MapEntryAccessorType& /* value */) {                         \
+    return WireFormatLite::k##DeclaredType##Size;                        \
+  }
+
+GET_FIXED_CACHED_SIZE(DOUBLE  , Double)
+GET_FIXED_CACHED_SIZE(FLOAT   , Float)
+GET_FIXED_CACHED_SIZE(FIXED64 , Fixed64)
+GET_FIXED_CACHED_SIZE(FIXED32 , Fixed32)
+GET_FIXED_CACHED_SIZE(SFIXED64, SFixed64)
+GET_FIXED_CACHED_SIZE(SFIXED32, SFixed32)
+GET_FIXED_CACHED_SIZE(BOOL    , Bool)
+
+#undef GET_FIXED_CACHED_SIZE
+
+template <typename Type>
+inline void MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::Write(
+    int field, const MapEntryAccessorType& value,
+    io::CodedOutputStream* output) {
+  WireFormatLite::WriteMessageMaybeToArray(field, value, output);
+}
+
+template <typename Type>
+inline uint8*
+MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::InternalWriteToArray(
+    int field, const MapEntryAccessorType& value, bool deterministic,
+    uint8* target) {
+  return WireFormatLite::InternalWriteMessageToArray(field, value,
+                                                     deterministic, target);
+}
+
+#define WRITE_METHOD(FieldType, DeclaredType)                                  \
+  template <typename Type>                                                     \
+  inline void MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Write(   \
+      int field, const MapEntryAccessorType& value,                            \
+      io::CodedOutputStream* output) {                                         \
+    return WireFormatLite::Write##DeclaredType(field, value, output);          \
+  }                                                                            \
+  template <typename Type>                                                     \
+  inline uint8*                                                                \
+  MapTypeHandler<WireFormatLite::TYPE_##FieldType,                             \
+                 Type>::InternalWriteToArray(                                  \
+      int field, const MapEntryAccessorType& value, bool, uint8* target) {     \
+    return WireFormatLite::Write##DeclaredType##ToArray(field, value, target); \
+  }
+
+WRITE_METHOD(STRING  , String)
+WRITE_METHOD(BYTES   , Bytes)
+WRITE_METHOD(INT64   , Int64)
+WRITE_METHOD(UINT64  , UInt64)
+WRITE_METHOD(INT32   , Int32)
+WRITE_METHOD(UINT32  , UInt32)
+WRITE_METHOD(SINT64  , SInt64)
+WRITE_METHOD(SINT32  , SInt32)
+WRITE_METHOD(ENUM    , Enum)
+WRITE_METHOD(DOUBLE  , Double)
+WRITE_METHOD(FLOAT   , Float)
+WRITE_METHOD(FIXED64 , Fixed64)
+WRITE_METHOD(FIXED32 , Fixed32)
+WRITE_METHOD(SFIXED64, SFixed64)
+WRITE_METHOD(SFIXED32, SFixed32)
+WRITE_METHOD(BOOL    , Bool)
+
+#undef WRITE_METHOD
+
+template <typename Type>
+inline bool MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::Read(
+    io::CodedInputStream* input, MapEntryAccessorType* value) {
+  return WireFormatLite::ReadMessageNoVirtual(input, value);
+}
+
+template <typename Type>
+inline bool MapTypeHandler<WireFormatLite::TYPE_STRING, Type>::Read(
+    io::CodedInputStream* input, MapEntryAccessorType* value) {
+  return WireFormatLite::ReadString(input, value);
+}
+
+template <typename Type>
+inline bool MapTypeHandler<WireFormatLite::TYPE_BYTES, Type>::Read(
+    io::CodedInputStream* input, MapEntryAccessorType* value) {
+  return WireFormatLite::ReadBytes(input, value);
+}
+
+#define READ_METHOD(FieldType)                                              \
+  template <typename Type>                                                  \
+  inline bool MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Read( \
+      io::CodedInputStream* input, MapEntryAccessorType* value) {           \
+    return WireFormatLite::ReadPrimitive<TypeOnMemory,                      \
+                                         WireFormatLite::TYPE_##FieldType>( \
+        input, value);                                                      \
+  }
+
+READ_METHOD(INT64)
+READ_METHOD(UINT64)
+READ_METHOD(INT32)
+READ_METHOD(UINT32)
+READ_METHOD(SINT64)
+READ_METHOD(SINT32)
+READ_METHOD(ENUM)
+READ_METHOD(DOUBLE)
+READ_METHOD(FLOAT)
+READ_METHOD(FIXED64)
+READ_METHOD(FIXED32)
+READ_METHOD(SFIXED64)
+READ_METHOD(SFIXED32)
+READ_METHOD(BOOL)
+
+#undef READ_METHOD
+
+// Definition for message handler
+
+template <typename Type>
+inline const Type&
+MapTypeHandler<WireFormatLite::TYPE_MESSAGE,
+                        Type>::GetExternalReference(const Type* value) {
+  return *value;
+}
+
+template <typename Type>
+inline size_t MapTypeHandler<WireFormatLite::TYPE_MESSAGE,
+                             Type>::SpaceUsedInMapEntryLong(const Type* value) {
+  return value->SpaceUsedLong();
+}
+
+template <typename Type>
+size_t MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::SpaceUsedInMapLong(
+    const Type& value) {
+  return value.SpaceUsedLong();
+}
+
+template <typename Type>
+inline void MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::Clear(
+    Type** value, Arena* /* arena */) {
+  if (*value != NULL) (*value)->Clear();
+}
+template <typename Type>
+inline void
+MapTypeHandler<WireFormatLite::TYPE_MESSAGE,
+                        Type>::ClearMaybeByDefaultEnum(Type** value,
+                                                       Arena* /* arena */,
+                                                       int /* default_enum_value */) {
+  if (*value != NULL) (*value)->Clear();
+}
+template <typename Type>
+inline void MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::Merge(
+    const Type& from, Type** to, Arena* /* arena */) {
+  (*to)->MergeFrom(from);
+}
+
+template <typename Type>
+void MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::DeleteNoArena(
+    const Type* ptr) {
+  delete ptr;
+}
+
+template <typename Type>
+inline void MapTypeHandler<WireFormatLite::TYPE_MESSAGE,
+                                    Type>::AssignDefaultValue(Type** value) {
+  *value = const_cast<Type*>(Type::internal_default_instance());
+}
+
+template <typename Type>
+inline void MapTypeHandler<WireFormatLite::TYPE_MESSAGE,
+                                    Type>::Initialize(Type** x,
+                                                      Arena* /* arena */) {
+  *x = NULL;
+}
+
+template <typename Type>
+inline void MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::
+    InitializeMaybeByDefaultEnum(Type** x, int /* default_enum_value */,
+                                 Arena* /* arena */) {
+  *x = NULL;
+}
+
+template <typename Type>
+inline Type* MapTypeHandler<WireFormatLite::TYPE_MESSAGE,
+                                     Type>::EnsureMutable(Type** value,
+                                                          Arena* arena) {
+  if (*value == NULL) {
+    *value =
+        MapArenaMessageCreator<Type, Arena::is_arena_constructable<Type>::
+                                         type::value>::CreateMessage(arena);
+  }
+  return *value;
+}
+
+template <typename Type>
+inline const Type& MapTypeHandler<WireFormatLite::TYPE_MESSAGE, Type>::
+    DefaultIfNotInitialized(const Type* value, const Type* default_value) {
+  return value != NULL ? *value : *default_value;
+}
+
+template <typename Type>
+inline bool MapTypeHandler<WireFormatLite::TYPE_MESSAGE,
+                                    Type>::IsInitialized(Type* value) {
+  return value->IsInitialized();
+}
+
+// Definition for string/bytes handler
+
+#define STRING_OR_BYTES_HANDLER_FUNCTIONS(FieldType)                           \
+  template <typename Type>                                                     \
+  inline const typename MapTypeHandler<WireFormatLite::TYPE_##FieldType,       \
+                                       Type>::MapEntryAccessorType&            \
+  MapTypeHandler<WireFormatLite::TYPE_##FieldType,                             \
+                 Type>::GetExternalReference(const TypeOnMemory& value) {      \
+    return value.Get();                                                        \
+  }                                                                            \
+  template <typename Type>                                                     \
+  inline size_t                                                                \
+  MapTypeHandler<WireFormatLite::TYPE_##FieldType,                             \
+                 Type>::SpaceUsedInMapEntryLong(const TypeOnMemory& value) {   \
+    return sizeof(value);                                                      \
+  }                                                                            \
+  template <typename Type>                                                     \
+  inline size_t                                                                \
+  MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::SpaceUsedInMapLong(  \
+      const TypeOnMemory& value) {                                             \
+    return sizeof(value);                                                      \
+  }                                                                            \
+  template <typename Type>                                                     \
+  inline size_t                                                                \
+  MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::SpaceUsedInMapLong(  \
+      const string& value) {                                                   \
+    return sizeof(value);                                                      \
+  }                                                                            \
+  template <typename Type>                                                     \
+  inline void MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Clear(   \
+      TypeOnMemory* value, Arena* arena) {                                     \
+    value->ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),    \
+                        arena);                                                \
+  }                                                                            \
+  template <typename Type>                                                     \
+  inline void MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::         \
+      ClearMaybeByDefaultEnum(TypeOnMemory* value, Arena* arena,               \
+                              int /* default_enum */) {                        \
+    Clear(value, arena);                                                       \
+  }                                                                            \
+  template <typename Type>                                                     \
+  inline void MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Merge(   \
+      const MapEntryAccessorType& from, TypeOnMemory* to, Arena* arena) {      \
+    to->Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from, arena);  \
+  }                                                                            \
+  template <typename Type>                                                     \
+  void MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::DeleteNoArena(  \
+      TypeOnMemory& value) {                                                   \
+    value.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());  \
+  }                                                                            \
+  template <typename Type>                                                     \
+  inline void MapTypeHandler<WireFormatLite::TYPE_##FieldType,                 \
+                             Type>::AssignDefaultValue(TypeOnMemory* /* value */) {} \
+  template <typename Type>                                                     \
+  inline void                                                                  \
+  MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Initialize(          \
+      TypeOnMemory* value, Arena* /* arena */) {                               \
+    value->UnsafeSetDefault(                                                   \
+        &::google::protobuf::internal::GetEmptyStringAlreadyInited());                   \
+  }                                                                            \
+  template <typename Type>                                                     \
+  inline void MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::         \
+      InitializeMaybeByDefaultEnum(TypeOnMemory* value,                        \
+                                   int /* default_enum_value */,               \
+                                   Arena* arena) {                             \
+    Initialize(value, arena);                                                  \
+  }                                                                            \
+  template <typename Type>                                                     \
+  inline typename MapTypeHandler<WireFormatLite::TYPE_##FieldType,             \
+                                 Type>::MapEntryAccessorType*                  \
+  MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::EnsureMutable(       \
+      TypeOnMemory* value, Arena* arena) {                                     \
+    return value->Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),  \
+                          arena);                                              \
+  }                                                                            \
+  template <typename Type>                                                     \
+  inline const typename MapTypeHandler<WireFormatLite::TYPE_##FieldType,       \
+                                       Type>::MapEntryAccessorType&            \
+  MapTypeHandler<WireFormatLite::TYPE_##FieldType,                             \
+                 Type>::DefaultIfNotInitialized(const TypeOnMemory& value,     \
+                                                const TypeOnMemory&            \
+                                                    /* default_value */) {     \
+    return value.Get();                                                        \
+  }                                                                            \
+  template <typename Type>                                                     \
+  inline bool MapTypeHandler<WireFormatLite::TYPE_##FieldType,                 \
+                             Type>::IsInitialized(const TypeOnMemory& /* value */) { \
+    return true;                                                               \
+  }
+STRING_OR_BYTES_HANDLER_FUNCTIONS(STRING)
+STRING_OR_BYTES_HANDLER_FUNCTIONS(BYTES)
+#undef STRING_OR_BYTES_HANDLER_FUNCTIONS
+
+#define PRIMITIVE_HANDLER_FUNCTIONS(FieldType)                                 \
+  template <typename Type>                                                     \
+  inline const typename MapTypeHandler<WireFormatLite::TYPE_##FieldType,       \
+                                       Type>::MapEntryAccessorType&            \
+  MapTypeHandler<WireFormatLite::TYPE_##FieldType,                             \
+                 Type>::GetExternalReference(const TypeOnMemory& value) {      \
+    return value;                                                              \
+  }                                                                            \
+  template <typename Type>                                                     \
+  inline size_t                                                                \
+  MapTypeHandler<WireFormatLite::TYPE_##FieldType,                             \
+                 Type>::SpaceUsedInMapEntryLong(const TypeOnMemory& /* value */) {   \
+    return 0;                                                                  \
+  }                                                                            \
+  template <typename Type>                                                     \
+  inline size_t                                                                \
+  MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::SpaceUsedInMapLong(  \
+      const TypeOnMemory& /* value */) {                                       \
+    return sizeof(Type);                                                       \
+  }                                                                            \
+  template <typename Type>                                                     \
+  inline void MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Clear(   \
+      TypeOnMemory* value, Arena* /* arena */) {                               \
+    *value = 0;                                                                \
+  }                                                                            \
+  template <typename Type>                                                     \
+  inline void MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::         \
+      ClearMaybeByDefaultEnum(TypeOnMemory* value, Arena* /* arena */,         \
+                              int default_enum_value) {                        \
+    *value = static_cast<TypeOnMemory>(default_enum_value);                    \
+  }                                                                            \
+  template <typename Type>                                                     \
+  inline void MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Merge(   \
+      const MapEntryAccessorType& from, TypeOnMemory* to,                      \
+      Arena* /* arena */) {                                                    \
+    *to = from;                                                                \
+  }                                                                            \
+  template <typename Type>                                                     \
+  inline void MapTypeHandler<WireFormatLite::TYPE_##FieldType,                 \
+                             Type>::DeleteNoArena(TypeOnMemory& /* x */) {}    \
+  template <typename Type>                                                     \
+  inline void MapTypeHandler<WireFormatLite::TYPE_##FieldType,                 \
+                             Type>::AssignDefaultValue(TypeOnMemory* /* value */) {} \
+  template <typename Type>                                                     \
+  inline void                                                                  \
+  MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::Initialize(          \
+      TypeOnMemory* value, Arena* /* arena */) {                               \
+    *value = 0;                                                                \
+  }                                                                            \
+  template <typename Type>                                                     \
+  inline void MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::         \
+      InitializeMaybeByDefaultEnum(TypeOnMemory* value,                        \
+                                   int default_enum_value,                     \
+                                   Arena* /* arena */) {                       \
+    *value = static_cast<TypeOnMemory>(default_enum_value);                    \
+  }                                                                            \
+  template <typename Type>                                                     \
+  inline typename MapTypeHandler<WireFormatLite::TYPE_##FieldType,             \
+                                 Type>::MapEntryAccessorType*                  \
+  MapTypeHandler<WireFormatLite::TYPE_##FieldType, Type>::EnsureMutable(       \
+      TypeOnMemory* value, Arena* /* arena */) {                               \
+    return value;                                                              \
+  }                                                                            \
+  template <typename Type>                                                     \
+  inline const typename MapTypeHandler<WireFormatLite::TYPE_##FieldType,       \
+                                       Type>::MapEntryAccessorType&            \
+  MapTypeHandler<WireFormatLite::TYPE_##FieldType,                             \
+                 Type>::DefaultIfNotInitialized(const TypeOnMemory& value,     \
+                                                const TypeOnMemory&            \
+                                                   /* default_value */) {      \
+    return value;                                                              \
+  }                                                                            \
+  template <typename Type>                                                     \
+  inline bool MapTypeHandler<WireFormatLite::TYPE_##FieldType,                 \
+                             Type>::IsInitialized(const TypeOnMemory& /* value */) { \
+    return true;                                                               \
+  }
+PRIMITIVE_HANDLER_FUNCTIONS(INT64)
+PRIMITIVE_HANDLER_FUNCTIONS(UINT64)
+PRIMITIVE_HANDLER_FUNCTIONS(INT32)
+PRIMITIVE_HANDLER_FUNCTIONS(UINT32)
+PRIMITIVE_HANDLER_FUNCTIONS(SINT64)
+PRIMITIVE_HANDLER_FUNCTIONS(SINT32)
+PRIMITIVE_HANDLER_FUNCTIONS(ENUM)
+PRIMITIVE_HANDLER_FUNCTIONS(DOUBLE)
+PRIMITIVE_HANDLER_FUNCTIONS(FLOAT)
+PRIMITIVE_HANDLER_FUNCTIONS(FIXED64)
+PRIMITIVE_HANDLER_FUNCTIONS(FIXED32)
+PRIMITIVE_HANDLER_FUNCTIONS(SFIXED64)
+PRIMITIVE_HANDLER_FUNCTIONS(SFIXED32)
+PRIMITIVE_HANDLER_FUNCTIONS(BOOL)
+#undef PRIMITIVE_HANDLER_FUNCTIONS
+
+}  // namespace internal
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_TYPE_HANDLER_H__
diff --git a/kortex_api/include/google/protobuf/message.h b/kortex_api/include/google/protobuf/message.h
new file mode 100644
index 0000000000000000000000000000000000000000..ab0185961f356db80bdb87710b1cc8f0548c93f1
--- /dev/null
+++ b/kortex_api/include/google/protobuf/message.h
@@ -0,0 +1,1170 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// Defines Message, the abstract interface implemented by non-lite
+// protocol message objects.  Although it's possible to implement this
+// interface manually, most users will use the protocol compiler to
+// generate implementations.
+//
+// Example usage:
+//
+// Say you have a message defined as:
+//
+//   message Foo {
+//     optional string text = 1;
+//     repeated int32 numbers = 2;
+//   }
+//
+// Then, if you used the protocol compiler to generate a class from the above
+// definition, you could use it like so:
+//
+//   string data;  // Will store a serialized version of the message.
+//
+//   {
+//     // Create a message and serialize it.
+//     Foo foo;
+//     foo.set_text("Hello World!");
+//     foo.add_numbers(1);
+//     foo.add_numbers(5);
+//     foo.add_numbers(42);
+//
+//     foo.SerializeToString(&data);
+//   }
+//
+//   {
+//     // Parse the serialized message and check that it contains the
+//     // correct data.
+//     Foo foo;
+//     foo.ParseFromString(data);
+//
+//     assert(foo.text() == "Hello World!");
+//     assert(foo.numbers_size() == 3);
+//     assert(foo.numbers(0) == 1);
+//     assert(foo.numbers(1) == 5);
+//     assert(foo.numbers(2) == 42);
+//   }
+//
+//   {
+//     // Same as the last block, but do it dynamically via the Message
+//     // reflection interface.
+//     Message* foo = new Foo;
+//     const Descriptor* descriptor = foo->GetDescriptor();
+//
+//     // Get the descriptors for the fields we're interested in and verify
+//     // their types.
+//     const FieldDescriptor* text_field = descriptor->FindFieldByName("text");
+//     assert(text_field != NULL);
+//     assert(text_field->type() == FieldDescriptor::TYPE_STRING);
+//     assert(text_field->label() == FieldDescriptor::LABEL_OPTIONAL);
+//     const FieldDescriptor* numbers_field = descriptor->
+//                                            FindFieldByName("numbers");
+//     assert(numbers_field != NULL);
+//     assert(numbers_field->type() == FieldDescriptor::TYPE_INT32);
+//     assert(numbers_field->label() == FieldDescriptor::LABEL_REPEATED);
+//
+//     // Parse the message.
+//     foo->ParseFromString(data);
+//
+//     // Use the reflection interface to examine the contents.
+//     const Reflection* reflection = foo->GetReflection();
+//     assert(reflection->GetString(*foo, text_field) == "Hello World!");
+//     assert(reflection->FieldSize(*foo, numbers_field) == 3);
+//     assert(reflection->GetRepeatedInt32(*foo, numbers_field, 0) == 1);
+//     assert(reflection->GetRepeatedInt32(*foo, numbers_field, 1) == 5);
+//     assert(reflection->GetRepeatedInt32(*foo, numbers_field, 2) == 42);
+//
+//     delete foo;
+//   }
+
+#ifndef GOOGLE_PROTOBUF_MESSAGE_H__
+#define GOOGLE_PROTOBUF_MESSAGE_H__
+
+#include <iosfwd>
+#include <string>
+#include <google/protobuf/stubs/type_traits.h>
+#include <vector>
+
+#include <google/protobuf/arena.h>
+#include <google/protobuf/message_lite.h>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/descriptor.h>
+
+
+#define GOOGLE_PROTOBUF_HAS_ONEOF
+#define GOOGLE_PROTOBUF_HAS_ARENAS
+
+namespace google {
+namespace protobuf {
+
+// Defined in this file.
+class Message;
+class Reflection;
+class MessageFactory;
+
+// Defined in other files.
+class MapKey;
+class MapValueRef;
+class MapIterator;
+class MapReflectionTester;
+
+namespace internal {
+class MapFieldBase;
+}
+class UnknownFieldSet;         // unknown_field_set.h
+namespace io {
+class ZeroCopyInputStream;     // zero_copy_stream.h
+class ZeroCopyOutputStream;    // zero_copy_stream.h
+class CodedInputStream;        // coded_stream.h
+class CodedOutputStream;       // coded_stream.h
+}
+namespace python {
+class MapReflectionFriend;     // scalar_map_container.h
+}
+
+
+namespace internal {
+class ReflectionOps;     // reflection_ops.h
+class MapKeySorter;      // wire_format.cc
+class WireFormat;        // wire_format.h
+class MapFieldReflectionTest;  // map_test.cc
+}
+
+template<typename T>
+class RepeatedField;     // repeated_field.h
+
+template<typename T>
+class RepeatedPtrField;  // repeated_field.h
+
+// A container to hold message metadata.
+struct Metadata {
+  const Descriptor* descriptor;
+  const Reflection* reflection;
+};
+
+// Abstract interface for protocol messages.
+//
+// See also MessageLite, which contains most every-day operations.  Message
+// adds descriptors and reflection on top of that.
+//
+// The methods of this class that are virtual but not pure-virtual have
+// default implementations based on reflection.  Message classes which are
+// optimized for speed will want to override these with faster implementations,
+// but classes optimized for code size may be happy with keeping them.  See
+// the optimize_for option in descriptor.proto.
+class LIBPROTOBUF_EXPORT Message : public MessageLite {
+ public:
+  inline Message() {}
+  virtual ~Message() {}
+
+  // Basic Operations ------------------------------------------------
+
+  // Construct a new instance of the same type.  Ownership is passed to the
+  // caller.  (This is also defined in MessageLite, but is defined again here
+  // for return-type covariance.)
+  virtual Message* New() const = 0;
+
+  // Construct a new instance on the arena. Ownership is passed to the caller
+  // if arena is a NULL. Default implementation allows for API compatibility
+  // during the Arena transition.
+  virtual Message* New(::google::protobuf::Arena* arena) const {
+    Message* message = New();
+    if (arena != NULL) {
+      arena->Own(message);
+    }
+    return message;
+  }
+
+  // Make this message into a copy of the given message.  The given message
+  // must have the same descriptor, but need not necessarily be the same class.
+  // By default this is just implemented as "Clear(); MergeFrom(from);".
+  virtual void CopyFrom(const Message& from);
+
+  // Merge the fields from the given message into this message.  Singular
+  // fields will be overwritten, if specified in from, except for embedded
+  // messages which will be merged.  Repeated fields will be concatenated.
+  // The given message must be of the same type as this message (i.e. the
+  // exact same class).
+  virtual void MergeFrom(const Message& from);
+
+  // Verifies that IsInitialized() returns true.  GOOGLE_CHECK-fails otherwise, with
+  // a nice error message.
+  void CheckInitialized() const;
+
+  // Slowly build a list of all required fields that are not set.
+  // This is much, much slower than IsInitialized() as it is implemented
+  // purely via reflection.  Generally, you should not call this unless you
+  // have already determined that an error exists by calling IsInitialized().
+  void FindInitializationErrors(std::vector<string>* errors) const;
+
+  // Like FindInitializationErrors, but joins all the strings, delimited by
+  // commas, and returns them.
+  string InitializationErrorString() const;
+
+  // Clears all unknown fields from this message and all embedded messages.
+  // Normally, if unknown tag numbers are encountered when parsing a message,
+  // the tag and value are stored in the message's UnknownFieldSet and
+  // then written back out when the message is serialized.  This allows servers
+  // which simply route messages to other servers to pass through messages
+  // that have new field definitions which they don't yet know about.  However,
+  // this behavior can have security implications.  To avoid it, call this
+  // method after parsing.
+  //
+  // See Reflection::GetUnknownFields() for more on unknown fields.
+  virtual void DiscardUnknownFields();
+
+  // Computes (an estimate of) the total number of bytes currently used for
+  // storing the message in memory.  The default implementation calls the
+  // Reflection object's SpaceUsed() method.
+  //
+  // SpaceUsed() is noticeably slower than ByteSize(), as it is implemented
+  // using reflection (rather than the generated code implementation for
+  // ByteSize()). Like ByteSize(), its CPU time is linear in the number of
+  // fields defined for the proto.
+  virtual size_t SpaceUsedLong() const;
+
+  PROTOBUF_RUNTIME_DEPRECATED("Please use SpaceUsedLong() instead")
+  int SpaceUsed() const { return internal::ToIntSize(SpaceUsedLong()); }
+
+  // Debugging & Testing----------------------------------------------
+
+  // Generates a human readable form of this message, useful for debugging
+  // and other purposes.
+  string DebugString() const;
+  // Like DebugString(), but with less whitespace.
+  string ShortDebugString() const;
+  // Like DebugString(), but do not escape UTF-8 byte sequences.
+  string Utf8DebugString() const;
+  // Convenience function useful in GDB.  Prints DebugString() to stdout.
+  void PrintDebugString() const;
+
+  // Heavy I/O -------------------------------------------------------
+  // Additional parsing and serialization methods not implemented by
+  // MessageLite because they are not supported by the lite library.
+
+  // Parse a protocol buffer from a file descriptor.  If successful, the entire
+  // input will be consumed.
+  bool ParseFromFileDescriptor(int file_descriptor);
+  // Like ParseFromFileDescriptor(), but accepts messages that are missing
+  // required fields.
+  bool ParsePartialFromFileDescriptor(int file_descriptor);
+  // Parse a protocol buffer from a C++ istream.  If successful, the entire
+  // input will be consumed.
+  bool ParseFromIstream(std::istream* input);
+  // Like ParseFromIstream(), but accepts messages that are missing
+  // required fields.
+  bool ParsePartialFromIstream(std::istream* input);
+
+  // Serialize the message and write it to the given file descriptor.  All
+  // required fields must be set.
+  bool SerializeToFileDescriptor(int file_descriptor) const;
+  // Like SerializeToFileDescriptor(), but allows missing required fields.
+  bool SerializePartialToFileDescriptor(int file_descriptor) const;
+  // Serialize the message and write it to the given C++ ostream.  All
+  // required fields must be set.
+  bool SerializeToOstream(std::ostream* output) const;
+  // Like SerializeToOstream(), but allows missing required fields.
+  bool SerializePartialToOstream(std::ostream* output) const;
+
+
+  // Reflection-based methods ----------------------------------------
+  // These methods are pure-virtual in MessageLite, but Message provides
+  // reflection-based default implementations.
+
+  virtual string GetTypeName() const;
+  virtual void Clear();
+  virtual bool IsInitialized() const;
+  virtual void CheckTypeAndMergeFrom(const MessageLite& other);
+  virtual bool MergePartialFromCodedStream(io::CodedInputStream* input);
+  virtual size_t ByteSizeLong() const;
+  virtual void SerializeWithCachedSizes(io::CodedOutputStream* output) const;
+
+ private:
+  // This is called only by the default implementation of ByteSize(), to
+  // update the cached size.  If you override ByteSize(), you do not need
+  // to override this.  If you do not override ByteSize(), you MUST override
+  // this; the default implementation will crash.
+  //
+  // The method is private because subclasses should never call it; only
+  // override it.  Yes, C++ lets you do that.  Crazy, huh?
+  virtual void SetCachedSize(int size) const;
+
+ public:
+
+  // Introspection ---------------------------------------------------
+
+  // Typedef for backwards-compatibility.
+  typedef google::protobuf::Reflection Reflection;
+
+  // Get a non-owning pointer to a Descriptor for this message's type.  This
+  // describes what fields the message contains, the types of those fields, etc.
+  // This object remains property of the Message.
+  const Descriptor* GetDescriptor() const { return GetMetadata().descriptor; }
+
+  // Get a non-owning pointer to the Reflection interface for this Message,
+  // which can be used to read and modify the fields of the Message dynamically
+  // (in other words, without knowing the message type at compile time).  This
+  // object remains property of the Message.
+  //
+  // This method remains virtual in case a subclass does not implement
+  // reflection and wants to override the default behavior.
+  virtual const Reflection* GetReflection() const PROTOBUF_FINAL {
+    return GetMetadata().reflection;
+  }
+
+ protected:
+  // Get a struct containing the metadata for the Message. Most subclasses only
+  // need to implement this method, rather than the GetDescriptor() and
+  // GetReflection() wrappers.
+  virtual Metadata GetMetadata() const  = 0;
+
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Message);
+};
+
+namespace internal {
+// Forward-declare interfaces used to implement RepeatedFieldRef.
+// These are protobuf internals that users shouldn't care about.
+class RepeatedFieldAccessor;
+}  // namespace internal
+
+// Forward-declare RepeatedFieldRef templates. The second type parameter is
+// used for SFINAE tricks. Users should ignore it.
+template<typename T, typename Enable = void>
+class RepeatedFieldRef;
+
+template<typename T, typename Enable = void>
+class MutableRepeatedFieldRef;
+
+// This interface contains methods that can be used to dynamically access
+// and modify the fields of a protocol message.  Their semantics are
+// similar to the accessors the protocol compiler generates.
+//
+// To get the Reflection for a given Message, call Message::GetReflection().
+//
+// This interface is separate from Message only for efficiency reasons;
+// the vast majority of implementations of Message will share the same
+// implementation of Reflection (GeneratedMessageReflection,
+// defined in generated_message.h), and all Messages of a particular class
+// should share the same Reflection object (though you should not rely on
+// the latter fact).
+//
+// There are several ways that these methods can be used incorrectly.  For
+// example, any of the following conditions will lead to undefined
+// results (probably assertion failures):
+// - The FieldDescriptor is not a field of this message type.
+// - The method called is not appropriate for the field's type.  For
+//   each field type in FieldDescriptor::TYPE_*, there is only one
+//   Get*() method, one Set*() method, and one Add*() method that is
+//   valid for that type.  It should be obvious which (except maybe
+//   for TYPE_BYTES, which are represented using strings in C++).
+// - A Get*() or Set*() method for singular fields is called on a repeated
+//   field.
+// - GetRepeated*(), SetRepeated*(), or Add*() is called on a non-repeated
+//   field.
+// - The Message object passed to any method is not of the right type for
+//   this Reflection object (i.e. message.GetReflection() != reflection).
+//
+// You might wonder why there is not any abstract representation for a field
+// of arbitrary type.  E.g., why isn't there just a "GetField()" method that
+// returns "const Field&", where "Field" is some class with accessors like
+// "GetInt32Value()".  The problem is that someone would have to deal with
+// allocating these Field objects.  For generated message classes, having to
+// allocate space for an additional object to wrap every field would at least
+// double the message's memory footprint, probably worse.  Allocating the
+// objects on-demand, on the other hand, would be expensive and prone to
+// memory leaks.  So, instead we ended up with this flat interface.
+//
+// TODO(kenton):  Create a utility class which callers can use to read and
+//   write fields from a Reflection without paying attention to the type.
+class LIBPROTOBUF_EXPORT Reflection {
+ public:
+  inline Reflection() {}
+  virtual ~Reflection();
+
+  // Get the UnknownFieldSet for the message.  This contains fields which
+  // were seen when the Message was parsed but were not recognized according
+  // to the Message's definition. For proto3 protos, this method will always
+  // return an empty UnknownFieldSet.
+  virtual const UnknownFieldSet& GetUnknownFields(
+      const Message& message) const = 0;
+  // Get a mutable pointer to the UnknownFieldSet for the message.  This
+  // contains fields which were seen when the Message was parsed but were not
+  // recognized according to the Message's definition. For proto3 protos, this
+  // method will return a valid mutable UnknownFieldSet pointer but modifying
+  // it won't affect the serialized bytes of the message.
+  virtual UnknownFieldSet* MutableUnknownFields(Message* message) const = 0;
+
+  // Estimate the amount of memory used by the message object.
+  virtual size_t SpaceUsedLong(const Message& message) const = 0;
+
+  PROTOBUF_RUNTIME_DEPRECATED("Please use SpaceUsedLong() instead")
+  int SpaceUsed(const Message& message) const {
+    return internal::ToIntSize(SpaceUsedLong(message));
+  }
+
+  // Check if the given non-repeated field is set.
+  virtual bool HasField(const Message& message,
+                        const FieldDescriptor* field) const = 0;
+
+  // Get the number of elements of a repeated field.
+  virtual int FieldSize(const Message& message,
+                        const FieldDescriptor* field) const = 0;
+
+  // Clear the value of a field, so that HasField() returns false or
+  // FieldSize() returns zero.
+  virtual void ClearField(Message* message,
+                          const FieldDescriptor* field) const = 0;
+
+  // Check if the oneof is set. Returns true if any field in oneof
+  // is set, false otherwise.
+  // TODO(jieluo) - make it pure virtual after updating all
+  // the subclasses.
+  virtual bool HasOneof(const Message& /*message*/,
+                        const OneofDescriptor* /*oneof_descriptor*/) const {
+    return false;
+  }
+
+  virtual void ClearOneof(Message* /*message*/,
+                          const OneofDescriptor* /*oneof_descriptor*/) const {}
+
+  // Returns the field descriptor if the oneof is set. NULL otherwise.
+  // TODO(jieluo) - make it pure virtual.
+  virtual const FieldDescriptor* GetOneofFieldDescriptor(
+      const Message& /*message*/,
+      const OneofDescriptor* /*oneof_descriptor*/) const {
+    return NULL;
+  }
+
+  // Removes the last element of a repeated field.
+  // We don't provide a way to remove any element other than the last
+  // because it invites inefficient use, such as O(n^2) filtering loops
+  // that should have been O(n).  If you want to remove an element other
+  // than the last, the best way to do it is to re-arrange the elements
+  // (using Swap()) so that the one you want removed is at the end, then
+  // call RemoveLast().
+  virtual void RemoveLast(Message* message,
+                          const FieldDescriptor* field) const = 0;
+  // Removes the last element of a repeated message field, and returns the
+  // pointer to the caller.  Caller takes ownership of the returned pointer.
+  virtual Message* ReleaseLast(Message* message,
+                               const FieldDescriptor* field) const = 0;
+
+  // Swap the complete contents of two messages.
+  virtual void Swap(Message* message1, Message* message2) const = 0;
+
+  // Swap fields listed in fields vector of two messages.
+  virtual void SwapFields(Message* message1,
+                          Message* message2,
+                          const std::vector<const FieldDescriptor*>& fields)
+      const = 0;
+
+  // Swap two elements of a repeated field.
+  virtual void SwapElements(Message* message,
+                            const FieldDescriptor* field,
+                            int index1,
+                            int index2) const = 0;
+
+  // List all fields of the message which are currently set, except for unknown
+  // fields, but including extension known to the parser (i.e. compiled in).
+  // Singular fields will only be listed if HasField(field) would return true
+  // and repeated fields will only be listed if FieldSize(field) would return
+  // non-zero.  Fields (both normal fields and extension fields) will be listed
+  // ordered by field number.
+  // Use Reflection::GetUnknownFields() or message.unknown_fields() to also get
+  // access to fields/extensions unknown to the parser.
+  virtual void ListFields(
+      const Message& message,
+      std::vector<const FieldDescriptor*>* output) const = 0;
+
+  // Singular field getters ------------------------------------------
+  // These get the value of a non-repeated field.  They return the default
+  // value for fields that aren't set.
+
+  virtual int32  GetInt32 (const Message& message,
+                           const FieldDescriptor* field) const = 0;
+  virtual int64  GetInt64 (const Message& message,
+                           const FieldDescriptor* field) const = 0;
+  virtual uint32 GetUInt32(const Message& message,
+                           const FieldDescriptor* field) const = 0;
+  virtual uint64 GetUInt64(const Message& message,
+                           const FieldDescriptor* field) const = 0;
+  virtual float  GetFloat (const Message& message,
+                           const FieldDescriptor* field) const = 0;
+  virtual double GetDouble(const Message& message,
+                           const FieldDescriptor* field) const = 0;
+  virtual bool   GetBool  (const Message& message,
+                           const FieldDescriptor* field) const = 0;
+  virtual string GetString(const Message& message,
+                           const FieldDescriptor* field) const = 0;
+  virtual const EnumValueDescriptor* GetEnum(
+      const Message& message, const FieldDescriptor* field) const = 0;
+
+  // GetEnumValue() returns an enum field's value as an integer rather than
+  // an EnumValueDescriptor*. If the integer value does not correspond to a
+  // known value descriptor, a new value descriptor is created. (Such a value
+  // will only be present when the new unknown-enum-value semantics are enabled
+  // for a message.)
+  virtual int GetEnumValue(
+      const Message& message, const FieldDescriptor* field) const = 0;
+
+  // See MutableMessage() for the meaning of the "factory" parameter.
+  virtual const Message& GetMessage(const Message& message,
+                                    const FieldDescriptor* field,
+                                    MessageFactory* factory = NULL) const = 0;
+
+  // Get a string value without copying, if possible.
+  //
+  // GetString() necessarily returns a copy of the string.  This can be
+  // inefficient when the string is already stored in a string object in the
+  // underlying message.  GetStringReference() will return a reference to the
+  // underlying string in this case.  Otherwise, it will copy the string into
+  // *scratch and return that.
+  //
+  // Note:  It is perfectly reasonable and useful to write code like:
+  //     str = reflection->GetStringReference(field, &str);
+  //   This line would ensure that only one copy of the string is made
+  //   regardless of the field's underlying representation.  When initializing
+  //   a newly-constructed string, though, it's just as fast and more readable
+  //   to use code like:
+  //     string str = reflection->GetString(message, field);
+  virtual const string& GetStringReference(const Message& message,
+                                           const FieldDescriptor* field,
+                                           string* scratch) const = 0;
+
+
+  // Singular field mutators -----------------------------------------
+  // These mutate the value of a non-repeated field.
+
+  virtual void SetInt32 (Message* message,
+                         const FieldDescriptor* field, int32  value) const = 0;
+  virtual void SetInt64 (Message* message,
+                         const FieldDescriptor* field, int64  value) const = 0;
+  virtual void SetUInt32(Message* message,
+                         const FieldDescriptor* field, uint32 value) const = 0;
+  virtual void SetUInt64(Message* message,
+                         const FieldDescriptor* field, uint64 value) const = 0;
+  virtual void SetFloat (Message* message,
+                         const FieldDescriptor* field, float  value) const = 0;
+  virtual void SetDouble(Message* message,
+                         const FieldDescriptor* field, double value) const = 0;
+  virtual void SetBool  (Message* message,
+                         const FieldDescriptor* field, bool   value) const = 0;
+  virtual void SetString(Message* message,
+                         const FieldDescriptor* field,
+                         const string& value) const = 0;
+  virtual void SetEnum  (Message* message,
+                         const FieldDescriptor* field,
+                         const EnumValueDescriptor* value) const = 0;
+  // Set an enum field's value with an integer rather than EnumValueDescriptor.
+  // If the value does not correspond to a known enum value, either behavior is
+  // undefined (for proto2 messages), or the value is accepted silently for
+  // messages with new unknown-enum-value semantics.
+  virtual void SetEnumValue(Message* message,
+                            const FieldDescriptor* field,
+                            int value) const = 0;
+
+  // Get a mutable pointer to a field with a message type.  If a MessageFactory
+  // is provided, it will be used to construct instances of the sub-message;
+  // otherwise, the default factory is used.  If the field is an extension that
+  // does not live in the same pool as the containing message's descriptor (e.g.
+  // it lives in an overlay pool), then a MessageFactory must be provided.
+  // If you have no idea what that meant, then you probably don't need to worry
+  // about it (don't provide a MessageFactory).  WARNING:  If the
+  // FieldDescriptor is for a compiled-in extension, then
+  // factory->GetPrototype(field->message_type()) MUST return an instance of
+  // the compiled-in class for this type, NOT DynamicMessage.
+  virtual Message* MutableMessage(Message* message,
+                                  const FieldDescriptor* field,
+                                  MessageFactory* factory = NULL) const = 0;
+  // Replaces the message specified by 'field' with the already-allocated object
+  // sub_message, passing ownership to the message.  If the field contained a
+  // message, that message is deleted.  If sub_message is NULL, the field is
+  // cleared.
+  virtual void SetAllocatedMessage(Message* message,
+                                   Message* sub_message,
+                                   const FieldDescriptor* field) const = 0;
+  // Releases the message specified by 'field' and returns the pointer,
+  // ReleaseMessage() will return the message the message object if it exists.
+  // Otherwise, it may or may not return NULL.  In any case, if the return value
+  // is non-NULL, the caller takes ownership of the pointer.
+  // If the field existed (HasField() is true), then the returned pointer will
+  // be the same as the pointer returned by MutableMessage().
+  // This function has the same effect as ClearField().
+  virtual Message* ReleaseMessage(Message* message,
+                                  const FieldDescriptor* field,
+                                  MessageFactory* factory = NULL) const = 0;
+
+
+  // Repeated field getters ------------------------------------------
+  // These get the value of one element of a repeated field.
+
+  virtual int32  GetRepeatedInt32 (const Message& message,
+                                   const FieldDescriptor* field,
+                                   int index) const = 0;
+  virtual int64  GetRepeatedInt64 (const Message& message,
+                                   const FieldDescriptor* field,
+                                   int index) const = 0;
+  virtual uint32 GetRepeatedUInt32(const Message& message,
+                                   const FieldDescriptor* field,
+                                   int index) const = 0;
+  virtual uint64 GetRepeatedUInt64(const Message& message,
+                                   const FieldDescriptor* field,
+                                   int index) const = 0;
+  virtual float  GetRepeatedFloat (const Message& message,
+                                   const FieldDescriptor* field,
+                                   int index) const = 0;
+  virtual double GetRepeatedDouble(const Message& message,
+                                   const FieldDescriptor* field,
+                                   int index) const = 0;
+  virtual bool   GetRepeatedBool  (const Message& message,
+                                   const FieldDescriptor* field,
+                                   int index) const = 0;
+  virtual string GetRepeatedString(const Message& message,
+                                   const FieldDescriptor* field,
+                                   int index) const = 0;
+  virtual const EnumValueDescriptor* GetRepeatedEnum(
+      const Message& message,
+      const FieldDescriptor* field, int index) const = 0;
+  // GetRepeatedEnumValue() returns an enum field's value as an integer rather
+  // than an EnumValueDescriptor*. If the integer value does not correspond to a
+  // known value descriptor, a new value descriptor is created. (Such a value
+  // will only be present when the new unknown-enum-value semantics are enabled
+  // for a message.)
+  virtual int GetRepeatedEnumValue(
+      const Message& message,
+      const FieldDescriptor* field, int index) const = 0;
+  virtual const Message& GetRepeatedMessage(
+      const Message& message,
+      const FieldDescriptor* field, int index) const = 0;
+
+  // See GetStringReference(), above.
+  virtual const string& GetRepeatedStringReference(
+      const Message& message, const FieldDescriptor* field,
+      int index, string* scratch) const = 0;
+
+
+  // Repeated field mutators -----------------------------------------
+  // These mutate the value of one element of a repeated field.
+
+  virtual void SetRepeatedInt32 (Message* message,
+                                 const FieldDescriptor* field,
+                                 int index, int32  value) const = 0;
+  virtual void SetRepeatedInt64 (Message* message,
+                                 const FieldDescriptor* field,
+                                 int index, int64  value) const = 0;
+  virtual void SetRepeatedUInt32(Message* message,
+                                 const FieldDescriptor* field,
+                                 int index, uint32 value) const = 0;
+  virtual void SetRepeatedUInt64(Message* message,
+                                 const FieldDescriptor* field,
+                                 int index, uint64 value) const = 0;
+  virtual void SetRepeatedFloat (Message* message,
+                                 const FieldDescriptor* field,
+                                 int index, float  value) const = 0;
+  virtual void SetRepeatedDouble(Message* message,
+                                 const FieldDescriptor* field,
+                                 int index, double value) const = 0;
+  virtual void SetRepeatedBool  (Message* message,
+                                 const FieldDescriptor* field,
+                                 int index, bool   value) const = 0;
+  virtual void SetRepeatedString(Message* message,
+                                 const FieldDescriptor* field,
+                                 int index, const string& value) const = 0;
+  virtual void SetRepeatedEnum(Message* message,
+                               const FieldDescriptor* field, int index,
+                               const EnumValueDescriptor* value) const = 0;
+  // Set an enum field's value with an integer rather than EnumValueDescriptor.
+  // If the value does not correspond to a known enum value, either behavior is
+  // undefined (for proto2 messages), or the value is accepted silently for
+  // messages with new unknown-enum-value semantics.
+  virtual void SetRepeatedEnumValue(Message* message,
+                                    const FieldDescriptor* field, int index,
+                                    int value) const = 0;
+  // Get a mutable pointer to an element of a repeated field with a message
+  // type.
+  virtual Message* MutableRepeatedMessage(
+      Message* message, const FieldDescriptor* field, int index) const = 0;
+
+
+  // Repeated field adders -------------------------------------------
+  // These add an element to a repeated field.
+
+  virtual void AddInt32 (Message* message,
+                         const FieldDescriptor* field, int32  value) const = 0;
+  virtual void AddInt64 (Message* message,
+                         const FieldDescriptor* field, int64  value) const = 0;
+  virtual void AddUInt32(Message* message,
+                         const FieldDescriptor* field, uint32 value) const = 0;
+  virtual void AddUInt64(Message* message,
+                         const FieldDescriptor* field, uint64 value) const = 0;
+  virtual void AddFloat (Message* message,
+                         const FieldDescriptor* field, float  value) const = 0;
+  virtual void AddDouble(Message* message,
+                         const FieldDescriptor* field, double value) const = 0;
+  virtual void AddBool  (Message* message,
+                         const FieldDescriptor* field, bool   value) const = 0;
+  virtual void AddString(Message* message,
+                         const FieldDescriptor* field,
+                         const string& value) const = 0;
+  virtual void AddEnum  (Message* message,
+                         const FieldDescriptor* field,
+                         const EnumValueDescriptor* value) const = 0;
+  // Set an enum field's value with an integer rather than EnumValueDescriptor.
+  // If the value does not correspond to a known enum value, either behavior is
+  // undefined (for proto2 messages), or the value is accepted silently for
+  // messages with new unknown-enum-value semantics.
+  virtual void AddEnumValue(Message* message,
+                            const FieldDescriptor* field,
+                            int value) const = 0;
+  // See MutableMessage() for comments on the "factory" parameter.
+  virtual Message* AddMessage(Message* message,
+                              const FieldDescriptor* field,
+                              MessageFactory* factory = NULL) const = 0;
+
+  // Appends an already-allocated object 'new_entry' to the repeated field
+  // specifyed by 'field' passing ownership to the message.
+  // TODO(tmarek): Make virtual after all subclasses have been
+  // updated.
+  virtual void AddAllocatedMessage(Message* message,
+                                   const FieldDescriptor* field,
+                                   Message* new_entry) const;
+
+
+  // Get a RepeatedFieldRef object that can be used to read the underlying
+  // repeated field. The type parameter T must be set according to the
+  // field's cpp type. The following table shows the mapping from cpp type
+  // to acceptable T.
+  //
+  //   field->cpp_type()      T
+  //   CPPTYPE_INT32        int32
+  //   CPPTYPE_UINT32       uint32
+  //   CPPTYPE_INT64        int64
+  //   CPPTYPE_UINT64       uint64
+  //   CPPTYPE_DOUBLE       double
+  //   CPPTYPE_FLOAT        float
+  //   CPPTYPE_BOOL         bool
+  //   CPPTYPE_ENUM         generated enum type or int32
+  //   CPPTYPE_STRING       string
+  //   CPPTYPE_MESSAGE      generated message type or google::protobuf::Message
+  //
+  // A RepeatedFieldRef object can be copied and the resulted object will point
+  // to the same repeated field in the same message. The object can be used as
+  // long as the message is not destroyed.
+  //
+  // Note that to use this method users need to include the header file
+  // "google/protobuf/reflection.h" (which defines the RepeatedFieldRef
+  // class templates).
+  template<typename T>
+  RepeatedFieldRef<T> GetRepeatedFieldRef(
+      const Message& message, const FieldDescriptor* field) const;
+
+  // Like GetRepeatedFieldRef() but return an object that can also be used
+  // manipulate the underlying repeated field.
+  template<typename T>
+  MutableRepeatedFieldRef<T> GetMutableRepeatedFieldRef(
+      Message* message, const FieldDescriptor* field) const;
+
+  // DEPRECATED. Please use Get(Mutable)RepeatedFieldRef() for repeated field
+  // access. The following repeated field accesors will be removed in the
+  // future.
+  //
+  // Repeated field accessors  -------------------------------------------------
+  // The methods above, e.g. GetRepeatedInt32(msg, fd, index), provide singular
+  // access to the data in a RepeatedField.  The methods below provide aggregate
+  // access by exposing the RepeatedField object itself with the Message.
+  // Applying these templates to inappropriate types will lead to an undefined
+  // reference at link time (e.g. GetRepeatedField<***double>), or possibly a
+  // template matching error at compile time (e.g. GetRepeatedPtrField<File>).
+  //
+  // Usage example: my_doubs = refl->GetRepeatedField<double>(msg, fd);
+
+  // DEPRECATED. Please use GetRepeatedFieldRef().
+  //
+  // for T = Cord and all protobuf scalar types except enums.
+  template<typename T>
+  const RepeatedField<T>& GetRepeatedField(
+      const Message&, const FieldDescriptor*) const;
+
+  // DEPRECATED. Please use GetMutableRepeatedFieldRef().
+  //
+  // for T = Cord and all protobuf scalar types except enums.
+  template<typename T>
+  RepeatedField<T>* MutableRepeatedField(
+      Message*, const FieldDescriptor*) const;
+
+  // DEPRECATED. Please use GetRepeatedFieldRef().
+  //
+  // for T = string, google::protobuf::internal::StringPieceField
+  //         google::protobuf::Message & descendants.
+  template<typename T>
+  const RepeatedPtrField<T>& GetRepeatedPtrField(
+      const Message&, const FieldDescriptor*) const;
+
+  // DEPRECATED. Please use GetMutableRepeatedFieldRef().
+  //
+  // for T = string, google::protobuf::internal::StringPieceField
+  //         google::protobuf::Message & descendants.
+  template<typename T>
+  RepeatedPtrField<T>* MutableRepeatedPtrField(
+      Message*, const FieldDescriptor*) const;
+
+  // Extensions ----------------------------------------------------------------
+
+  // Try to find an extension of this message type by fully-qualified field
+  // name.  Returns NULL if no extension is known for this name or number.
+  virtual const FieldDescriptor* FindKnownExtensionByName(
+      const string& name) const = 0;
+
+  // Try to find an extension of this message type by field number.
+  // Returns NULL if no extension is known for this name or number.
+  virtual const FieldDescriptor* FindKnownExtensionByNumber(
+      int number) const = 0;
+
+  // Feature Flags -------------------------------------------------------------
+
+  // Does this message support storing arbitrary integer values in enum fields?
+  // If |true|, GetEnumValue/SetEnumValue and associated repeated-field versions
+  // take arbitrary integer values, and the legacy GetEnum() getter will
+  // dynamically create an EnumValueDescriptor for any integer value without
+  // one. If |false|, setting an unknown enum value via the integer-based
+  // setters results in undefined behavior (in practice, GOOGLE_DCHECK-fails).
+  //
+  // Generic code that uses reflection to handle messages with enum fields
+  // should check this flag before using the integer-based setter, and either
+  // downgrade to a compatible value or use the UnknownFieldSet if not. For
+  // example:
+  //
+  //   int new_value = GetValueFromApplicationLogic();
+  //   if (reflection->SupportsUnknownEnumValues()) {
+  //     reflection->SetEnumValue(message, field, new_value);
+  //   } else {
+  //     if (field_descriptor->enum_type()->
+  //             FindValueByNumber(new_value) != NULL) {
+  //       reflection->SetEnumValue(message, field, new_value);
+  //     } else if (emit_unknown_enum_values) {
+  //       reflection->MutableUnknownFields(message)->AddVarint(
+  //           field->number(), new_value);
+  //     } else {
+  //       // convert value to a compatible/default value.
+  //       new_value = CompatibleDowngrade(new_value);
+  //       reflection->SetEnumValue(message, field, new_value);
+  //     }
+  //   }
+  virtual bool SupportsUnknownEnumValues() const { return false; }
+
+  // Returns the MessageFactory associated with this message.  This can be
+  // useful for determining if a message is a generated message or not, for
+  // example:
+  //   if (message->GetReflection()->GetMessageFactory() ==
+  //       google::protobuf::MessageFactory::generated_factory()) {
+  //     // This is a generated message.
+  //   }
+  // It can also be used to create more messages of this type, though
+  // Message::New() is an easier way to accomplish this.
+  virtual MessageFactory* GetMessageFactory() const;
+
+  // ---------------------------------------------------------------------------
+
+ protected:
+  // Obtain a pointer to a Repeated Field Structure and do some type checking:
+  //   on field->cpp_type(),
+  //   on field->field_option().ctype() (if ctype >= 0)
+  //   of field->message_type() (if message_type != NULL).
+  // We use 2 routine rather than 4 (const vs mutable) x (scalar vs pointer).
+  virtual void* MutableRawRepeatedField(
+      Message* message, const FieldDescriptor* field, FieldDescriptor::CppType,
+      int ctype, const Descriptor* message_type) const = 0;
+
+  // TODO(jieluo) - make it pure virtual after updating all the subclasses.
+  virtual const void* GetRawRepeatedField(
+      const Message& message, const FieldDescriptor* field,
+      FieldDescriptor::CppType cpptype, int ctype,
+      const Descriptor* message_type) const {
+    return MutableRawRepeatedField(
+        const_cast<Message*>(&message), field, cpptype, ctype, message_type);
+  }
+
+  // The following methods are used to implement (Mutable)RepeatedFieldRef.
+  // A Ref object will store a raw pointer to the repeated field data (obtained
+  // from RepeatedFieldData()) and a pointer to a Accessor (obtained from
+  // RepeatedFieldAccessor) which will be used to access the raw data.
+  //
+  // TODO(xiaofeng): Make these methods pure-virtual.
+
+  // Returns a raw pointer to the repeated field
+  //
+  // "cpp_type" and "message_type" are deduced from the type parameter T passed
+  // to Get(Mutable)RepeatedFieldRef. If T is a generated message type,
+  // "message_type" should be set to its descriptor. Otherwise "message_type"
+  // should be set to NULL. Implementations of this method should check whether
+  // "cpp_type"/"message_type" is consistent with the actual type of the field.
+  // We use 1 routine rather than 2 (const vs mutable) because it is protected
+  // and it doesn't change the message.
+  virtual void* RepeatedFieldData(
+      Message* message, const FieldDescriptor* field,
+      FieldDescriptor::CppType cpp_type,
+      const Descriptor* message_type) const;
+
+  // The returned pointer should point to a singleton instance which implements
+  // the RepeatedFieldAccessor interface.
+  virtual const internal::RepeatedFieldAccessor* RepeatedFieldAccessor(
+      const FieldDescriptor* field) const;
+
+ private:
+  template<typename T, typename Enable>
+  friend class RepeatedFieldRef;
+  template<typename T, typename Enable>
+  friend class MutableRepeatedFieldRef;
+  friend class ::google::protobuf::python::MapReflectionFriend;
+  friend class internal::MapFieldReflectionTest;
+  friend class internal::MapKeySorter;
+  friend class internal::WireFormat;
+  friend class internal::ReflectionOps;
+
+  // Special version for specialized implementations of string.  We can't call
+  // MutableRawRepeatedField directly here because we don't have access to
+  // FieldOptions::* which are defined in descriptor.pb.h.  Including that
+  // file here is not possible because it would cause a circular include cycle.
+  // We use 1 routine rather than 2 (const vs mutable) because it is private
+  // and mutable a repeated string field doesn't change the message.
+  void* MutableRawRepeatedString(
+      Message* message, const FieldDescriptor* field, bool is_string) const;
+
+  friend class MapReflectionTester;
+  // TODO(jieluo) - make the map APIs pure virtual after updating
+  // all the subclasses.
+  // Returns true if key is in map. Returns false if key is not in map field.
+  virtual bool ContainsMapKey(const Message& /* message */,
+                              const FieldDescriptor* /* field */,
+                              const MapKey& /* key */) const {
+    return false;
+  }
+
+  // If key is in map field: Saves the value pointer to val and returns
+  // false. If key in not in map field: Insert the key into map, saves
+  // value pointer to val and retuns true.
+  virtual bool InsertOrLookupMapValue(Message* /* message */,
+                                      const FieldDescriptor* /* field */,
+                                      const MapKey& /* key */,
+                                      MapValueRef* /* val */) const {
+    return false;
+  }
+
+  // Delete and returns true if key is in the map field. Returns false
+  // otherwise.
+  virtual bool DeleteMapValue(Message* /* message */,
+                              const FieldDescriptor* /* field */,
+                              const MapKey& /* key */) const {
+    return false;
+  }
+
+  // Returns a MapIterator referring to the first element in the map field.
+  // If the map field is empty, this function returns the same as
+  // reflection::MapEnd. Mutation to the field may invalidate the iterator.
+  virtual MapIterator MapBegin(
+      Message* message,
+      const FieldDescriptor* field) const;
+
+  // Returns a MapIterator referring to the theoretical element that would
+  // follow the last element in the map field. It does not point to any
+  // real element. Mutation to the field may invalidate the iterator.
+  virtual MapIterator MapEnd(
+      Message* message,
+      const FieldDescriptor* field) const;
+
+  // Get the number of <key, value> pair of a map field. The result may be
+  // different from FieldSize which can have duplicate keys.
+  virtual int MapSize(const Message& /* message */,
+                      const FieldDescriptor* /* field */) const {
+    return 0;
+  }
+
+  // Help method for MapIterator.
+  friend class MapIterator;
+  virtual internal::MapFieldBase* MapData(
+      Message* /* message */, const FieldDescriptor* /* field */) const {
+    return NULL;
+  }
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Reflection);
+};
+
+// Abstract interface for a factory for message objects.
+class LIBPROTOBUF_EXPORT MessageFactory {
+ public:
+  inline MessageFactory() {}
+  virtual ~MessageFactory();
+
+  // Given a Descriptor, gets or constructs the default (prototype) Message
+  // of that type.  You can then call that message's New() method to construct
+  // a mutable message of that type.
+  //
+  // Calling this method twice with the same Descriptor returns the same
+  // object.  The returned object remains property of the factory.  Also, any
+  // objects created by calling the prototype's New() method share some data
+  // with the prototype, so these must be destroyed before the MessageFactory
+  // is destroyed.
+  //
+  // The given descriptor must outlive the returned message, and hence must
+  // outlive the MessageFactory.
+  //
+  // Some implementations do not support all types.  GetPrototype() will
+  // return NULL if the descriptor passed in is not supported.
+  //
+  // This method may or may not be thread-safe depending on the implementation.
+  // Each implementation should document its own degree thread-safety.
+  virtual const Message* GetPrototype(const Descriptor* type) = 0;
+
+  // Gets a MessageFactory which supports all generated, compiled-in messages.
+  // In other words, for any compiled-in type FooMessage, the following is true:
+  //   MessageFactory::generated_factory()->GetPrototype(
+  //     FooMessage::descriptor()) == FooMessage::default_instance()
+  // This factory supports all types which are found in
+  // DescriptorPool::generated_pool().  If given a descriptor from any other
+  // pool, GetPrototype() will return NULL.  (You can also check if a
+  // descriptor is for a generated message by checking if
+  // descriptor->file()->pool() == DescriptorPool::generated_pool().)
+  //
+  // This factory is 100% thread-safe; calling GetPrototype() does not modify
+  // any shared data.
+  //
+  // This factory is a singleton.  The caller must not delete the object.
+  static MessageFactory* generated_factory();
+
+  // For internal use only:  Registers a .proto file at static initialization
+  // time, to be placed in generated_factory.  The first time GetPrototype()
+  // is called with a descriptor from this file, |register_messages| will be
+  // called, with the file name as the parameter.  It must call
+  // InternalRegisterGeneratedMessage() (below) to register each message type
+  // in the file.  This strange mechanism is necessary because descriptors are
+  // built lazily, so we can't register types by their descriptor until we
+  // know that the descriptor exists.  |filename| must be a permanent string.
+  static void InternalRegisterGeneratedFile(
+      const char* filename, void (*register_messages)(const string&));
+
+  // For internal use only:  Registers a message type.  Called only by the
+  // functions which are registered with InternalRegisterGeneratedFile(),
+  // above.
+  static void InternalRegisterGeneratedMessage(const Descriptor* descriptor,
+                                               const Message* prototype);
+
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MessageFactory);
+};
+
+#define DECLARE_GET_REPEATED_FIELD(TYPE)                         \
+template<>                                                       \
+LIBPROTOBUF_EXPORT                                               \
+const RepeatedField<TYPE>& Reflection::GetRepeatedField<TYPE>(   \
+    const Message& message, const FieldDescriptor* field) const; \
+                                                                 \
+template<>                                                       \
+LIBPROTOBUF_EXPORT                                               \
+RepeatedField<TYPE>* Reflection::MutableRepeatedField<TYPE>(     \
+    Message* message, const FieldDescriptor* field) const;
+
+DECLARE_GET_REPEATED_FIELD(int32)
+DECLARE_GET_REPEATED_FIELD(int64)
+DECLARE_GET_REPEATED_FIELD(uint32)
+DECLARE_GET_REPEATED_FIELD(uint64)
+DECLARE_GET_REPEATED_FIELD(float)
+DECLARE_GET_REPEATED_FIELD(double)
+DECLARE_GET_REPEATED_FIELD(bool)
+
+#undef DECLARE_GET_REPEATED_FIELD
+
+// =============================================================================
+// Implementation details for {Get,Mutable}RawRepeatedPtrField.  We provide
+// specializations for <string>, <StringPieceField> and <Message> and handle
+// everything else with the default template which will match any type having
+// a method with signature "static const google::protobuf::Descriptor* descriptor()".
+// Such a type presumably is a descendant of google::protobuf::Message.
+
+template<>
+inline const RepeatedPtrField<string>& Reflection::GetRepeatedPtrField<string>(
+    const Message& message, const FieldDescriptor* field) const {
+  return *static_cast<RepeatedPtrField<string>* >(
+      MutableRawRepeatedString(const_cast<Message*>(&message), field, true));
+}
+
+template<>
+inline RepeatedPtrField<string>* Reflection::MutableRepeatedPtrField<string>(
+    Message* message, const FieldDescriptor* field) const {
+  return static_cast<RepeatedPtrField<string>* >(
+      MutableRawRepeatedString(message, field, true));
+}
+
+
+// -----
+
+template<>
+inline const RepeatedPtrField<Message>& Reflection::GetRepeatedPtrField(
+    const Message& message, const FieldDescriptor* field) const {
+  return *static_cast<const RepeatedPtrField<Message>* >(
+      GetRawRepeatedField(message, field, FieldDescriptor::CPPTYPE_MESSAGE,
+                          -1, NULL));
+}
+
+template<>
+inline RepeatedPtrField<Message>* Reflection::MutableRepeatedPtrField(
+    Message* message, const FieldDescriptor* field) const {
+  return static_cast<RepeatedPtrField<Message>* >(
+      MutableRawRepeatedField(message, field,
+          FieldDescriptor::CPPTYPE_MESSAGE, -1,
+          NULL));
+}
+
+template<typename PB>
+inline const RepeatedPtrField<PB>& Reflection::GetRepeatedPtrField(
+    const Message& message, const FieldDescriptor* field) const {
+  return *static_cast<const RepeatedPtrField<PB>* >(
+      GetRawRepeatedField(message, field, FieldDescriptor::CPPTYPE_MESSAGE,
+                          -1, PB::default_instance().GetDescriptor()));
+}
+
+template<typename PB>
+inline RepeatedPtrField<PB>* Reflection::MutableRepeatedPtrField(
+    Message* message, const FieldDescriptor* field) const {
+  return static_cast<RepeatedPtrField<PB>* >(
+      MutableRawRepeatedField(message, field,
+          FieldDescriptor::CPPTYPE_MESSAGE, -1,
+          PB::default_instance().GetDescriptor()));
+}
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_MESSAGE_H__
diff --git a/kortex_api/include/google/protobuf/message_lite.h b/kortex_api/include/google/protobuf/message_lite.h
new file mode 100644
index 0000000000000000000000000000000000000000..5cd6babc09cd746767a4b176d7864a06cb14ce96
--- /dev/null
+++ b/kortex_api/include/google/protobuf/message_lite.h
@@ -0,0 +1,412 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Authors: wink@google.com (Wink Saville),
+//          kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// Defines MessageLite, the abstract interface implemented by all (lite
+// and non-lite) protocol message objects.
+
+#ifndef GOOGLE_PROTOBUF_MESSAGE_LITE_H__
+#define GOOGLE_PROTOBUF_MESSAGE_LITE_H__
+
+#include <climits>
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/logging.h>
+#include <google/protobuf/stubs/once.h>
+#include <google/protobuf/stubs/port.h>
+
+namespace google {
+namespace protobuf {
+class Arena;
+namespace io {
+class CodedInputStream;
+class CodedOutputStream;
+class ZeroCopyInputStream;
+class ZeroCopyOutputStream;
+}
+namespace internal {
+
+class WireFormatLite;
+
+#ifndef SWIG
+// We compute sizes as size_t but cache them as int.  This function converts a
+// computed size to a cached size.  Since we don't proceed with serialization
+// if the total size was > INT_MAX, it is not important what this function
+// returns for inputs > INT_MAX.  However this case should not error or
+// GOOGLE_CHECK-fail, because the full size_t resolution is still returned from
+// ByteSizeLong() and checked against INT_MAX; we can catch the overflow
+// there.
+inline int ToCachedSize(size_t size) { return static_cast<int>(size); }
+
+// We mainly calculate sizes in terms of size_t, but some functions that
+// compute sizes return "int".  These int sizes are expected to always be
+// positive. This function is more efficient than casting an int to size_t
+// directly on 64-bit platforms because it avoids making the compiler emit a
+// sign extending instruction, which we don't want and don't want to pay for.
+inline size_t FromIntSize(int size) {
+  // Convert to unsigned before widening so sign extension is not necessary.
+  return static_cast<unsigned int>(size);
+}
+
+// For cases where a legacy function returns an integer size.  We GOOGLE_DCHECK()
+// that the conversion will fit within an integer; if this is false then we
+// are losing information.
+inline int ToIntSize(size_t size) {
+  GOOGLE_DCHECK_LE(size, static_cast<size_t>(INT_MAX));
+  return static_cast<int>(size);
+}
+
+// This type wraps a variable whose constructor and destructor are explicitly
+// called. It is particularly useful for a global variable, without its
+// constructor and destructor run on start and end of the program lifetime.
+// This circumvents the initial construction order fiasco, while keeping
+// the address of the empty string a compile time constant.
+//
+// Pay special attention to the initialization state of the object.
+// 1. The object is "uninitialized" to begin with.
+// 2. Call DefaultConstruct() only if the object is uninitialized.
+//    After the call, the object becomes "initialized".
+// 3. Call get() and get_mutable() only if the object is initialized.
+// 4. Call Destruct() only if the object is initialized.
+//    After the call, the object becomes uninitialized.
+template <typename T>
+class ExplicitlyConstructed {
+ public:
+  void DefaultConstruct() {
+    new (&union_) T();
+  }
+
+  void Destruct() {
+    get_mutable()->~T();
+  }
+
+#if LANG_CXX11
+  constexpr
+#endif
+      const T&
+      get() const {
+    return reinterpret_cast<const T&>(union_);
+  }
+  T* get_mutable() { return reinterpret_cast<T*>(&union_); }
+
+ private:
+  // Prefer c++14 aligned_storage, but for compatibility this will do.
+  union AlignedUnion {
+    char space[sizeof(T)];
+    int64 align_to_int64;
+    void* align_to_ptr;
+  } union_;
+};
+
+// Default empty string object. Don't use this directly. Instead, call
+// GetEmptyString() to get the reference.
+extern ExplicitlyConstructed< ::std::string> fixed_address_empty_string;
+LIBPROTOBUF_EXPORT extern ProtobufOnceType empty_string_once_init_;
+LIBPROTOBUF_EXPORT void InitEmptyString();
+
+
+LIBPROTOBUF_EXPORT inline const ::std::string& GetEmptyStringAlreadyInited() {
+  return fixed_address_empty_string.get();
+}
+
+LIBPROTOBUF_EXPORT inline const ::std::string& GetEmptyString() {
+  ::google::protobuf::GoogleOnceInit(&empty_string_once_init_, &InitEmptyString);
+  return GetEmptyStringAlreadyInited();
+}
+
+LIBPROTOBUF_EXPORT size_t StringSpaceUsedExcludingSelfLong(const string& str);
+#endif  // SWIG
+}  // namespace internal
+
+// Interface to light weight protocol messages.
+//
+// This interface is implemented by all protocol message objects.  Non-lite
+// messages additionally implement the Message interface, which is a
+// subclass of MessageLite.  Use MessageLite instead when you only need
+// the subset of features which it supports -- namely, nothing that uses
+// descriptors or reflection.  You can instruct the protocol compiler
+// to generate classes which implement only MessageLite, not the full
+// Message interface, by adding the following line to the .proto file:
+//
+//   option optimize_for = LITE_RUNTIME;
+//
+// This is particularly useful on resource-constrained systems where
+// the full protocol buffers runtime library is too big.
+//
+// Note that on non-constrained systems (e.g. servers) when you need
+// to link in lots of protocol definitions, a better way to reduce
+// total code footprint is to use optimize_for = CODE_SIZE.  This
+// will make the generated code smaller while still supporting all the
+// same features (at the expense of speed).  optimize_for = LITE_RUNTIME
+// is best when you only have a small number of message types linked
+// into your binary, in which case the size of the protocol buffers
+// runtime itself is the biggest problem.
+class LIBPROTOBUF_EXPORT MessageLite {
+ public:
+  inline MessageLite() {}
+  virtual ~MessageLite() {}
+
+  // Basic Operations ------------------------------------------------
+
+  // Get the name of this message type, e.g. "foo.bar.BazProto".
+  virtual string GetTypeName() const = 0;
+
+  // Construct a new instance of the same type.  Ownership is passed to the
+  // caller.
+  virtual MessageLite* New() const = 0;
+
+  // Construct a new instance on the arena. Ownership is passed to the caller
+  // if arena is a NULL. Default implementation for backwards compatibility.
+  virtual MessageLite* New(::google::protobuf::Arena* arena) const;
+
+  // Get the arena, if any, associated with this message. Virtual method
+  // required for generic operations but most arena-related operations should
+  // use the GetArenaNoVirtual() generated-code method. Default implementation
+  // to reduce code size by avoiding the need for per-type implementations
+  // when types do not implement arena support.
+  virtual ::google::protobuf::Arena* GetArena() const { return NULL; }
+
+  // Get a pointer that may be equal to this message's arena, or may not be.
+  // If the value returned by this method is equal to some arena pointer, then
+  // this message is on that arena; however, if this message is on some arena,
+  // this method may or may not return that arena's pointer. As a tradeoff,
+  // this method may be more efficient than GetArena(). The intent is to allow
+  // underlying representations that use e.g. tagged pointers to sometimes
+  // store the arena pointer directly, and sometimes in a more indirect way,
+  // and allow a fastpath comparison against the arena pointer when it's easy
+  // to obtain.
+  virtual void* GetMaybeArenaPointer() const { return GetArena(); }
+
+  // Clear all fields of the message and set them to their default values.
+  // Clear() avoids freeing memory, assuming that any memory allocated
+  // to hold parts of the message will be needed again to hold the next
+  // message.  If you actually want to free the memory used by a Message,
+  // you must delete it.
+  virtual void Clear() = 0;
+
+  // Quickly check if all required fields have values set.
+  virtual bool IsInitialized() const = 0;
+
+  // This is not implemented for Lite messages -- it just returns "(cannot
+  // determine missing fields for lite message)".  However, it is implemented
+  // for full messages.  See message.h.
+  virtual string InitializationErrorString() const;
+
+  // If |other| is the exact same class as this, calls MergeFrom(). Otherwise,
+  // results are undefined (probably crash).
+  virtual void CheckTypeAndMergeFrom(const MessageLite& other) = 0;
+
+  // Parsing ---------------------------------------------------------
+  // Methods for parsing in protocol buffer format.  Most of these are
+  // just simple wrappers around MergeFromCodedStream().  Clear() will be
+  // called before merging the input.
+
+  // Fill the message with a protocol buffer parsed from the given input
+  // stream. Returns false on a read error or if the input is in the wrong
+  // format.  A successful return does not indicate the entire input is
+  // consumed, ensure you call ConsumedEntireMessage() to check that if
+  // applicable.
+  bool ParseFromCodedStream(io::CodedInputStream* input);
+  // Like ParseFromCodedStream(), but accepts messages that are missing
+  // required fields.
+  bool ParsePartialFromCodedStream(io::CodedInputStream* input);
+  // Read a protocol buffer from the given zero-copy input stream.  If
+  // successful, the entire input will be consumed.
+  bool ParseFromZeroCopyStream(io::ZeroCopyInputStream* input);
+  // Like ParseFromZeroCopyStream(), but accepts messages that are missing
+  // required fields.
+  bool ParsePartialFromZeroCopyStream(io::ZeroCopyInputStream* input);
+  // Read a protocol buffer from the given zero-copy input stream, expecting
+  // the message to be exactly "size" bytes long.  If successful, exactly
+  // this many bytes will have been consumed from the input.
+  bool ParseFromBoundedZeroCopyStream(io::ZeroCopyInputStream* input, int size);
+  // Like ParseFromBoundedZeroCopyStream(), but accepts messages that are
+  // missing required fields.
+  bool ParsePartialFromBoundedZeroCopyStream(io::ZeroCopyInputStream* input,
+                                             int size);
+  // Parses a protocol buffer contained in a string. Returns true on success.
+  // This function takes a string in the (non-human-readable) binary wire
+  // format, matching the encoding output by MessageLite::SerializeToString().
+  // If you'd like to convert a human-readable string into a protocol buffer
+  // object, see google::protobuf::TextFormat::ParseFromString().
+  bool ParseFromString(const string& data);
+  // Like ParseFromString(), but accepts messages that are missing
+  // required fields.
+  bool ParsePartialFromString(const string& data);
+  // Parse a protocol buffer contained in an array of bytes.
+  bool ParseFromArray(const void* data, int size);
+  // Like ParseFromArray(), but accepts messages that are missing
+  // required fields.
+  bool ParsePartialFromArray(const void* data, int size);
+
+
+  // Reads a protocol buffer from the stream and merges it into this
+  // Message.  Singular fields read from the input overwrite what is
+  // already in the Message and repeated fields are appended to those
+  // already present.
+  //
+  // It is the responsibility of the caller to call input->LastTagWas()
+  // (for groups) or input->ConsumedEntireMessage() (for non-groups) after
+  // this returns to verify that the message's end was delimited correctly.
+  //
+  // ParsefromCodedStream() is implemented as Clear() followed by
+  // MergeFromCodedStream().
+  bool MergeFromCodedStream(io::CodedInputStream* input);
+
+  // Like MergeFromCodedStream(), but succeeds even if required fields are
+  // missing in the input.
+  //
+  // MergeFromCodedStream() is just implemented as MergePartialFromCodedStream()
+  // followed by IsInitialized().
+  virtual bool MergePartialFromCodedStream(io::CodedInputStream* input) = 0;
+
+
+  // Serialization ---------------------------------------------------
+  // Methods for serializing in protocol buffer format.  Most of these
+  // are just simple wrappers around ByteSize() and SerializeWithCachedSizes().
+
+  // Write a protocol buffer of this message to the given output.  Returns
+  // false on a write error.  If the message is missing required fields,
+  // this may GOOGLE_CHECK-fail.
+  bool SerializeToCodedStream(io::CodedOutputStream* output) const;
+  // Like SerializeToCodedStream(), but allows missing required fields.
+  bool SerializePartialToCodedStream(io::CodedOutputStream* output) const;
+  // Write the message to the given zero-copy output stream.  All required
+  // fields must be set.
+  bool SerializeToZeroCopyStream(io::ZeroCopyOutputStream* output) const;
+  // Like SerializeToZeroCopyStream(), but allows missing required fields.
+  bool SerializePartialToZeroCopyStream(io::ZeroCopyOutputStream* output) const;
+  // Serialize the message and store it in the given string.  All required
+  // fields must be set.
+  bool SerializeToString(string* output) const;
+  // Like SerializeToString(), but allows missing required fields.
+  bool SerializePartialToString(string* output) const;
+  // Serialize the message and store it in the given byte array.  All required
+  // fields must be set.
+  bool SerializeToArray(void* data, int size) const;
+  // Like SerializeToArray(), but allows missing required fields.
+  bool SerializePartialToArray(void* data, int size) const;
+
+  // Make a string encoding the message. Is equivalent to calling
+  // SerializeToString() on a string and using that.  Returns the empty
+  // string if SerializeToString() would have returned an error.
+  // Note: If you intend to generate many such strings, you may
+  // reduce heap fragmentation by instead re-using the same string
+  // object with calls to SerializeToString().
+  string SerializeAsString() const;
+  // Like SerializeAsString(), but allows missing required fields.
+  string SerializePartialAsString() const;
+
+  // Like SerializeToString(), but appends to the data to the string's existing
+  // contents.  All required fields must be set.
+  bool AppendToString(string* output) const;
+  // Like AppendToString(), but allows missing required fields.
+  bool AppendPartialToString(string* output) const;
+
+  // Computes the serialized size of the message.  This recursively calls
+  // ByteSizeLong() on all embedded messages.
+  //
+  // ByteSizeLong() is generally linear in the number of fields defined for the
+  // proto.
+  virtual size_t ByteSizeLong() const = 0;
+
+  // Legacy ByteSize() API.
+  PROTOBUF_RUNTIME_DEPRECATED("Please use ByteSizeLong() instead")
+  int ByteSize() const {
+    return internal::ToIntSize(ByteSizeLong());
+  }
+
+  // Serializes the message without recomputing the size.  The message must not
+  // have changed since the last call to ByteSize(), and the value returned by
+  // ByteSize must be non-negative.  Otherwise the results are undefined.
+  virtual void SerializeWithCachedSizes(
+      io::CodedOutputStream* output) const;
+
+  // Functions below here are not part of the public interface.  It isn't
+  // enforced, but they should be treated as private, and will be private
+  // at some future time.  Unfortunately the implementation of the "friend"
+  // keyword in GCC is broken at the moment, but we expect it will be fixed.
+
+  // Like SerializeWithCachedSizes, but writes directly to *target, returning
+  // a pointer to the byte immediately after the last byte written.  "target"
+  // must point at a byte array of at least ByteSize() bytes.  Whether to use
+  // deterministic serialization, e.g., maps in sorted order, is determined by
+  // CodedOutputStream::IsDefaultSerializationDeterministic().
+  virtual uint8* SerializeWithCachedSizesToArray(uint8* target) const;
+
+  // Returns the result of the last call to ByteSize().  An embedded message's
+  // size is needed both to serialize it (because embedded messages are
+  // length-delimited) and to compute the outer message's size.  Caching
+  // the size avoids computing it multiple times.
+  //
+  // ByteSize() does not automatically use the cached size when available
+  // because this would require invalidating it every time the message was
+  // modified, which would be too hard and expensive.  (E.g. if a deeply-nested
+  // sub-message is changed, all of its parents' cached sizes would need to be
+  // invalidated, which is too much work for an otherwise inlined setter
+  // method.)
+  virtual int GetCachedSize() const = 0;
+
+  virtual uint8* InternalSerializeWithCachedSizesToArray(bool deterministic,
+                                                         uint8* target) const;
+
+ private:
+  // TODO(gerbens) make this a pure abstract function
+  virtual const void* InternalGetTable() const { return NULL; }
+
+  friend class internal::WireFormatLite;
+  friend class Message;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MessageLite);
+};
+
+namespace internal {
+
+extern bool LIBPROTOBUF_EXPORT proto3_preserve_unknown_;
+
+// DO NOT USE: For migration only. Will be removed when Proto3 defaults to
+// preserve unknowns.
+inline bool GetProto3PreserveUnknownsDefault() {
+  return proto3_preserve_unknown_;
+}
+
+// DO NOT USE: For migration only. Will be removed when Proto3 defaults to
+// preserve unknowns.
+void LIBPROTOBUF_EXPORT SetProto3PreserveUnknownsDefault(bool preserve);
+}  // namespace internal
+
+
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_MESSAGE_LITE_H__
diff --git a/kortex_api/include/google/protobuf/metadata.h b/kortex_api/include/google/protobuf/metadata.h
new file mode 100644
index 0000000000000000000000000000000000000000..0a6507c0677df85700d12e2b02a37d4e5f6684a1
--- /dev/null
+++ b/kortex_api/include/google/protobuf/metadata.h
@@ -0,0 +1,78 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// This header file defines an internal class that encapsulates internal message
+// metadata (Unknown-field set, Arena pointer, ...) and allows its
+// representation to be made more space-efficient via various optimizations.
+//
+// Note that this is distinct from google::protobuf::Metadata, which encapsulates
+// Descriptor and Reflection pointers.
+
+#ifndef GOOGLE_PROTOBUF_METADATA_H__
+#define GOOGLE_PROTOBUF_METADATA_H__
+
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/unknown_field_set.h>
+
+namespace google {
+namespace protobuf {
+namespace internal {
+
+class InternalMetadataWithArena
+    : public InternalMetadataWithArenaBase<UnknownFieldSet,
+                                           InternalMetadataWithArena> {
+ public:
+  InternalMetadataWithArena() {}
+  explicit InternalMetadataWithArena(Arena* arena)
+      : InternalMetadataWithArenaBase<UnknownFieldSet,
+                                           InternalMetadataWithArena>(arena) {}
+
+  void DoSwap(UnknownFieldSet* other) {
+    mutable_unknown_fields()->Swap(other);
+  }
+
+  void DoMergeFrom(const UnknownFieldSet& other) {
+    mutable_unknown_fields()->MergeFrom(other);
+  }
+
+  void DoClear() {
+    mutable_unknown_fields()->Clear();
+  }
+
+  static const UnknownFieldSet& default_instance() {
+    return *UnknownFieldSet::default_instance();
+  }
+};
+
+}  // namespace internal
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_METADATA_H__
diff --git a/kortex_api/include/google/protobuf/metadata_lite.h b/kortex_api/include/google/protobuf/metadata_lite.h
new file mode 100644
index 0000000000000000000000000000000000000000..454d088c965e8c95a327db9d8c405caa0fe48d15
--- /dev/null
+++ b/kortex_api/include/google/protobuf/metadata_lite.h
@@ -0,0 +1,224 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_METADATA_LITE_H__
+#define GOOGLE_PROTOBUF_METADATA_LITE_H__
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/message_lite.h>
+#include <google/protobuf/stubs/port.h>
+
+namespace google {
+namespace protobuf {
+namespace internal {
+
+// This is the representation for messages that support arena allocation. It
+// uses a tagged pointer to either store the Arena pointer, if there are no
+// unknown fields, or a pointer to a block of memory with both the Arena pointer
+// and the UnknownFieldSet, if there are unknown fields. This optimization
+// allows for "zero-overhead" storage of the Arena pointer, relative to the
+// above baseline implementation.
+//
+// The tagged pointer uses the LSB to disambiguate cases, and uses bit 0 == 0 to
+// indicate an arena pointer and bit 0 == 1 to indicate a UFS+Arena-container
+// pointer.
+template <class T, class Derived>
+class InternalMetadataWithArenaBase {
+ public:
+  InternalMetadataWithArenaBase() : ptr_(NULL) {}
+  explicit InternalMetadataWithArenaBase(Arena* arena) : ptr_(arena) {}
+
+  ~InternalMetadataWithArenaBase() {
+    if (have_unknown_fields() && arena() == NULL) {
+      delete PtrValue<Container>();
+    }
+    ptr_ = NULL;
+  }
+
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE const T& unknown_fields() const {
+    if (GOOGLE_PREDICT_FALSE(have_unknown_fields())) {
+      return PtrValue<Container>()->unknown_fields;
+    } else {
+      return Derived::default_instance();
+    }
+  }
+
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE T* mutable_unknown_fields() {
+    if (GOOGLE_PREDICT_TRUE(have_unknown_fields())) {
+      return &PtrValue<Container>()->unknown_fields;
+    } else {
+      return mutable_unknown_fields_slow();
+    }
+  }
+
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE Arena* arena() const {
+    if (GOOGLE_PREDICT_FALSE(have_unknown_fields())) {
+      return PtrValue<Container>()->arena;
+    } else {
+      return PtrValue<Arena>();
+    }
+  }
+
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE bool have_unknown_fields() const {
+    return PtrTag() == kTagContainer;
+  }
+
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE void Swap(Derived* other) {
+    // Semantics here are that we swap only the unknown fields, not the arena
+    // pointer. We cannot simply swap ptr_ with other->ptr_ because we need to
+    // maintain our own arena ptr. Also, our ptr_ and other's ptr_ may be in
+    // different states (direct arena pointer vs. container with UFS) so we
+    // cannot simply swap ptr_ and then restore the arena pointers. We reuse
+    // UFS's swap implementation instead.
+    if (have_unknown_fields() || other->have_unknown_fields()) {
+      static_cast<Derived*>(this)->DoSwap(other->mutable_unknown_fields());
+    }
+  }
+
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE void MergeFrom(const Derived& other) {
+    if (other.have_unknown_fields()) {
+      static_cast<Derived*>(this)->DoMergeFrom(other.unknown_fields());
+    }
+  }
+
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE void Clear() {
+    if (have_unknown_fields()) {
+      static_cast<Derived*>(this)->DoClear();
+    }
+  }
+
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE void* raw_arena_ptr() const {
+    return ptr_;
+  }
+
+ private:
+  void* ptr_;
+
+  // Tagged pointer implementation.
+  enum {
+    // ptr_ is an Arena*.
+    kTagArena = 0,
+    // ptr_ is a Container*.
+    kTagContainer = 1,
+  };
+  static const intptr_t kPtrTagMask = 1;
+  static const intptr_t kPtrValueMask = ~kPtrTagMask;
+
+  // Accessors for pointer tag and pointer value.
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE int PtrTag() const {
+    return reinterpret_cast<intptr_t>(ptr_) & kPtrTagMask;
+  }
+
+  template<typename U> U* PtrValue() const {
+    return reinterpret_cast<U*>(
+        reinterpret_cast<intptr_t>(ptr_) & kPtrValueMask);
+  }
+
+  // If ptr_'s tag is kTagContainer, it points to an instance of this struct.
+  struct Container {
+    T unknown_fields;
+    Arena* arena;
+  };
+
+  GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE T* mutable_unknown_fields_slow() {
+    Arena* my_arena = arena();
+    Container* container = Arena::Create<Container>(my_arena);
+    // Two-step assignment works around a bug in clang's static analyzer:
+    // https://bugs.llvm.org/show_bug.cgi?id=34198.
+    ptr_ = container;
+    ptr_ = reinterpret_cast<void*>(
+        reinterpret_cast<intptr_t>(ptr_) | kTagContainer);
+    container->arena = my_arena;
+    return &(container->unknown_fields);
+  }
+};
+
+// We store unknown fields as a string right now, because there is currently no
+// good interface for reading unknown fields into an ArenaString.  We may want
+// to revisit this to allow unknown fields to be parsed onto the Arena.
+class InternalMetadataWithArenaLite
+    : public InternalMetadataWithArenaBase<string,
+                                           InternalMetadataWithArenaLite> {
+ public:
+  InternalMetadataWithArenaLite() {}
+
+  explicit InternalMetadataWithArenaLite(Arena* arena)
+      : InternalMetadataWithArenaBase<string,
+                                      InternalMetadataWithArenaLite>(arena) {}
+
+  void DoSwap(string* other) {
+    mutable_unknown_fields()->swap(*other);
+  }
+
+  void DoMergeFrom(const string& other) {
+    mutable_unknown_fields()->append(other);
+  }
+
+  void DoClear() {
+    mutable_unknown_fields()->clear();
+  }
+
+  static const string& default_instance() {
+    return GetEmptyStringAlreadyInited();
+  }
+};
+
+// This helper RAII class is needed to efficiently parse unknown fields. We
+// should only call mutable_unknown_fields if there are actual unknown fields.
+// The obvious thing to just use a stack string and swap it at the end of the
+// parse won't work, because the destructor of StringOutputStream needs to be
+// called before we can modify the string (it check-fails). Using
+// LiteUnknownFieldSetter setter(&_internal_metadata_);
+// StringOutputStream stream(setter.buffer());
+// guarantees that the string is only swapped after stream is destroyed.
+class LIBPROTOBUF_EXPORT LiteUnknownFieldSetter {
+ public:
+  explicit LiteUnknownFieldSetter(InternalMetadataWithArenaLite* metadata)
+      : metadata_(metadata) {
+    if (metadata->have_unknown_fields()) {
+      buffer_.swap(*metadata->mutable_unknown_fields());
+    }
+  }
+  ~LiteUnknownFieldSetter() {
+    if (!buffer_.empty()) metadata_->mutable_unknown_fields()->swap(buffer_);
+  }
+  string* buffer() { return &buffer_; }
+
+ private:
+  InternalMetadataWithArenaLite* metadata_;
+  string buffer_;
+};
+
+}  // namespace internal
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_METADATA_LITE_H__
diff --git a/kortex_api/include/google/protobuf/reflection.h b/kortex_api/include/google/protobuf/reflection.h
new file mode 100644
index 0000000000000000000000000000000000000000..fcb9a435592385ab1cd00486017d2e567b69265e
--- /dev/null
+++ b/kortex_api/include/google/protobuf/reflection.h
@@ -0,0 +1,613 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// This header defines the RepeatedFieldRef class template used to access
+// repeated fields with protobuf reflection API.
+#ifndef GOOGLE_PROTOBUF_REFLECTION_H__
+#define GOOGLE_PROTOBUF_REFLECTION_H__
+
+#include <memory>
+#ifndef _SHARED_PTR_H
+#include <google/protobuf/stubs/shared_ptr.h>
+#endif
+
+#include <google/protobuf/message.h>
+#include <google/protobuf/generated_enum_util.h>
+
+namespace google {
+namespace protobuf {
+namespace internal {
+template<typename T, typename Enable = void>
+struct RefTypeTraits;
+}  // namespace internal
+
+template<typename T>
+RepeatedFieldRef<T> Reflection::GetRepeatedFieldRef(
+    const Message& message, const FieldDescriptor* field) const {
+  return RepeatedFieldRef<T>(message, field);
+}
+
+template<typename T>
+MutableRepeatedFieldRef<T> Reflection::GetMutableRepeatedFieldRef(
+    Message* message, const FieldDescriptor* field) const {
+  return MutableRepeatedFieldRef<T>(message, field);
+}
+
+// RepeatedFieldRef definition for non-message types.
+template<typename T>
+class RepeatedFieldRef<
+    T, typename internal::enable_if<!internal::is_base_of<Message, T>::value>::type> {
+  typedef typename internal::RefTypeTraits<T>::iterator IteratorType;
+  typedef typename internal::RefTypeTraits<T>::AccessorType AccessorType;
+
+ public:
+  bool empty() const {
+    return accessor_->IsEmpty(data_);
+  }
+  int size() const {
+    return accessor_->Size(data_);
+  }
+  T Get(int index) const {
+    return accessor_->template Get<T>(data_, index);
+  }
+
+  typedef IteratorType iterator;
+  typedef IteratorType const_iterator;
+  typedef T value_type;
+  typedef T& reference;
+  typedef const T& const_reference;
+  typedef int size_type;
+  typedef ptrdiff_t difference_type;
+
+  iterator begin() const {
+    return iterator(data_, accessor_, true);
+  }
+  iterator end() const {
+    return iterator(data_, accessor_, false);
+  }
+
+ private:
+  friend class Reflection;
+  RepeatedFieldRef(
+      const Message& message,
+      const FieldDescriptor* field) {
+    const Reflection* reflection = message.GetReflection();
+    data_ = reflection->RepeatedFieldData(
+        const_cast<Message*>(&message), field,
+        internal::RefTypeTraits<T>::cpp_type, NULL);
+    accessor_ = reflection->RepeatedFieldAccessor(field);
+  }
+
+  const void* data_;
+  const AccessorType* accessor_;
+};
+
+// MutableRepeatedFieldRef definition for non-message types.
+template<typename T>
+class MutableRepeatedFieldRef<
+    T, typename internal::enable_if<!internal::is_base_of<Message, T>::value>::type> {
+  typedef typename internal::RefTypeTraits<T>::AccessorType AccessorType;
+
+ public:
+  bool empty() const {
+    return accessor_->IsEmpty(data_);
+  }
+  int size() const {
+    return accessor_->Size(data_);
+  }
+  T Get(int index) const {
+    return accessor_->template Get<T>(data_, index);
+  }
+
+  void Set(int index, const T& value) const {
+    accessor_->template Set<T>(data_, index, value);
+  }
+  void Add(const T& value) const {
+    accessor_->template Add<T>(data_, value);
+  }
+  void RemoveLast() const {
+    accessor_->RemoveLast(data_);
+  }
+  void SwapElements(int index1, int index2) const {
+    accessor_->SwapElements(data_, index1, index2);
+  }
+  void Clear() const {
+    accessor_->Clear(data_);
+  }
+
+  void Swap(const MutableRepeatedFieldRef& other) const {
+    accessor_->Swap(data_, other.accessor_, other.data_);
+  }
+
+  template<typename Container>
+  void MergeFrom(const Container& container) const {
+    typedef typename Container::const_iterator Iterator;
+    for (Iterator it = container.begin(); it != container.end(); ++it) {
+      Add(*it);
+    }
+  }
+  template<typename Container>
+  void CopyFrom(const Container& container) const {
+    Clear();
+    MergeFrom(container);
+  }
+
+ private:
+  friend class Reflection;
+  MutableRepeatedFieldRef(
+      Message* message,
+      const FieldDescriptor* field) {
+    const Reflection* reflection = message->GetReflection();
+    data_ = reflection->RepeatedFieldData(
+        message, field, internal::RefTypeTraits<T>::cpp_type, NULL);
+    accessor_ = reflection->RepeatedFieldAccessor(field);
+  }
+
+  void* data_;
+  const AccessorType* accessor_;
+};
+
+// RepeatedFieldRef definition for message types.
+template<typename T>
+class RepeatedFieldRef<
+    T, typename internal::enable_if<internal::is_base_of<Message, T>::value>::type> {
+  typedef typename internal::RefTypeTraits<T>::iterator IteratorType;
+  typedef typename internal::RefTypeTraits<T>::AccessorType AccessorType;
+
+ public:
+  bool empty() const {
+    return accessor_->IsEmpty(data_);
+  }
+  int size() const {
+    return accessor_->Size(data_);
+  }
+  // This method returns a reference to the underlying message object if it
+  // exists. If a message object doesn't exist (e.g., data stored in serialized
+  // form), scratch_space will be filled with the data and a reference to it
+  // will be returned.
+  //
+  // Example:
+  //   RepeatedFieldRef<Message> h = ...
+  //   unique_ptr<Message> scratch_space(h.NewMessage());
+  //   const Message& item = h.Get(index, scratch_space.get());
+  const T& Get(int index, T* scratch_space) const {
+    return *static_cast<const T*>(accessor_->Get(data_, index, scratch_space));
+  }
+  // Create a new message of the same type as the messages stored in this
+  // repeated field. Caller takes ownership of the returned object.
+  T* NewMessage() const {
+    return static_cast<T*>(default_instance_->New());
+  }
+
+  typedef IteratorType iterator;
+  typedef IteratorType const_iterator;
+  typedef T value_type;
+  typedef T& reference;
+  typedef const T& const_reference;
+  typedef int size_type;
+  typedef ptrdiff_t difference_type;
+
+  iterator begin() const {
+    return iterator(data_, accessor_, true, NewMessage());
+  }
+  iterator end() const {
+    // The end iterator must not be dereferenced, no need for scratch space.
+    return iterator(data_, accessor_, false, NULL);
+  }
+
+ private:
+  friend class Reflection;
+  RepeatedFieldRef(
+      const Message& message,
+      const FieldDescriptor* field) {
+    const Reflection* reflection = message.GetReflection();
+    data_ = reflection->RepeatedFieldData(
+        const_cast<Message*>(&message), field,
+        internal::RefTypeTraits<T>::cpp_type,
+        internal::RefTypeTraits<T>::GetMessageFieldDescriptor());
+    accessor_ = reflection->RepeatedFieldAccessor(field);
+    default_instance_ =
+        reflection->GetMessageFactory()->GetPrototype(field->message_type());
+  }
+
+  const void* data_;
+  const AccessorType* accessor_;
+  const Message* default_instance_;
+};
+
+// MutableRepeatedFieldRef definition for message types.
+template<typename T>
+class MutableRepeatedFieldRef<
+    T, typename internal::enable_if<internal::is_base_of<Message, T>::value>::type> {
+  typedef typename internal::RefTypeTraits<T>::AccessorType AccessorType;
+
+ public:
+  bool empty() const {
+    return accessor_->IsEmpty(data_);
+  }
+  int size() const {
+    return accessor_->Size(data_);
+  }
+  // See comments for RepeatedFieldRef<Message>::Get()
+  const T& Get(int index, T* scratch_space) const {
+    return *static_cast<const T*>(accessor_->Get(data_, index, scratch_space));
+  }
+  // Create a new message of the same type as the messages stored in this
+  // repeated field. Caller takes ownership of the returned object.
+  T* NewMessage() const {
+    return static_cast<T*>(default_instance_->New());
+  }
+
+  void Set(int index, const T& value) const {
+    accessor_->Set(data_, index, &value);
+  }
+  void Add(const T& value) const {
+    accessor_->Add(data_, &value);
+  }
+  void RemoveLast() const {
+    accessor_->RemoveLast(data_);
+  }
+  void SwapElements(int index1, int index2) const {
+    accessor_->SwapElements(data_, index1, index2);
+  }
+  void Clear() const {
+    accessor_->Clear(data_);
+  }
+
+  void Swap(const MutableRepeatedFieldRef& other) const {
+    accessor_->Swap(data_, other.accessor_, other.data_);
+  }
+
+  template<typename Container>
+  void MergeFrom(const Container& container) const {
+    typedef typename Container::const_iterator Iterator;
+    for (Iterator it = container.begin(); it != container.end(); ++it) {
+      Add(*it);
+    }
+  }
+  template<typename Container>
+  void CopyFrom(const Container& container) const {
+    Clear();
+    MergeFrom(container);
+  }
+
+ private:
+  friend class Reflection;
+  MutableRepeatedFieldRef(
+      Message* message,
+      const FieldDescriptor* field) {
+    const Reflection* reflection = message->GetReflection();
+    data_ = reflection->RepeatedFieldData(
+        message, field, internal::RefTypeTraits<T>::cpp_type,
+        internal::RefTypeTraits<T>::GetMessageFieldDescriptor());
+    accessor_ = reflection->RepeatedFieldAccessor(field);
+    default_instance_ =
+        reflection->GetMessageFactory()->GetPrototype(field->message_type());
+  }
+
+  void* data_;
+  const AccessorType* accessor_;
+  const Message* default_instance_;
+};
+
+namespace internal {
+// Interfaces used to implement reflection RepeatedFieldRef API.
+// Reflection::GetRepeatedAccessor() should return a pointer to an singleton
+// object that implements the below interface.
+//
+// This interface passes/returns values using void pointers. The actual type
+// of the value depends on the field's cpp_type. Following is a mapping from
+// cpp_type to the type that should be used in this interface:
+//
+//   field->cpp_type()      T                Actual type of void*
+//   CPPTYPE_INT32        int32                   int32
+//   CPPTYPE_UINT32       uint32                  uint32
+//   CPPTYPE_INT64        int64                   int64
+//   CPPTYPE_UINT64       uint64                  uint64
+//   CPPTYPE_DOUBLE       double                  double
+//   CPPTYPE_FLOAT        float                   float
+//   CPPTYPE_BOOL         bool                    bool
+//   CPPTYPE_ENUM         generated enum type     int32
+//   CPPTYPE_STRING       string                  string
+//   CPPTYPE_MESSAGE      generated message type  google::protobuf::Message
+//                        or google::protobuf::Message
+//
+// Note that for enums we use int32 in the interface.
+//
+// You can map from T to the actual type using RefTypeTraits:
+//   typedef RefTypeTraits<T>::AccessorValueType ActualType;
+class LIBPROTOBUF_EXPORT RepeatedFieldAccessor {
+ public:
+  // Typedefs for clarity.
+  typedef void Field;
+  typedef void Value;
+  typedef void Iterator;
+
+  virtual ~RepeatedFieldAccessor();
+  virtual bool IsEmpty(const Field* data) const = 0;
+  virtual int Size(const Field* data) const = 0;
+  // Depends on the underlying representation of the repeated field, this
+  // method can return a pointer to the underlying object if such an object
+  // exists, or fill the data into scratch_space and return scratch_space.
+  // Callers of this method must ensure scratch_space is a valid pointer
+  // to a mutable object of the correct type.
+  virtual const Value* Get(
+      const Field* data, int index, Value* scratch_space) const = 0;
+
+  virtual void Clear(Field* data) const = 0;
+  virtual void Set(Field* data, int index, const Value* value) const = 0;
+  virtual void Add(Field* data, const Value* value) const = 0;
+  virtual void RemoveLast(Field* data) const = 0;
+  virtual void SwapElements(Field* data, int index1, int index2) const = 0;
+  virtual void Swap(Field* data, const RepeatedFieldAccessor* other_mutator,
+                    Field* other_data) const = 0;
+
+  // Create an iterator that points at the beginning of the repeated field.
+  virtual Iterator* BeginIterator(const Field* data) const = 0;
+  // Create an iterator that points at the end of the repeated field.
+  virtual Iterator* EndIterator(const Field* data) const = 0;
+  // Make a copy of an iterator and return the new copy.
+  virtual Iterator* CopyIterator(const Field* data,
+                                 const Iterator* iterator) const = 0;
+  // Move an iterator to point to the next element.
+  virtual Iterator* AdvanceIterator(const Field* data,
+                                    Iterator* iterator) const = 0;
+  // Compare whether two iterators point to the same element.
+  virtual bool EqualsIterator(const Field* data, const Iterator* a,
+                              const Iterator* b) const = 0;
+  // Delete an iterator created by BeginIterator(), EndIterator() and
+  // CopyIterator().
+  virtual void DeleteIterator(const Field* data, Iterator* iterator) const = 0;
+  // Like Get() but for iterators.
+  virtual const Value* GetIteratorValue(const Field* data,
+                                        const Iterator* iterator,
+                                        Value* scratch_space) const = 0;
+
+  // Templated methods that make using this interface easier for non-message
+  // types.
+  template<typename T>
+  T Get(const Field* data, int index) const {
+    typedef typename RefTypeTraits<T>::AccessorValueType ActualType;
+    ActualType scratch_space;
+    return static_cast<T>(
+        *reinterpret_cast<const ActualType*>(
+            Get(data, index, static_cast<Value*>(&scratch_space))));
+  }
+
+  template<typename T, typename ValueType>
+  void Set(Field* data, int index, const ValueType& value) const {
+    typedef typename RefTypeTraits<T>::AccessorValueType ActualType;
+    // In this RepeatedFieldAccessor interface we pass/return data using
+    // raw pointers. Type of the data these raw pointers point to should
+    // be ActualType. Here we have a ValueType object and want a ActualType
+    // pointer. We can't cast a ValueType pointer to an ActualType pointer
+    // directly because their type might be different (for enums ValueType
+    // may be a generated enum type while ActualType is int32). To be safe
+    // we make a copy to get a temporary ActualType object and use it.
+    ActualType tmp = static_cast<ActualType>(value);
+    Set(data, index, static_cast<const Value*>(&tmp));
+  }
+
+  template<typename T, typename ValueType>
+  void Add(Field* data, const ValueType& value) const {
+    typedef typename RefTypeTraits<T>::AccessorValueType ActualType;
+    // In this RepeatedFieldAccessor interface we pass/return data using
+    // raw pointers. Type of the data these raw pointers point to should
+    // be ActualType. Here we have a ValueType object and want a ActualType
+    // pointer. We can't cast a ValueType pointer to an ActualType pointer
+    // directly because their type might be different (for enums ValueType
+    // may be a generated enum type while ActualType is int32). To be safe
+    // we make a copy to get a temporary ActualType object and use it.
+    ActualType tmp = static_cast<ActualType>(value);
+    Add(data, static_cast<const Value*>(&tmp));
+  }
+};
+
+// Implement (Mutable)RepeatedFieldRef::iterator
+template<typename T>
+class RepeatedFieldRefIterator
+    : public std::iterator<std::forward_iterator_tag, T> {
+  typedef typename RefTypeTraits<T>::AccessorValueType AccessorValueType;
+  typedef typename RefTypeTraits<T>::IteratorValueType IteratorValueType;
+  typedef typename RefTypeTraits<T>::IteratorPointerType IteratorPointerType;
+
+ public:
+  // Constructor for non-message fields.
+  RepeatedFieldRefIterator(const void* data,
+                           const RepeatedFieldAccessor* accessor, bool begin)
+      : data_(data),
+        accessor_(accessor),
+        iterator_(begin ? accessor->BeginIterator(data)
+                        : accessor->EndIterator(data)),
+        // The end iterator must not be dereferenced, no need for scratch space.
+        scratch_space_(begin ? new AccessorValueType : NULL) {}
+  // Constructor for message fields.
+  RepeatedFieldRefIterator(const void* data,
+                           const RepeatedFieldAccessor* accessor,
+                           bool begin,
+                           AccessorValueType* scratch_space)
+      : data_(data), accessor_(accessor),
+        iterator_(begin ? accessor->BeginIterator(data) :
+                          accessor->EndIterator(data)),
+        scratch_space_(scratch_space) {
+  }
+  ~RepeatedFieldRefIterator() {
+    accessor_->DeleteIterator(data_, iterator_);
+  }
+  RepeatedFieldRefIterator operator++(int) {
+    RepeatedFieldRefIterator tmp(*this);
+    iterator_ = accessor_->AdvanceIterator(data_, iterator_);
+    return tmp;
+  }
+  RepeatedFieldRefIterator& operator++() {
+    iterator_ = accessor_->AdvanceIterator(data_, iterator_);
+    return *this;
+  }
+  IteratorValueType operator*() const {
+    return static_cast<IteratorValueType>(
+        *static_cast<const AccessorValueType*>(
+            accessor_->GetIteratorValue(
+                data_, iterator_, scratch_space_.get())));
+  }
+  IteratorPointerType operator->() const {
+    return static_cast<IteratorPointerType>(
+        accessor_->GetIteratorValue(
+            data_, iterator_, scratch_space_.get()));
+  }
+  bool operator!=(const RepeatedFieldRefIterator& other) const {
+    assert(data_ == other.data_);
+    assert(accessor_ == other.accessor_);
+    return !accessor_->EqualsIterator(data_, iterator_, other.iterator_);
+  }
+  bool operator==(const RepeatedFieldRefIterator& other) const {
+    return !this->operator!=(other);
+  }
+
+  RepeatedFieldRefIterator(const RepeatedFieldRefIterator& other)
+      : data_(other.data_), accessor_(other.accessor_),
+        iterator_(accessor_->CopyIterator(data_, other.iterator_)) {
+  }
+  RepeatedFieldRefIterator& operator=(const RepeatedFieldRefIterator& other) {
+    if (this != &other) {
+      accessor_->DeleteIterator(data_, iterator_);
+      data_ = other.data_;
+      accessor_ = other.accessor_;
+      iterator_ = accessor_->CopyIterator(data_, other.iterator_);
+    }
+    return *this;
+  }
+
+ protected:
+  const void* data_;
+  const RepeatedFieldAccessor* accessor_;
+  void* iterator_;
+  google::protobuf::scoped_ptr<AccessorValueType> scratch_space_;
+};
+
+// TypeTraits that maps the type parameter T of RepeatedFieldRef or
+// MutableRepeatedFieldRef to corresponding iterator type,
+// RepeatedFieldAccessor type, etc.
+template<typename T>
+struct PrimitiveTraits {
+  static const bool is_primitive = false;
+};
+#define DEFINE_PRIMITIVE(TYPE, type) \
+    template<> struct PrimitiveTraits<type> { \
+      static const bool is_primitive = true; \
+      static const FieldDescriptor::CppType cpp_type = \
+          FieldDescriptor::CPPTYPE_ ## TYPE; \
+    };
+DEFINE_PRIMITIVE(INT32, int32)
+DEFINE_PRIMITIVE(UINT32, uint32)
+DEFINE_PRIMITIVE(INT64, int64)
+DEFINE_PRIMITIVE(UINT64, uint64)
+DEFINE_PRIMITIVE(FLOAT, float)
+DEFINE_PRIMITIVE(DOUBLE, double)
+DEFINE_PRIMITIVE(BOOL, bool)
+#undef DEFINE_PRIMITIVE
+
+template<typename T>
+struct RefTypeTraits<
+    T, typename internal::enable_if<PrimitiveTraits<T>::is_primitive>::type> {
+  typedef RepeatedFieldRefIterator<T> iterator;
+  typedef RepeatedFieldAccessor AccessorType;
+  typedef T AccessorValueType;
+  typedef T IteratorValueType;
+  typedef T* IteratorPointerType;
+  static const FieldDescriptor::CppType cpp_type =
+      PrimitiveTraits<T>::cpp_type;
+  static const Descriptor* GetMessageFieldDescriptor() {
+    return NULL;
+  }
+};
+
+template<typename T>
+struct RefTypeTraits<
+    T, typename internal::enable_if<is_proto_enum<T>::value>::type> {
+  typedef RepeatedFieldRefIterator<T> iterator;
+  typedef RepeatedFieldAccessor AccessorType;
+  // We use int32 for repeated enums in RepeatedFieldAccessor.
+  typedef int32 AccessorValueType;
+  typedef T IteratorValueType;
+  typedef int32* IteratorPointerType;
+  static const FieldDescriptor::CppType cpp_type =
+      FieldDescriptor::CPPTYPE_ENUM;
+  static const Descriptor* GetMessageFieldDescriptor() {
+    return NULL;
+  }
+};
+
+template<typename T>
+struct RefTypeTraits<
+    T, typename internal::enable_if< ::google::protobuf::internal::is_same<string, T>::value>::type> {
+  typedef RepeatedFieldRefIterator<T> iterator;
+  typedef RepeatedFieldAccessor AccessorType;
+  typedef string AccessorValueType;
+  typedef const string IteratorValueType;
+  typedef const string* IteratorPointerType;
+  static const FieldDescriptor::CppType cpp_type =
+      FieldDescriptor::CPPTYPE_STRING;
+  static const Descriptor* GetMessageFieldDescriptor() {
+    return NULL;
+  }
+};
+
+template<typename T>
+struct MessageDescriptorGetter {
+  static const Descriptor* get() {
+    return T::default_instance().GetDescriptor();
+  }
+};
+template<>
+struct MessageDescriptorGetter<Message> {
+  static const Descriptor* get() {
+    return NULL;
+  }
+};
+
+template<typename T>
+struct RefTypeTraits<
+    T, typename internal::enable_if<internal::is_base_of<Message, T>::value>::type> {
+  typedef RepeatedFieldRefIterator<T> iterator;
+  typedef RepeatedFieldAccessor AccessorType;
+  typedef Message AccessorValueType;
+  typedef const T& IteratorValueType;
+  typedef const T* IteratorPointerType;
+  static const FieldDescriptor::CppType cpp_type =
+      FieldDescriptor::CPPTYPE_MESSAGE;
+  static const Descriptor* GetMessageFieldDescriptor() {
+    return MessageDescriptorGetter<T>::get();
+  }
+};
+}  // namespace internal
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_REFLECTION_H__
diff --git a/kortex_api/include/google/protobuf/reflection_ops.h b/kortex_api/include/google/protobuf/reflection_ops.h
new file mode 100644
index 0000000000000000000000000000000000000000..45d8c650ef81580b85c8692091b64d50e1c52cbe
--- /dev/null
+++ b/kortex_api/include/google/protobuf/reflection_ops.h
@@ -0,0 +1,81 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// This header is logically internal, but is made public because it is used
+// from protocol-compiler-generated code, which may reside in other components.
+
+#ifndef GOOGLE_PROTOBUF_REFLECTION_OPS_H__
+#define GOOGLE_PROTOBUF_REFLECTION_OPS_H__
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/message.h>
+
+namespace google {
+namespace protobuf {
+namespace internal {
+
+// Basic operations that can be performed using reflection.
+// These can be used as a cheap way to implement the corresponding
+// methods of the Message interface, though they are likely to be
+// slower than implementations tailored for the specific message type.
+//
+// This class should stay limited to operations needed to implement
+// the Message interface.
+//
+// This class is really a namespace that contains only static methods.
+class LIBPROTOBUF_EXPORT ReflectionOps {
+ public:
+  static void Copy(const Message& from, Message* to);
+  static void Merge(const Message& from, Message* to);
+  static void Clear(Message* message);
+  static bool IsInitialized(const Message& message);
+  static void DiscardUnknownFields(Message* message);
+
+  // Finds all unset required fields in the message and adds their full
+  // paths (e.g. "foo.bar[5].baz") to *names.  "prefix" will be attached to
+  // the front of each name.
+  static void FindInitializationErrors(const Message& message,
+                                       const string& prefix,
+                                       std::vector<string>* errors);
+
+ private:
+  // All methods are static.  No need to construct.
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ReflectionOps);
+};
+
+}  // namespace internal
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_REFLECTION_OPS_H__
diff --git a/kortex_api/include/google/protobuf/repeated_field.h b/kortex_api/include/google/protobuf/repeated_field.h
new file mode 100644
index 0000000000000000000000000000000000000000..8eb6c795b5c4627d256c4f73bedcda22250c28f3
--- /dev/null
+++ b/kortex_api/include/google/protobuf/repeated_field.h
@@ -0,0 +1,2657 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// RepeatedField and RepeatedPtrField are used by generated protocol message
+// classes to manipulate repeated fields.  These classes are very similar to
+// STL's vector, but include a number of optimizations found to be useful
+// specifically in the case of Protocol Buffers.  RepeatedPtrField is
+// particularly different from STL vector as it manages ownership of the
+// pointers that it contains.
+//
+// Typically, clients should not need to access RepeatedField objects directly,
+// but should instead use the accessor functions generated automatically by the
+// protocol compiler.
+
+#ifndef GOOGLE_PROTOBUF_REPEATED_FIELD_H__
+#define GOOGLE_PROTOBUF_REPEATED_FIELD_H__
+
+#ifdef _MSC_VER
+// This is required for min/max on VS2013 only.
+#include <algorithm>
+#endif
+
+#include <iterator>
+#include <limits>
+#include <string>
+#include <google/protobuf/stubs/casts.h>
+#include <google/protobuf/stubs/logging.h>
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/type_traits.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/message_lite.h>
+#include <google/protobuf/stubs/port.h>
+
+
+// Forward-declare these so that we can make them friends.
+namespace google {
+namespace upb {
+namespace google_opensource {
+class GMR_Handlers;
+}  // namespace google_opensource
+}  // namespace upb
+
+namespace protobuf {
+
+class Message;
+
+namespace internal {
+
+class MergePartialFromCodedStreamHelper;
+
+static const int kMinRepeatedFieldAllocationSize = 4;
+
+// A utility function for logging that doesn't need any template types.
+void LogIndexOutOfBounds(int index, int size);
+
+template <typename Iter>
+inline int CalculateReserve(Iter begin, Iter end, std::forward_iterator_tag) {
+  return std::distance(begin, end);
+}
+
+template <typename Iter>
+inline int CalculateReserve(Iter /*begin*/, Iter /*end*/,
+                            std::input_iterator_tag /*unused*/) {
+  return -1;
+}
+
+template <typename Iter>
+inline int CalculateReserve(Iter begin, Iter end) {
+  typedef typename std::iterator_traits<Iter>::iterator_category Category;
+  return CalculateReserve(begin, end, Category());
+}
+}  // namespace internal
+
+
+// RepeatedField is used to represent repeated fields of a primitive type (in
+// other words, everything except strings and nested Messages).  Most users will
+// not ever use a RepeatedField directly; they will use the get-by-index,
+// set-by-index, and add accessors that are generated for all repeated fields.
+template <typename Element>
+class RepeatedField PROTOBUF_FINAL {
+ public:
+  RepeatedField();
+  explicit RepeatedField(Arena* arena);
+  RepeatedField(const RepeatedField& other);
+  template <typename Iter>
+  RepeatedField(Iter begin, const Iter& end);
+  ~RepeatedField();
+
+  RepeatedField& operator=(const RepeatedField& other);
+
+#if LANG_CXX11
+  RepeatedField(RepeatedField&& other) noexcept;
+  RepeatedField& operator=(RepeatedField&& other) noexcept;
+#endif
+
+  bool empty() const;
+  int size() const;
+
+  const Element& Get(int index) const;
+  Element* Mutable(int index);
+
+  const Element& operator[](int index) const { return Get(index); }
+  Element& operator[](int index) { return *Mutable(index); }
+
+  void Set(int index, const Element& value);
+  void Add(const Element& value);
+  // Appends a new element and return a pointer to it.
+  // The new element is uninitialized if |Element| is a POD type.
+  Element* Add();
+  // Remove the last element in the array.
+  void RemoveLast();
+
+  // Extract elements with indices in "[start .. start+num-1]".
+  // Copy them into "elements[0 .. num-1]" if "elements" is not NULL.
+  // Caution: implementation also moves elements with indices [start+num ..].
+  // Calling this routine inside a loop can cause quadratic behavior.
+  void ExtractSubrange(int start, int num, Element* elements);
+
+  void Clear();
+  void MergeFrom(const RepeatedField& other);
+  void CopyFrom(const RepeatedField& other);
+
+  // Reserve space to expand the field to at least the given size.  If the
+  // array is grown, it will always be at least doubled in size.
+  void Reserve(int new_size);
+
+  // Resize the RepeatedField to a new, smaller size.  This is O(1).
+  void Truncate(int new_size);
+
+  void AddAlreadyReserved(const Element& value);
+  // Appends a new element and return a pointer to it.
+  // The new element is uninitialized if |Element| is a POD type.
+  // Should be called only if Capacity() > Size().
+  Element* AddAlreadyReserved();
+  Element* AddNAlreadyReserved(int elements);
+  int Capacity() const;
+
+  // Like STL resize.  Uses value to fill appended elements.
+  // Like Truncate() if new_size <= size(), otherwise this is
+  // O(new_size - size()).
+  void Resize(int new_size, const Element& value);
+
+  // Gets the underlying array.  This pointer is possibly invalidated by
+  // any add or remove operation.
+  Element* mutable_data();
+  const Element* data() const;
+
+  // Swap entire contents with "other". If they are separate arenas then, copies
+  // data between each other.
+  void Swap(RepeatedField* other);
+
+  // Swap entire contents with "other". Should be called only if the caller can
+  // guarantee that both repeated fields are on the same arena or are on the
+  // heap. Swapping between different arenas is disallowed and caught by a
+  // GOOGLE_DCHECK (see API docs for details).
+  void UnsafeArenaSwap(RepeatedField* other);
+
+  // Swap two elements.
+  void SwapElements(int index1, int index2);
+
+  // STL-like iterator support
+  typedef Element* iterator;
+  typedef const Element* const_iterator;
+  typedef Element value_type;
+  typedef value_type& reference;
+  typedef const value_type& const_reference;
+  typedef value_type* pointer;
+  typedef const value_type* const_pointer;
+  typedef int size_type;
+  typedef ptrdiff_t difference_type;
+
+  iterator begin();
+  const_iterator begin() const;
+  const_iterator cbegin() const;
+  iterator end();
+  const_iterator end() const;
+  const_iterator cend() const;
+
+  // Reverse iterator support
+  typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+  typedef std::reverse_iterator<iterator> reverse_iterator;
+  reverse_iterator rbegin() {
+    return reverse_iterator(end());
+  }
+  const_reverse_iterator rbegin() const {
+    return const_reverse_iterator(end());
+  }
+  reverse_iterator rend() {
+    return reverse_iterator(begin());
+  }
+  const_reverse_iterator rend() const {
+    return const_reverse_iterator(begin());
+  }
+
+  // Returns the number of bytes used by the repeated field, excluding
+  // sizeof(*this)
+  size_t SpaceUsedExcludingSelfLong() const;
+
+  int SpaceUsedExcludingSelf() const {
+    return internal::ToIntSize(SpaceUsedExcludingSelfLong());
+  }
+
+  // Removes the element referenced by position.
+  //
+  // Returns an iterator to the element immediately following the removed
+  // element.
+  //
+  // Invalidates all iterators at or after the removed element, including end().
+  iterator erase(const_iterator position);
+
+  // Removes the elements in the range [first, last).
+  //
+  // Returns an iterator to the element immediately following the removed range.
+  //
+  // Invalidates all iterators at or after the removed range, including end().
+  iterator erase(const_iterator first, const_iterator last);
+
+  // Get the Arena on which this RepeatedField stores its elements.
+  ::google::protobuf::Arena* GetArena() const {
+    return GetArenaNoVirtual();
+  }
+
+  // For internal use only.
+  //
+  // This is public due to it being called by generated code.
+  inline void InternalSwap(RepeatedField* other);
+
+ private:
+  static const int kInitialSize = 0;
+  // A note on the representation here (see also comment below for
+  // RepeatedPtrFieldBase's struct Rep):
+  //
+  // We maintain the same sizeof(RepeatedField) as before we added arena support
+  // so that we do not degrade performance by bloating memory usage. Directly
+  // adding an arena_ element to RepeatedField is quite costly. By using
+  // indirection in this way, we keep the same size when the RepeatedField is
+  // empty (common case), and add only an 8-byte header to the elements array
+  // when non-empty. We make sure to place the size fields directly in the
+  // RepeatedField class to avoid costly cache misses due to the indirection.
+  int current_size_;
+  int total_size_;
+  struct Rep {
+    Arena* arena;
+    Element elements[1];
+  };
+  // We can not use sizeof(Rep) - sizeof(Element) due to the trailing padding on
+  // the struct. We can not use sizeof(Arena*) as well because there might be
+  // a "gap" after the field arena and before the field elements (e.g., when
+  // Element is double and pointer is 32bit).
+  static const size_t kRepHeaderSize;
+  // Contains arena ptr and the elements array. We also keep the invariant that
+  // if rep_ is NULL, then arena is NULL.
+  Rep* rep_;
+
+  friend class Arena;
+  typedef void InternalArenaConstructable_;
+
+
+  // Move the contents of |from| into |to|, possibly clobbering |from| in the
+  // process.  For primitive types this is just a memcpy(), but it could be
+  // specialized for non-primitive types to, say, swap each element instead.
+  void MoveArray(Element* to, Element* from, int size);
+
+  // Copy the elements of |from| into |to|.
+  void CopyArray(Element* to, const Element* from, int size);
+
+  // Internal helper expected by Arena methods.
+  inline Arena* GetArenaNoVirtual() const {
+    return (rep_ == NULL) ? NULL : rep_->arena;
+  }
+
+  // Internal helper to delete all elements and deallocate the storage.
+  // If Element has a trivial destructor (for example, if it's a fundamental
+  // type, like int32), the loop will be removed by the optimizer.
+  void InternalDeallocate(Rep* rep, int size) {
+    if (rep != NULL) {
+      Element* e = &rep->elements[0];
+      Element* limit = &rep->elements[size];
+      for (; e < limit; e++) {
+        e->~Element();
+      }
+      if (rep->arena == NULL) {
+#if defined(__GXX_DELETE_WITH_SIZE__) || defined(__cpp_sized_deallocation)
+        const size_t bytes = size * sizeof(*e) + kRepHeaderSize;
+        ::operator delete(static_cast<void*>(rep), bytes);
+#else
+        ::operator delete(static_cast<void*>(rep));
+#endif
+      }
+    }
+  }
+
+  friend class internal::WireFormatLite;
+  const Element* unsafe_data() const;
+};
+
+template<typename Element>
+const size_t RepeatedField<Element>::kRepHeaderSize =
+    reinterpret_cast<size_t>(&reinterpret_cast<Rep*>(16)->elements[0]) - 16;
+
+namespace internal {
+template <typename It> class RepeatedPtrIterator;
+template <typename It, typename VoidPtr> class RepeatedPtrOverPtrsIterator;
+}  // namespace internal
+
+namespace internal {
+
+// This is a helper template to copy an array of elements efficiently when they
+// have a trivial copy constructor, and correctly otherwise. This really
+// shouldn't be necessary, but our compiler doesn't optimize std::copy very
+// effectively.
+template <typename Element,
+          bool HasTrivialCopy =
+              has_trivial_copy<Element>::value>
+struct ElementCopier {
+  void operator()(Element* to, const Element* from, int array_size);
+};
+
+}  // namespace internal
+
+namespace internal {
+
+// type-traits helper for RepeatedPtrFieldBase: we only want to invoke
+// arena-related "copy if on different arena" behavior if the necessary methods
+// exist on the contained type. In particular, we rely on MergeFrom() existing
+// as a general proxy for the fact that a copy will work, and we also provide a
+// specific override for string*.
+template <typename T>
+struct TypeImplementsMergeBehaviorProbeForMergeFrom {
+  typedef char HasMerge;
+  typedef long HasNoMerge;
+
+  // We accept either of:
+  // - void MergeFrom(const T& other)
+  // - bool MergeFrom(const T& other)
+  //
+  // We mangle these names a bit to avoid compatibility issues in 'unclean'
+  // include environments that may have, e.g., "#define test ..." (yes, this
+  // exists).
+  template<typename U, typename RetType, RetType (U::*)(const U& arg)>
+      struct CheckType;
+  template<typename U> static HasMerge Check(
+      CheckType<U, void, &U::MergeFrom>*);
+  template<typename U> static HasMerge Check(
+      CheckType<U, bool, &U::MergeFrom>*);
+  template<typename U> static HasNoMerge Check(...);
+
+  // Resolves to either google::protobuf::internal::true_type or google::protobuf::internal::false_type.
+  typedef google::protobuf::internal::integral_constant<bool,
+               (sizeof(Check<T>(0)) == sizeof(HasMerge))> type;
+};
+
+template <typename T, typename = void>
+struct TypeImplementsMergeBehavior :
+    TypeImplementsMergeBehaviorProbeForMergeFrom<T> {};
+
+
+template <>
+struct TypeImplementsMergeBehavior< ::std::string> {
+  typedef google::protobuf::internal::true_type type;
+};
+
+// This is the common base class for RepeatedPtrFields.  It deals only in void*
+// pointers.  Users should not use this interface directly.
+//
+// The methods of this interface correspond to the methods of RepeatedPtrField,
+// but may have a template argument called TypeHandler.  Its signature is:
+//   class TypeHandler {
+//    public:
+//     typedef MyType Type;
+//     static Type* New();
+//     static void Delete(Type*);
+//     static void Clear(Type*);
+//     static void Merge(const Type& from, Type* to);
+//
+//     // Only needs to be implemented if SpaceUsedExcludingSelf() is called.
+//     static int SpaceUsedLong(const Type&);
+//   };
+class LIBPROTOBUF_EXPORT RepeatedPtrFieldBase {
+ protected:
+  // The reflection implementation needs to call protected methods directly,
+  // reinterpreting pointers as being to Message instead of a specific Message
+  // subclass.
+  friend class GeneratedMessageReflection;
+
+  // ExtensionSet stores repeated message extensions as
+  // RepeatedPtrField<MessageLite>, but non-lite ExtensionSets need to implement
+  // SpaceUsedLong(), and thus need to call SpaceUsedExcludingSelfLong()
+  // reinterpreting MessageLite as Message.  ExtensionSet also needs to make use
+  // of AddFromCleared(), which is not part of the public interface.
+  friend class ExtensionSet;
+
+  // The MapFieldBase implementation needs to call protected methods directly,
+  // reinterpreting pointers as being to Message instead of a specific Message
+  // subclass.
+  friend class MapFieldBase;
+
+  // The table-driven MergePartialFromCodedStream implementation needs to
+  // operate on RepeatedPtrField<MessageLite>.
+  friend class MergePartialFromCodedStreamHelper;
+
+  // To parse directly into a proto2 generated class, the upb class GMR_Handlers
+  // needs to be able to modify a RepeatedPtrFieldBase directly.
+  friend class upb::google_opensource::GMR_Handlers;
+
+  RepeatedPtrFieldBase();
+  explicit RepeatedPtrFieldBase(::google::protobuf::Arena* arena);
+  ~RepeatedPtrFieldBase() {}
+
+  // Must be called from destructor.
+  template <typename TypeHandler>
+  void Destroy();
+
+  bool empty() const;
+  int size() const;
+
+  template <typename TypeHandler>
+  const typename TypeHandler::Type& Get(int index) const;
+  template <typename TypeHandler>
+  typename TypeHandler::Type* Mutable(int index);
+  template <typename TypeHandler>
+  void Delete(int index);
+  template <typename TypeHandler>
+  typename TypeHandler::Type* Add(typename TypeHandler::Type* prototype = NULL);
+#if LANG_CXX11
+  template <typename TypeHandler>
+  void Add(typename TypeHandler::Type&& value,
+           internal::enable_if<TypeHandler::Moveable>* dummy = NULL);
+#endif
+
+  template <typename TypeHandler>
+  void RemoveLast();
+  template <typename TypeHandler>
+  void Clear();
+  template <typename TypeHandler>
+  void MergeFrom(const RepeatedPtrFieldBase& other);
+  template <typename TypeHandler>
+  void CopyFrom(const RepeatedPtrFieldBase& other);
+
+  void CloseGap(int start, int num);
+
+  void Reserve(int new_size);
+
+  int Capacity() const;
+
+  // Used for constructing iterators.
+  void* const* raw_data() const;
+  void** raw_mutable_data() const;
+
+  template <typename TypeHandler>
+  typename TypeHandler::Type** mutable_data();
+  template <typename TypeHandler>
+  const typename TypeHandler::Type* const* data() const;
+
+  template <typename TypeHandler> GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  void Swap(RepeatedPtrFieldBase* other);
+
+  void SwapElements(int index1, int index2);
+
+  template <typename TypeHandler>
+  size_t SpaceUsedExcludingSelfLong() const;
+
+
+  // Advanced memory management --------------------------------------
+
+  // Like Add(), but if there are no cleared objects to use, returns NULL.
+  template <typename TypeHandler>
+  typename TypeHandler::Type* AddFromCleared();
+
+  template<typename TypeHandler>
+  void AddAllocated(typename TypeHandler::Type* value) {
+    typename TypeImplementsMergeBehavior<typename TypeHandler::Type>::type t;
+    AddAllocatedInternal<TypeHandler>(value, t);
+  }
+
+  template <typename TypeHandler>
+  void UnsafeArenaAddAllocated(typename TypeHandler::Type* value);
+
+  template <typename TypeHandler>
+  typename TypeHandler::Type* ReleaseLast() {
+    typename TypeImplementsMergeBehavior<typename TypeHandler::Type>::type t;
+    return ReleaseLastInternal<TypeHandler>(t);
+  }
+
+  // Releases last element and returns it, but does not do out-of-arena copy.
+  // And just returns the raw pointer to the contained element in the arena.
+  template <typename TypeHandler>
+  typename TypeHandler::Type* UnsafeArenaReleaseLast();
+
+  int ClearedCount() const;
+  template <typename TypeHandler>
+  void AddCleared(typename TypeHandler::Type* value);
+  template <typename TypeHandler>
+  typename TypeHandler::Type* ReleaseCleared();
+
+ protected:
+  inline void InternalSwap(RepeatedPtrFieldBase* other);
+
+  template <typename TypeHandler>
+  void AddAllocatedInternal(typename TypeHandler::Type* value, google::protobuf::internal::true_type);
+  template <typename TypeHandler>
+  void AddAllocatedInternal(typename TypeHandler::Type* value, google::protobuf::internal::false_type);
+
+  template <typename TypeHandler> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE
+  void AddAllocatedSlowWithCopy(typename TypeHandler::Type* value,
+                                Arena* value_arena,
+                                Arena* my_arena);
+  template <typename TypeHandler> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE
+  void AddAllocatedSlowWithoutCopy(typename TypeHandler::Type* value);
+
+  template <typename TypeHandler>
+  typename TypeHandler::Type* ReleaseLastInternal(google::protobuf::internal::true_type);
+  template <typename TypeHandler>
+  typename TypeHandler::Type* ReleaseLastInternal(google::protobuf::internal::false_type);
+
+  template<typename TypeHandler> GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE
+  void SwapFallback(RepeatedPtrFieldBase* other);
+
+  inline Arena* GetArenaNoVirtual() const {
+    return arena_;
+  }
+
+ private:
+  static const int kInitialSize = 0;
+  // A few notes on internal representation:
+  //
+  // We use an indirected approach, with struct Rep, to keep
+  // sizeof(RepeatedPtrFieldBase) equivalent to what it was before arena support
+  // was added, namely, 3 8-byte machine words on x86-64. An instance of Rep is
+  // allocated only when the repeated field is non-empty, and it is a
+  // dynamically-sized struct (the header is directly followed by elements[]).
+  // We place arena_ and current_size_ directly in the object to avoid cache
+  // misses due to the indirection, because these fields are checked frequently.
+  // Placing all fields directly in the RepeatedPtrFieldBase instance costs
+  // significant performance for memory-sensitive workloads.
+  Arena* arena_;
+  int    current_size_;
+  int    total_size_;
+  struct Rep {
+    int    allocated_size;
+    void*  elements[1];
+  };
+  static const size_t kRepHeaderSize = sizeof(Rep) - sizeof(void*);
+  // Contains arena ptr and the elements array. We also keep the invariant that
+  // if rep_ is NULL, then arena is NULL.
+  Rep* rep_;
+
+  template <typename TypeHandler>
+  static inline typename TypeHandler::Type* cast(void* element) {
+    return reinterpret_cast<typename TypeHandler::Type*>(element);
+  }
+  template <typename TypeHandler>
+  static inline const typename TypeHandler::Type* cast(const void* element) {
+    return reinterpret_cast<const typename TypeHandler::Type*>(element);
+  }
+
+  // Non-templated inner function to avoid code duplication. Takes a function
+  // pointer to the type-specific (templated) inner allocate/merge loop.
+  void MergeFromInternal(
+      const RepeatedPtrFieldBase& other,
+      void (RepeatedPtrFieldBase::*inner_loop)(void**, void**, int, int));
+
+  template<typename TypeHandler>
+  void MergeFromInnerLoop(
+      void** our_elems, void** other_elems, int length, int already_allocated);
+
+  // Internal helper: extend array space if necessary to contain |extend_amount|
+  // more elements, and return a pointer to the element immediately following
+  // the old list of elements.  This interface factors out common behavior from
+  // Reserve() and MergeFrom() to reduce code size. |extend_amount| must be > 0.
+  void** InternalExtend(int extend_amount);
+
+  friend class AccessorHelper;
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(RepeatedPtrFieldBase);
+};
+
+template <typename GenericType>
+class GenericTypeHandler {
+ public:
+  typedef GenericType Type;
+#if LANG_CXX11
+  static const bool Moveable = false;
+#endif
+
+  static inline GenericType* New(Arena* arena) {
+    return ::google::protobuf::Arena::CreateMaybeMessage<Type>(arena);
+  }
+  static inline GenericType* NewFromPrototype(
+      const GenericType* prototype, ::google::protobuf::Arena* arena = NULL);
+  static inline void Delete(GenericType* value, Arena* arena) {
+    if (arena == NULL) {
+      delete value;
+    }
+  }
+  static inline ::google::protobuf::Arena* GetArena(GenericType* value) {
+    return ::google::protobuf::Arena::GetArena<Type>(value);
+  }
+  static inline void* GetMaybeArenaPointer(GenericType* value) {
+    return ::google::protobuf::Arena::GetArena<Type>(value);
+  }
+
+  static inline void Clear(GenericType* value) { value->Clear(); }
+  GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE
+  static void Merge(const GenericType& from, GenericType* to);
+  static inline size_t SpaceUsedLong(const GenericType& value) {
+    return value.SpaceUsedLong();
+  }
+  static inline const Type& default_instance() {
+    return Type::default_instance();
+  }
+};
+
+template <typename GenericType>
+GenericType* GenericTypeHandler<GenericType>::NewFromPrototype(
+    const GenericType* /* prototype */, ::google::protobuf::Arena* arena) {
+  return New(arena);
+}
+template <typename GenericType>
+void GenericTypeHandler<GenericType>::Merge(const GenericType& from,
+                                            GenericType* to) {
+  to->MergeFrom(from);
+}
+
+// NewFromPrototype() and Merge() are not defined inline here, as we will need
+// to do a virtual function dispatch anyways to go from Message* to call
+// New/Merge.
+template<>
+MessageLite* GenericTypeHandler<MessageLite>::NewFromPrototype(
+    const MessageLite* prototype, google::protobuf::Arena* arena);
+template<>
+inline google::protobuf::Arena* GenericTypeHandler<MessageLite>::GetArena(
+    MessageLite* value) {
+  return value->GetArena();
+}
+template<>
+inline void* GenericTypeHandler<MessageLite>::GetMaybeArenaPointer(
+    MessageLite* value) {
+  return value->GetMaybeArenaPointer();
+}
+template <>
+void GenericTypeHandler<MessageLite>::Merge(const MessageLite& from,
+                                            MessageLite* to);
+template<>
+inline void GenericTypeHandler<string>::Clear(string* value) {
+  value->clear();
+}
+template<>
+void GenericTypeHandler<string>::Merge(const string& from,
+                                       string* to);
+
+// Declarations of the specialization as we cannot define them here, as the
+// header that defines ProtocolMessage depends on types defined in this header.
+#define DECLARE_SPECIALIZATIONS_FOR_BASE_PROTO_TYPES(TypeName)                 \
+    template<>                                                                 \
+    TypeName* GenericTypeHandler<TypeName>::NewFromPrototype(                  \
+        const TypeName* prototype, google::protobuf::Arena* arena);                      \
+    template<>                                                                 \
+    google::protobuf::Arena* GenericTypeHandler<TypeName>::GetArena(                     \
+        TypeName* value);                                                      \
+    template<>                                                                 \
+    void* GenericTypeHandler<TypeName>::GetMaybeArenaPointer(                  \
+        TypeName* value);
+
+// Message specialization bodies defined in message.cc. This split is necessary
+// to allow proto2-lite (which includes this header) to be independent of
+// Message.
+DECLARE_SPECIALIZATIONS_FOR_BASE_PROTO_TYPES(Message)
+
+
+#undef DECLARE_SPECIALIZATIONS_FOR_BASE_PROTO_TYPES
+
+template <>
+inline const MessageLite& GenericTypeHandler<MessageLite>::default_instance() {
+  // Yes, the behavior of the code is undefined, but this function is only
+  // called when we're already deep into the world of undefined, because the
+  // caller called Get(index) out of bounds.
+  MessageLite* null = NULL;
+  return *null;
+}
+
+template <>
+inline const Message& GenericTypeHandler<Message>::default_instance() {
+  // Yes, the behavior of the code is undefined, but this function is only
+  // called when we're already deep into the world of undefined, because the
+  // caller called Get(index) out of bounds.
+  Message* null = NULL;
+  return *null;
+}
+
+
+class StringTypeHandler {
+ public:
+  typedef string Type;
+#if LANG_CXX11
+  static const bool Moveable =
+      std::is_move_constructible<Type>::value &&
+      std::is_move_assignable<Type>::value;
+#endif
+
+  static inline string* New(Arena* arena) {
+    return Arena::Create<string>(arena);
+  }
+#if LANG_CXX11
+  static inline string* New(Arena* arena, string&& value) {
+    return Arena::Create<string>(arena, std::move(value));
+  }
+#endif
+  static inline string* NewFromPrototype(const string*,
+                                         ::google::protobuf::Arena* arena) {
+    return New(arena);
+  }
+  static inline ::google::protobuf::Arena* GetArena(string*) {
+    return NULL;
+  }
+  static inline void* GetMaybeArenaPointer(string* /* value */) {
+    return NULL;
+  }
+  static inline void Delete(string* value, Arena* arena) {
+    if (arena == NULL) {
+      delete value;
+    }
+  }
+  static inline void Clear(string* value) { value->clear(); }
+  static inline void Merge(const string& from, string* to) { *to = from; }
+  static inline const Type& default_instance() {
+    return ::google::protobuf::internal::GetEmptyString();
+  }
+  static size_t SpaceUsedLong(const string& value)  {
+    return sizeof(value) + StringSpaceUsedExcludingSelfLong(value);
+  }
+};
+
+}  // namespace internal
+
+// RepeatedPtrField is like RepeatedField, but used for repeated strings or
+// Messages.
+template <typename Element>
+class RepeatedPtrField PROTOBUF_FINAL : public internal::RepeatedPtrFieldBase {
+ public:
+  RepeatedPtrField();
+  explicit RepeatedPtrField(::google::protobuf::Arena* arena);
+
+  RepeatedPtrField(const RepeatedPtrField& other);
+  template <typename Iter>
+  RepeatedPtrField(Iter begin, const Iter& end);
+  ~RepeatedPtrField();
+
+  RepeatedPtrField& operator=(const RepeatedPtrField& other);
+
+#if LANG_CXX11
+  RepeatedPtrField(RepeatedPtrField&& other) noexcept;
+  RepeatedPtrField& operator=(RepeatedPtrField&& other) noexcept;
+#endif
+
+  bool empty() const;
+  int size() const;
+
+  const Element& Get(int index) const;
+  Element* Mutable(int index);
+  Element* Add();
+#if LANG_CXX11
+  void Add(Element&& value);
+#endif
+
+  const Element& operator[](int index) const { return Get(index); }
+  Element& operator[](int index) { return *Mutable(index); }
+
+  // Remove the last element in the array.
+  // Ownership of the element is retained by the array.
+  void RemoveLast();
+
+  // Delete elements with indices in the range [start .. start+num-1].
+  // Caution: implementation moves all elements with indices [start+num .. ].
+  // Calling this routine inside a loop can cause quadratic behavior.
+  void DeleteSubrange(int start, int num);
+
+  void Clear();
+  void MergeFrom(const RepeatedPtrField& other);
+  void CopyFrom(const RepeatedPtrField& other);
+
+  // Reserve space to expand the field to at least the given size.  This only
+  // resizes the pointer array; it doesn't allocate any objects.  If the
+  // array is grown, it will always be at least doubled in size.
+  void Reserve(int new_size);
+
+  int Capacity() const;
+
+  // Gets the underlying array.  This pointer is possibly invalidated by
+  // any add or remove operation.
+  Element** mutable_data();
+  const Element* const* data() const;
+
+  // Swap entire contents with "other". If they are on separate arenas, then
+  // copies data.
+  void Swap(RepeatedPtrField* other);
+
+  // Swap entire contents with "other". Caller should guarantee that either both
+  // fields are on the same arena or both are on the heap. Swapping between
+  // different arenas with this function is disallowed and is caught via
+  // GOOGLE_DCHECK.
+  void UnsafeArenaSwap(RepeatedPtrField* other);
+
+  // Swap two elements.
+  void SwapElements(int index1, int index2);
+
+  // STL-like iterator support
+  typedef internal::RepeatedPtrIterator<Element> iterator;
+  typedef internal::RepeatedPtrIterator<const Element> const_iterator;
+  typedef Element value_type;
+  typedef value_type& reference;
+  typedef const value_type& const_reference;
+  typedef value_type* pointer;
+  typedef const value_type* const_pointer;
+  typedef int size_type;
+  typedef ptrdiff_t difference_type;
+
+  iterator begin();
+  const_iterator begin() const;
+  const_iterator cbegin() const;
+  iterator end();
+  const_iterator end() const;
+  const_iterator cend() const;
+
+  // Reverse iterator support
+  typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+  typedef std::reverse_iterator<iterator> reverse_iterator;
+  reverse_iterator rbegin() {
+    return reverse_iterator(end());
+  }
+  const_reverse_iterator rbegin() const {
+    return const_reverse_iterator(end());
+  }
+  reverse_iterator rend() {
+    return reverse_iterator(begin());
+  }
+  const_reverse_iterator rend() const {
+    return const_reverse_iterator(begin());
+  }
+
+  // Custom STL-like iterator that iterates over and returns the underlying
+  // pointers to Element rather than Element itself.
+  typedef internal::RepeatedPtrOverPtrsIterator<Element*, void*>
+      pointer_iterator;
+  typedef internal::RepeatedPtrOverPtrsIterator<const Element* const,
+                                                const void* const>
+      const_pointer_iterator;
+  pointer_iterator pointer_begin();
+  const_pointer_iterator pointer_begin() const;
+  pointer_iterator pointer_end();
+  const_pointer_iterator pointer_end() const;
+
+  // Returns (an estimate of) the number of bytes used by the repeated field,
+  // excluding sizeof(*this).
+  size_t SpaceUsedExcludingSelfLong() const;
+
+  int SpaceUsedExcludingSelf() const {
+    return internal::ToIntSize(SpaceUsedExcludingSelfLong());
+  }
+
+  // Advanced memory management --------------------------------------
+  // When hardcore memory management becomes necessary -- as it sometimes
+  // does here at Google -- the following methods may be useful.
+
+  // Add an already-allocated object, passing ownership to the
+  // RepeatedPtrField.
+  //
+  // Note that some special behavior occurs with respect to arenas:
+  //
+  //   (i) if this field holds submessages, the new submessage will be copied if
+  //   the original is in an arena and this RepeatedPtrField is either in a
+  //   different arena, or on the heap.
+  //   (ii) if this field holds strings, the passed-in string *must* be
+  //   heap-allocated, not arena-allocated. There is no way to dynamically check
+  //   this at runtime, so User Beware.
+  void AddAllocated(Element* value);
+
+  // Remove the last element and return it, passing ownership to the caller.
+  // Requires:  size() > 0
+  //
+  // If this RepeatedPtrField is on an arena, an object copy is required to pass
+  // ownership back to the user (for compatible semantics). Use
+  // UnsafeArenaReleaseLast() if this behavior is undesired.
+  Element* ReleaseLast();
+
+  // Add an already-allocated object, skipping arena-ownership checks. The user
+  // must guarantee that the given object is in the same arena as this
+  // RepeatedPtrField.
+  // It is also useful in legacy code that uses temporary ownership to avoid
+  // copies. Example:
+  //   RepeatedPtrField<T> temp_field;
+  //   temp_field.AddAllocated(new T);
+  //   ... // Do something with temp_field
+  //   temp_field.ExtractSubrange(0, temp_field.size(), NULL);
+  // If you put temp_field on the arena this fails, because the ownership
+  // transfers to the arena at the "AddAllocated" call and is not released
+  // anymore causing a double delete. UnsafeArenaAddAllocated prevents this.
+  void UnsafeArenaAddAllocated(Element* value);
+
+  // Remove the last element and return it.  Works only when operating on an
+  // arena. The returned pointer is to the original object in the arena, hence
+  // has the arena's lifetime.
+  // Requires:  current_size_ > 0
+  Element* UnsafeArenaReleaseLast();
+
+  // Extract elements with indices in the range "[start .. start+num-1]".
+  // The caller assumes ownership of the extracted elements and is responsible
+  // for deleting them when they are no longer needed.
+  // If "elements" is non-NULL, then pointers to the extracted elements
+  // are stored in "elements[0 .. num-1]" for the convenience of the caller.
+  // If "elements" is NULL, then the caller must use some other mechanism
+  // to perform any further operations (like deletion) on these elements.
+  // Caution: implementation also moves elements with indices [start+num ..].
+  // Calling this routine inside a loop can cause quadratic behavior.
+  //
+  // Memory copying behavior is identical to ReleaseLast(), described above: if
+  // this RepeatedPtrField is on an arena, an object copy is performed for each
+  // returned element, so that all returned element pointers are to
+  // heap-allocated copies. If this copy is not desired, the user should call
+  // UnsafeArenaExtractSubrange().
+  void ExtractSubrange(int start, int num, Element** elements);
+
+  // Identical to ExtractSubrange() described above, except that when this
+  // repeated field is on an arena, no object copies are performed. Instead, the
+  // raw object pointers are returned. Thus, if on an arena, the returned
+  // objects must not be freed, because they will not be heap-allocated objects.
+  void UnsafeArenaExtractSubrange(int start, int num, Element** elements);
+
+  // When elements are removed by calls to RemoveLast() or Clear(), they
+  // are not actually freed.  Instead, they are cleared and kept so that
+  // they can be reused later.  This can save lots of CPU time when
+  // repeatedly reusing a protocol message for similar purposes.
+  //
+  // Hardcore programs may choose to manipulate these cleared objects
+  // to better optimize memory management using the following routines.
+
+  // Get the number of cleared objects that are currently being kept
+  // around for reuse.
+  int ClearedCount() const;
+  // Add an element to the pool of cleared objects, passing ownership to
+  // the RepeatedPtrField.  The element must be cleared prior to calling
+  // this method.
+  //
+  // This method cannot be called when the repeated field is on an arena or when
+  // |value| is; both cases will trigger a GOOGLE_DCHECK-failure.
+  void AddCleared(Element* value);
+  // Remove a single element from the cleared pool and return it, passing
+  // ownership to the caller.  The element is guaranteed to be cleared.
+  // Requires:  ClearedCount() > 0
+  //
+  //
+  // This method cannot be called when the repeated field is on an arena; doing
+  // so will trigger a GOOGLE_DCHECK-failure.
+  Element* ReleaseCleared();
+
+  // Removes the element referenced by position.
+  //
+  // Returns an iterator to the element immediately following the removed
+  // element.
+  //
+  // Invalidates all iterators at or after the removed element, including end().
+  iterator erase(const_iterator position);
+
+  // Removes the elements in the range [first, last).
+  //
+  // Returns an iterator to the element immediately following the removed range.
+  //
+  // Invalidates all iterators at or after the removed range, including end().
+  iterator erase(const_iterator first, const_iterator last);
+
+  // Gets the arena on which this RepeatedPtrField stores its elements.
+  ::google::protobuf::Arena* GetArena() const {
+    return GetArenaNoVirtual();
+  }
+
+  // For internal use only.
+  //
+  // This is public due to it being called by generated code.
+  using RepeatedPtrFieldBase::InternalSwap;
+
+ private:
+  // Note:  RepeatedPtrField SHOULD NOT be subclassed by users.
+  class TypeHandler;
+
+  // Internal arena accessor expected by helpers in Arena.
+  inline Arena* GetArenaNoVirtual() const;
+
+  // Implementations for ExtractSubrange(). The copying behavior must be
+  // included only if the type supports the necessary operations (e.g.,
+  // MergeFrom()), so we must resolve this at compile time. ExtractSubrange()
+  // uses SFINAE to choose one of the below implementations.
+  void ExtractSubrangeInternal(int start, int num, Element** elements,
+                               google::protobuf::internal::true_type);
+  void ExtractSubrangeInternal(int start, int num, Element** elements,
+                               google::protobuf::internal::false_type);
+
+  friend class Arena;
+  typedef void InternalArenaConstructable_;
+
+};
+
+// implementation ====================================================
+
+template <typename Element>
+inline RepeatedField<Element>::RepeatedField()
+  : current_size_(0),
+    total_size_(0),
+    rep_(NULL) {
+}
+
+template <typename Element>
+inline RepeatedField<Element>::RepeatedField(Arena* arena)
+  : current_size_(0),
+    total_size_(0),
+    rep_(NULL) {
+  // In case arena is NULL, then we do not create rep_, as code has an invariant
+  // `rep_ == NULL then arena == NULL`.
+  if (arena != NULL) {
+    rep_ = reinterpret_cast<Rep*>(
+        ::google::protobuf::Arena::CreateArray<char>(arena, kRepHeaderSize));
+    rep_->arena = arena;
+  }
+}
+
+template <typename Element>
+inline RepeatedField<Element>::RepeatedField(const RepeatedField& other)
+  : current_size_(0),
+    total_size_(0),
+    rep_(NULL) {
+  if (other.current_size_ != 0) {
+    Reserve(other.current_size_);
+    CopyArray(rep_->elements,
+              other.rep_->elements, other.current_size_);
+    current_size_ = other.current_size_;
+  }
+}
+
+template <typename Element>
+template <typename Iter>
+RepeatedField<Element>::RepeatedField(Iter begin, const Iter& end)
+  : current_size_(0),
+    total_size_(0),
+    rep_(NULL) {
+  int reserve = internal::CalculateReserve(begin, end);
+  if (reserve != -1) {
+    Reserve(reserve);
+    for (; begin != end; ++begin) {
+      AddAlreadyReserved(*begin);
+    }
+  } else {
+    for (; begin != end; ++begin) {
+      Add(*begin);
+    }
+  }
+}
+
+template <typename Element>
+RepeatedField<Element>::~RepeatedField() {
+  // See explanation in Reserve(): we need to invoke destructors here for the
+  // case that Element has a non-trivial destructor.
+  InternalDeallocate(rep_, total_size_);
+}
+
+template <typename Element>
+inline RepeatedField<Element>&
+RepeatedField<Element>::operator=(const RepeatedField& other) {
+  if (this != &other)
+    CopyFrom(other);
+  return *this;
+}
+
+#if LANG_CXX11
+
+template <typename Element>
+inline RepeatedField<Element>::RepeatedField(RepeatedField&& other) noexcept
+    : RepeatedField() {
+  // We don't just call Swap(&other) here because it would perform 3 copies if
+  // the two fields are on different arenas.
+  if (other.GetArenaNoVirtual()) {
+    CopyFrom(other);
+  } else {
+    InternalSwap(&other);
+  }
+}
+
+template <typename Element>
+inline RepeatedField<Element>& RepeatedField<Element>::operator=(
+    RepeatedField&& other) noexcept {
+  // We don't just call Swap(&other) here because it would perform 3 copies if
+  // the two fields are on different arenas.
+  if (this != &other) {
+    if (this->GetArenaNoVirtual() != other.GetArenaNoVirtual()) {
+      CopyFrom(other);
+    } else {
+      InternalSwap(&other);
+    }
+  }
+  return *this;
+}
+
+#endif  // LANG_CXX11
+
+template <typename Element>
+inline bool RepeatedField<Element>::empty() const {
+  return current_size_ == 0;
+}
+
+template <typename Element>
+inline int RepeatedField<Element>::size() const {
+  return current_size_;
+}
+
+template <typename Element>
+inline int RepeatedField<Element>::Capacity() const {
+  return total_size_;
+}
+
+template<typename Element>
+inline void RepeatedField<Element>::AddAlreadyReserved(const Element& value) {
+  GOOGLE_DCHECK_LT(current_size_, total_size_);
+  rep_->elements[current_size_++] = value;
+}
+
+template<typename Element>
+inline Element* RepeatedField<Element>::AddAlreadyReserved() {
+  GOOGLE_DCHECK_LT(current_size_, total_size_);
+  return &rep_->elements[current_size_++];
+}
+
+template<typename Element>
+inline Element* RepeatedField<Element>::AddNAlreadyReserved(int elements) {
+  GOOGLE_DCHECK_LE(current_size_ + elements, total_size_);
+  Element* ret = &rep_->elements[current_size_];
+  current_size_ += elements;
+  return ret;
+}
+
+template<typename Element>
+inline void RepeatedField<Element>::Resize(int new_size, const Element& value) {
+  GOOGLE_DCHECK_GE(new_size, 0);
+  if (new_size > current_size_) {
+    Reserve(new_size);
+    std::fill(&rep_->elements[current_size_],
+              &rep_->elements[new_size], value);
+  }
+  current_size_ = new_size;
+}
+
+template <typename Element>
+inline const Element& RepeatedField<Element>::Get(int index) const {
+  GOOGLE_DCHECK_GE(index, 0);
+  GOOGLE_DCHECK_LT(index, current_size_);
+  return rep_->elements[index];
+}
+
+template <typename Element>
+inline Element* RepeatedField<Element>::Mutable(int index) {
+  GOOGLE_DCHECK_GE(index, 0);
+  GOOGLE_DCHECK_LT(index, current_size_);
+  return &rep_->elements[index];
+}
+
+template <typename Element>
+inline void RepeatedField<Element>::Set(int index, const Element& value) {
+  GOOGLE_DCHECK_GE(index, 0);
+  GOOGLE_DCHECK_LT(index, current_size_);
+  rep_->elements[index] = value;
+}
+
+template <typename Element>
+inline void RepeatedField<Element>::Add(const Element& value) {
+  if (current_size_ == total_size_) Reserve(total_size_ + 1);
+  rep_->elements[current_size_++] = value;
+}
+
+template <typename Element>
+inline Element* RepeatedField<Element>::Add() {
+  if (current_size_ == total_size_) Reserve(total_size_ + 1);
+  return &rep_->elements[current_size_++];
+}
+
+template <typename Element>
+inline void RepeatedField<Element>::RemoveLast() {
+  GOOGLE_DCHECK_GT(current_size_, 0);
+  current_size_--;
+}
+
+template <typename Element>
+void RepeatedField<Element>::ExtractSubrange(
+    int start, int num, Element* elements) {
+  GOOGLE_DCHECK_GE(start, 0);
+  GOOGLE_DCHECK_GE(num, 0);
+  GOOGLE_DCHECK_LE(start + num, this->current_size_);
+
+  // Save the values of the removed elements if requested.
+  if (elements != NULL) {
+    for (int i = 0; i < num; ++i)
+      elements[i] = this->Get(i + start);
+  }
+
+  // Slide remaining elements down to fill the gap.
+  if (num > 0) {
+    for (int i = start + num; i < this->current_size_; ++i)
+      this->Set(i - num, this->Get(i));
+    this->Truncate(this->current_size_ - num);
+  }
+}
+
+template <typename Element>
+inline void RepeatedField<Element>::Clear() {
+  current_size_ = 0;
+}
+
+template <typename Element>
+inline void RepeatedField<Element>::MergeFrom(const RepeatedField& other) {
+  GOOGLE_DCHECK_NE(&other, this);
+  if (other.current_size_ != 0) {
+    Reserve(current_size_ + other.current_size_);
+    CopyArray(rep_->elements + current_size_,
+              other.rep_->elements, other.current_size_);
+    current_size_ += other.current_size_;
+  }
+}
+
+template <typename Element>
+inline void RepeatedField<Element>::CopyFrom(const RepeatedField& other) {
+  if (&other == this) return;
+  Clear();
+  MergeFrom(other);
+}
+
+template <typename Element>
+inline typename RepeatedField<Element>::iterator RepeatedField<Element>::erase(
+    const_iterator position) {
+  return erase(position, position + 1);
+}
+
+template <typename Element>
+inline typename RepeatedField<Element>::iterator RepeatedField<Element>::erase(
+    const_iterator first, const_iterator last) {
+  size_type first_offset = first - cbegin();
+  if (first != last) {
+    Truncate(std::copy(last, cend(), begin() + first_offset) - cbegin());
+  }
+  return begin() + first_offset;
+}
+
+template <typename Element>
+inline Element* RepeatedField<Element>::mutable_data() {
+  return rep_ ? rep_->elements : NULL;
+}
+
+template <typename Element>
+inline const Element* RepeatedField<Element>::data() const {
+  return rep_ ? rep_->elements : NULL;
+}
+
+template <typename Element>
+inline const Element* RepeatedField<Element>::unsafe_data() const {
+  GOOGLE_DCHECK(rep_);
+  return rep_->elements;
+}
+
+template <typename Element>
+inline void RepeatedField<Element>::InternalSwap(RepeatedField* other) {
+  GOOGLE_DCHECK(this != other);
+  GOOGLE_DCHECK(GetArenaNoVirtual() == other->GetArenaNoVirtual());
+
+  std::swap(rep_, other->rep_);
+  std::swap(current_size_, other->current_size_);
+  std::swap(total_size_, other->total_size_);
+}
+
+template <typename Element>
+void RepeatedField<Element>::Swap(RepeatedField* other) {
+  if (this == other) return;
+  if (GetArenaNoVirtual() == other->GetArenaNoVirtual()) {
+    InternalSwap(other);
+  } else {
+    RepeatedField<Element> temp(other->GetArenaNoVirtual());
+    temp.MergeFrom(*this);
+    CopyFrom(*other);
+    other->UnsafeArenaSwap(&temp);
+  }
+}
+
+template <typename Element>
+void RepeatedField<Element>::UnsafeArenaSwap(RepeatedField* other) {
+  if (this == other) return;
+  InternalSwap(other);
+}
+
+template <typename Element>
+void RepeatedField<Element>::SwapElements(int index1, int index2) {
+  using std::swap;  // enable ADL with fallback
+  swap(rep_->elements[index1], rep_->elements[index2]);
+}
+
+template <typename Element>
+inline typename RepeatedField<Element>::iterator
+RepeatedField<Element>::begin() {
+  return rep_ ? rep_->elements : NULL;
+}
+template <typename Element>
+inline typename RepeatedField<Element>::const_iterator
+RepeatedField<Element>::begin() const {
+  return rep_ ? rep_->elements : NULL;
+}
+template <typename Element>
+inline typename RepeatedField<Element>::const_iterator
+RepeatedField<Element>::cbegin() const {
+  return rep_ ? rep_->elements : NULL;
+}
+template <typename Element>
+inline typename RepeatedField<Element>::iterator
+RepeatedField<Element>::end() {
+  return rep_ ? rep_->elements + current_size_ : NULL;
+}
+template <typename Element>
+inline typename RepeatedField<Element>::const_iterator
+RepeatedField<Element>::end() const {
+  return rep_ ? rep_->elements + current_size_ : NULL;
+}
+template <typename Element>
+inline typename RepeatedField<Element>::const_iterator
+RepeatedField<Element>::cend() const {
+  return rep_ ? rep_->elements + current_size_ : NULL;
+}
+
+template <typename Element>
+inline size_t RepeatedField<Element>::SpaceUsedExcludingSelfLong() const {
+  return rep_ ? (total_size_ * sizeof(Element) + kRepHeaderSize) : 0;
+}
+
+// Avoid inlining of Reserve(): new, copy, and delete[] lead to a significant
+// amount of code bloat.
+template <typename Element>
+void RepeatedField<Element>::Reserve(int new_size) {
+  if (total_size_ >= new_size) return;
+  Rep* old_rep = rep_;
+  Arena* arena = GetArenaNoVirtual();
+  new_size = std::max(google::protobuf::internal::kMinRepeatedFieldAllocationSize,
+                      std::max(total_size_ * 2, new_size));
+  GOOGLE_DCHECK_LE(
+      static_cast<size_t>(new_size),
+      (std::numeric_limits<size_t>::max() - kRepHeaderSize) / sizeof(Element))
+      << "Requested size is too large to fit into size_t.";
+  size_t bytes = kRepHeaderSize + sizeof(Element) * static_cast<size_t>(new_size);
+  if (arena == NULL) {
+    rep_ = static_cast<Rep*>(::operator new(bytes));
+  } else {
+    rep_ = reinterpret_cast<Rep*>(
+            ::google::protobuf::Arena::CreateArray<char>(arena, bytes));
+  }
+  rep_->arena = arena;
+  int old_total_size = total_size_;
+  total_size_ = new_size;
+  // Invoke placement-new on newly allocated elements. We shouldn't have to do
+  // this, since Element is supposed to be POD, but a previous version of this
+  // code allocated storage with "new Element[size]" and some code uses
+  // RepeatedField with non-POD types, relying on constructor invocation. If
+  // Element has a trivial constructor (e.g., int32), gcc (tested with -O2)
+  // completely removes this loop because the loop body is empty, so this has no
+  // effect unless its side-effects are required for correctness.
+  // Note that we do this before MoveArray() below because Element's copy
+  // assignment implementation will want an initialized instance first.
+  Element* e = &rep_->elements[0];
+  Element* limit = &rep_->elements[total_size_];
+  for (; e < limit; e++) {
+    new (e) Element;
+  }
+  if (current_size_ > 0) {
+    MoveArray(rep_->elements, old_rep->elements, current_size_);
+  }
+
+  // Likewise, we need to invoke destructors on the old array.
+  InternalDeallocate(old_rep, old_total_size);
+
+}
+
+template <typename Element>
+inline void RepeatedField<Element>::Truncate(int new_size) {
+  GOOGLE_DCHECK_LE(new_size, current_size_);
+  if (current_size_ > 0) {
+    current_size_ = new_size;
+  }
+}
+
+template <typename Element>
+inline void RepeatedField<Element>::MoveArray(
+  Element* to, Element* from, int array_size) {
+  CopyArray(to, from, array_size);
+}
+
+template <typename Element>
+inline void RepeatedField<Element>::CopyArray(
+  Element* to, const Element* from, int array_size) {
+  internal::ElementCopier<Element>()(to, from, array_size);
+}
+
+namespace internal {
+
+template <typename Element, bool HasTrivialCopy>
+void ElementCopier<Element, HasTrivialCopy>::operator()(
+  Element* to, const Element* from, int array_size) {
+  std::copy(from, from + array_size, to);
+}
+
+template <typename Element>
+struct ElementCopier<Element, true> {
+  void operator()(Element* to, const Element* from, int array_size) {
+    memcpy(to, from, static_cast<size_t>(array_size) * sizeof(Element));
+  }
+};
+
+}  // namespace internal
+
+
+// -------------------------------------------------------------------
+
+namespace internal {
+
+inline RepeatedPtrFieldBase::RepeatedPtrFieldBase()
+  : arena_(NULL),
+    current_size_(0),
+    total_size_(0),
+    rep_(NULL) {
+}
+
+inline RepeatedPtrFieldBase::RepeatedPtrFieldBase(::google::protobuf::Arena* arena)
+  : arena_(arena),
+    current_size_(0),
+    total_size_(0),
+    rep_(NULL) {
+}
+
+template <typename TypeHandler>
+void RepeatedPtrFieldBase::Destroy() {
+  if (rep_ != NULL && arena_ == NULL) {
+    int n = rep_->allocated_size;
+    void* const* elements = rep_->elements;
+    for (int i = 0; i < n; i++) {
+      TypeHandler::Delete(cast<TypeHandler>(elements[i]), NULL);
+    }
+#if defined(__GXX_DELETE_WITH_SIZE__) || defined(__cpp_sized_deallocation)
+    const size_t size = total_size_ * sizeof(elements[0]) + kRepHeaderSize;
+    ::operator delete(static_cast<void*>(rep_), size);
+#else
+    ::operator delete(static_cast<void*>(rep_));
+#endif
+  }
+  rep_ = NULL;
+}
+
+template <typename TypeHandler>
+inline void RepeatedPtrFieldBase::Swap(RepeatedPtrFieldBase* other) {
+  if (other->GetArenaNoVirtual() == GetArenaNoVirtual()) {
+    InternalSwap(other);
+  } else {
+    SwapFallback<TypeHandler>(other);
+  }
+}
+
+template <typename TypeHandler>
+void RepeatedPtrFieldBase::SwapFallback(RepeatedPtrFieldBase* other) {
+  GOOGLE_DCHECK(other->GetArenaNoVirtual() != GetArenaNoVirtual());
+
+  // Copy semantics in this case. We try to improve efficiency by placing the
+  // temporary on |other|'s arena so that messages are copied cross-arena only
+  // once, not twice.
+  RepeatedPtrFieldBase temp(other->GetArenaNoVirtual());
+  temp.MergeFrom<TypeHandler>(*this);
+  this->Clear<TypeHandler>();
+  this->MergeFrom<TypeHandler>(*other);
+  other->Clear<TypeHandler>();
+  other->InternalSwap(&temp);
+  temp.Destroy<TypeHandler>();  // Frees rep_ if `other` had no arena.
+}
+
+inline bool RepeatedPtrFieldBase::empty() const {
+  return current_size_ == 0;
+}
+
+inline int RepeatedPtrFieldBase::size() const {
+  return current_size_;
+}
+
+template <typename TypeHandler>
+inline const typename TypeHandler::Type&
+RepeatedPtrFieldBase::Get(int index) const {
+  GOOGLE_DCHECK_GE(index, 0);
+  GOOGLE_DCHECK_LT(index, current_size_);
+  return *cast<TypeHandler>(rep_->elements[index]);
+}
+
+
+template <typename TypeHandler>
+inline typename TypeHandler::Type*
+RepeatedPtrFieldBase::Mutable(int index) {
+  GOOGLE_DCHECK_GE(index, 0);
+  GOOGLE_DCHECK_LT(index, current_size_);
+  return cast<TypeHandler>(rep_->elements[index]);
+}
+
+template <typename TypeHandler>
+inline void RepeatedPtrFieldBase::Delete(int index) {
+  GOOGLE_DCHECK_GE(index, 0);
+  GOOGLE_DCHECK_LT(index, current_size_);
+  TypeHandler::Delete(cast<TypeHandler>(rep_->elements[index]), arena_);
+}
+
+template <typename TypeHandler>
+inline typename TypeHandler::Type* RepeatedPtrFieldBase::Add(
+    typename TypeHandler::Type* prototype) {
+  if (rep_ != NULL && current_size_ < rep_->allocated_size) {
+    return cast<TypeHandler>(rep_->elements[current_size_++]);
+  }
+  if (!rep_ || rep_->allocated_size == total_size_) {
+    Reserve(total_size_ + 1);
+  }
+  ++rep_->allocated_size;
+  typename TypeHandler::Type* result =
+      TypeHandler::NewFromPrototype(prototype, arena_);
+  rep_->elements[current_size_++] = result;
+  return result;
+}
+
+#if LANG_CXX11
+template <typename TypeHandler>
+inline void RepeatedPtrFieldBase::Add(
+    typename TypeHandler::Type&& value,
+    internal::enable_if<TypeHandler::Moveable>*) {
+  if (rep_ != NULL && current_size_ < rep_->allocated_size) {
+    *cast<TypeHandler>(rep_->elements[current_size_++]) = std::move(value);
+    return;
+  }
+  if (!rep_ || rep_->allocated_size == total_size_) {
+    Reserve(total_size_ + 1);
+  }
+  ++rep_->allocated_size;
+  typename TypeHandler::Type* result =
+      TypeHandler::New(arena_, std::move(value));
+  rep_->elements[current_size_++] = result;
+}
+#endif
+
+template <typename TypeHandler>
+inline void RepeatedPtrFieldBase::RemoveLast() {
+  GOOGLE_DCHECK_GT(current_size_, 0);
+  TypeHandler::Clear(cast<TypeHandler>(rep_->elements[--current_size_]));
+}
+
+template <typename TypeHandler>
+void RepeatedPtrFieldBase::Clear() {
+  const int n = current_size_;
+  GOOGLE_DCHECK_GE(n, 0);
+  if (n > 0) {
+    void* const* elements = rep_->elements;
+    int i = 0;
+    do {
+      TypeHandler::Clear(cast<TypeHandler>(elements[i++]));
+    } while (i < n);
+    current_size_ = 0;
+  }
+}
+
+// To avoid unnecessary code duplication and reduce binary size, we use a
+// layered approach to implementing MergeFrom(). The toplevel method is
+// templated, so we get a small thunk per concrete message type in the binary.
+// This calls a shared implementation with most of the logic, passing a function
+// pointer to another type-specific piece of code that calls the object-allocate
+// and merge handlers.
+template <typename TypeHandler>
+inline void RepeatedPtrFieldBase::MergeFrom(const RepeatedPtrFieldBase& other) {
+  GOOGLE_DCHECK_NE(&other, this);
+  if (other.current_size_ == 0) return;
+  MergeFromInternal(
+      other, &RepeatedPtrFieldBase::MergeFromInnerLoop<TypeHandler>);
+}
+
+inline void RepeatedPtrFieldBase::MergeFromInternal(
+    const RepeatedPtrFieldBase& other,
+    void (RepeatedPtrFieldBase::*inner_loop)(void**, void**, int, int)) {
+  // Note: wrapper has already guaranteed that other.rep_ != NULL here.
+  int other_size = other.current_size_;
+  void** other_elements = other.rep_->elements;
+  void** new_elements = InternalExtend(other_size);
+  int allocated_elems = rep_->allocated_size - current_size_;
+  (this->*inner_loop)(new_elements, other_elements,
+                      other_size, allocated_elems);
+  current_size_ += other_size;
+  if (rep_->allocated_size < current_size_) {
+    rep_->allocated_size = current_size_;
+  }
+}
+
+// Merges other_elems to our_elems.
+template<typename TypeHandler>
+void RepeatedPtrFieldBase::MergeFromInnerLoop(
+    void** our_elems, void** other_elems, int length, int already_allocated) {
+  // Split into two loops, over ranges [0, allocated) and [allocated, length),
+  // to avoid a branch within the loop.
+  for (int i = 0; i < already_allocated && i < length; i++) {
+    // Already allocated: use existing element.
+    typename TypeHandler::Type* other_elem =
+        reinterpret_cast<typename TypeHandler::Type*>(other_elems[i]);
+    typename TypeHandler::Type* new_elem =
+        reinterpret_cast<typename TypeHandler::Type*>(our_elems[i]);
+    TypeHandler::Merge(*other_elem, new_elem);
+  }
+  Arena* arena = GetArenaNoVirtual();
+  for (int i = already_allocated; i < length; i++) {
+    // Not allocated: alloc a new element first, then merge it.
+    typename TypeHandler::Type* other_elem =
+        reinterpret_cast<typename TypeHandler::Type*>(other_elems[i]);
+    typename TypeHandler::Type* new_elem =
+        TypeHandler::NewFromPrototype(other_elem, arena);
+    TypeHandler::Merge(*other_elem, new_elem);
+    our_elems[i] = new_elem;
+  }
+}
+
+template <typename TypeHandler>
+inline void RepeatedPtrFieldBase::CopyFrom(const RepeatedPtrFieldBase& other) {
+  if (&other == this) return;
+  RepeatedPtrFieldBase::Clear<TypeHandler>();
+  RepeatedPtrFieldBase::MergeFrom<TypeHandler>(other);
+}
+
+inline int RepeatedPtrFieldBase::Capacity() const {
+  return total_size_;
+}
+
+inline void* const* RepeatedPtrFieldBase::raw_data() const {
+  return rep_ ? rep_->elements : NULL;
+}
+
+inline void** RepeatedPtrFieldBase::raw_mutable_data() const {
+  return rep_ ? const_cast<void**>(rep_->elements) : NULL;
+}
+
+template <typename TypeHandler>
+inline typename TypeHandler::Type** RepeatedPtrFieldBase::mutable_data() {
+  // TODO(kenton):  Breaks C++ aliasing rules.  We should probably remove this
+  //   method entirely.
+  return reinterpret_cast<typename TypeHandler::Type**>(raw_mutable_data());
+}
+
+template <typename TypeHandler>
+inline const typename TypeHandler::Type* const*
+RepeatedPtrFieldBase::data() const {
+  // TODO(kenton):  Breaks C++ aliasing rules.  We should probably remove this
+  //   method entirely.
+  return reinterpret_cast<const typename TypeHandler::Type* const*>(raw_data());
+}
+
+inline void RepeatedPtrFieldBase::SwapElements(int index1, int index2) {
+  using std::swap;  // enable ADL with fallback
+  swap(rep_->elements[index1], rep_->elements[index2]);
+}
+
+template <typename TypeHandler>
+inline size_t RepeatedPtrFieldBase::SpaceUsedExcludingSelfLong() const {
+  size_t allocated_bytes = static_cast<size_t>(total_size_) * sizeof(void*);
+  if (rep_ != NULL) {
+    for (int i = 0; i < rep_->allocated_size; ++i) {
+      allocated_bytes += TypeHandler::SpaceUsedLong(
+          *cast<TypeHandler>(rep_->elements[i]));
+    }
+    allocated_bytes += kRepHeaderSize;
+  }
+  return allocated_bytes;
+}
+
+template <typename TypeHandler>
+inline typename TypeHandler::Type* RepeatedPtrFieldBase::AddFromCleared() {
+  if (rep_ != NULL && current_size_ < rep_->allocated_size) {
+    return cast<TypeHandler>(rep_->elements[current_size_++]);
+  } else {
+    return NULL;
+  }
+}
+
+// AddAllocated version that implements arena-safe copying behavior.
+template <typename TypeHandler>
+void RepeatedPtrFieldBase::AddAllocatedInternal(
+    typename TypeHandler::Type* value,
+    google::protobuf::internal::true_type) {
+  Arena* element_arena = reinterpret_cast<Arena*>(
+      TypeHandler::GetMaybeArenaPointer(value));
+  Arena* arena = GetArenaNoVirtual();
+  if (arena == element_arena && rep_ &&
+      rep_->allocated_size < total_size_) {
+    // Fast path: underlying arena representation (tagged pointer) is equal to
+    // our arena pointer, and we can add to array without resizing it (at least
+    // one slot that is not allocated).
+    void** elems = rep_->elements;
+    if (current_size_ < rep_->allocated_size) {
+      // Make space at [current] by moving first allocated element to end of
+      // allocated list.
+      elems[rep_->allocated_size] = elems[current_size_];
+    }
+    elems[current_size_] = value;
+    current_size_ = current_size_ + 1;
+    rep_->allocated_size = rep_->allocated_size + 1;
+  } else {
+    AddAllocatedSlowWithCopy<TypeHandler>(
+        value, TypeHandler::GetArena(value), arena);
+  }
+}
+
+// Slowpath handles all cases, copying if necessary.
+template<typename TypeHandler>
+void RepeatedPtrFieldBase::AddAllocatedSlowWithCopy(
+    // Pass value_arena and my_arena to avoid duplicate virtual call (value) or
+    // load (mine).
+    typename TypeHandler::Type* value, Arena* value_arena, Arena* my_arena) {
+  // Ensure that either the value is in the same arena, or if not, we do the
+  // appropriate thing: Own() it (if it's on heap and we're in an arena) or copy
+  // it to our arena/heap (otherwise).
+  if (my_arena != NULL && value_arena == NULL) {
+    my_arena->Own(value);
+  } else if (my_arena != value_arena) {
+    typename TypeHandler::Type* new_value =
+        TypeHandler::NewFromPrototype(value, my_arena);
+    TypeHandler::Merge(*value, new_value);
+    TypeHandler::Delete(value, value_arena);
+    value = new_value;
+  }
+
+  UnsafeArenaAddAllocated<TypeHandler>(value);
+}
+
+// AddAllocated version that does not implement arena-safe copying behavior.
+template <typename TypeHandler>
+void RepeatedPtrFieldBase::AddAllocatedInternal(
+    typename TypeHandler::Type* value,
+    google::protobuf::internal::false_type) {
+  if (rep_ &&  rep_->allocated_size < total_size_) {
+    // Fast path: underlying arena representation (tagged pointer) is equal to
+    // our arena pointer, and we can add to array without resizing it (at least
+    // one slot that is not allocated).
+    void** elems = rep_->elements;
+    if (current_size_ < rep_->allocated_size) {
+      // Make space at [current] by moving first allocated element to end of
+      // allocated list.
+      elems[rep_->allocated_size] = elems[current_size_];
+    }
+    elems[current_size_] = value;
+    current_size_ = current_size_ + 1;
+    ++rep_->allocated_size;
+  } else {
+    UnsafeArenaAddAllocated<TypeHandler>(value);
+  }
+}
+
+template <typename TypeHandler>
+void RepeatedPtrFieldBase::UnsafeArenaAddAllocated(
+    typename TypeHandler::Type* value) {
+  // Make room for the new pointer.
+  if (!rep_ || current_size_ == total_size_) {
+    // The array is completely full with no cleared objects, so grow it.
+    Reserve(total_size_ + 1);
+    ++rep_->allocated_size;
+  } else if (rep_->allocated_size == total_size_) {
+    // There is no more space in the pointer array because it contains some
+    // cleared objects awaiting reuse.  We don't want to grow the array in this
+    // case because otherwise a loop calling AddAllocated() followed by Clear()
+    // would leak memory.
+    TypeHandler::Delete(
+        cast<TypeHandler>(rep_->elements[current_size_]), arena_);
+  } else if (current_size_ < rep_->allocated_size) {
+    // We have some cleared objects.  We don't care about their order, so we
+    // can just move the first one to the end to make space.
+    rep_->elements[rep_->allocated_size] = rep_->elements[current_size_];
+    ++rep_->allocated_size;
+  } else {
+    // There are no cleared objects.
+    ++rep_->allocated_size;
+  }
+
+  rep_->elements[current_size_++] = value;
+}
+
+// ReleaseLast() for types that implement merge/copy behavior.
+template <typename TypeHandler>
+inline typename TypeHandler::Type*
+RepeatedPtrFieldBase::ReleaseLastInternal(google::protobuf::internal::true_type) {
+  // First, release an element.
+  typename TypeHandler::Type* result = UnsafeArenaReleaseLast<TypeHandler>();
+  // Now perform a copy if we're on an arena.
+  Arena* arena = GetArenaNoVirtual();
+  if (arena == NULL) {
+    return result;
+  } else {
+    typename TypeHandler::Type* new_result =
+        TypeHandler::NewFromPrototype(result, NULL);
+    TypeHandler::Merge(*result, new_result);
+    return new_result;
+  }
+}
+
+// ReleaseLast() for types that *do not* implement merge/copy behavior -- this
+// is the same as UnsafeArenaReleaseLast(). Note that we GOOGLE_DCHECK-fail if we're on
+// an arena, since the user really should implement the copy operation in this
+// case.
+template <typename TypeHandler>
+inline typename TypeHandler::Type*
+RepeatedPtrFieldBase::ReleaseLastInternal(google::protobuf::internal::false_type) {
+  GOOGLE_DCHECK(GetArenaNoVirtual() == NULL)
+      << "ReleaseLast() called on a RepeatedPtrField that is on an arena, "
+      << "with a type that does not implement MergeFrom. This is unsafe; "
+      << "please implement MergeFrom for your type.";
+  return UnsafeArenaReleaseLast<TypeHandler>();
+}
+
+template <typename TypeHandler>
+inline typename TypeHandler::Type*
+  RepeatedPtrFieldBase::UnsafeArenaReleaseLast() {
+  GOOGLE_DCHECK_GT(current_size_, 0);
+  typename TypeHandler::Type* result =
+      cast<TypeHandler>(rep_->elements[--current_size_]);
+  --rep_->allocated_size;
+  if (current_size_ < rep_->allocated_size) {
+    // There are cleared elements on the end; replace the removed element
+    // with the last allocated element.
+    rep_->elements[current_size_] = rep_->elements[rep_->allocated_size];
+  }
+  return result;
+}
+
+inline int RepeatedPtrFieldBase::ClearedCount() const {
+  return rep_ ? (rep_->allocated_size - current_size_) : 0;
+}
+
+template <typename TypeHandler>
+inline void RepeatedPtrFieldBase::AddCleared(
+    typename TypeHandler::Type* value) {
+  GOOGLE_DCHECK(GetArenaNoVirtual() == NULL)
+      << "AddCleared() can only be used on a RepeatedPtrField not on an arena.";
+  GOOGLE_DCHECK(TypeHandler::GetArena(value) == NULL)
+      << "AddCleared() can only accept values not on an arena.";
+  if (!rep_ || rep_->allocated_size == total_size_) {
+    Reserve(total_size_ + 1);
+  }
+  rep_->elements[rep_->allocated_size++] = value;
+}
+
+template <typename TypeHandler>
+inline typename TypeHandler::Type* RepeatedPtrFieldBase::ReleaseCleared() {
+  GOOGLE_DCHECK(GetArenaNoVirtual() == NULL)
+      << "ReleaseCleared() can only be used on a RepeatedPtrField not on "
+      << "an arena.";
+  GOOGLE_DCHECK(GetArenaNoVirtual() == NULL);
+  GOOGLE_DCHECK(rep_ != NULL);
+  GOOGLE_DCHECK_GT(rep_->allocated_size, current_size_);
+  return cast<TypeHandler>(rep_->elements[--rep_->allocated_size]);
+}
+
+}  // namespace internal
+
+// -------------------------------------------------------------------
+
+template <typename Element>
+class RepeatedPtrField<Element>::TypeHandler
+    : public internal::GenericTypeHandler<Element> {
+};
+
+template <>
+class RepeatedPtrField<string>::TypeHandler
+    : public internal::StringTypeHandler {
+};
+
+template <typename Element>
+inline RepeatedPtrField<Element>::RepeatedPtrField()
+  : RepeatedPtrFieldBase() {}
+
+template <typename Element>
+inline RepeatedPtrField<Element>::RepeatedPtrField(::google::protobuf::Arena* arena) :
+  RepeatedPtrFieldBase(arena) {}
+
+template <typename Element>
+inline RepeatedPtrField<Element>::RepeatedPtrField(
+    const RepeatedPtrField& other)
+  : RepeatedPtrFieldBase() {
+  MergeFrom(other);
+}
+
+template <typename Element>
+template <typename Iter>
+inline RepeatedPtrField<Element>::RepeatedPtrField(
+    Iter begin, const Iter& end) {
+  int reserve = internal::CalculateReserve(begin, end);
+  if (reserve != -1) {
+    Reserve(reserve);
+  }
+  for (; begin != end; ++begin) {
+    *Add() = *begin;
+  }
+}
+
+template <typename Element>
+RepeatedPtrField<Element>::~RepeatedPtrField() {
+  Destroy<TypeHandler>();
+}
+
+template <typename Element>
+inline RepeatedPtrField<Element>& RepeatedPtrField<Element>::operator=(
+    const RepeatedPtrField& other) {
+  if (this != &other)
+    CopyFrom(other);
+  return *this;
+}
+
+#if LANG_CXX11
+
+template <typename Element>
+inline RepeatedPtrField<Element>::RepeatedPtrField(
+    RepeatedPtrField&& other) noexcept
+    : RepeatedPtrField() {
+  // We don't just call Swap(&other) here because it would perform 3 copies if
+  // the two fields are on different arenas.
+  if (other.GetArenaNoVirtual()) {
+    CopyFrom(other);
+  } else {
+    InternalSwap(&other);
+  }
+}
+
+template <typename Element>
+inline RepeatedPtrField<Element>& RepeatedPtrField<Element>::operator=(
+    RepeatedPtrField&& other) noexcept {
+  // We don't just call Swap(&other) here because it would perform 3 copies if
+  // the two fields are on different arenas.
+  if (this != &other) {
+    if (this->GetArenaNoVirtual() != other.GetArenaNoVirtual()) {
+      CopyFrom(other);
+    } else {
+      InternalSwap(&other);
+    }
+  }
+  return *this;
+}
+
+#endif  // LANG_CXX11
+
+template <typename Element>
+inline bool RepeatedPtrField<Element>::empty() const {
+  return RepeatedPtrFieldBase::empty();
+}
+
+template <typename Element>
+inline int RepeatedPtrField<Element>::size() const {
+  return RepeatedPtrFieldBase::size();
+}
+
+template <typename Element>
+inline const Element& RepeatedPtrField<Element>::Get(int index) const {
+  return RepeatedPtrFieldBase::Get<TypeHandler>(index);
+}
+
+
+template <typename Element>
+inline Element* RepeatedPtrField<Element>::Mutable(int index) {
+  return RepeatedPtrFieldBase::Mutable<TypeHandler>(index);
+}
+
+template <typename Element>
+inline Element* RepeatedPtrField<Element>::Add() {
+  return RepeatedPtrFieldBase::Add<TypeHandler>();
+}
+
+#if LANG_CXX11
+template <typename Element>
+inline void RepeatedPtrField<Element>::Add(Element&& value) {
+  RepeatedPtrFieldBase::Add<TypeHandler>(std::move(value));
+}
+#endif
+
+template <typename Element>
+inline void RepeatedPtrField<Element>::RemoveLast() {
+  RepeatedPtrFieldBase::RemoveLast<TypeHandler>();
+}
+
+template <typename Element>
+inline void RepeatedPtrField<Element>::DeleteSubrange(int start, int num) {
+  GOOGLE_DCHECK_GE(start, 0);
+  GOOGLE_DCHECK_GE(num, 0);
+  GOOGLE_DCHECK_LE(start + num, size());
+  for (int i = 0; i < num; ++i) {
+    RepeatedPtrFieldBase::Delete<TypeHandler>(start + i);
+  }
+  ExtractSubrange(start, num, NULL);
+}
+
+template <typename Element>
+inline void RepeatedPtrField<Element>::ExtractSubrange(
+    int start, int num, Element** elements) {
+  typename internal::TypeImplementsMergeBehavior<
+      typename TypeHandler::Type>::type t;
+  ExtractSubrangeInternal(start, num, elements, t);
+}
+
+// ExtractSubrange() implementation for types that implement merge/copy
+// behavior.
+template <typename Element>
+inline void RepeatedPtrField<Element>::ExtractSubrangeInternal(
+    int start, int num, Element** elements, google::protobuf::internal::true_type) {
+  GOOGLE_DCHECK_GE(start, 0);
+  GOOGLE_DCHECK_GE(num, 0);
+  GOOGLE_DCHECK_LE(start + num, size());
+
+  if (num > 0) {
+    // Save the values of the removed elements if requested.
+    if (elements != NULL) {
+      if (GetArenaNoVirtual() != NULL) {
+        // If we're on an arena, we perform a copy for each element so that the
+        // returned elements are heap-allocated.
+        for (int i = 0; i < num; ++i) {
+          Element* element = RepeatedPtrFieldBase::
+              Mutable<TypeHandler>(i + start);
+          typename TypeHandler::Type* new_value =
+              TypeHandler::NewFromPrototype(element, NULL);
+          TypeHandler::Merge(*element, new_value);
+          elements[i] = new_value;
+        }
+      } else {
+        for (int i = 0; i < num; ++i) {
+          elements[i] = RepeatedPtrFieldBase::Mutable<TypeHandler>(i + start);
+        }
+      }
+    }
+    CloseGap(start, num);
+  }
+}
+
+// ExtractSubrange() implementation for types that do not implement merge/copy
+// behavior.
+template<typename Element>
+inline void RepeatedPtrField<Element>::ExtractSubrangeInternal(
+    int start, int num, Element** elements, google::protobuf::internal::false_type) {
+  // This case is identical to UnsafeArenaExtractSubrange(). However, since
+  // ExtractSubrange() must return heap-allocated objects by contract, and we
+  // cannot fulfill this contract if we are an on arena, we must GOOGLE_DCHECK() that
+  // we are not on an arena.
+  GOOGLE_DCHECK(GetArenaNoVirtual() == NULL)
+      << "ExtractSubrange() when arena is non-NULL is only supported when "
+      << "the Element type supplies a MergeFrom() operation to make copies.";
+  UnsafeArenaExtractSubrange(start, num, elements);
+}
+
+template <typename Element>
+inline void RepeatedPtrField<Element>::UnsafeArenaExtractSubrange(
+    int start, int num, Element** elements) {
+  GOOGLE_DCHECK_GE(start, 0);
+  GOOGLE_DCHECK_GE(num, 0);
+  GOOGLE_DCHECK_LE(start + num, size());
+
+  if (num > 0) {
+    // Save the values of the removed elements if requested.
+    if (elements != NULL) {
+      for (int i = 0; i < num; ++i) {
+        elements[i] = RepeatedPtrFieldBase::Mutable<TypeHandler>(i + start);
+      }
+    }
+    CloseGap(start, num);
+  }
+}
+
+template <typename Element>
+inline void RepeatedPtrField<Element>::Clear() {
+  RepeatedPtrFieldBase::Clear<TypeHandler>();
+}
+
+template <typename Element>
+inline void RepeatedPtrField<Element>::MergeFrom(
+    const RepeatedPtrField& other) {
+  RepeatedPtrFieldBase::MergeFrom<TypeHandler>(other);
+}
+
+template <typename Element>
+inline void RepeatedPtrField<Element>::CopyFrom(
+    const RepeatedPtrField& other) {
+  RepeatedPtrFieldBase::CopyFrom<TypeHandler>(other);
+}
+
+template <typename Element>
+inline typename RepeatedPtrField<Element>::iterator
+RepeatedPtrField<Element>::erase(const_iterator position) {
+  return erase(position, position + 1);
+}
+
+template <typename Element>
+inline typename RepeatedPtrField<Element>::iterator
+RepeatedPtrField<Element>::erase(const_iterator first, const_iterator last) {
+  size_type pos_offset = std::distance(cbegin(), first);
+  size_type last_offset = std::distance(cbegin(), last);
+  DeleteSubrange(pos_offset, last_offset - pos_offset);
+  return begin() + pos_offset;
+}
+
+template <typename Element>
+inline Element** RepeatedPtrField<Element>::mutable_data() {
+  return RepeatedPtrFieldBase::mutable_data<TypeHandler>();
+}
+
+template <typename Element>
+inline const Element* const* RepeatedPtrField<Element>::data() const {
+  return RepeatedPtrFieldBase::data<TypeHandler>();
+}
+
+template <typename Element>
+inline void RepeatedPtrField<Element>::Swap(RepeatedPtrField* other) {
+  if (this == other)
+    return;
+  RepeatedPtrFieldBase::Swap<TypeHandler>(other);
+}
+
+template <typename Element>
+inline void RepeatedPtrField<Element>::UnsafeArenaSwap(
+    RepeatedPtrField* other) {
+  if (this == other)
+      return;
+  RepeatedPtrFieldBase::InternalSwap(other);
+}
+
+template <typename Element>
+inline void RepeatedPtrField<Element>::SwapElements(int index1, int index2) {
+  RepeatedPtrFieldBase::SwapElements(index1, index2);
+}
+
+template <typename Element>
+inline Arena* RepeatedPtrField<Element>::GetArenaNoVirtual() const {
+  return RepeatedPtrFieldBase::GetArenaNoVirtual();
+}
+
+template <typename Element>
+inline size_t RepeatedPtrField<Element>::SpaceUsedExcludingSelfLong() const {
+  return RepeatedPtrFieldBase::SpaceUsedExcludingSelfLong<TypeHandler>();
+}
+
+template <typename Element>
+inline void RepeatedPtrField<Element>::AddAllocated(Element* value) {
+  RepeatedPtrFieldBase::AddAllocated<TypeHandler>(value);
+}
+
+template <typename Element>
+inline void RepeatedPtrField<Element>::UnsafeArenaAddAllocated(Element* value) {
+  RepeatedPtrFieldBase::UnsafeArenaAddAllocated<TypeHandler>(value);
+}
+
+template <typename Element>
+inline Element* RepeatedPtrField<Element>::ReleaseLast() {
+  return RepeatedPtrFieldBase::ReleaseLast<TypeHandler>();
+}
+
+template <typename Element>
+inline Element* RepeatedPtrField<Element>::UnsafeArenaReleaseLast() {
+  return RepeatedPtrFieldBase::UnsafeArenaReleaseLast<TypeHandler>();
+}
+
+template <typename Element>
+inline int RepeatedPtrField<Element>::ClearedCount() const {
+  return RepeatedPtrFieldBase::ClearedCount();
+}
+
+template <typename Element>
+inline void RepeatedPtrField<Element>::AddCleared(Element* value) {
+  return RepeatedPtrFieldBase::AddCleared<TypeHandler>(value);
+}
+
+template <typename Element>
+inline Element* RepeatedPtrField<Element>::ReleaseCleared() {
+  return RepeatedPtrFieldBase::ReleaseCleared<TypeHandler>();
+}
+
+template <typename Element>
+inline void RepeatedPtrField<Element>::Reserve(int new_size) {
+  return RepeatedPtrFieldBase::Reserve(new_size);
+}
+
+template <typename Element>
+inline int RepeatedPtrField<Element>::Capacity() const {
+  return RepeatedPtrFieldBase::Capacity();
+}
+
+// -------------------------------------------------------------------
+
+namespace internal {
+
+// STL-like iterator implementation for RepeatedPtrField.  You should not
+// refer to this class directly; use RepeatedPtrField<T>::iterator instead.
+//
+// The iterator for RepeatedPtrField<T>, RepeatedPtrIterator<T>, is
+// very similar to iterator_ptr<T**> in util/gtl/iterator_adaptors.h,
+// but adds random-access operators and is modified to wrap a void** base
+// iterator (since RepeatedPtrField stores its array as a void* array and
+// casting void** to T** would violate C++ aliasing rules).
+//
+// This code based on net/proto/proto-array-internal.h by Jeffrey Yasskin
+// (jyasskin@google.com).
+template<typename Element>
+class RepeatedPtrIterator
+    : public std::iterator<
+          std::random_access_iterator_tag, Element> {
+ public:
+  typedef RepeatedPtrIterator<Element> iterator;
+  typedef std::iterator<
+          std::random_access_iterator_tag, Element> superclass;
+
+  // Shadow the value_type in std::iterator<> because const_iterator::value_type
+  // needs to be T, not const T.
+  typedef typename remove_const<Element>::type value_type;
+
+  // Let the compiler know that these are type names, so we don't have to
+  // write "typename" in front of them everywhere.
+  typedef typename superclass::reference reference;
+  typedef typename superclass::pointer pointer;
+  typedef typename superclass::difference_type difference_type;
+
+  RepeatedPtrIterator() : it_(NULL) {}
+  explicit RepeatedPtrIterator(void* const* it) : it_(it) {}
+
+  // Allow "upcasting" from RepeatedPtrIterator<T**> to
+  // RepeatedPtrIterator<const T*const*>.
+  template<typename OtherElement>
+  RepeatedPtrIterator(const RepeatedPtrIterator<OtherElement>& other)
+      : it_(other.it_) {
+    // Force a compiler error if the other type is not convertible to ours.
+    if (false) {
+      implicit_cast<Element*>(static_cast<OtherElement*>(NULL));
+    }
+  }
+
+  // dereferenceable
+  reference operator*() const { return *reinterpret_cast<Element*>(*it_); }
+  pointer   operator->() const { return &(operator*()); }
+
+  // {inc,dec}rementable
+  iterator& operator++() { ++it_; return *this; }
+  iterator  operator++(int) { return iterator(it_++); }
+  iterator& operator--() { --it_; return *this; }
+  iterator  operator--(int) { return iterator(it_--); }
+
+  // equality_comparable
+  bool operator==(const iterator& x) const { return it_ == x.it_; }
+  bool operator!=(const iterator& x) const { return it_ != x.it_; }
+
+  // less_than_comparable
+  bool operator<(const iterator& x) const { return it_ < x.it_; }
+  bool operator<=(const iterator& x) const { return it_ <= x.it_; }
+  bool operator>(const iterator& x) const { return it_ > x.it_; }
+  bool operator>=(const iterator& x) const { return it_ >= x.it_; }
+
+  // addable, subtractable
+  iterator& operator+=(difference_type d) {
+    it_ += d;
+    return *this;
+  }
+  friend iterator operator+(iterator it, const difference_type d) {
+    it += d;
+    return it;
+  }
+  friend iterator operator+(const difference_type d, iterator it) {
+    it += d;
+    return it;
+  }
+  iterator& operator-=(difference_type d) {
+    it_ -= d;
+    return *this;
+  }
+  friend iterator operator-(iterator it, difference_type d) {
+    it -= d;
+    return it;
+  }
+
+  // indexable
+  reference operator[](difference_type d) const { return *(*this + d); }
+
+  // random access iterator
+  difference_type operator-(const iterator& x) const { return it_ - x.it_; }
+
+ private:
+  template<typename OtherElement>
+  friend class RepeatedPtrIterator;
+
+  // The internal iterator.
+  void* const* it_;
+};
+
+// Provide an iterator that operates on pointers to the underlying objects
+// rather than the objects themselves as RepeatedPtrIterator does.
+// Consider using this when working with stl algorithms that change
+// the array.
+// The VoidPtr template parameter holds the type-agnostic pointer value
+// referenced by the iterator.  It should either be "void *" for a mutable
+// iterator, or "const void* const" for a constant iterator.
+template <typename Element, typename VoidPtr>
+class RepeatedPtrOverPtrsIterator
+    : public std::iterator<std::random_access_iterator_tag, Element> {
+ public:
+  typedef RepeatedPtrOverPtrsIterator<Element, VoidPtr> iterator;
+  typedef std::iterator<std::random_access_iterator_tag, Element> superclass;
+
+  // Shadow the value_type in std::iterator<> because const_iterator::value_type
+  // needs to be T, not const T.
+  typedef typename remove_const<Element>::type value_type;
+
+  // Let the compiler know that these are type names, so we don't have to
+  // write "typename" in front of them everywhere.
+  typedef typename superclass::reference reference;
+  typedef typename superclass::pointer pointer;
+  typedef typename superclass::difference_type difference_type;
+
+  RepeatedPtrOverPtrsIterator() : it_(NULL) {}
+  explicit RepeatedPtrOverPtrsIterator(VoidPtr* it) : it_(it) {}
+
+  // dereferenceable
+  reference operator*() const { return *reinterpret_cast<Element*>(it_); }
+  pointer   operator->() const { return &(operator*()); }
+
+  // {inc,dec}rementable
+  iterator& operator++() { ++it_; return *this; }
+  iterator  operator++(int) { return iterator(it_++); }
+  iterator& operator--() { --it_; return *this; }
+  iterator  operator--(int) { return iterator(it_--); }
+
+  // equality_comparable
+  bool operator==(const iterator& x) const { return it_ == x.it_; }
+  bool operator!=(const iterator& x) const { return it_ != x.it_; }
+
+  // less_than_comparable
+  bool operator<(const iterator& x) const { return it_ < x.it_; }
+  bool operator<=(const iterator& x) const { return it_ <= x.it_; }
+  bool operator>(const iterator& x) const { return it_ > x.it_; }
+  bool operator>=(const iterator& x) const { return it_ >= x.it_; }
+
+  // addable, subtractable
+  iterator& operator+=(difference_type d) {
+    it_ += d;
+    return *this;
+  }
+  friend iterator operator+(iterator it, difference_type d) {
+    it += d;
+    return it;
+  }
+  friend iterator operator+(difference_type d, iterator it) {
+    it += d;
+    return it;
+  }
+  iterator& operator-=(difference_type d) {
+    it_ -= d;
+    return *this;
+  }
+  friend iterator operator-(iterator it, difference_type d) {
+    it -= d;
+    return it;
+  }
+
+  // indexable
+  reference operator[](difference_type d) const { return *(*this + d); }
+
+  // random access iterator
+  difference_type operator-(const iterator& x) const { return it_ - x.it_; }
+
+ private:
+  template<typename OtherElement>
+  friend class RepeatedPtrIterator;
+
+  // The internal iterator.
+  VoidPtr* it_;
+};
+
+void RepeatedPtrFieldBase::InternalSwap(RepeatedPtrFieldBase* other) {
+  GOOGLE_DCHECK(this != other);
+  GOOGLE_DCHECK(GetArenaNoVirtual() == other->GetArenaNoVirtual());
+
+  std::swap(rep_, other->rep_);
+  std::swap(current_size_, other->current_size_);
+  std::swap(total_size_, other->total_size_);
+}
+
+}  // namespace internal
+
+template <typename Element>
+inline typename RepeatedPtrField<Element>::iterator
+RepeatedPtrField<Element>::begin() {
+  return iterator(raw_data());
+}
+template <typename Element>
+inline typename RepeatedPtrField<Element>::const_iterator
+RepeatedPtrField<Element>::begin() const {
+  return iterator(raw_data());
+}
+template <typename Element>
+inline typename RepeatedPtrField<Element>::const_iterator
+RepeatedPtrField<Element>::cbegin() const {
+  return begin();
+}
+template <typename Element>
+inline typename RepeatedPtrField<Element>::iterator
+RepeatedPtrField<Element>::end() {
+  return iterator(raw_data() + size());
+}
+template <typename Element>
+inline typename RepeatedPtrField<Element>::const_iterator
+RepeatedPtrField<Element>::end() const {
+  return iterator(raw_data() + size());
+}
+template <typename Element>
+inline typename RepeatedPtrField<Element>::const_iterator
+RepeatedPtrField<Element>::cend() const {
+  return end();
+}
+
+template <typename Element>
+inline typename RepeatedPtrField<Element>::pointer_iterator
+RepeatedPtrField<Element>::pointer_begin() {
+  return pointer_iterator(raw_mutable_data());
+}
+template <typename Element>
+inline typename RepeatedPtrField<Element>::const_pointer_iterator
+RepeatedPtrField<Element>::pointer_begin() const {
+  return const_pointer_iterator(const_cast<const void* const*>(raw_data()));
+}
+template <typename Element>
+inline typename RepeatedPtrField<Element>::pointer_iterator
+RepeatedPtrField<Element>::pointer_end() {
+  return pointer_iterator(raw_mutable_data() + size());
+}
+template <typename Element>
+inline typename RepeatedPtrField<Element>::const_pointer_iterator
+RepeatedPtrField<Element>::pointer_end() const {
+  return const_pointer_iterator(
+      const_cast<const void* const*>(raw_data() + size()));
+}
+
+
+// Iterators and helper functions that follow the spirit of the STL
+// std::back_insert_iterator and std::back_inserter but are tailor-made
+// for RepeatedField and RepeatedPtrField. Typical usage would be:
+//
+//   std::copy(some_sequence.begin(), some_sequence.end(),
+//             google::protobuf::RepeatedFieldBackInserter(proto.mutable_sequence()));
+//
+// Ported by johannes from util/gtl/proto-array-iterators.h
+
+namespace internal {
+// A back inserter for RepeatedField objects.
+template<typename T> class RepeatedFieldBackInsertIterator
+    : public std::iterator<std::output_iterator_tag, T> {
+ public:
+  explicit RepeatedFieldBackInsertIterator(
+      RepeatedField<T>* const mutable_field)
+      : field_(mutable_field) {
+  }
+  RepeatedFieldBackInsertIterator<T>& operator=(const T& value) {
+    field_->Add(value);
+    return *this;
+  }
+  RepeatedFieldBackInsertIterator<T>& operator*() {
+    return *this;
+  }
+  RepeatedFieldBackInsertIterator<T>& operator++() {
+    return *this;
+  }
+  RepeatedFieldBackInsertIterator<T>& operator++(int /* unused */) {
+    return *this;
+  }
+
+ private:
+  RepeatedField<T>* field_;
+};
+
+// A back inserter for RepeatedPtrField objects.
+template<typename T> class RepeatedPtrFieldBackInsertIterator
+    : public std::iterator<std::output_iterator_tag, T> {
+ public:
+  RepeatedPtrFieldBackInsertIterator(
+      RepeatedPtrField<T>* const mutable_field)
+      : field_(mutable_field) {
+  }
+  RepeatedPtrFieldBackInsertIterator<T>& operator=(const T& value) {
+    *field_->Add() = value;
+    return *this;
+  }
+  RepeatedPtrFieldBackInsertIterator<T>& operator=(
+      const T* const ptr_to_value) {
+    *field_->Add() = *ptr_to_value;
+    return *this;
+  }
+#if LANG_CXX11
+  RepeatedPtrFieldBackInsertIterator<T>& operator=(T&& value) {
+    *field_->Add() = std::move(value);
+    return *this;
+  }
+#endif
+  RepeatedPtrFieldBackInsertIterator<T>& operator*() {
+    return *this;
+  }
+  RepeatedPtrFieldBackInsertIterator<T>& operator++() {
+    return *this;
+  }
+  RepeatedPtrFieldBackInsertIterator<T>& operator++(int /* unused */) {
+    return *this;
+  }
+
+ private:
+  RepeatedPtrField<T>* field_;
+};
+
+// A back inserter for RepeatedPtrFields that inserts by transferring ownership
+// of a pointer.
+template<typename T> class AllocatedRepeatedPtrFieldBackInsertIterator
+    : public std::iterator<std::output_iterator_tag, T> {
+ public:
+  explicit AllocatedRepeatedPtrFieldBackInsertIterator(
+      RepeatedPtrField<T>* const mutable_field)
+      : field_(mutable_field) {
+  }
+  AllocatedRepeatedPtrFieldBackInsertIterator<T>& operator=(
+      T* const ptr_to_value) {
+    field_->AddAllocated(ptr_to_value);
+    return *this;
+  }
+  AllocatedRepeatedPtrFieldBackInsertIterator<T>& operator*() {
+    return *this;
+  }
+  AllocatedRepeatedPtrFieldBackInsertIterator<T>& operator++() {
+    return *this;
+  }
+  AllocatedRepeatedPtrFieldBackInsertIterator<T>& operator++(
+      int /* unused */) {
+    return *this;
+  }
+
+ private:
+  RepeatedPtrField<T>* field_;
+};
+
+// Almost identical to AllocatedRepeatedPtrFieldBackInsertIterator. This one
+// uses the UnsafeArenaAddAllocated instead.
+template<typename T>
+class UnsafeArenaAllocatedRepeatedPtrFieldBackInsertIterator
+    : public std::iterator<std::output_iterator_tag, T> {
+ public:
+  explicit UnsafeArenaAllocatedRepeatedPtrFieldBackInsertIterator(
+    ::google::protobuf::RepeatedPtrField<T>* const mutable_field)
+  : field_(mutable_field) {
+  }
+  UnsafeArenaAllocatedRepeatedPtrFieldBackInsertIterator<T>& operator=(
+    T const* const ptr_to_value) {
+    field_->UnsafeArenaAddAllocated(const_cast<T*>(ptr_to_value));
+    return *this;
+  }
+  UnsafeArenaAllocatedRepeatedPtrFieldBackInsertIterator<T>& operator*() {
+    return *this;
+  }
+  UnsafeArenaAllocatedRepeatedPtrFieldBackInsertIterator<T>& operator++() {
+    return *this;
+  }
+  UnsafeArenaAllocatedRepeatedPtrFieldBackInsertIterator<T>& operator++(
+      int /* unused */) {
+    return *this;
+  }
+
+ private:
+  ::google::protobuf::RepeatedPtrField<T>* field_;
+};
+
+}  // namespace internal
+
+// Provides a back insert iterator for RepeatedField instances,
+// similar to std::back_inserter().
+template<typename T> internal::RepeatedFieldBackInsertIterator<T>
+RepeatedFieldBackInserter(RepeatedField<T>* const mutable_field) {
+  return internal::RepeatedFieldBackInsertIterator<T>(mutable_field);
+}
+
+// Provides a back insert iterator for RepeatedPtrField instances,
+// similar to std::back_inserter().
+template<typename T> internal::RepeatedPtrFieldBackInsertIterator<T>
+RepeatedPtrFieldBackInserter(RepeatedPtrField<T>* const mutable_field) {
+  return internal::RepeatedPtrFieldBackInsertIterator<T>(mutable_field);
+}
+
+// Special back insert iterator for RepeatedPtrField instances, just in
+// case someone wants to write generic template code that can access both
+// RepeatedFields and RepeatedPtrFields using a common name.
+template<typename T> internal::RepeatedPtrFieldBackInsertIterator<T>
+RepeatedFieldBackInserter(RepeatedPtrField<T>* const mutable_field) {
+  return internal::RepeatedPtrFieldBackInsertIterator<T>(mutable_field);
+}
+
+// Provides a back insert iterator for RepeatedPtrField instances
+// similar to std::back_inserter() which transfers the ownership while
+// copying elements.
+template<typename T> internal::AllocatedRepeatedPtrFieldBackInsertIterator<T>
+AllocatedRepeatedPtrFieldBackInserter(
+    RepeatedPtrField<T>* const mutable_field) {
+  return internal::AllocatedRepeatedPtrFieldBackInsertIterator<T>(
+      mutable_field);
+}
+
+// Similar to AllocatedRepeatedPtrFieldBackInserter, using
+// UnsafeArenaAddAllocated instead of AddAllocated.
+// This is slightly faster if that matters. It is also useful in legacy code
+// that uses temporary ownership to avoid copies. Example:
+//   RepeatedPtrField<T> temp_field;
+//   temp_field.AddAllocated(new T);
+//   ... // Do something with temp_field
+//   temp_field.ExtractSubrange(0, temp_field.size(), NULL);
+// If you put temp_field on the arena this fails, because the ownership
+// transfers to the arena at the "AddAllocated" call and is not released anymore
+// causing a double delete. Using UnsafeArenaAddAllocated prevents this.
+template<typename T>
+internal::UnsafeArenaAllocatedRepeatedPtrFieldBackInsertIterator<T>
+UnsafeArenaAllocatedRepeatedPtrFieldBackInserter(
+    ::google::protobuf::RepeatedPtrField<T>* const mutable_field) {
+  return internal::UnsafeArenaAllocatedRepeatedPtrFieldBackInsertIterator<T>(
+      mutable_field);
+}
+
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_REPEATED_FIELD_H__
diff --git a/kortex_api/include/google/protobuf/service.h b/kortex_api/include/google/protobuf/service.h
new file mode 100644
index 0000000000000000000000000000000000000000..ad6f968548fe69dc4ffac0e3e56fb0341681ee62
--- /dev/null
+++ b/kortex_api/include/google/protobuf/service.h
@@ -0,0 +1,292 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// DEPRECATED:  This module declares the abstract interfaces underlying proto2
+// RPC services.  These are intented to be independent of any particular RPC
+// implementation, so that proto2 services can be used on top of a variety
+// of implementations.  Starting with version 2.3.0, RPC implementations should
+// not try to build on these, but should instead provide code generator plugins
+// which generate code specific to the particular RPC implementation.  This way
+// the generated code can be more appropriate for the implementation in use
+// and can avoid unnecessary layers of indirection.
+//
+//
+// When you use the protocol compiler to compile a service definition, it
+// generates two classes:  An abstract interface for the service (with
+// methods matching the service definition) and a "stub" implementation.
+// A stub is just a type-safe wrapper around an RpcChannel which emulates a
+// local implementation of the service.
+//
+// For example, the service definition:
+//   service MyService {
+//     rpc Foo(MyRequest) returns(MyResponse);
+//   }
+// will generate abstract interface "MyService" and class "MyService::Stub".
+// You could implement a MyService as follows:
+//   class MyServiceImpl : public MyService {
+//    public:
+//     MyServiceImpl() {}
+//     ~MyServiceImpl() {}
+//
+//     // implements MyService ---------------------------------------
+//
+//     void Foo(google::protobuf::RpcController* controller,
+//              const MyRequest* request,
+//              MyResponse* response,
+//              Closure* done) {
+//       // ... read request and fill in response ...
+//       done->Run();
+//     }
+//   };
+// You would then register an instance of MyServiceImpl with your RPC server
+// implementation.  (How to do that depends on the implementation.)
+//
+// To call a remote MyServiceImpl, first you need an RpcChannel connected to it.
+// How to construct a channel depends, again, on your RPC implementation.
+// Here we use a hypothetical "MyRpcChannel" as an example:
+//   MyRpcChannel channel("rpc:hostname:1234/myservice");
+//   MyRpcController controller;
+//   MyServiceImpl::Stub stub(&channel);
+//   FooRequest request;
+//   FooResponse response;
+//
+//   // ... fill in request ...
+//
+//   stub.Foo(&controller, request, &response, NewCallback(HandleResponse));
+//
+// On Thread-Safety:
+//
+// Different RPC implementations may make different guarantees about what
+// threads they may run callbacks on, and what threads the application is
+// allowed to use to call the RPC system.  Portable software should be ready
+// for callbacks to be called on any thread, but should not try to call the
+// RPC system from any thread except for the ones on which it received the
+// callbacks.  Realistically, though, simple software will probably want to
+// use a single-threaded RPC system while high-end software will want to
+// use multiple threads.  RPC implementations should provide multiple
+// choices.
+
+#ifndef GOOGLE_PROTOBUF_SERVICE_H__
+#define GOOGLE_PROTOBUF_SERVICE_H__
+
+#include <string>
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/callback.h>
+
+namespace google {
+namespace protobuf {
+
+// Defined in this file.
+class Service;
+class RpcController;
+class RpcChannel;
+
+// Defined in other files.
+class Descriptor;            // descriptor.h
+class ServiceDescriptor;     // descriptor.h
+class MethodDescriptor;      // descriptor.h
+class Message;               // message.h
+
+// Abstract base interface for protocol-buffer-based RPC services.  Services
+// themselves are abstract interfaces (implemented either by servers or as
+// stubs), but they subclass this base interface.  The methods of this
+// interface can be used to call the methods of the Service without knowing
+// its exact type at compile time (analogous to Reflection).
+class LIBPROTOBUF_EXPORT Service {
+ public:
+  inline Service() {}
+  virtual ~Service();
+
+  // When constructing a stub, you may pass STUB_OWNS_CHANNEL as the second
+  // parameter to the constructor to tell it to delete its RpcChannel when
+  // destroyed.
+  enum ChannelOwnership {
+    STUB_OWNS_CHANNEL,
+    STUB_DOESNT_OWN_CHANNEL
+  };
+
+  // Get the ServiceDescriptor describing this service and its methods.
+  virtual const ServiceDescriptor* GetDescriptor() = 0;
+
+  // Call a method of the service specified by MethodDescriptor.  This is
+  // normally implemented as a simple switch() that calls the standard
+  // definitions of the service's methods.
+  //
+  // Preconditions:
+  // * method->service() == GetDescriptor()
+  // * request and response are of the exact same classes as the objects
+  //   returned by GetRequestPrototype(method) and
+  //   GetResponsePrototype(method).
+  // * After the call has started, the request must not be modified and the
+  //   response must not be accessed at all until "done" is called.
+  // * "controller" is of the correct type for the RPC implementation being
+  //   used by this Service.  For stubs, the "correct type" depends on the
+  //   RpcChannel which the stub is using.  Server-side Service
+  //   implementations are expected to accept whatever type of RpcController
+  //   the server-side RPC implementation uses.
+  //
+  // Postconditions:
+  // * "done" will be called when the method is complete.  This may be
+  //   before CallMethod() returns or it may be at some point in the future.
+  // * If the RPC succeeded, "response" contains the response returned by
+  //   the server.
+  // * If the RPC failed, "response"'s contents are undefined.  The
+  //   RpcController can be queried to determine if an error occurred and
+  //   possibly to get more information about the error.
+  virtual void CallMethod(const MethodDescriptor* method,
+                          RpcController* controller,
+                          const Message* request,
+                          Message* response,
+                          Closure* done) = 0;
+
+  // CallMethod() requires that the request and response passed in are of a
+  // particular subclass of Message.  GetRequestPrototype() and
+  // GetResponsePrototype() get the default instances of these required types.
+  // You can then call Message::New() on these instances to construct mutable
+  // objects which you can then pass to CallMethod().
+  //
+  // Example:
+  //   const MethodDescriptor* method =
+  //     service->GetDescriptor()->FindMethodByName("Foo");
+  //   Message* request  = stub->GetRequestPrototype (method)->New();
+  //   Message* response = stub->GetResponsePrototype(method)->New();
+  //   request->ParseFromString(input);
+  //   service->CallMethod(method, *request, response, callback);
+  virtual const Message& GetRequestPrototype(
+    const MethodDescriptor* method) const = 0;
+  virtual const Message& GetResponsePrototype(
+    const MethodDescriptor* method) const = 0;
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Service);
+};
+
+// An RpcController mediates a single method call.  The primary purpose of
+// the controller is to provide a way to manipulate settings specific to the
+// RPC implementation and to find out about RPC-level errors.
+//
+// The methods provided by the RpcController interface are intended to be a
+// "least common denominator" set of features which we expect all
+// implementations to support.  Specific implementations may provide more
+// advanced features (e.g. deadline propagation).
+class LIBPROTOBUF_EXPORT RpcController {
+ public:
+  inline RpcController() {}
+  virtual ~RpcController();
+
+  // Client-side methods ---------------------------------------------
+  // These calls may be made from the client side only.  Their results
+  // are undefined on the server side (may crash).
+
+  // Resets the RpcController to its initial state so that it may be reused in
+  // a new call.  Must not be called while an RPC is in progress.
+  virtual void Reset() = 0;
+
+  // After a call has finished, returns true if the call failed.  The possible
+  // reasons for failure depend on the RPC implementation.  Failed() must not
+  // be called before a call has finished.  If Failed() returns true, the
+  // contents of the response message are undefined.
+  virtual bool Failed() const = 0;
+
+  // If Failed() is true, returns a human-readable description of the error.
+  virtual string ErrorText() const = 0;
+
+  // Advises the RPC system that the caller desires that the RPC call be
+  // canceled.  The RPC system may cancel it immediately, may wait awhile and
+  // then cancel it, or may not even cancel the call at all.  If the call is
+  // canceled, the "done" callback will still be called and the RpcController
+  // will indicate that the call failed at that time.
+  virtual void StartCancel() = 0;
+
+  // Server-side methods ---------------------------------------------
+  // These calls may be made from the server side only.  Their results
+  // are undefined on the client side (may crash).
+
+  // Causes Failed() to return true on the client side.  "reason" will be
+  // incorporated into the message returned by ErrorText().  If you find
+  // you need to return machine-readable information about failures, you
+  // should incorporate it into your response protocol buffer and should
+  // NOT call SetFailed().
+  virtual void SetFailed(const string& reason) = 0;
+
+  // If true, indicates that the client canceled the RPC, so the server may
+  // as well give up on replying to it.  The server should still call the
+  // final "done" callback.
+  virtual bool IsCanceled() const = 0;
+
+  // Asks that the given callback be called when the RPC is canceled.  The
+  // callback will always be called exactly once.  If the RPC completes without
+  // being canceled, the callback will be called after completion.  If the RPC
+  // has already been canceled when NotifyOnCancel() is called, the callback
+  // will be called immediately.
+  //
+  // NotifyOnCancel() must be called no more than once per request.
+  virtual void NotifyOnCancel(Closure* callback) = 0;
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(RpcController);
+};
+
+// Abstract interface for an RPC channel.  An RpcChannel represents a
+// communication line to a Service which can be used to call that Service's
+// methods.  The Service may be running on another machine.  Normally, you
+// should not call an RpcChannel directly, but instead construct a stub Service
+// wrapping it.  Example:
+//   RpcChannel* channel = new MyRpcChannel("remotehost.example.com:1234");
+//   MyService* service = new MyService::Stub(channel);
+//   service->MyMethod(request, &response, callback);
+class LIBPROTOBUF_EXPORT RpcChannel {
+ public:
+  inline RpcChannel() {}
+  virtual ~RpcChannel();
+
+  // Call the given method of the remote service.  The signature of this
+  // procedure looks the same as Service::CallMethod(), but the requirements
+  // are less strict in one important way:  the request and response objects
+  // need not be of any specific class as long as their descriptors are
+  // method->input_type() and method->output_type().
+  virtual void CallMethod(const MethodDescriptor* method,
+                          RpcController* controller,
+                          const Message* request,
+                          Message* response,
+                          Closure* done) = 0;
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(RpcChannel);
+};
+
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_SERVICE_H__
diff --git a/kortex_api/include/google/protobuf/source_context.pb.h b/kortex_api/include/google/protobuf/source_context.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..dfa2444ccb6f4dcc6913f7b7d951ce4e9008f277
--- /dev/null
+++ b/kortex_api/include/google/protobuf/source_context.pb.h
@@ -0,0 +1,243 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: google/protobuf/source_context.proto
+
+#ifndef PROTOBUF_google_2fprotobuf_2fsource_5fcontext_2eproto__INCLUDED
+#define PROTOBUF_google_2fprotobuf_2fsource_5fcontext_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 3005000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 3005001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+// @@protoc_insertion_point(includes)
+
+namespace protobuf_google_2fprotobuf_2fsource_5fcontext_2eproto {
+// Internal implementation detail -- do not use these members.
+struct LIBPROTOBUF_EXPORT TableStruct {
+  static const ::google::protobuf::internal::ParseTableField entries[];
+  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
+  static const ::google::protobuf::internal::ParseTable schema[1];
+  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
+  static const ::google::protobuf::internal::SerializationTable serialization_table[];
+  static const ::google::protobuf::uint32 offsets[];
+};
+void LIBPROTOBUF_EXPORT AddDescriptors();
+void LIBPROTOBUF_EXPORT InitDefaultsSourceContextImpl();
+void LIBPROTOBUF_EXPORT InitDefaultsSourceContext();
+inline void LIBPROTOBUF_EXPORT InitDefaults() {
+  InitDefaultsSourceContext();
+}
+}  // namespace protobuf_google_2fprotobuf_2fsource_5fcontext_2eproto
+namespace google {
+namespace protobuf {
+class SourceContext;
+class SourceContextDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern SourceContextDefaultTypeInternal _SourceContext_default_instance_;
+}  // namespace protobuf
+}  // namespace google
+namespace google {
+namespace protobuf {
+
+// ===================================================================
+
+class LIBPROTOBUF_EXPORT SourceContext : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.SourceContext) */ {
+ public:
+  SourceContext();
+  virtual ~SourceContext();
+
+  SourceContext(const SourceContext& from);
+
+  inline SourceContext& operator=(const SourceContext& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  SourceContext(SourceContext&& from) noexcept
+    : SourceContext() {
+    *this = ::std::move(from);
+  }
+
+  inline SourceContext& operator=(SourceContext&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SourceContext& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const SourceContext* internal_default_instance() {
+    return reinterpret_cast<const SourceContext*>(
+               &_SourceContext_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    0;
+
+  void Swap(SourceContext* other);
+  friend void swap(SourceContext& a, SourceContext& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SourceContext* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  SourceContext* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const SourceContext& from);
+  void MergeFrom(const SourceContext& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(SourceContext* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // string file_name = 1;
+  void clear_file_name();
+  static const int kFileNameFieldNumber = 1;
+  const ::std::string& file_name() const;
+  void set_file_name(const ::std::string& value);
+  #if LANG_CXX11
+  void set_file_name(::std::string&& value);
+  #endif
+  void set_file_name(const char* value);
+  void set_file_name(const char* value, size_t size);
+  ::std::string* mutable_file_name();
+  ::std::string* release_file_name();
+  void set_allocated_file_name(::std::string* file_name);
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.SourceContext)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::internal::ArenaStringPtr file_name_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_google_2fprotobuf_2fsource_5fcontext_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2fsource_5fcontext_2eproto::InitDefaultsSourceContextImpl();
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// SourceContext
+
+// string file_name = 1;
+inline void SourceContext::clear_file_name() {
+  file_name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& SourceContext::file_name() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.SourceContext.file_name)
+  return file_name_.GetNoArena();
+}
+inline void SourceContext::set_file_name(const ::std::string& value) {
+  
+  file_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:google.protobuf.SourceContext.file_name)
+}
+#if LANG_CXX11
+inline void SourceContext::set_file_name(::std::string&& value) {
+  
+  file_name_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.SourceContext.file_name)
+}
+#endif
+inline void SourceContext::set_file_name(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  file_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:google.protobuf.SourceContext.file_name)
+}
+inline void SourceContext::set_file_name(const char* value, size_t size) {
+  
+  file_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.SourceContext.file_name)
+}
+inline ::std::string* SourceContext::mutable_file_name() {
+  
+  // @@protoc_insertion_point(field_mutable:google.protobuf.SourceContext.file_name)
+  return file_name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* SourceContext::release_file_name() {
+  // @@protoc_insertion_point(field_release:google.protobuf.SourceContext.file_name)
+  
+  return file_name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void SourceContext::set_allocated_file_name(::std::string* file_name) {
+  if (file_name != NULL) {
+    
+  } else {
+    
+  }
+  file_name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), file_name);
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.SourceContext.file_name)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace protobuf
+}  // namespace google
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_google_2fprotobuf_2fsource_5fcontext_2eproto__INCLUDED
diff --git a/kortex_api/include/google/protobuf/struct.pb.h b/kortex_api/include/google/protobuf/struct.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..cdc00dcd4784dea697f29250c34f6da02c9ce6db
--- /dev/null
+++ b/kortex_api/include/google/protobuf/struct.pb.h
@@ -0,0 +1,1030 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: google/protobuf/struct.proto
+
+#ifndef PROTOBUF_google_2fprotobuf_2fstruct_2eproto__INCLUDED
+#define PROTOBUF_google_2fprotobuf_2fstruct_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 3005000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 3005001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/map.h>  // IWYU pragma: export
+#include <google/protobuf/map_entry.h>
+#include <google/protobuf/map_field_inl.h>
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+// @@protoc_insertion_point(includes)
+
+namespace protobuf_google_2fprotobuf_2fstruct_2eproto {
+// Internal implementation detail -- do not use these members.
+struct LIBPROTOBUF_EXPORT TableStruct {
+  static const ::google::protobuf::internal::ParseTableField entries[];
+  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
+  static const ::google::protobuf::internal::ParseTable schema[4];
+  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
+  static const ::google::protobuf::internal::SerializationTable serialization_table[];
+  static const ::google::protobuf::uint32 offsets[];
+};
+void LIBPROTOBUF_EXPORT AddDescriptors();
+void LIBPROTOBUF_EXPORT InitDefaultsListValueImpl();
+void LIBPROTOBUF_EXPORT InitDefaultsListValue();
+inline void LIBPROTOBUF_EXPORT InitDefaults() {
+  InitDefaultsListValue();
+}
+}  // namespace protobuf_google_2fprotobuf_2fstruct_2eproto
+namespace google {
+namespace protobuf {
+class ListValue;
+class ListValueDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern ListValueDefaultTypeInternal _ListValue_default_instance_;
+class Struct;
+class StructDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern StructDefaultTypeInternal _Struct_default_instance_;
+class Struct_FieldsEntry_DoNotUse;
+class Struct_FieldsEntry_DoNotUseDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern Struct_FieldsEntry_DoNotUseDefaultTypeInternal _Struct_FieldsEntry_DoNotUse_default_instance_;
+class Value;
+class ValueDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern ValueDefaultTypeInternal _Value_default_instance_;
+}  // namespace protobuf
+}  // namespace google
+namespace google {
+namespace protobuf {
+
+enum NullValue {
+  NULL_VALUE = 0,
+  NullValue_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  NullValue_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+LIBPROTOBUF_EXPORT bool NullValue_IsValid(int value);
+const NullValue NullValue_MIN = NULL_VALUE;
+const NullValue NullValue_MAX = NULL_VALUE;
+const int NullValue_ARRAYSIZE = NullValue_MAX + 1;
+
+LIBPROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor* NullValue_descriptor();
+inline const ::std::string& NullValue_Name(NullValue value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    NullValue_descriptor(), value);
+}
+inline bool NullValue_Parse(
+    const ::std::string& name, NullValue* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<NullValue>(
+    NullValue_descriptor(), name, value);
+}
+// ===================================================================
+
+class Struct_FieldsEntry_DoNotUse : public ::google::protobuf::internal::MapEntry<Struct_FieldsEntry_DoNotUse, 
+    ::std::string, ::google::protobuf::Value,
+    ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
+    ::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE,
+    0 > {
+public:
+  typedef ::google::protobuf::internal::MapEntry<Struct_FieldsEntry_DoNotUse, 
+    ::std::string, ::google::protobuf::Value,
+    ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
+    ::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE,
+    0 > SuperType;
+  Struct_FieldsEntry_DoNotUse();
+  Struct_FieldsEntry_DoNotUse(::google::protobuf::Arena* arena);
+  void MergeFrom(const Struct_FieldsEntry_DoNotUse& other);
+  static const Struct_FieldsEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const Struct_FieldsEntry_DoNotUse*>(&_Struct_FieldsEntry_DoNotUse_default_instance_); }
+  void MergeFrom(const ::google::protobuf::Message& other) PROTOBUF_FINAL;
+  ::google::protobuf::Metadata GetMetadata() const;
+};
+
+// -------------------------------------------------------------------
+
+class LIBPROTOBUF_EXPORT Struct : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Struct) */ {
+ public:
+  Struct();
+  virtual ~Struct();
+
+  Struct(const Struct& from);
+
+  inline Struct& operator=(const Struct& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Struct(Struct&& from) noexcept
+    : Struct() {
+    *this = ::std::move(from);
+  }
+
+  inline Struct& operator=(Struct&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
+    return GetArenaNoVirtual();
+  }
+  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
+    return MaybeArenaPtr();
+  }
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Struct& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Struct* internal_default_instance() {
+    return reinterpret_cast<const Struct*>(
+               &_Struct_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    1;
+
+  void UnsafeArenaSwap(Struct* other);
+  void Swap(Struct* other);
+  friend void swap(Struct& a, Struct& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Struct* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Struct* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Struct& from);
+  void MergeFrom(const Struct& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Struct* other);
+  protected:
+  explicit Struct(::google::protobuf::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return _internal_metadata_.arena();
+  }
+  inline void* MaybeArenaPtr() const {
+    return _internal_metadata_.raw_arena_ptr();
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+
+  // accessors -------------------------------------------------------
+
+  // map<string, .google.protobuf.Value> fields = 1;
+  int fields_size() const;
+  void clear_fields();
+  static const int kFieldsFieldNumber = 1;
+  const ::google::protobuf::Map< ::std::string, ::google::protobuf::Value >&
+      fields() const;
+  ::google::protobuf::Map< ::std::string, ::google::protobuf::Value >*
+      mutable_fields();
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.Struct)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::google::protobuf::internal::MapField<
+      Struct_FieldsEntry_DoNotUse,
+      ::std::string, ::google::protobuf::Value,
+      ::google::protobuf::internal::WireFormatLite::TYPE_STRING,
+      ::google::protobuf::internal::WireFormatLite::TYPE_MESSAGE,
+      0 > fields_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_google_2fprotobuf_2fstruct_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2fstruct_2eproto::InitDefaultsListValueImpl();
+};
+// -------------------------------------------------------------------
+
+class LIBPROTOBUF_EXPORT Value : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Value) */ {
+ public:
+  Value();
+  virtual ~Value();
+
+  Value(const Value& from);
+
+  inline Value& operator=(const Value& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Value(Value&& from) noexcept
+    : Value() {
+    *this = ::std::move(from);
+  }
+
+  inline Value& operator=(Value&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
+    return GetArenaNoVirtual();
+  }
+  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
+    return MaybeArenaPtr();
+  }
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Value& default_instance();
+
+  enum KindCase {
+    kNullValue = 1,
+    kNumberValue = 2,
+    kStringValue = 3,
+    kBoolValue = 4,
+    kStructValue = 5,
+    kListValue = 6,
+    KIND_NOT_SET = 0,
+  };
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Value* internal_default_instance() {
+    return reinterpret_cast<const Value*>(
+               &_Value_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    2;
+
+  void UnsafeArenaSwap(Value* other);
+  void Swap(Value* other);
+  friend void swap(Value& a, Value& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Value* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Value* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Value& from);
+  void MergeFrom(const Value& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Value* other);
+  protected:
+  explicit Value(::google::protobuf::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return _internal_metadata_.arena();
+  }
+  inline void* MaybeArenaPtr() const {
+    return _internal_metadata_.raw_arena_ptr();
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .google.protobuf.NullValue null_value = 1;
+  private:
+  bool has_null_value() const;
+  public:
+  void clear_null_value();
+  static const int kNullValueFieldNumber = 1;
+  ::google::protobuf::NullValue null_value() const;
+  void set_null_value(::google::protobuf::NullValue value);
+
+  // double number_value = 2;
+  private:
+  bool has_number_value() const;
+  public:
+  void clear_number_value();
+  static const int kNumberValueFieldNumber = 2;
+  double number_value() const;
+  void set_number_value(double value);
+
+  // string string_value = 3;
+  private:
+  bool has_string_value() const;
+  public:
+  void clear_string_value();
+  static const int kStringValueFieldNumber = 3;
+  const ::std::string& string_value() const;
+  void set_string_value(const ::std::string& value);
+  #if LANG_CXX11
+  void set_string_value(::std::string&& value);
+  #endif
+  void set_string_value(const char* value);
+  void set_string_value(const char* value, size_t size);
+  ::std::string* mutable_string_value();
+  ::std::string* release_string_value();
+  void set_allocated_string_value(::std::string* string_value);
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  ::std::string* unsafe_arena_release_string_value();
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  void unsafe_arena_set_allocated_string_value(
+      ::std::string* string_value);
+
+  // bool bool_value = 4;
+  private:
+  bool has_bool_value() const;
+  public:
+  void clear_bool_value();
+  static const int kBoolValueFieldNumber = 4;
+  bool bool_value() const;
+  void set_bool_value(bool value);
+
+  // .google.protobuf.Struct struct_value = 5;
+  bool has_struct_value() const;
+  void clear_struct_value();
+  static const int kStructValueFieldNumber = 5;
+  private:
+  void _slow_mutable_struct_value();
+  public:
+  const ::google::protobuf::Struct& struct_value() const;
+  ::google::protobuf::Struct* release_struct_value();
+  ::google::protobuf::Struct* mutable_struct_value();
+  void set_allocated_struct_value(::google::protobuf::Struct* struct_value);
+  void unsafe_arena_set_allocated_struct_value(
+      ::google::protobuf::Struct* struct_value);
+  ::google::protobuf::Struct* unsafe_arena_release_struct_value();
+
+  // .google.protobuf.ListValue list_value = 6;
+  bool has_list_value() const;
+  void clear_list_value();
+  static const int kListValueFieldNumber = 6;
+  private:
+  void _slow_mutable_list_value();
+  public:
+  const ::google::protobuf::ListValue& list_value() const;
+  ::google::protobuf::ListValue* release_list_value();
+  ::google::protobuf::ListValue* mutable_list_value();
+  void set_allocated_list_value(::google::protobuf::ListValue* list_value);
+  void unsafe_arena_set_allocated_list_value(
+      ::google::protobuf::ListValue* list_value);
+  ::google::protobuf::ListValue* unsafe_arena_release_list_value();
+
+  KindCase kind_case() const;
+  // @@protoc_insertion_point(class_scope:google.protobuf.Value)
+ private:
+  void set_has_null_value();
+  void set_has_number_value();
+  void set_has_string_value();
+  void set_has_bool_value();
+  void set_has_struct_value();
+  void set_has_list_value();
+
+  inline bool has_kind() const;
+  void clear_kind();
+  inline void clear_has_kind();
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  union KindUnion {
+    KindUnion() {}
+    int null_value_;
+    double number_value_;
+    ::google::protobuf::internal::ArenaStringPtr string_value_;
+    bool bool_value_;
+    ::google::protobuf::Struct* struct_value_;
+    ::google::protobuf::ListValue* list_value_;
+  } kind_;
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _oneof_case_[1];
+
+  friend struct ::protobuf_google_2fprotobuf_2fstruct_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2fstruct_2eproto::InitDefaultsListValueImpl();
+};
+// -------------------------------------------------------------------
+
+class LIBPROTOBUF_EXPORT ListValue : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.ListValue) */ {
+ public:
+  ListValue();
+  virtual ~ListValue();
+
+  ListValue(const ListValue& from);
+
+  inline ListValue& operator=(const ListValue& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ListValue(ListValue&& from) noexcept
+    : ListValue() {
+    *this = ::std::move(from);
+  }
+
+  inline ListValue& operator=(ListValue&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
+    return GetArenaNoVirtual();
+  }
+  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
+    return MaybeArenaPtr();
+  }
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ListValue& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ListValue* internal_default_instance() {
+    return reinterpret_cast<const ListValue*>(
+               &_ListValue_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    3;
+
+  void UnsafeArenaSwap(ListValue* other);
+  void Swap(ListValue* other);
+  friend void swap(ListValue& a, ListValue& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ListValue* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ListValue* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ListValue& from);
+  void MergeFrom(const ListValue& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ListValue* other);
+  protected:
+  explicit ListValue(::google::protobuf::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return _internal_metadata_.arena();
+  }
+  inline void* MaybeArenaPtr() const {
+    return _internal_metadata_.raw_arena_ptr();
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .google.protobuf.Value values = 1;
+  int values_size() const;
+  void clear_values();
+  static const int kValuesFieldNumber = 1;
+  const ::google::protobuf::Value& values(int index) const;
+  ::google::protobuf::Value* mutable_values(int index);
+  ::google::protobuf::Value* add_values();
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::Value >*
+      mutable_values();
+  const ::google::protobuf::RepeatedPtrField< ::google::protobuf::Value >&
+      values() const;
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.ListValue)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::Value > values_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_google_2fprotobuf_2fstruct_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2fstruct_2eproto::InitDefaultsListValueImpl();
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// Struct
+
+// map<string, .google.protobuf.Value> fields = 1;
+inline int Struct::fields_size() const {
+  return fields_.size();
+}
+inline void Struct::clear_fields() {
+  fields_.Clear();
+}
+inline const ::google::protobuf::Map< ::std::string, ::google::protobuf::Value >&
+Struct::fields() const {
+  // @@protoc_insertion_point(field_map:google.protobuf.Struct.fields)
+  return fields_.GetMap();
+}
+inline ::google::protobuf::Map< ::std::string, ::google::protobuf::Value >*
+Struct::mutable_fields() {
+  // @@protoc_insertion_point(field_mutable_map:google.protobuf.Struct.fields)
+  return fields_.MutableMap();
+}
+
+// -------------------------------------------------------------------
+
+// Value
+
+// .google.protobuf.NullValue null_value = 1;
+inline bool Value::has_null_value() const {
+  return kind_case() == kNullValue;
+}
+inline void Value::set_has_null_value() {
+  _oneof_case_[0] = kNullValue;
+}
+inline void Value::clear_null_value() {
+  if (has_null_value()) {
+    kind_.null_value_ = 0;
+    clear_has_kind();
+  }
+}
+inline ::google::protobuf::NullValue Value::null_value() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Value.null_value)
+  if (has_null_value()) {
+    return static_cast< ::google::protobuf::NullValue >(kind_.null_value_);
+  }
+  return static_cast< ::google::protobuf::NullValue >(0);
+}
+inline void Value::set_null_value(::google::protobuf::NullValue value) {
+  if (!has_null_value()) {
+    clear_kind();
+    set_has_null_value();
+  }
+  kind_.null_value_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.Value.null_value)
+}
+
+// double number_value = 2;
+inline bool Value::has_number_value() const {
+  return kind_case() == kNumberValue;
+}
+inline void Value::set_has_number_value() {
+  _oneof_case_[0] = kNumberValue;
+}
+inline void Value::clear_number_value() {
+  if (has_number_value()) {
+    kind_.number_value_ = 0;
+    clear_has_kind();
+  }
+}
+inline double Value::number_value() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Value.number_value)
+  if (has_number_value()) {
+    return kind_.number_value_;
+  }
+  return 0;
+}
+inline void Value::set_number_value(double value) {
+  if (!has_number_value()) {
+    clear_kind();
+    set_has_number_value();
+  }
+  kind_.number_value_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.Value.number_value)
+}
+
+// string string_value = 3;
+inline bool Value::has_string_value() const {
+  return kind_case() == kStringValue;
+}
+inline void Value::set_has_string_value() {
+  _oneof_case_[0] = kStringValue;
+}
+inline void Value::clear_string_value() {
+  if (has_string_value()) {
+    kind_.string_value_.Destroy(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+        GetArenaNoVirtual());
+    clear_has_kind();
+  }
+}
+inline const ::std::string& Value::string_value() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Value.string_value)
+  if (has_string_value()) {
+    return kind_.string_value_.Get();
+  }
+  return *&::google::protobuf::internal::GetEmptyStringAlreadyInited();
+}
+inline void Value::set_string_value(const ::std::string& value) {
+  if (!has_string_value()) {
+    clear_kind();
+    set_has_string_value();
+    kind_.string_value_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  kind_.string_value_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value,
+      GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set:google.protobuf.Value.string_value)
+}
+#if LANG_CXX11
+inline void Value::set_string_value(::std::string&& value) {
+  // @@protoc_insertion_point(field_set:google.protobuf.Value.string_value)
+  if (!has_string_value()) {
+    clear_kind();
+    set_has_string_value();
+    kind_.string_value_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  kind_.string_value_.Set(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.Value.string_value)
+}
+#endif
+inline void Value::set_string_value(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  if (!has_string_value()) {
+    clear_kind();
+    set_has_string_value();
+    kind_.string_value_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  kind_.string_value_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(value), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_char:google.protobuf.Value.string_value)
+}
+inline void Value::set_string_value(const char* value,
+                             size_t size) {
+  if (!has_string_value()) {
+    clear_kind();
+    set_has_string_value();
+    kind_.string_value_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  kind_.string_value_.Set(
+      &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
+      reinterpret_cast<const char*>(value), size),
+      GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.Value.string_value)
+}
+inline ::std::string* Value::mutable_string_value() {
+  if (!has_string_value()) {
+    clear_kind();
+    set_has_string_value();
+    kind_.string_value_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  return kind_.string_value_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Value.string_value)
+}
+inline ::std::string* Value::release_string_value() {
+  // @@protoc_insertion_point(field_release:google.protobuf.Value.string_value)
+  if (has_string_value()) {
+    clear_has_kind();
+    return kind_.string_value_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+        GetArenaNoVirtual());
+  } else {
+    return NULL;
+  }
+}
+inline void Value::set_allocated_string_value(::std::string* string_value) {
+  if (!has_string_value()) {
+    kind_.string_value_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  clear_kind();
+  if (string_value != NULL) {
+    set_has_string_value();
+    kind_.string_value_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), string_value,
+        GetArenaNoVirtual());
+  }
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Value.string_value)
+}
+inline ::std::string* Value::unsafe_arena_release_string_value() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.Value.string_value)
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  if (has_string_value()) {
+    clear_has_kind();
+    return kind_.string_value_.UnsafeArenaRelease(
+        &::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+  } else {
+    return NULL;
+  }
+}
+inline void Value::unsafe_arena_set_allocated_string_value(::std::string* string_value) {
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  if (!has_string_value()) {
+    kind_.string_value_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+  }
+  clear_kind();
+  if (string_value) {
+    set_has_string_value();
+    kind_.string_value_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), string_value, GetArenaNoVirtual());
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.Value.string_value)
+}
+
+// bool bool_value = 4;
+inline bool Value::has_bool_value() const {
+  return kind_case() == kBoolValue;
+}
+inline void Value::set_has_bool_value() {
+  _oneof_case_[0] = kBoolValue;
+}
+inline void Value::clear_bool_value() {
+  if (has_bool_value()) {
+    kind_.bool_value_ = false;
+    clear_has_kind();
+  }
+}
+inline bool Value::bool_value() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Value.bool_value)
+  if (has_bool_value()) {
+    return kind_.bool_value_;
+  }
+  return false;
+}
+inline void Value::set_bool_value(bool value) {
+  if (!has_bool_value()) {
+    clear_kind();
+    set_has_bool_value();
+  }
+  kind_.bool_value_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.Value.bool_value)
+}
+
+// .google.protobuf.Struct struct_value = 5;
+inline bool Value::has_struct_value() const {
+  return kind_case() == kStructValue;
+}
+inline void Value::set_has_struct_value() {
+  _oneof_case_[0] = kStructValue;
+}
+inline void Value::clear_struct_value() {
+  if (has_struct_value()) {
+    if (GetArenaNoVirtual() == NULL) {
+      delete kind_.struct_value_;
+    }
+    clear_has_kind();
+  }
+}
+inline ::google::protobuf::Struct* Value::release_struct_value() {
+  // @@protoc_insertion_point(field_release:google.protobuf.Value.struct_value)
+  if (has_struct_value()) {
+    clear_has_kind();
+      ::google::protobuf::Struct* temp = kind_.struct_value_;
+    if (GetArenaNoVirtual() != NULL) {
+      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp, NULL);
+    }
+    kind_.struct_value_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline const ::google::protobuf::Struct& Value::struct_value() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Value.struct_value)
+  return has_struct_value()
+      ? *kind_.struct_value_
+      : *reinterpret_cast< ::google::protobuf::Struct*>(&::google::protobuf::_Struct_default_instance_);
+}
+inline ::google::protobuf::Struct* Value::unsafe_arena_release_struct_value() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.Value.struct_value)
+  if (has_struct_value()) {
+    clear_has_kind();
+    ::google::protobuf::Struct* temp = kind_.struct_value_;
+    kind_.struct_value_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline void Value::unsafe_arena_set_allocated_struct_value(::google::protobuf::Struct* struct_value) {
+  clear_kind();
+  if (struct_value) {
+    set_has_struct_value();
+    kind_.struct_value_ = struct_value;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.Value.struct_value)
+}
+inline ::google::protobuf::Struct* Value::mutable_struct_value() {
+  if (!has_struct_value()) {
+    clear_kind();
+    set_has_struct_value();
+    kind_.struct_value_ = 
+      ::google::protobuf::Arena::CreateMessage< ::google::protobuf::Struct >(
+      GetArenaNoVirtual());
+  }
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Value.struct_value)
+  return kind_.struct_value_;
+}
+
+// .google.protobuf.ListValue list_value = 6;
+inline bool Value::has_list_value() const {
+  return kind_case() == kListValue;
+}
+inline void Value::set_has_list_value() {
+  _oneof_case_[0] = kListValue;
+}
+inline void Value::clear_list_value() {
+  if (has_list_value()) {
+    if (GetArenaNoVirtual() == NULL) {
+      delete kind_.list_value_;
+    }
+    clear_has_kind();
+  }
+}
+inline ::google::protobuf::ListValue* Value::release_list_value() {
+  // @@protoc_insertion_point(field_release:google.protobuf.Value.list_value)
+  if (has_list_value()) {
+    clear_has_kind();
+      ::google::protobuf::ListValue* temp = kind_.list_value_;
+    if (GetArenaNoVirtual() != NULL) {
+      temp = ::google::protobuf::internal::DuplicateIfNonNull(temp, NULL);
+    }
+    kind_.list_value_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline const ::google::protobuf::ListValue& Value::list_value() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Value.list_value)
+  return has_list_value()
+      ? *kind_.list_value_
+      : *reinterpret_cast< ::google::protobuf::ListValue*>(&::google::protobuf::_ListValue_default_instance_);
+}
+inline ::google::protobuf::ListValue* Value::unsafe_arena_release_list_value() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.Value.list_value)
+  if (has_list_value()) {
+    clear_has_kind();
+    ::google::protobuf::ListValue* temp = kind_.list_value_;
+    kind_.list_value_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline void Value::unsafe_arena_set_allocated_list_value(::google::protobuf::ListValue* list_value) {
+  clear_kind();
+  if (list_value) {
+    set_has_list_value();
+    kind_.list_value_ = list_value;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.Value.list_value)
+}
+inline ::google::protobuf::ListValue* Value::mutable_list_value() {
+  if (!has_list_value()) {
+    clear_kind();
+    set_has_list_value();
+    kind_.list_value_ = 
+      ::google::protobuf::Arena::CreateMessage< ::google::protobuf::ListValue >(
+      GetArenaNoVirtual());
+  }
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Value.list_value)
+  return kind_.list_value_;
+}
+
+inline bool Value::has_kind() const {
+  return kind_case() != KIND_NOT_SET;
+}
+inline void Value::clear_has_kind() {
+  _oneof_case_[0] = KIND_NOT_SET;
+}
+inline Value::KindCase Value::kind_case() const {
+  return Value::KindCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// ListValue
+
+// repeated .google.protobuf.Value values = 1;
+inline int ListValue::values_size() const {
+  return values_.size();
+}
+inline void ListValue::clear_values() {
+  values_.Clear();
+}
+inline const ::google::protobuf::Value& ListValue::values(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.ListValue.values)
+  return values_.Get(index);
+}
+inline ::google::protobuf::Value* ListValue::mutable_values(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.ListValue.values)
+  return values_.Mutable(index);
+}
+inline ::google::protobuf::Value* ListValue::add_values() {
+  // @@protoc_insertion_point(field_add:google.protobuf.ListValue.values)
+  return values_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::Value >*
+ListValue::mutable_values() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.ListValue.values)
+  return &values_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::Value >&
+ListValue::values() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.ListValue.values)
+  return values_;
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace protobuf
+}  // namespace google
+
+namespace google {
+namespace protobuf {
+
+template <> struct is_proto_enum< ::google::protobuf::NullValue> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::google::protobuf::NullValue>() {
+  return ::google::protobuf::NullValue_descriptor();
+}
+
+}  // namespace protobuf
+}  // namespace google
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_google_2fprotobuf_2fstruct_2eproto__INCLUDED
diff --git a/kortex_api/include/google/protobuf/stubs/atomic_sequence_num.h b/kortex_api/include/google/protobuf/stubs/atomic_sequence_num.h
new file mode 100644
index 0000000000000000000000000000000000000000..bb20942f2f77041df602544a8e888341e46feb4b
--- /dev/null
+++ b/kortex_api/include/google/protobuf/stubs/atomic_sequence_num.h
@@ -0,0 +1,54 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2014 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#ifndef GOOGLE_PROTOBUF_ATOMIC_SEQUENCE_NUM_H_
+#define GOOGLE_PROTOBUF_ATOMIC_SEQUENCE_NUM_H_
+
+#include <google/protobuf/stubs/atomicops.h>
+
+namespace google {
+namespace protobuf {
+namespace internal {
+
+class SequenceNumber {
+ public:
+  SequenceNumber() : word_(0) {}
+
+  AtomicWord GetNext() {
+    return NoBarrier_AtomicIncrement(&word_, 1) - 1;
+  }
+ private:
+  AtomicWord word_;
+};
+
+}  // namespace internal
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_ATOMIC_SEQUENCE_NUM_H_
diff --git a/kortex_api/include/google/protobuf/stubs/atomicops.h b/kortex_api/include/google/protobuf/stubs/atomicops.h
new file mode 100644
index 0000000000000000000000000000000000000000..cb4553b1ee0db64cdb3db098149991e5dc5b6388
--- /dev/null
+++ b/kortex_api/include/google/protobuf/stubs/atomicops.h
@@ -0,0 +1,237 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2012 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// The routines exported by this module are subtle.  If you use them, even if
+// you get the code right, it will depend on careful reasoning about atomicity
+// and memory ordering; it will be less readable, and harder to maintain.  If
+// you plan to use these routines, you should have a good reason, such as solid
+// evidence that performance would otherwise suffer, or there being no
+// alternative.  You should assume only properties explicitly guaranteed by the
+// specifications in this file.  You are almost certainly _not_ writing code
+// just for the x86; if you assume x86 semantics, x86 hardware bugs and
+// implementations on other archtectures will cause your code to break.  If you
+// do not know what you are doing, avoid these routines, and use a Mutex.
+//
+// It is incorrect to make direct assignments to/from an atomic variable.
+// You should use one of the Load or Store routines.  The NoBarrier
+// versions are provided when no barriers are needed:
+//   NoBarrier_Store()
+//   NoBarrier_Load()
+// Although there are currently no compiler enforcement, you are encouraged
+// to use these.
+
+// This header and the implementations for each platform (located in
+// atomicops_internals_*) must be kept in sync with the upstream code (V8).
+
+#ifndef GOOGLE_PROTOBUF_ATOMICOPS_H_
+#define GOOGLE_PROTOBUF_ATOMICOPS_H_
+
+// Don't include this file for people not concerned about thread safety.
+#ifndef GOOGLE_PROTOBUF_NO_THREAD_SAFETY
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/platform_macros.h>
+
+namespace google {
+namespace protobuf {
+namespace internal {
+
+#ifdef GOOGLE_PROTOBUF_ARCH_32_BIT
+  typedef intptr_t Atomic32;
+  typedef int64 Atomic64;
+#else
+  // We need to be able to go between Atomic64 and AtomicWord implicitly.  This
+  // means Atomic64 and AtomicWord should be the same type on 64-bit.
+  #if defined(__ILP32__) || defined(GOOGLE_PROTOBUF_OS_NACL)
+  // NaCl's intptr_t is not actually 64-bits on 64-bit!
+  // http://code.google.com/p/nativeclient/issues/detail?id=1162
+  // sparcv9's pointer type is 32bits
+  typedef intptr_t Atomic32;
+  typedef int64 Atomic64;
+  #else
+  typedef int32 Atomic32;
+  typedef intptr_t Atomic64;
+  #endif
+#endif
+
+// Use AtomicWord for a machine-sized pointer.  It will use the Atomic32 or
+// Atomic64 routines below, depending on your architecture.
+typedef intptr_t AtomicWord;
+
+// Atomically execute:
+//      result = *ptr;
+//      if (*ptr == old_value)
+//        *ptr = new_value;
+//      return result;
+//
+// I.e., replace "*ptr" with "new_value" if "*ptr" used to be "old_value".
+// Always return the old value of "*ptr"
+//
+// This routine implies no memory barriers.
+Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr,
+                                  Atomic32 old_value,
+                                  Atomic32 new_value);
+
+// Atomically store new_value into *ptr, returning the previous value held in
+// *ptr.  This routine implies no memory barriers.
+Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr, Atomic32 new_value);
+
+// Atomically increment *ptr by "increment".  Returns the new value of
+// *ptr with the increment applied.  This routine implies no memory barriers.
+Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr, Atomic32 increment);
+
+Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr,
+                                 Atomic32 increment);
+
+// These following lower-level operations are typically useful only to people
+// implementing higher-level synchronization operations like spinlocks,
+// mutexes, and condition-variables.  They combine CompareAndSwap(), a load, or
+// a store with appropriate memory-ordering instructions.  "Acquire" operations
+// ensure that no later memory access can be reordered ahead of the operation.
+// "Release" operations ensure that no previous memory access can be reordered
+// after the operation.  "Barrier" operations have both "Acquire" and "Release"
+// semantics.   A MemoryBarrierInternal() has "Barrier" semantics, but does no
+// memory access.
+Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr,
+                                Atomic32 old_value,
+                                Atomic32 new_value);
+Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr,
+                                Atomic32 old_value,
+                                Atomic32 new_value);
+
+// This function was renamed from MemoryBarrier to MemoryBarrierInternal
+// because MemoryBarrier is a define in Windows ARM builds and we do not
+// undefine it because we call it from this function.
+void MemoryBarrierInternal();
+void NoBarrier_Store(volatile Atomic32* ptr, Atomic32 value);
+void Acquire_Store(volatile Atomic32* ptr, Atomic32 value);
+void Release_Store(volatile Atomic32* ptr, Atomic32 value);
+
+Atomic32 NoBarrier_Load(volatile const Atomic32* ptr);
+Atomic32 Acquire_Load(volatile const Atomic32* ptr);
+Atomic32 Release_Load(volatile const Atomic32* ptr);
+
+// 64-bit atomic operations (only available on 64-bit processors).
+#ifdef GOOGLE_PROTOBUF_ARCH_64_BIT
+Atomic64 NoBarrier_CompareAndSwap(volatile Atomic64* ptr,
+                                  Atomic64 old_value,
+                                  Atomic64 new_value);
+Atomic64 NoBarrier_AtomicExchange(volatile Atomic64* ptr, Atomic64 new_value);
+Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64* ptr, Atomic64 increment);
+Atomic64 Barrier_AtomicIncrement(volatile Atomic64* ptr, Atomic64 increment);
+
+Atomic64 Acquire_CompareAndSwap(volatile Atomic64* ptr,
+                                Atomic64 old_value,
+                                Atomic64 new_value);
+Atomic64 Release_CompareAndSwap(volatile Atomic64* ptr,
+                                Atomic64 old_value,
+                                Atomic64 new_value);
+void NoBarrier_Store(volatile Atomic64* ptr, Atomic64 value);
+void Acquire_Store(volatile Atomic64* ptr, Atomic64 value);
+void Release_Store(volatile Atomic64* ptr, Atomic64 value);
+Atomic64 NoBarrier_Load(volatile const Atomic64* ptr);
+Atomic64 Acquire_Load(volatile const Atomic64* ptr);
+Atomic64 Release_Load(volatile const Atomic64* ptr);
+#endif  // GOOGLE_PROTOBUF_ARCH_64_BIT
+
+}  // namespace internal
+}  // namespace protobuf
+}  // namespace google
+
+// Include our platform specific implementation.
+#define GOOGLE_PROTOBUF_ATOMICOPS_ERROR \
+"Atomic operations are not supported on your platform"
+
+// ThreadSanitizer, http://clang.llvm.org/docs/ThreadSanitizer.html.
+#if defined(THREAD_SANITIZER)
+#include <google/protobuf/stubs/atomicops_internals_tsan.h>
+// MSVC.
+#elif defined(_MSC_VER)
+#if defined(GOOGLE_PROTOBUF_ARCH_IA32) || defined(GOOGLE_PROTOBUF_ARCH_X64) || defined(GOOGLE_PROTOBUF_ARCH_ARM)
+#include <google/protobuf/stubs/atomicops_internals_x86_msvc.h>
+#else
+#error GOOGLE_PROTOBUF_ATOMICOPS_ERROR
+#endif
+
+// Solaris
+#elif defined(GOOGLE_PROTOBUF_OS_SOLARIS)
+#include <google/protobuf/stubs/atomicops_internals_solaris.h>
+
+// AIX
+#elif defined(GOOGLE_PROTOBUF_OS_AIX)
+#include <google/protobuf/stubs/atomicops_internals_power.h>
+
+// GCC.
+#elif defined(__GNUC__)
+#if defined(GOOGLE_PROTOBUF_ARCH_IA32) || defined(GOOGLE_PROTOBUF_ARCH_X64)
+#include <google/protobuf/stubs/atomicops_internals_x86_gcc.h>
+#elif defined(GOOGLE_PROTOBUF_ARCH_ARM) && defined(__linux__)
+#if (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4))
+#include <google/protobuf/stubs/atomicops_internals_generic_gcc.h>
+#else
+#include <google/protobuf/stubs/atomicops_internals_arm_gcc.h>
+#endif
+#elif defined(GOOGLE_PROTOBUF_ARCH_AARCH64)
+#include <google/protobuf/stubs/atomicops_internals_arm64_gcc.h>
+#elif defined(GOOGLE_PROTOBUF_ARCH_ARM_QNX)
+#include <google/protobuf/stubs/atomicops_internals_arm_qnx.h>
+#elif defined(GOOGLE_PROTOBUF_ARCH_MIPS) || defined(GOOGLE_PROTOBUF_ARCH_MIPS64)
+#include <google/protobuf/stubs/atomicops_internals_mips_gcc.h>
+#elif defined(GOOGLE_PROTOBUF_ARCH_POWER)
+#include <google/protobuf/stubs/atomicops_internals_power.h>
+#elif defined(__native_client__)
+// The static_asserts in the C++11 atomics implementation cause it to fail
+// with certain compilers, e.g. nvcc on macOS. Don't use elsewhere unless
+// the TODO in that file is addressed.
+#include <google/protobuf/stubs/atomicops_internals_generic_c11_atomic.h>
+#elif defined(GOOGLE_PROTOBUF_ARCH_PPC)
+#include <google/protobuf/stubs/atomicops_internals_ppc_gcc.h>
+#elif (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4))
+#include <google/protobuf/stubs/atomicops_internals_generic_gcc.h>
+#elif defined(__clang__)
+#if __has_extension(c_atomic)
+#include <google/protobuf/stubs/atomicops_internals_generic_gcc.h>
+#else
+#error GOOGLE_PROTOBUF_ATOMICOPS_ERROR
+#endif
+#else
+#error GOOGLE_PROTOBUF_ATOMICOPS_ERROR
+#endif
+
+// Unknown.
+#else
+#error GOOGLE_PROTOBUF_ATOMICOPS_ERROR
+#endif
+
+#undef GOOGLE_PROTOBUF_ATOMICOPS_ERROR
+
+#endif  // GOOGLE_PROTOBUF_NO_THREAD_SAFETY
+
+#endif  // GOOGLE_PROTOBUF_ATOMICOPS_H_
diff --git a/kortex_api/include/google/protobuf/stubs/atomicops_internals_arm64_gcc.h b/kortex_api/include/google/protobuf/stubs/atomicops_internals_arm64_gcc.h
new file mode 100644
index 0000000000000000000000000000000000000000..9a69d21ad68d54f304cdb8a0d828750be192b6ba
--- /dev/null
+++ b/kortex_api/include/google/protobuf/stubs/atomicops_internals_arm64_gcc.h
@@ -0,0 +1,325 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2012 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// This file is an internal atomic implementation, use atomicops.h instead.
+
+#ifndef GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_ARM64_GCC_H_
+#define GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_ARM64_GCC_H_
+
+namespace google {
+namespace protobuf {
+namespace internal {
+
+inline void MemoryBarrierInternal() {
+  __asm__ __volatile__ ("dmb ish" ::: "memory");  // NOLINT
+}
+
+// NoBarrier versions of the operation include "memory" in the clobber list.
+// This is not required for direct usage of the NoBarrier versions of the
+// operations. However this is required for correctness when they are used as
+// part of the Acquire or Release versions, to ensure that nothing from outside
+// the call is reordered between the operation and the memory barrier. This does
+// not change the code generated, so has no or minimal impact on the
+// NoBarrier operations.
+
+inline Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr,
+                                         Atomic32 old_value,
+                                         Atomic32 new_value) {
+  Atomic32 prev;
+  int32_t temp;
+
+  __asm__ __volatile__ (  // NOLINT
+    "0:                                    \n\t"
+    "ldxr %w[prev], %[ptr]                 \n\t"  // Load the previous value.
+    "cmp %w[prev], %w[old_value]           \n\t"
+    "bne 1f                                \n\t"
+    "stxr %w[temp], %w[new_value], %[ptr]  \n\t"  // Try to store the new value.
+    "cbnz %w[temp], 0b                     \n\t"  // Retry if it did not work.
+    "1:                                    \n\t"
+    : [prev]"=&r" (prev),
+      [temp]"=&r" (temp),
+      [ptr]"+Q" (*ptr)
+    : [old_value]"IJr" (old_value),
+      [new_value]"r" (new_value)
+    : "cc", "memory"
+  );  // NOLINT
+
+  return prev;
+}
+
+inline Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr,
+                                         Atomic32 new_value) {
+  Atomic32 result;
+  int32_t temp;
+
+  __asm__ __volatile__ (  // NOLINT
+    "0:                                    \n\t"
+    "ldxr %w[result], %[ptr]               \n\t"  // Load the previous value.
+    "stxr %w[temp], %w[new_value], %[ptr]  \n\t"  // Try to store the new value.
+    "cbnz %w[temp], 0b                     \n\t"  // Retry if it did not work.
+    : [result]"=&r" (result),
+      [temp]"=&r" (temp),
+      [ptr]"+Q" (*ptr)
+    : [new_value]"r" (new_value)
+    : "memory"
+  );  // NOLINT
+
+  return result;
+}
+
+inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr,
+                                          Atomic32 increment) {
+  Atomic32 result;
+  int32_t temp;
+
+  __asm__ __volatile__ (  // NOLINT
+    "0:                                       \n\t"
+    "ldxr %w[result], %[ptr]                  \n\t"  // Load the previous value.
+    "add %w[result], %w[result], %w[increment]\n\t"
+    "stxr %w[temp], %w[result], %[ptr]        \n\t"  // Try to store the result.
+    "cbnz %w[temp], 0b                        \n\t"  // Retry on failure.
+    : [result]"=&r" (result),
+      [temp]"=&r" (temp),
+      [ptr]"+Q" (*ptr)
+    : [increment]"IJr" (increment)
+    : "memory"
+  );  // NOLINT
+
+  return result;
+}
+
+inline Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr,
+                                        Atomic32 increment) {
+  MemoryBarrierInternal();
+  Atomic32 result = NoBarrier_AtomicIncrement(ptr, increment);
+  MemoryBarrierInternal();
+
+  return result;
+}
+
+inline Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr,
+                                       Atomic32 old_value,
+                                       Atomic32 new_value) {
+  Atomic32 prev = NoBarrier_CompareAndSwap(ptr, old_value, new_value);
+  MemoryBarrierInternal();
+
+  return prev;
+}
+
+inline Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr,
+                                       Atomic32 old_value,
+                                       Atomic32 new_value) {
+  MemoryBarrierInternal();
+  Atomic32 prev = NoBarrier_CompareAndSwap(ptr, old_value, new_value);
+
+  return prev;
+}
+
+inline void NoBarrier_Store(volatile Atomic32* ptr, Atomic32 value) {
+  *ptr = value;
+}
+
+inline void Acquire_Store(volatile Atomic32* ptr, Atomic32 value) {
+  *ptr = value;
+  MemoryBarrierInternal();
+}
+
+inline void Release_Store(volatile Atomic32* ptr, Atomic32 value) {
+  __asm__ __volatile__ (  // NOLINT
+    "stlr %w[value], %[ptr]  \n\t"
+    : [ptr]"=Q" (*ptr)
+    : [value]"r" (value)
+    : "memory"
+  );  // NOLINT
+}
+
+inline Atomic32 NoBarrier_Load(volatile const Atomic32* ptr) {
+  return *ptr;
+}
+
+inline Atomic32 Acquire_Load(volatile const Atomic32* ptr) {
+  Atomic32 value;
+
+  __asm__ __volatile__ (  // NOLINT
+    "ldar %w[value], %[ptr]  \n\t"
+    : [value]"=r" (value)
+    : [ptr]"Q" (*ptr)
+    : "memory"
+  );  // NOLINT
+
+  return value;
+}
+
+inline Atomic32 Release_Load(volatile const Atomic32* ptr) {
+  MemoryBarrierInternal();
+  return *ptr;
+}
+
+// 64-bit versions of the operations.
+// See the 32-bit versions for comments.
+
+inline Atomic64 NoBarrier_CompareAndSwap(volatile Atomic64* ptr,
+                                         Atomic64 old_value,
+                                         Atomic64 new_value) {
+  Atomic64 prev;
+  int32_t temp;
+
+  __asm__ __volatile__ (  // NOLINT
+    "0:                                    \n\t"
+    "ldxr %[prev], %[ptr]                  \n\t"
+    "cmp %[prev], %[old_value]             \n\t"
+    "bne 1f                                \n\t"
+    "stxr %w[temp], %[new_value], %[ptr]   \n\t"
+    "cbnz %w[temp], 0b                     \n\t"
+    "1:                                    \n\t"
+    : [prev]"=&r" (prev),
+      [temp]"=&r" (temp),
+      [ptr]"+Q" (*ptr)
+    : [old_value]"IJr" (old_value),
+      [new_value]"r" (new_value)
+    : "cc", "memory"
+  );  // NOLINT
+
+  return prev;
+}
+
+inline Atomic64 NoBarrier_AtomicExchange(volatile Atomic64* ptr,
+                                         Atomic64 new_value) {
+  Atomic64 result;
+  int32_t temp;
+
+  __asm__ __volatile__ (  // NOLINT
+    "0:                                    \n\t"
+    "ldxr %[result], %[ptr]                \n\t"
+    "stxr %w[temp], %[new_value], %[ptr]   \n\t"
+    "cbnz %w[temp], 0b                     \n\t"
+    : [result]"=&r" (result),
+      [temp]"=&r" (temp),
+      [ptr]"+Q" (*ptr)
+    : [new_value]"r" (new_value)
+    : "memory"
+  );  // NOLINT
+
+  return result;
+}
+
+inline Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64* ptr,
+                                          Atomic64 increment) {
+  Atomic64 result;
+  int32_t temp;
+
+  __asm__ __volatile__ (  // NOLINT
+    "0:                                     \n\t"
+    "ldxr %[result], %[ptr]                 \n\t"
+    "add %[result], %[result], %[increment] \n\t"
+    "stxr %w[temp], %[result], %[ptr]       \n\t"
+    "cbnz %w[temp], 0b                      \n\t"
+    : [result]"=&r" (result),
+      [temp]"=&r" (temp),
+      [ptr]"+Q" (*ptr)
+    : [increment]"IJr" (increment)
+    : "memory"
+  );  // NOLINT
+
+  return result;
+}
+
+inline Atomic64 Barrier_AtomicIncrement(volatile Atomic64* ptr,
+                                        Atomic64 increment) {
+  MemoryBarrierInternal();
+  Atomic64 result = NoBarrier_AtomicIncrement(ptr, increment);
+  MemoryBarrierInternal();
+
+  return result;
+}
+
+inline Atomic64 Acquire_CompareAndSwap(volatile Atomic64* ptr,
+                                       Atomic64 old_value,
+                                       Atomic64 new_value) {
+  Atomic64 prev = NoBarrier_CompareAndSwap(ptr, old_value, new_value);
+  MemoryBarrierInternal();
+
+  return prev;
+}
+
+inline Atomic64 Release_CompareAndSwap(volatile Atomic64* ptr,
+                                       Atomic64 old_value,
+                                       Atomic64 new_value) {
+  MemoryBarrierInternal();
+  Atomic64 prev = NoBarrier_CompareAndSwap(ptr, old_value, new_value);
+
+  return prev;
+}
+
+inline void NoBarrier_Store(volatile Atomic64* ptr, Atomic64 value) {
+  *ptr = value;
+}
+
+inline void Acquire_Store(volatile Atomic64* ptr, Atomic64 value) {
+  *ptr = value;
+  MemoryBarrierInternal();
+}
+
+inline void Release_Store(volatile Atomic64* ptr, Atomic64 value) {
+  __asm__ __volatile__ (  // NOLINT
+    "stlr %x[value], %[ptr]  \n\t"
+    : [ptr]"=Q" (*ptr)
+    : [value]"r" (value)
+    : "memory"
+  );  // NOLINT
+}
+
+inline Atomic64 NoBarrier_Load(volatile const Atomic64* ptr) {
+  return *ptr;
+}
+
+inline Atomic64 Acquire_Load(volatile const Atomic64* ptr) {
+  Atomic64 value;
+
+  __asm__ __volatile__ (  // NOLINT
+    "ldar %x[value], %[ptr]  \n\t"
+    : [value]"=r" (value)
+    : [ptr]"Q" (*ptr)
+    : "memory"
+  );  // NOLINT
+
+  return value;
+}
+
+inline Atomic64 Release_Load(volatile const Atomic64* ptr) {
+  MemoryBarrierInternal();
+  return *ptr;
+}
+
+}  // namespace internal
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_ARM64_GCC_H_
diff --git a/kortex_api/include/google/protobuf/stubs/atomicops_internals_arm_gcc.h b/kortex_api/include/google/protobuf/stubs/atomicops_internals_arm_gcc.h
new file mode 100644
index 0000000000000000000000000000000000000000..6e2de67fa5a114b3483b216396cee93dc3fd11d4
--- /dev/null
+++ b/kortex_api/include/google/protobuf/stubs/atomicops_internals_arm_gcc.h
@@ -0,0 +1,151 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2012 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// This file is an internal atomic implementation, use atomicops.h instead.
+//
+// LinuxKernelCmpxchg and Barrier_AtomicIncrement are from Google Gears.
+
+#ifndef GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_ARM_GCC_H_
+#define GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_ARM_GCC_H_
+
+namespace google {
+namespace protobuf {
+namespace internal {
+
+// 0xffff0fc0 is the hard coded address of a function provided by
+// the kernel which implements an atomic compare-exchange. On older
+// ARM architecture revisions (pre-v6) this may be implemented using
+// a syscall. This address is stable, and in active use (hard coded)
+// by at least glibc-2.7 and the Android C library.
+typedef Atomic32 (*LinuxKernelCmpxchgFunc)(Atomic32 old_value,
+                                           Atomic32 new_value,
+                                           volatile Atomic32* ptr);
+LinuxKernelCmpxchgFunc pLinuxKernelCmpxchg __attribute__((weak)) =
+    (LinuxKernelCmpxchgFunc) 0xffff0fc0;
+
+typedef void (*LinuxKernelMemoryBarrierFunc)(void);
+LinuxKernelMemoryBarrierFunc pLinuxKernelMemoryBarrier __attribute__((weak)) =
+    (LinuxKernelMemoryBarrierFunc) 0xffff0fa0;
+
+
+inline Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr,
+                                         Atomic32 old_value,
+                                         Atomic32 new_value) {
+  Atomic32 prev_value = *ptr;
+  do {
+    if (!pLinuxKernelCmpxchg(old_value, new_value,
+                             const_cast<Atomic32*>(ptr))) {
+      return old_value;
+    }
+    prev_value = *ptr;
+  } while (prev_value == old_value);
+  return prev_value;
+}
+
+inline Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr,
+                                         Atomic32 new_value) {
+  Atomic32 old_value;
+  do {
+    old_value = *ptr;
+  } while (pLinuxKernelCmpxchg(old_value, new_value,
+                               const_cast<Atomic32*>(ptr)));
+  return old_value;
+}
+
+inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr,
+                                          Atomic32 increment) {
+  return Barrier_AtomicIncrement(ptr, increment);
+}
+
+inline Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr,
+                                        Atomic32 increment) {
+  for (;;) {
+    // Atomic exchange the old value with an incremented one.
+    Atomic32 old_value = *ptr;
+    Atomic32 new_value = old_value + increment;
+    if (pLinuxKernelCmpxchg(old_value, new_value,
+                            const_cast<Atomic32*>(ptr)) == 0) {
+      // The exchange took place as expected.
+      return new_value;
+    }
+    // Otherwise, *ptr changed mid-loop and we need to retry.
+  }
+}
+
+inline Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr,
+                                       Atomic32 old_value,
+                                       Atomic32 new_value) {
+  return NoBarrier_CompareAndSwap(ptr, old_value, new_value);
+}
+
+inline Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr,
+                                       Atomic32 old_value,
+                                       Atomic32 new_value) {
+  return NoBarrier_CompareAndSwap(ptr, old_value, new_value);
+}
+
+inline void NoBarrier_Store(volatile Atomic32* ptr, Atomic32 value) {
+  *ptr = value;
+}
+
+inline void MemoryBarrierInternal() {
+  pLinuxKernelMemoryBarrier();
+}
+
+inline void Acquire_Store(volatile Atomic32* ptr, Atomic32 value) {
+  *ptr = value;
+  MemoryBarrierInternal();
+}
+
+inline void Release_Store(volatile Atomic32* ptr, Atomic32 value) {
+  MemoryBarrierInternal();
+  *ptr = value;
+}
+
+inline Atomic32 NoBarrier_Load(volatile const Atomic32* ptr) {
+  return *ptr;
+}
+
+inline Atomic32 Acquire_Load(volatile const Atomic32* ptr) {
+  Atomic32 value = *ptr;
+  MemoryBarrierInternal();
+  return value;
+}
+
+inline Atomic32 Release_Load(volatile const Atomic32* ptr) {
+  MemoryBarrierInternal();
+  return *ptr;
+}
+
+}  // namespace internal
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_ARM_GCC_H_
diff --git a/kortex_api/include/google/protobuf/stubs/atomicops_internals_arm_qnx.h b/kortex_api/include/google/protobuf/stubs/atomicops_internals_arm_qnx.h
new file mode 100644
index 0000000000000000000000000000000000000000..cd97e0c994281cdfd73c2e173a46cab371e3728a
--- /dev/null
+++ b/kortex_api/include/google/protobuf/stubs/atomicops_internals_arm_qnx.h
@@ -0,0 +1,146 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2012 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// This file is an internal atomic implementation, use atomicops.h instead.
+
+#ifndef GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_ARM_QNX_H_
+#define GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_ARM_QNX_H_
+
+// For _smp_cmpxchg()
+#include <pthread.h>
+
+namespace google {
+namespace protobuf {
+namespace internal {
+
+inline Atomic32 QNXCmpxchg(Atomic32 old_value,
+                           Atomic32 new_value,
+                           volatile Atomic32* ptr) {
+  return static_cast<Atomic32>(
+      _smp_cmpxchg((volatile unsigned *)ptr,
+                   (unsigned)old_value,
+                   (unsigned)new_value));
+}
+
+
+inline Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr,
+                                         Atomic32 old_value,
+                                         Atomic32 new_value) {
+  Atomic32 prev_value = *ptr;
+  do {
+    if (!QNXCmpxchg(old_value, new_value,
+                    const_cast<Atomic32*>(ptr))) {
+      return old_value;
+    }
+    prev_value = *ptr;
+  } while (prev_value == old_value);
+  return prev_value;
+}
+
+inline Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr,
+                                         Atomic32 new_value) {
+  Atomic32 old_value;
+  do {
+    old_value = *ptr;
+  } while (QNXCmpxchg(old_value, new_value,
+                      const_cast<Atomic32*>(ptr)));
+  return old_value;
+}
+
+inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr,
+                                          Atomic32 increment) {
+  return Barrier_AtomicIncrement(ptr, increment);
+}
+
+inline Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr,
+                                        Atomic32 increment) {
+  for (;;) {
+    // Atomic exchange the old value with an incremented one.
+    Atomic32 old_value = *ptr;
+    Atomic32 new_value = old_value + increment;
+    if (QNXCmpxchg(old_value, new_value,
+                   const_cast<Atomic32*>(ptr)) == 0) {
+      // The exchange took place as expected.
+      return new_value;
+    }
+    // Otherwise, *ptr changed mid-loop and we need to retry.
+  }
+}
+
+inline Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr,
+                                       Atomic32 old_value,
+                                       Atomic32 new_value) {
+  return NoBarrier_CompareAndSwap(ptr, old_value, new_value);
+}
+
+inline Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr,
+                                       Atomic32 old_value,
+                                       Atomic32 new_value) {
+  return NoBarrier_CompareAndSwap(ptr, old_value, new_value);
+}
+
+inline void NoBarrier_Store(volatile Atomic32* ptr, Atomic32 value) {
+  *ptr = value;
+}
+
+inline void MemoryBarrierInternal() {
+  __sync_synchronize();
+}
+
+inline void Acquire_Store(volatile Atomic32* ptr, Atomic32 value) {
+  *ptr = value;
+  MemoryBarrierInternal();
+}
+
+inline void Release_Store(volatile Atomic32* ptr, Atomic32 value) {
+  MemoryBarrierInternal();
+  *ptr = value;
+}
+
+inline Atomic32 NoBarrier_Load(volatile const Atomic32* ptr) {
+  return *ptr;
+}
+
+inline Atomic32 Acquire_Load(volatile const Atomic32* ptr) {
+  Atomic32 value = *ptr;
+  MemoryBarrierInternal();
+  return value;
+}
+
+inline Atomic32 Release_Load(volatile const Atomic32* ptr) {
+  MemoryBarrierInternal();
+  return *ptr;
+}
+
+}  // namespace internal
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_ARM_QNX_H_
diff --git a/kortex_api/include/google/protobuf/stubs/atomicops_internals_generic_c11_atomic.h b/kortex_api/include/google/protobuf/stubs/atomicops_internals_generic_c11_atomic.h
new file mode 100644
index 0000000000000000000000000000000000000000..44ef9c9e03512c34a5ae237ef78481bb43d20501
--- /dev/null
+++ b/kortex_api/include/google/protobuf/stubs/atomicops_internals_generic_c11_atomic.h
@@ -0,0 +1,231 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2012 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// This file is an internal atomic implementation, use atomicops.h instead.
+
+#ifndef GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_GENERIC_C11_ATOMIC_H_
+#define GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_GENERIC_C11_ATOMIC_H_
+
+#include <atomic>
+
+namespace google {
+namespace protobuf {
+namespace internal {
+
+// This implementation is transitional and maintains the original API for
+// atomicops.h. This requires casting memory locations to the atomic types, and
+// assumes that the API and the C++11 implementation are layout-compatible,
+// which isn't true for all implementations or hardware platforms. The static
+// assertion should detect this issue, were it to fire then this header
+// shouldn't be used.
+//
+// TODO(jfb) If this header manages to stay committed then the API should be
+//           modified, and all call sites updated.
+typedef volatile std::atomic<Atomic32>* AtomicLocation32;
+static_assert(sizeof(*(AtomicLocation32) nullptr) == sizeof(Atomic32),
+              "incompatible 32-bit atomic layout");
+
+inline void MemoryBarrierInternal() {
+#if defined(__GLIBCXX__)
+  // Work around libstdc++ bug 51038 where atomic_thread_fence was declared but
+  // not defined, leading to the linker complaining about undefined references.
+  __atomic_thread_fence(std::memory_order_seq_cst);
+#else
+  std::atomic_thread_fence(std::memory_order_seq_cst);
+#endif
+}
+
+inline Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr,
+                                         Atomic32 old_value,
+                                         Atomic32 new_value) {
+  ((AtomicLocation32)ptr)
+      ->compare_exchange_strong(old_value,
+                                new_value,
+                                std::memory_order_relaxed,
+                                std::memory_order_relaxed);
+  return old_value;
+}
+
+inline Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr,
+                                         Atomic32 new_value) {
+  return ((AtomicLocation32)ptr)
+      ->exchange(new_value, std::memory_order_relaxed);
+}
+
+inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr,
+                                          Atomic32 increment) {
+  return increment +
+         ((AtomicLocation32)ptr)
+             ->fetch_add(increment, std::memory_order_relaxed);
+}
+
+inline Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr,
+                                        Atomic32 increment) {
+  return increment + ((AtomicLocation32)ptr)->fetch_add(increment);
+}
+
+inline Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr,
+                                       Atomic32 old_value,
+                                       Atomic32 new_value) {
+  ((AtomicLocation32)ptr)
+      ->compare_exchange_strong(old_value,
+                                new_value,
+                                std::memory_order_acquire,
+                                std::memory_order_acquire);
+  return old_value;
+}
+
+inline Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr,
+                                       Atomic32 old_value,
+                                       Atomic32 new_value) {
+  ((AtomicLocation32)ptr)
+      ->compare_exchange_strong(old_value,
+                                new_value,
+                                std::memory_order_release,
+                                std::memory_order_relaxed);
+  return old_value;
+}
+
+inline void NoBarrier_Store(volatile Atomic32* ptr, Atomic32 value) {
+  ((AtomicLocation32)ptr)->store(value, std::memory_order_relaxed);
+}
+
+inline void Acquire_Store(volatile Atomic32* ptr, Atomic32 value) {
+  ((AtomicLocation32)ptr)->store(value, std::memory_order_relaxed);
+  MemoryBarrierInternal();
+}
+
+inline void Release_Store(volatile Atomic32* ptr, Atomic32 value) {
+  ((AtomicLocation32)ptr)->store(value, std::memory_order_release);
+}
+
+inline Atomic32 NoBarrier_Load(volatile const Atomic32* ptr) {
+  return ((AtomicLocation32)ptr)->load(std::memory_order_relaxed);
+}
+
+inline Atomic32 Acquire_Load(volatile const Atomic32* ptr) {
+  return ((AtomicLocation32)ptr)->load(std::memory_order_acquire);
+}
+
+inline Atomic32 Release_Load(volatile const Atomic32* ptr) {
+  MemoryBarrierInternal();
+  return ((AtomicLocation32)ptr)->load(std::memory_order_relaxed);
+}
+
+#if defined(GOOGLE_PROTOBUF_ARCH_64_BIT)
+
+typedef volatile std::atomic<Atomic64>* AtomicLocation64;
+static_assert(sizeof(*(AtomicLocation64) nullptr) == sizeof(Atomic64),
+              "incompatible 64-bit atomic layout");
+
+inline Atomic64 NoBarrier_CompareAndSwap(volatile Atomic64* ptr,
+                                         Atomic64 old_value,
+                                         Atomic64 new_value) {
+  ((AtomicLocation64)ptr)
+      ->compare_exchange_strong(old_value,
+                                new_value,
+                                std::memory_order_relaxed,
+                                std::memory_order_relaxed);
+  return old_value;
+}
+
+inline Atomic64 NoBarrier_AtomicExchange(volatile Atomic64* ptr,
+                                         Atomic64 new_value) {
+  return ((AtomicLocation64)ptr)
+      ->exchange(new_value, std::memory_order_relaxed);
+}
+
+inline Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64* ptr,
+                                          Atomic64 increment) {
+  return increment +
+         ((AtomicLocation64)ptr)
+             ->fetch_add(increment, std::memory_order_relaxed);
+}
+
+inline Atomic64 Barrier_AtomicIncrement(volatile Atomic64* ptr,
+                                        Atomic64 increment) {
+  return increment + ((AtomicLocation64)ptr)->fetch_add(increment);
+}
+
+inline Atomic64 Acquire_CompareAndSwap(volatile Atomic64* ptr,
+                                       Atomic64 old_value,
+                                       Atomic64 new_value) {
+  ((AtomicLocation64)ptr)
+      ->compare_exchange_strong(old_value,
+                                new_value,
+                                std::memory_order_acquire,
+                                std::memory_order_acquire);
+  return old_value;
+}
+
+inline Atomic64 Release_CompareAndSwap(volatile Atomic64* ptr,
+                                       Atomic64 old_value,
+                                       Atomic64 new_value) {
+  ((AtomicLocation64)ptr)
+      ->compare_exchange_strong(old_value,
+                                new_value,
+                                std::memory_order_release,
+                                std::memory_order_relaxed);
+  return old_value;
+}
+
+inline void NoBarrier_Store(volatile Atomic64* ptr, Atomic64 value) {
+  ((AtomicLocation64)ptr)->store(value, std::memory_order_relaxed);
+}
+
+inline void Acquire_Store(volatile Atomic64* ptr, Atomic64 value) {
+  ((AtomicLocation64)ptr)->store(value, std::memory_order_relaxed);
+  MemoryBarrierInternal();
+}
+
+inline void Release_Store(volatile Atomic64* ptr, Atomic64 value) {
+  ((AtomicLocation64)ptr)->store(value, std::memory_order_release);
+}
+
+inline Atomic64 NoBarrier_Load(volatile const Atomic64* ptr) {
+  return ((AtomicLocation64)ptr)->load(std::memory_order_relaxed);
+}
+
+inline Atomic64 Acquire_Load(volatile const Atomic64* ptr) {
+  return ((AtomicLocation64)ptr)->load(std::memory_order_acquire);
+}
+
+inline Atomic64 Release_Load(volatile const Atomic64* ptr) {
+  MemoryBarrierInternal();
+  return ((AtomicLocation64)ptr)->load(std::memory_order_relaxed);
+}
+
+#endif  // defined(GOOGLE_PROTOBUF_ARCH_64_BIT)
+
+}  // namespace internal
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_GENERIC_C11_ATOMIC_H_
diff --git a/kortex_api/include/google/protobuf/stubs/atomicops_internals_generic_gcc.h b/kortex_api/include/google/protobuf/stubs/atomicops_internals_generic_gcc.h
new file mode 100644
index 0000000000000000000000000000000000000000..0b0b06ce6cf92be8d69b97730595008c19ff84ef
--- /dev/null
+++ b/kortex_api/include/google/protobuf/stubs/atomicops_internals_generic_gcc.h
@@ -0,0 +1,155 @@
+// Copyright 2013 Red Hat Inc.  All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Red Hat Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// This file is an internal atomic implementation, use atomicops.h instead.
+
+#ifndef GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_GENERIC_GCC_H_
+#define GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_GENERIC_GCC_H_
+
+namespace google {
+namespace protobuf {
+namespace internal {
+
+inline Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr,
+                                         Atomic32 old_value,
+                                         Atomic32 new_value) {
+  __atomic_compare_exchange_n(ptr, &old_value, new_value, false,
+                              __ATOMIC_RELAXED, __ATOMIC_RELAXED);
+  return old_value;
+}
+
+inline Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr,
+                                         Atomic32 new_value) {
+  return __atomic_exchange_n(ptr, new_value, __ATOMIC_RELAXED);
+}
+
+inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr,
+                                          Atomic32 increment) {
+  return __atomic_add_fetch(ptr, increment, __ATOMIC_RELAXED);
+}
+
+inline Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr,
+                                        Atomic32 increment) {
+  return __atomic_add_fetch(ptr, increment, __ATOMIC_SEQ_CST);
+}
+
+inline Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr,
+                                       Atomic32 old_value,
+                                       Atomic32 new_value) {
+  __atomic_compare_exchange_n(ptr, &old_value, new_value, false,
+                              __ATOMIC_ACQUIRE, __ATOMIC_ACQUIRE);
+  return old_value;
+}
+
+inline Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr,
+                                       Atomic32 old_value,
+                                       Atomic32 new_value) {
+  __atomic_compare_exchange_n(ptr, &old_value, new_value, false,
+                              __ATOMIC_RELEASE, __ATOMIC_ACQUIRE);
+  return old_value;
+}
+
+inline void NoBarrier_Store(volatile Atomic32* ptr, Atomic32 value) {
+  __atomic_store_n(ptr, value, __ATOMIC_RELAXED);
+}
+
+inline void MemoryBarrierInternal() {
+  __sync_synchronize();
+}
+
+inline void Acquire_Store(volatile Atomic32* ptr, Atomic32 value) {
+  __atomic_store_n(ptr, value, __ATOMIC_SEQ_CST);
+}
+
+inline void Release_Store(volatile Atomic32* ptr, Atomic32 value) {
+  __atomic_store_n(ptr, value, __ATOMIC_RELEASE);
+}
+
+inline Atomic32 NoBarrier_Load(volatile const Atomic32* ptr) {
+  return __atomic_load_n(ptr, __ATOMIC_RELAXED);
+}
+
+inline Atomic32 Acquire_Load(volatile const Atomic32* ptr) {
+  return __atomic_load_n(ptr, __ATOMIC_ACQUIRE);
+}
+
+inline Atomic32 Release_Load(volatile const Atomic32* ptr) {
+  return __atomic_load_n(ptr, __ATOMIC_SEQ_CST);
+}
+
+#ifdef __LP64__
+
+inline void Release_Store(volatile Atomic64* ptr, Atomic64 value) {
+  __atomic_store_n(ptr, value, __ATOMIC_RELEASE);
+}
+
+inline Atomic64 Acquire_Load(volatile const Atomic64* ptr) {
+  return __atomic_load_n(ptr, __ATOMIC_ACQUIRE);
+}
+
+inline Atomic64 Acquire_CompareAndSwap(volatile Atomic64* ptr,
+                                       Atomic64 old_value,
+                                       Atomic64 new_value) {
+  __atomic_compare_exchange_n(ptr, &old_value, new_value, false,
+                              __ATOMIC_ACQUIRE, __ATOMIC_ACQUIRE);
+  return old_value;
+}
+
+inline Atomic64 NoBarrier_CompareAndSwap(volatile Atomic64* ptr,
+                                         Atomic64 old_value,
+                                         Atomic64 new_value) {
+  __atomic_compare_exchange_n(ptr, &old_value, new_value, false,
+                              __ATOMIC_RELAXED, __ATOMIC_RELAXED);
+  return old_value;
+}
+
+inline Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64* ptr,
+                                          Atomic64 increment) {
+  return __atomic_add_fetch(ptr, increment, __ATOMIC_RELAXED);
+}
+
+inline void NoBarrier_Store(volatile Atomic64* ptr, Atomic64 value) {
+  __atomic_store_n(ptr, value, __ATOMIC_RELAXED);
+}
+
+inline Atomic64 NoBarrier_AtomicExchange(volatile Atomic64* ptr,
+                                         Atomic64 new_value) {
+  return __atomic_exchange_n(ptr, new_value, __ATOMIC_RELAXED);
+}
+
+inline Atomic64 NoBarrier_Load(volatile const Atomic64* ptr) {
+  return __atomic_load_n(ptr, __ATOMIC_RELAXED);
+}
+
+#endif // defined(__LP64__)
+
+}  // namespace internal
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_GENERIC_GCC_H_
diff --git a/kortex_api/include/google/protobuf/stubs/atomicops_internals_mips_gcc.h b/kortex_api/include/google/protobuf/stubs/atomicops_internals_mips_gcc.h
new file mode 100644
index 0000000000000000000000000000000000000000..6ce6820ec26c28dc9a2145ae6b1ffb063d198d7c
--- /dev/null
+++ b/kortex_api/include/google/protobuf/stubs/atomicops_internals_mips_gcc.h
@@ -0,0 +1,313 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2012 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// This file is an internal atomic implementation, use atomicops.h instead.
+
+#ifndef GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_MIPS_GCC_H_
+#define GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_MIPS_GCC_H_
+
+#define ATOMICOPS_COMPILER_BARRIER() __asm__ __volatile__("" : : : "memory")
+
+namespace google {
+namespace protobuf {
+namespace internal {
+
+// Atomically execute:
+//      result = *ptr;
+//      if (*ptr == old_value)
+//        *ptr = new_value;
+//      return result;
+//
+// I.e., replace "*ptr" with "new_value" if "*ptr" used to be "old_value".
+// Always return the old value of "*ptr"
+//
+// This routine implies no memory barriers.
+inline Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr,
+                                         Atomic32 old_value,
+                                         Atomic32 new_value) {
+  Atomic32 prev, tmp;
+  __asm__ __volatile__(".set push\n"
+                       ".set noreorder\n"
+                       "1:\n"
+                       "ll %0, %5\n"  // prev = *ptr
+                       "bne %0, %3, 2f\n"  // if (prev != old_value) goto 2
+                       "move %2, %4\n"  // tmp = new_value
+                       "sc %2, %1\n"  // *ptr = tmp (with atomic check)
+                       "beqz %2, 1b\n"  // start again on atomic error
+                       "nop\n"  // delay slot nop
+                       "2:\n"
+                       ".set pop\n"
+                       : "=&r" (prev), "=m" (*ptr), "=&r" (tmp)
+                       : "r" (old_value), "r" (new_value), "m" (*ptr)
+                       : "memory");
+  return prev;
+}
+
+// Atomically store new_value into *ptr, returning the previous value held in
+// *ptr.  This routine implies no memory barriers.
+inline Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr,
+                                         Atomic32 new_value) {
+  Atomic32 temp, old;
+  __asm__ __volatile__(".set push\n"
+                       ".set noreorder\n"
+                       "1:\n"
+                       "ll %1, %4\n"  // old = *ptr
+                       "move %0, %3\n"  // temp = new_value
+                       "sc %0, %2\n"  // *ptr = temp (with atomic check)
+                       "beqz %0, 1b\n"  // start again on atomic error
+                       "nop\n"  // delay slot nop
+                       ".set pop\n"
+                       : "=&r" (temp), "=&r" (old), "=m" (*ptr)
+                       : "r" (new_value), "m" (*ptr)
+                       : "memory");
+
+  return old;
+}
+
+// Atomically increment *ptr by "increment".  Returns the new value of
+// *ptr with the increment applied.  This routine implies no memory barriers.
+inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr,
+                                          Atomic32 increment) {
+  Atomic32 temp, temp2;
+
+  __asm__ __volatile__(".set push\n"
+                       ".set noreorder\n"
+                       "1:\n"
+                       "ll %0, %4\n"  // temp = *ptr
+                       "addu %1, %0, %3\n"  // temp2 = temp + increment
+                       "sc %1, %2\n"  // *ptr = temp2 (with atomic check)
+                       "beqz %1, 1b\n"  // start again on atomic error
+                       "addu %1, %0, %3\n"  // temp2 = temp + increment
+                       ".set pop\n"
+                       : "=&r" (temp), "=&r" (temp2), "=m" (*ptr)
+                       : "Ir" (increment), "m" (*ptr)
+                       : "memory");
+  // temp2 now holds the final value.
+  return temp2;
+}
+
+inline Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr,
+                                        Atomic32 increment) {
+  ATOMICOPS_COMPILER_BARRIER();
+  Atomic32 res = NoBarrier_AtomicIncrement(ptr, increment);
+  ATOMICOPS_COMPILER_BARRIER();
+  return res;
+}
+
+// "Acquire" operations
+// ensure that no later memory access can be reordered ahead of the operation.
+// "Release" operations ensure that no previous memory access can be reordered
+// after the operation.  "Barrier" operations have both "Acquire" and "Release"
+// semantics.   A MemoryBarrierInternal() has "Barrier" semantics, but does no
+// memory access.
+inline Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr,
+                                       Atomic32 old_value,
+                                       Atomic32 new_value) {
+  ATOMICOPS_COMPILER_BARRIER();
+  Atomic32 res = NoBarrier_CompareAndSwap(ptr, old_value, new_value);
+  ATOMICOPS_COMPILER_BARRIER();
+  return res;
+}
+
+inline Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr,
+                                       Atomic32 old_value,
+                                       Atomic32 new_value) {
+  ATOMICOPS_COMPILER_BARRIER();
+  Atomic32 res = NoBarrier_CompareAndSwap(ptr, old_value, new_value);
+  ATOMICOPS_COMPILER_BARRIER();
+  return res;
+}
+
+inline void NoBarrier_Store(volatile Atomic32* ptr, Atomic32 value) {
+  *ptr = value;
+}
+
+inline void MemoryBarrierInternal() {
+  __asm__ __volatile__("sync" : : : "memory");
+}
+
+inline void Acquire_Store(volatile Atomic32* ptr, Atomic32 value) {
+  *ptr = value;
+  MemoryBarrierInternal();
+}
+
+inline void Release_Store(volatile Atomic32* ptr, Atomic32 value) {
+  MemoryBarrierInternal();
+  *ptr = value;
+}
+
+inline Atomic32 NoBarrier_Load(volatile const Atomic32* ptr) {
+  return *ptr;
+}
+
+inline Atomic32 Acquire_Load(volatile const Atomic32* ptr) {
+  Atomic32 value = *ptr;
+  MemoryBarrierInternal();
+  return value;
+}
+
+inline Atomic32 Release_Load(volatile const Atomic32* ptr) {
+  MemoryBarrierInternal();
+  return *ptr;
+}
+
+#if defined(__LP64__)
+// 64-bit versions of the atomic ops.
+
+inline Atomic64 NoBarrier_CompareAndSwap(volatile Atomic64* ptr,
+                                         Atomic64 old_value,
+                                         Atomic64 new_value) {
+  Atomic64 prev, tmp;
+  __asm__ __volatile__(".set push\n"
+                       ".set noreorder\n"
+                       "1:\n"
+                       "lld %0, %5\n"  // prev = *ptr
+                       "bne %0, %3, 2f\n"  // if (prev != old_value) goto 2
+                       "move %2, %4\n"  // tmp = new_value
+                       "scd %2, %1\n"  // *ptr = tmp (with atomic check)
+                       "beqz %2, 1b\n"  // start again on atomic error
+                       "nop\n"  // delay slot nop
+                       "2:\n"
+                       ".set pop\n"
+                       : "=&r" (prev), "=m" (*ptr), "=&r" (tmp)
+                       : "r" (old_value), "r" (new_value), "m" (*ptr)
+                       : "memory");
+  return prev;
+}
+
+// Atomically store new_value into *ptr, returning the previous value held in
+// *ptr.  This routine implies no memory barriers.
+inline Atomic64 NoBarrier_AtomicExchange(volatile Atomic64* ptr,
+                                         Atomic64 new_value) {
+  Atomic64 temp, old;
+  __asm__ __volatile__(".set push\n"
+                       ".set noreorder\n"
+                       "1:\n"
+                       "lld %1, %4\n"  // old = *ptr
+                       "move %0, %3\n"  // temp = new_value
+                       "scd %0, %2\n"  // *ptr = temp (with atomic check)
+                       "beqz %0, 1b\n"  // start again on atomic error
+                       "nop\n"  // delay slot nop
+                       ".set pop\n"
+                       : "=&r" (temp), "=&r" (old), "=m" (*ptr)
+                       : "r" (new_value), "m" (*ptr)
+                       : "memory");
+
+  return old;
+}
+
+// Atomically increment *ptr by "increment".  Returns the new value of
+// *ptr with the increment applied.  This routine implies no memory barriers.
+inline Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64* ptr,
+                                          Atomic64 increment) {
+  Atomic64 temp, temp2;
+
+  __asm__ __volatile__(".set push\n"
+                       ".set noreorder\n"
+                       "1:\n"
+                       "lld %0, %4\n"  // temp = *ptr
+                       "daddu %1, %0, %3\n"  // temp2 = temp + increment
+                       "scd %1, %2\n"  // *ptr = temp2 (with atomic check)
+                       "beqz %1, 1b\n"  // start again on atomic error
+                       "daddu %1, %0, %3\n"  // temp2 = temp + increment
+                       ".set pop\n"
+                       : "=&r" (temp), "=&r" (temp2), "=m" (*ptr)
+                       : "Ir" (increment), "m" (*ptr)
+                       : "memory");
+  // temp2 now holds the final value.
+  return temp2;
+}
+
+inline Atomic64 Barrier_AtomicIncrement(volatile Atomic64* ptr,
+                                        Atomic64 increment) {
+  MemoryBarrierInternal();
+  Atomic64 res = NoBarrier_AtomicIncrement(ptr, increment);
+  MemoryBarrierInternal();
+  return res;
+}
+
+// "Acquire" operations
+// ensure that no later memory access can be reordered ahead of the operation.
+// "Release" operations ensure that no previous memory access can be reordered
+// after the operation.  "Barrier" operations have both "Acquire" and "Release"
+// semantics.   A MemoryBarrierInternal() has "Barrier" semantics, but does no
+// memory access.
+inline Atomic64 Acquire_CompareAndSwap(volatile Atomic64* ptr,
+                                       Atomic64 old_value,
+                                       Atomic64 new_value) {
+  Atomic64 res = NoBarrier_CompareAndSwap(ptr, old_value, new_value);
+  MemoryBarrierInternal();
+  return res;
+}
+
+inline Atomic64 Release_CompareAndSwap(volatile Atomic64* ptr,
+                                       Atomic64 old_value,
+                                       Atomic64 new_value) {
+  MemoryBarrierInternal();
+  return NoBarrier_CompareAndSwap(ptr, old_value, new_value);
+}
+
+inline void NoBarrier_Store(volatile Atomic64* ptr, Atomic64 value) {
+  *ptr = value;
+}
+
+inline void Acquire_Store(volatile Atomic64* ptr, Atomic64 value) {
+  *ptr = value;
+  MemoryBarrierInternal();
+}
+
+inline void Release_Store(volatile Atomic64* ptr, Atomic64 value) {
+  MemoryBarrierInternal();
+  *ptr = value;
+}
+
+inline Atomic64 NoBarrier_Load(volatile const Atomic64* ptr) {
+  return *ptr;
+}
+
+inline Atomic64 Acquire_Load(volatile const Atomic64* ptr) {
+  Atomic64 value = *ptr;
+  MemoryBarrierInternal();
+  return value;
+}
+
+inline Atomic64 Release_Load(volatile const Atomic64* ptr) {
+  MemoryBarrierInternal();
+  return *ptr;
+}
+#endif
+
+}  // namespace internal
+}  // namespace protobuf
+}  // namespace google
+
+#undef ATOMICOPS_COMPILER_BARRIER
+
+#endif  // GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_MIPS_GCC_H_
diff --git a/kortex_api/include/google/protobuf/stubs/atomicops_internals_power.h b/kortex_api/include/google/protobuf/stubs/atomicops_internals_power.h
new file mode 100644
index 0000000000000000000000000000000000000000..cad9f1e35444a5dcff84594a8118d59c87dd5128
--- /dev/null
+++ b/kortex_api/include/google/protobuf/stubs/atomicops_internals_power.h
@@ -0,0 +1,440 @@
+// Copyright 2014 Bloomberg Finance LP. All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Bloomberg Finance LP. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// This file is an internal atomic implementation, use atomicops.h instead.
+
+#ifndef GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_AIX_H_
+#define GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_AIX_H_
+
+namespace google {
+namespace protobuf {
+namespace internal {
+
+inline Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr,
+                                         Atomic32 old_value,
+                                         Atomic32 new_value) {
+  Atomic32 result;
+
+  asm volatile (
+      "1:     lwarx %[res], %[zero], %[obj]   \n\t"  // load and reserve
+      "       cmpw %[cmp], %[res]             \n\t"  // compare values
+      "       bne- 2f                         \n\t"
+      "       stwcx. %[val], %[zero], %[obj]  \n\t"  // store new value
+      "       bne- 1b                         \n\t"
+      "2:                                     \n\t"
+              : [res]  "=&b" (result)
+              : [obj]  "b"   (ptr),
+                [cmp]  "b"   (old_value),
+                [val]  "b"   (new_value),
+                [zero] "i"   (0)
+              : "cr0", "ctr");
+
+  return result;
+}
+
+inline Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr,
+                                         Atomic32 new_value) {
+  Atomic32 result;
+
+  asm volatile (
+      "1:     lwarx %[res], %[zero], %[obj]       \n\t"
+      "       stwcx. %[val], %[zero], %[obj]      \n\t"
+      "       bne- 1b                             \n\t"
+              : [res]  "=&b" (result)
+              : [obj]  "b"   (ptr),
+                [val]  "b"   (new_value),
+                [zero] "i"   (0)
+              : "cr0", "ctr");
+
+  return result;
+}
+
+inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr,
+                                          Atomic32 increment) {
+  Atomic32 result;
+
+  asm volatile (
+      "1:     lwarx %[res], %[zero], %[obj]   \n\t"  // load and reserve
+      "       add %[res], %[val], %[res]      \n\t"  // add the operand
+      "       stwcx. %[res], %[zero], %[obj]  \n\t"  // store old value
+                                                     // if still reserved
+      "       bne- 1b                         \n\t"
+              : [res]  "=&b" (result)
+              : [obj]  "b"   (ptr),
+                [val]  "b"   (increment),
+                [zero] "i"   (0)
+              : "cr0", "ctr");
+
+  return result;
+}
+
+inline void MemoryBarrierInternal(void) {
+  asm volatile (
+      "       lwsync                          \n\t"
+      "       isync                           \n\t"
+              :
+              :
+              : "memory");
+}
+
+inline Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr,
+                                        Atomic32 increment) {
+  Atomic32 result;
+
+  asm volatile (
+      "       lwsync                          \n\t"
+
+      "1:     lwarx %[res], %[zero], %[obj]   \n\t"  // load and reserve
+      "       add %[res], %[val], %[res]      \n\t"  // add the operand
+      "       stwcx. %[res], %[zero], %[obj]  \n\t"  // store old value
+                                                     // if still reserved
+      "       bne- 1b                         \n\t"
+      "       isync                           \n\t"
+              : [res]  "=&b" (result)
+              : [obj]  "b"   (ptr),
+                [val]  "b"   (increment),
+                [zero] "i"   (0)
+              : "cr0", "ctr");
+
+  return result;
+}
+
+inline Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr,
+                                       Atomic32 old_value,
+                                       Atomic32 new_value) {
+  Atomic32 result;
+
+  asm volatile (
+      "1:     lwarx %[res], %[zero], %[obj]   \n\t"  // load and reserve
+      "       cmpw %[cmp], %[res]             \n\t"  // compare values
+      "       bne- 2f                         \n\t"
+      "       stwcx. %[val], %[zero], %[obj]  \n\t"  // store new value
+      "       bne- 1b                         \n\t"
+
+      "       isync                           \n\t"
+      "2:                                     \n\t"
+              : [res]  "=&b" (result)
+              : [obj]  "b"   (ptr),
+                [cmp]  "b"   (old_value),
+                [val]  "b"   (new_value),
+                [zero] "i"   (0)
+              : "cr0", "ctr");
+
+  return result;
+}
+
+inline Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr,
+                                       Atomic32 old_value,
+                                       Atomic32 new_value) {
+  Atomic32 result;
+
+  asm volatile (
+      "       lwsync                          \n\t"
+
+      "1:     lwarx %[res], %[zero], %[obj]   \n\t"  // load and reserve
+      "       cmpw %[cmp], %[res]             \n\t"  // compare values
+      "       bne- 2f                         \n\t"
+      "       stwcx. %[val], %[zero], %[obj]  \n\t"  // store new value
+      "       bne- 1b                         \n\t"
+
+      "2:                                     \n\t"
+              : [res]  "=&b" (result)
+              : [obj]  "b"   (ptr),
+                [cmp]  "b"   (old_value),
+                [val]  "b"   (new_value),
+                [zero] "i"   (0)
+              : "cr0", "ctr");
+
+  return result;
+}
+
+inline void NoBarrier_Store(volatile Atomic32* ptr, Atomic32 value) {
+  *ptr = value;
+}
+
+inline void Acquire_Store(volatile Atomic32* ptr, Atomic32 value) {
+  asm volatile (
+      "       stw %[val], %[obj]      \n\t"
+      "       isync                   \n\t"
+              : [obj] "=m" (*ptr)
+              : [val]  "b"  (value));
+}
+
+inline void Release_Store(volatile Atomic32* ptr, Atomic32 value) {
+  asm volatile (
+      "       lwsync                  \n\t"
+      "       stw %[val], %[obj]      \n\t"
+              : [obj] "=m" (*ptr)
+              : [val]  "b"  (value));
+}
+
+inline Atomic32 NoBarrier_Load(volatile const Atomic32* ptr) {
+  return *ptr;
+}
+
+inline Atomic32 Acquire_Load(volatile const Atomic32* ptr) {
+  Atomic32 result;
+
+  asm volatile (
+      "1:     lwz %[res], %[obj]              \n\t"
+      "       cmpw %[res], %[res]             \n\t" // create data
+                                                    // dependency for
+                                                    // load/load ordering
+      "       bne- 1b                         \n\t" // never taken
+
+      "       isync                           \n\t"
+              : [res]  "=b" (result)
+              : [obj]  "m"  (*ptr),
+                [zero] "i"  (0)
+              : "cr0", "ctr");
+
+  return result;
+}
+
+inline Atomic32 Release_Load(volatile const Atomic32* ptr) {
+  Atomic32 result;
+
+  asm volatile (
+      "       lwsync                          \n\t"
+
+      "1:     lwz %[res], %[obj]              \n\t"
+      "       cmpw %[res], %[res]             \n\t" // create data
+                                                    // dependency for
+                                                    // load/load ordering
+      "       bne- 1b                         \n\t" // never taken
+              : [res]  "=b" (result)
+              : [obj]  "m"  (*ptr),
+                [zero] "i"  (0)
+              : "cr0", "ctr");
+
+  return result;
+}
+
+#ifdef GOOGLE_PROTOBUF_ARCH_64_BIT
+inline Atomic64 NoBarrier_CompareAndSwap(volatile Atomic64* ptr,
+                                         Atomic64 old_value,
+                                         Atomic64 new_value) {
+  Atomic64 result;
+
+  asm volatile (
+      "1:     ldarx %[res], %[zero], %[obj]   \n\t"  // load and reserve
+      "       cmpd %[cmp], %[res]             \n\t"  // compare values
+      "       bne- 2f                         \n\t"
+
+      "       stdcx. %[val], %[zero], %[obj]  \n\t"  // store the new value
+      "       bne- 1b                         \n\t"
+      "2:                                     \n\t"
+              : [res]  "=&b" (result)
+              : [obj]  "b"   (ptr),
+                [cmp]  "b"   (old_value),
+                [val]  "b"   (new_value),
+                [zero] "i"   (0)
+              : "cr0", "ctr");
+
+  return result;
+}
+
+inline Atomic64 NoBarrier_AtomicExchange(volatile Atomic64* ptr,
+                                         Atomic64 new_value) {
+  Atomic64 result;
+
+  asm volatile (
+      "1:     ldarx %[res], %[zero], %[obj]       \n\t"
+      "       stdcx. %[val], %[zero], %[obj]      \n\t"
+      "       bne- 1b                             \n\t"
+              : [res]  "=&b" (result)
+              : [obj]  "b"   (ptr),
+                [val]  "b"   (new_value),
+                [zero] "i"   (0)
+              : "cr0", "ctr");
+
+  return result;
+}
+
+inline Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64* ptr,
+                                          Atomic64 increment) {
+  Atomic64 result;
+
+  asm volatile (
+      "1:     ldarx %[res], %[zero], %[obj]   \n\t" // load and reserve
+      "       add %[res], %[res], %[val]      \n\t" // add the operand
+      "       stdcx. %[res], %[zero], %[obj]  \n\t" // store old value if
+                                                    // still reserved
+
+      "       bne- 1b                         \n\t"
+              : [res]  "=&b" (result)
+              : [obj]  "b"   (ptr),
+                [val]  "b"   (increment),
+                [zero] "i"   (0)
+              : "cr0", "ctr");
+
+  return result;
+}
+
+inline Atomic64 Barrier_AtomicIncrement(volatile Atomic64* ptr,
+                                        Atomic64 increment) {
+
+  Atomic64 result;
+
+  asm volatile (
+      "       lwsync                          \n\t"
+
+      "1:     ldarx %[res], %[zero], %[obj]   \n\t" // load and reserve
+      "       add %[res], %[res], %[val]      \n\t" // add the operand
+      "       stdcx. %[res], %[zero], %[obj]  \n\t" // store old value if
+                                                    // still reserved
+
+      "       bne- 1b                         \n\t"
+
+      "       isync                           \n\t"
+              : [res]  "=&b" (result)
+              : [obj]  "b"   (ptr),
+                [val]  "b"   (increment),
+                [zero] "i"   (0)
+              : "cr0", "ctr");
+
+  return result;
+}
+
+inline Atomic64 Acquire_CompareAndSwap(volatile Atomic64* ptr,
+                                       Atomic64 old_value,
+                                       Atomic64 new_value) {
+  Atomic64 result;
+
+  asm volatile (
+      "1:     ldarx %[res], %[zero], %[obj]   \n\t"  // load and reserve
+      "       cmpd %[cmp], %[res]             \n\t"  // compare values
+      "       bne- 2f                         \n\t"
+
+      "       stdcx. %[val], %[zero], %[obj]  \n\t"  // store the new value
+      "       bne- 1b                         \n\t"
+      "       isync                           \n\t"
+      "2:                                     \n\t"
+              : [res]  "=&b" (result)
+              : [obj]  "b"   (ptr),
+                [cmp]  "b"   (old_value),
+                [val]  "b"   (new_value),
+                [zero] "i"   (0)
+              : "cr0", "ctr");
+
+  return result;
+}
+
+inline Atomic64 Release_CompareAndSwap(volatile Atomic64* ptr,
+                                       Atomic64 old_value,
+                                       Atomic64 new_value) {
+  Atomic64 result;
+
+  asm volatile (
+      "       lwsync                          \n\t"
+
+      "1:     ldarx %[res], %[zero], %[obj]   \n\t"  // load and reserve
+      "       cmpd %[cmp], %[res]             \n\t"  // compare values
+      "       bne- 2f                         \n\t"
+
+      "       stdcx. %[val], %[zero], %[obj]  \n\t"  // store the new value
+      "       bne- 1b                         \n\t"
+      "2:                                     \n\t"
+              : [res]  "=&b" (result)
+              : [obj]  "b"   (ptr),
+                [cmp]  "b"   (old_value),
+                [val]  "b"   (new_value),
+                [zero] "i"   (0)
+              : "cr0", "ctr");
+
+  return result;
+}
+
+inline void NoBarrier_Store(volatile Atomic64* ptr, Atomic64 value) {
+  *ptr = value;
+}
+
+inline void Acquire_Store(volatile Atomic64* ptr, Atomic64 value) {
+  asm volatile (
+      "       std %[val], %[obj]          \n\t"
+      "       isync                       \n\t"
+              : [obj] "=m" (*ptr)
+              : [val] "b"  (value));
+}
+
+inline void Release_Store(volatile Atomic64* ptr, Atomic64 value) {
+  asm volatile (
+      "       lwsync                      \n\t"
+      "       std %[val], %[obj]          \n\t"
+              : [obj] "=m" (*ptr)
+              : [val] "b"  (value));
+}
+
+inline Atomic64 NoBarrier_Load(volatile const Atomic64* ptr) {
+  return *ptr;
+}
+
+inline Atomic64 Acquire_Load(volatile const Atomic64* ptr) {
+  Atomic64 result;
+
+  asm volatile (
+      "1:     ld %[res], %[obj]                   \n\t"
+      "       cmpd %[res], %[res]                 \n\t" // create data
+                                                        // dependency for
+                                                        // load/load ordering
+      "       bne- 1b                             \n\t" // never taken
+
+      "       isync                               \n\t"
+              : [res]  "=b" (result)
+              : [obj]  "m"  (*ptr),
+                [zero] "i"  (0)
+              : "cr0", "ctr");
+
+  return result;
+}
+
+inline Atomic64 Release_Load(volatile const Atomic64* ptr) {
+  Atomic64 result;
+
+  asm volatile (
+      "       lwsync                              \n\t"
+
+      "1:     ld %[res], %[obj]                   \n\t"
+      "       cmpd %[res], %[res]                 \n\t" // create data
+                                                        // dependency for
+                                                        // load/load ordering
+      "       bne- 1b                             \n\t" // never taken
+              : [res]  "=b" (result)
+              : [obj]  "m"  (*ptr),
+                [zero] "i"  (0)
+              : "cr0", "ctr");
+
+  return result;
+}
+#endif
+
+}  // namespace internal
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_SPARC_GCC_H_
diff --git a/kortex_api/include/google/protobuf/stubs/atomicops_internals_ppc_gcc.h b/kortex_api/include/google/protobuf/stubs/atomicops_internals_ppc_gcc.h
new file mode 100644
index 0000000000000000000000000000000000000000..d477dc6ddadb4c8ee9673f46f8f43d95d25b5124
--- /dev/null
+++ b/kortex_api/include/google/protobuf/stubs/atomicops_internals_ppc_gcc.h
@@ -0,0 +1,155 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2015 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: ogabbay@advaoptical.com (Oded Gabbay)
+// Cleaned up by: bsilver16384@gmail.com (Brian Silverman)
+//
+// This file is an internal atomic implementation, use atomicops.h instead.
+
+#ifndef GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_PPC_GCC_H_
+#define GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_PPC_GCC_H_
+
+#define ATOMICOPS_COMPILER_BARRIER() __asm__ __volatile__("" : : : "memory")
+
+namespace google {
+namespace protobuf {
+namespace internal {
+
+inline Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32 *ptr,
+                                         Atomic32 old_value,
+                                         Atomic32 new_value) {
+  Atomic32 prev;
+
+  __asm__ __volatile__(
+      "0:                                  \n\t"
+      "lwarx %[prev],0,%[ptr]              \n\t"
+      "cmpw 0,%[prev],%[old_value]         \n\t"
+      "bne- 1f                             \n\t"
+      "stwcx. %[new_value],0,%[ptr]        \n\t"
+      "bne- 0b                             \n\t"
+      "1:                                  \n\t"
+      : [prev] "=&r"(prev), "+m"(*ptr)
+      : [ptr] "r"(ptr), [old_value] "r"(old_value), [new_value] "r"(new_value)
+      : "cc", "memory");
+
+  return prev;
+}
+
+inline Atomic32 NoBarrier_AtomicExchange(volatile Atomic32 *ptr,
+                                         Atomic32 new_value) {
+  Atomic32 old;
+
+  __asm__ __volatile__(
+      "0:                                  \n\t"
+      "lwarx %[old],0,%[ptr]               \n\t"
+      "stwcx. %[new_value],0,%[ptr]        \n\t"
+      "bne- 0b                             \n\t"
+      : [old] "=&r"(old), "+m"(*ptr)
+      : [ptr] "r"(ptr), [new_value] "r"(new_value)
+      : "cc", "memory");
+
+  return old;
+}
+
+inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32 *ptr,
+                                          Atomic32 increment) {
+  Atomic32 temp;
+
+  __asm__ __volatile__(
+      "0:                                  \n\t"
+      "lwarx %[temp],0,%[ptr]              \n\t"
+      "add %[temp],%[increment],%[temp]    \n\t"
+      "stwcx. %[temp],0,%[ptr]             \n\t"
+      "bne- 0b                             \n\t"
+      : [temp] "=&r"(temp)
+      : [increment] "r"(increment), [ptr] "r"(ptr)
+      : "cc", "memory");
+
+  return temp;
+}
+
+inline Atomic32 Barrier_AtomicIncrement(volatile Atomic32 *ptr,
+                                        Atomic32 increment) {
+  MemoryBarrierInternal();
+  Atomic32 res = NoBarrier_AtomicIncrement(ptr, increment);
+  MemoryBarrierInternal();
+  return res;
+}
+
+inline Atomic32 Acquire_CompareAndSwap(volatile Atomic32 *ptr,
+                                       Atomic32 old_value, Atomic32 new_value) {
+  Atomic32 res = NoBarrier_CompareAndSwap(ptr, old_value, new_value);
+  MemoryBarrierInternal();
+  return res;
+}
+
+inline Atomic32 Release_CompareAndSwap(volatile Atomic32 *ptr,
+                                       Atomic32 old_value, Atomic32 new_value) {
+  MemoryBarrierInternal();
+  Atomic32 res = NoBarrier_CompareAndSwap(ptr, old_value, new_value);
+  return res;
+}
+
+inline void NoBarrier_Store(volatile Atomic32 *ptr, Atomic32 value) {
+  *ptr = value;
+}
+
+inline void MemoryBarrierInternal() { __asm__ __volatile__("sync" : : : "memory"); }
+
+inline void Acquire_Store(volatile Atomic32 *ptr, Atomic32 value) {
+  *ptr = value;
+  MemoryBarrierInternal();
+}
+
+inline void Release_Store(volatile Atomic32 *ptr, Atomic32 value) {
+  MemoryBarrierInternal();
+  *ptr = value;
+}
+
+inline Atomic32 NoBarrier_Load(volatile const Atomic32 *ptr) { return *ptr; }
+
+inline Atomic32 Acquire_Load(volatile const Atomic32 *ptr) {
+  Atomic32 value = *ptr;
+  MemoryBarrierInternal();
+  return value;
+}
+
+inline Atomic32 Release_Load(volatile const Atomic32 *ptr) {
+  MemoryBarrierInternal();
+  return *ptr;
+}
+
+}  // namespace internal
+}  // namespace protobuf
+}  // namespace google
+
+#undef ATOMICOPS_COMPILER_BARRIER
+
+#endif  // GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_PPC_GCC_H_
diff --git a/kortex_api/include/google/protobuf/stubs/atomicops_internals_solaris.h b/kortex_api/include/google/protobuf/stubs/atomicops_internals_solaris.h
new file mode 100644
index 0000000000000000000000000000000000000000..baecb993bc0ceec14431583a397d65bed2ce687b
--- /dev/null
+++ b/kortex_api/include/google/protobuf/stubs/atomicops_internals_solaris.h
@@ -0,0 +1,188 @@
+// Copyright 2014 Google Inc. All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// This file is an internal atomic implementation, use atomicops.h instead.
+
+#ifndef GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_SPARC_GCC_H_
+#define GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_SPARC_GCC_H_
+
+#include <atomic.h>
+
+namespace google {
+namespace protobuf {
+namespace internal {
+
+inline Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr,
+                                         Atomic32 old_value,
+                                         Atomic32 new_value) {
+  return (Atomic32)atomic_cas_32((volatile uint32_t*)ptr, (uint32_t)old_value, (uint32_t)new_value);
+}
+
+inline Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr,
+                                         Atomic32 new_value) {
+  return (Atomic32)atomic_swap_32((volatile uint32_t*)ptr, (uint32_t)new_value);
+}
+
+inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr,
+                                          Atomic32 increment) {
+  return (Atomic32)atomic_add_32_nv((volatile uint32_t*)ptr, (uint32_t)increment);
+}
+
+inline void MemoryBarrierInternal(void) {
+	membar_producer();
+	membar_consumer();
+}
+
+inline Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr,
+                                        Atomic32 increment) {
+  MemoryBarrierInternal();
+  Atomic32 ret = NoBarrier_AtomicIncrement(ptr, increment);
+  MemoryBarrierInternal();
+
+  return ret;
+}
+
+inline Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr,
+                                       Atomic32 old_value,
+                                       Atomic32 new_value) {
+  Atomic32 ret = NoBarrier_CompareAndSwap(ptr, old_value, new_value);
+  MemoryBarrierInternal();
+
+  return ret;
+}
+
+inline Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr,
+                                       Atomic32 old_value,
+                                       Atomic32 new_value) {
+  MemoryBarrierInternal();
+  return NoBarrier_CompareAndSwap(ptr, old_value, new_value);
+}
+
+inline void NoBarrier_Store(volatile Atomic32* ptr, Atomic32 value) {
+  *ptr = value;
+}
+
+inline void Acquire_Store(volatile Atomic32* ptr, Atomic32 value) {
+  *ptr = value;
+  membar_producer();
+}
+
+inline void Release_Store(volatile Atomic32* ptr, Atomic32 value) {
+  membar_consumer();
+  *ptr = value;
+}
+
+inline Atomic32 NoBarrier_Load(volatile const Atomic32* ptr) {
+  return *ptr;
+}
+
+inline Atomic32 Acquire_Load(volatile const Atomic32* ptr) {
+  Atomic32 val = *ptr;
+  membar_consumer();
+  return val;
+}
+
+inline Atomic32 Release_Load(volatile const Atomic32* ptr) {
+  membar_producer();
+  return *ptr;
+}
+
+#ifdef GOOGLE_PROTOBUF_ARCH_64_BIT
+inline Atomic64 NoBarrier_CompareAndSwap(volatile Atomic64* ptr,
+                                         Atomic64 old_value,
+                                         Atomic64 new_value) {
+  return atomic_cas_64((volatile uint64_t*)ptr, (uint64_t)old_value, (uint64_t)new_value);
+}
+
+inline Atomic64 NoBarrier_AtomicExchange(volatile Atomic64* ptr, Atomic64 new_value) {
+  return atomic_swap_64((volatile uint64_t*)ptr, (uint64_t)new_value);
+}
+
+inline Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64* ptr, Atomic64 increment) {
+  return atomic_add_64_nv((volatile uint64_t*)ptr, increment);
+}
+
+inline Atomic64 Barrier_AtomicIncrement(volatile Atomic64* ptr, Atomic64 increment) {
+  MemoryBarrierInternal();
+  Atomic64 ret = atomic_add_64_nv((volatile uint64_t*)ptr, increment);
+  MemoryBarrierInternal();
+  return ret;
+}
+
+inline Atomic64 Acquire_CompareAndSwap(volatile Atomic64* ptr,
+                                       Atomic64 old_value,
+                                       Atomic64 new_value) {
+  Atomic64 ret = NoBarrier_CompareAndSwap(ptr, old_value, new_value);
+  MemoryBarrierInternal();
+  return ret;
+}
+
+inline Atomic64 Release_CompareAndSwap(volatile Atomic64* ptr,
+                                       Atomic64 old_value,
+                                       Atomic64 new_value) {
+  MemoryBarrierInternal();
+  return NoBarrier_CompareAndSwap(ptr, old_value, new_value);
+}
+
+inline void NoBarrier_Store(volatile Atomic64* ptr, Atomic64 value) {
+  *ptr = value;
+}
+
+inline void Acquire_Store(volatile Atomic64* ptr, Atomic64 value) {
+  *ptr = value;
+  membar_producer();
+}
+
+inline void Release_Store(volatile Atomic64* ptr, Atomic64 value) {
+  membar_consumer();
+  *ptr = value;
+}
+
+inline Atomic64 NoBarrier_Load(volatile const Atomic64* ptr) {
+  return *ptr;
+}
+
+inline Atomic64 Acquire_Load(volatile const Atomic64* ptr) {
+  Atomic64 ret = *ptr;
+  membar_consumer();
+  return ret;
+}
+
+inline Atomic64 Release_Load(volatile const Atomic64* ptr) {
+  membar_producer();
+  return *ptr;
+}
+#endif
+
+}  // namespace internal
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_SPARC_GCC_H_
+
diff --git a/kortex_api/include/google/protobuf/stubs/atomicops_internals_tsan.h b/kortex_api/include/google/protobuf/stubs/atomicops_internals_tsan.h
new file mode 100644
index 0000000000000000000000000000000000000000..676380b1d536194821aeef6f662d5143098e5fc9
--- /dev/null
+++ b/kortex_api/include/google/protobuf/stubs/atomicops_internals_tsan.h
@@ -0,0 +1,219 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2013 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// This file is an internal atomic implementation for compiler-based
+// ThreadSanitizer (http://clang.llvm.org/docs/ThreadSanitizer.html).
+// Use atomicops.h instead.
+
+#ifndef GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_TSAN_H_
+#define GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_TSAN_H_
+
+#define ATOMICOPS_COMPILER_BARRIER() __asm__ __volatile__("" : : : "memory")
+
+#include <sanitizer/tsan_interface_atomic.h>
+
+namespace google {
+namespace protobuf {
+namespace internal {
+
+inline Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32 *ptr,
+                                         Atomic32 old_value,
+                                         Atomic32 new_value) {
+  Atomic32 cmp = old_value;
+  __tsan_atomic32_compare_exchange_strong(ptr, &cmp, new_value,
+      __tsan_memory_order_relaxed, __tsan_memory_order_relaxed);
+  return cmp;
+}
+
+inline Atomic32 NoBarrier_AtomicExchange(volatile Atomic32 *ptr,
+                                         Atomic32 new_value) {
+  return __tsan_atomic32_exchange(ptr, new_value,
+      __tsan_memory_order_relaxed);
+}
+
+inline Atomic32 Acquire_AtomicExchange(volatile Atomic32 *ptr,
+                                       Atomic32 new_value) {
+  return __tsan_atomic32_exchange(ptr, new_value,
+      __tsan_memory_order_acquire);
+}
+
+inline Atomic32 Release_AtomicExchange(volatile Atomic32 *ptr,
+                                       Atomic32 new_value) {
+  return __tsan_atomic32_exchange(ptr, new_value,
+      __tsan_memory_order_release);
+}
+
+inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32 *ptr,
+                                          Atomic32 increment) {
+  return increment + __tsan_atomic32_fetch_add(ptr, increment,
+      __tsan_memory_order_relaxed);
+}
+
+inline Atomic32 Barrier_AtomicIncrement(volatile Atomic32 *ptr,
+                                        Atomic32 increment) {
+  return increment + __tsan_atomic32_fetch_add(ptr, increment,
+      __tsan_memory_order_acq_rel);
+}
+
+inline Atomic32 Acquire_CompareAndSwap(volatile Atomic32 *ptr,
+                                       Atomic32 old_value,
+                                       Atomic32 new_value) {
+  Atomic32 cmp = old_value;
+  __tsan_atomic32_compare_exchange_strong(ptr, &cmp, new_value,
+      __tsan_memory_order_acquire, __tsan_memory_order_acquire);
+  return cmp;
+}
+
+inline Atomic32 Release_CompareAndSwap(volatile Atomic32 *ptr,
+                                       Atomic32 old_value,
+                                       Atomic32 new_value) {
+  Atomic32 cmp = old_value;
+  __tsan_atomic32_compare_exchange_strong(ptr, &cmp, new_value,
+      __tsan_memory_order_release, __tsan_memory_order_relaxed);
+  return cmp;
+}
+
+inline void NoBarrier_Store(volatile Atomic32 *ptr, Atomic32 value) {
+  __tsan_atomic32_store(ptr, value, __tsan_memory_order_relaxed);
+}
+
+inline void Acquire_Store(volatile Atomic32 *ptr, Atomic32 value) {
+  __tsan_atomic32_store(ptr, value, __tsan_memory_order_relaxed);
+  __tsan_atomic_thread_fence(__tsan_memory_order_seq_cst);
+}
+
+inline void Release_Store(volatile Atomic32 *ptr, Atomic32 value) {
+  __tsan_atomic32_store(ptr, value, __tsan_memory_order_release);
+}
+
+inline Atomic32 NoBarrier_Load(volatile const Atomic32 *ptr) {
+  return __tsan_atomic32_load(ptr, __tsan_memory_order_relaxed);
+}
+
+inline Atomic32 Acquire_Load(volatile const Atomic32 *ptr) {
+  return __tsan_atomic32_load(ptr, __tsan_memory_order_acquire);
+}
+
+inline Atomic32 Release_Load(volatile const Atomic32 *ptr) {
+  __tsan_atomic_thread_fence(__tsan_memory_order_seq_cst);
+  return __tsan_atomic32_load(ptr, __tsan_memory_order_relaxed);
+}
+
+inline Atomic64 NoBarrier_CompareAndSwap(volatile Atomic64 *ptr,
+                                         Atomic64 old_value,
+                                         Atomic64 new_value) {
+  Atomic64 cmp = old_value;
+  __tsan_atomic64_compare_exchange_strong(ptr, &cmp, new_value,
+      __tsan_memory_order_relaxed, __tsan_memory_order_relaxed);
+  return cmp;
+}
+
+inline Atomic64 NoBarrier_AtomicExchange(volatile Atomic64 *ptr,
+                                         Atomic64 new_value) {
+  return __tsan_atomic64_exchange(ptr, new_value, __tsan_memory_order_relaxed);
+}
+
+inline Atomic64 Acquire_AtomicExchange(volatile Atomic64 *ptr,
+                                       Atomic64 new_value) {
+  return __tsan_atomic64_exchange(ptr, new_value, __tsan_memory_order_acquire);
+}
+
+inline Atomic64 Release_AtomicExchange(volatile Atomic64 *ptr,
+                                       Atomic64 new_value) {
+  return __tsan_atomic64_exchange(ptr, new_value, __tsan_memory_order_release);
+}
+
+inline Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64 *ptr,
+                                          Atomic64 increment) {
+  return increment + __tsan_atomic64_fetch_add(ptr, increment,
+      __tsan_memory_order_relaxed);
+}
+
+inline Atomic64 Barrier_AtomicIncrement(volatile Atomic64 *ptr,
+                                        Atomic64 increment) {
+  return increment + __tsan_atomic64_fetch_add(ptr, increment,
+      __tsan_memory_order_acq_rel);
+}
+
+inline void NoBarrier_Store(volatile Atomic64 *ptr, Atomic64 value) {
+  __tsan_atomic64_store(ptr, value, __tsan_memory_order_relaxed);
+}
+
+inline void Acquire_Store(volatile Atomic64 *ptr, Atomic64 value) {
+  __tsan_atomic64_store(ptr, value, __tsan_memory_order_relaxed);
+  __tsan_atomic_thread_fence(__tsan_memory_order_seq_cst);
+}
+
+inline void Release_Store(volatile Atomic64 *ptr, Atomic64 value) {
+  __tsan_atomic64_store(ptr, value, __tsan_memory_order_release);
+}
+
+inline Atomic64 NoBarrier_Load(volatile const Atomic64 *ptr) {
+  return __tsan_atomic64_load(ptr, __tsan_memory_order_relaxed);
+}
+
+inline Atomic64 Acquire_Load(volatile const Atomic64 *ptr) {
+  return __tsan_atomic64_load(ptr, __tsan_memory_order_acquire);
+}
+
+inline Atomic64 Release_Load(volatile const Atomic64 *ptr) {
+  __tsan_atomic_thread_fence(__tsan_memory_order_seq_cst);
+  return __tsan_atomic64_load(ptr, __tsan_memory_order_relaxed);
+}
+
+inline Atomic64 Acquire_CompareAndSwap(volatile Atomic64 *ptr,
+                                       Atomic64 old_value,
+                                       Atomic64 new_value) {
+  Atomic64 cmp = old_value;
+  __tsan_atomic64_compare_exchange_strong(ptr, &cmp, new_value,
+      __tsan_memory_order_acquire, __tsan_memory_order_acquire);
+  return cmp;
+}
+
+inline Atomic64 Release_CompareAndSwap(volatile Atomic64 *ptr,
+                                       Atomic64 old_value,
+                                       Atomic64 new_value) {
+  Atomic64 cmp = old_value;
+  __tsan_atomic64_compare_exchange_strong(ptr, &cmp, new_value,
+      __tsan_memory_order_release, __tsan_memory_order_relaxed);
+  return cmp;
+}
+
+inline void MemoryBarrierInternal() {
+  __tsan_atomic_thread_fence(__tsan_memory_order_seq_cst);
+}
+
+}  // namespace internal
+}  // namespace protobuf
+}  // namespace google
+
+#undef ATOMICOPS_COMPILER_BARRIER
+
+#endif  // GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_TSAN_H_
diff --git a/kortex_api/include/google/protobuf/stubs/atomicops_internals_x86_gcc.h b/kortex_api/include/google/protobuf/stubs/atomicops_internals_x86_gcc.h
new file mode 100644
index 0000000000000000000000000000000000000000..e80121fdf8e0cc26b1274883cd8cc5d01acfea58
--- /dev/null
+++ b/kortex_api/include/google/protobuf/stubs/atomicops_internals_x86_gcc.h
@@ -0,0 +1,293 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2012 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// This file is an internal atomic implementation, use atomicops.h instead.
+
+#ifndef GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_X86_GCC_H_
+#define GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_X86_GCC_H_
+
+namespace google {
+namespace protobuf {
+namespace internal {
+
+// This struct is not part of the public API of this module; clients may not
+// use it.
+// Features of this x86.  Values may not be correct before main() is run,
+// but are set conservatively.
+struct AtomicOps_x86CPUFeatureStruct {
+  bool has_amd_lock_mb_bug;  // Processor has AMD memory-barrier bug; do lfence
+                             // after acquire compare-and-swap.
+  bool has_sse2;             // Processor has SSE2.
+};
+extern struct AtomicOps_x86CPUFeatureStruct AtomicOps_Internalx86CPUFeatures;
+
+#define ATOMICOPS_COMPILER_BARRIER() __asm__ __volatile__("" : : : "memory")
+
+// 32-bit low-level operations on any platform.
+
+inline Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr,
+                                         Atomic32 old_value,
+                                         Atomic32 new_value) {
+  Atomic32 prev;
+  __asm__ __volatile__("lock; cmpxchgl %1,%2"
+                       : "=a" (prev)
+                       : "q" (new_value), "m" (*ptr), "0" (old_value)
+                       : "memory");
+  return prev;
+}
+
+inline Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr,
+                                         Atomic32 new_value) {
+  __asm__ __volatile__("xchgl %1,%0"  // The lock prefix is implicit for xchg.
+                       : "=r" (new_value)
+                       : "m" (*ptr), "0" (new_value)
+                       : "memory");
+  return new_value;  // Now it's the previous value.
+}
+
+inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr,
+                                          Atomic32 increment) {
+  Atomic32 temp = increment;
+  __asm__ __volatile__("lock; xaddl %0,%1"
+                       : "+r" (temp), "+m" (*ptr)
+                       : : "memory");
+  // temp now holds the old value of *ptr
+  return temp + increment;
+}
+
+inline Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr,
+                                        Atomic32 increment) {
+  Atomic32 temp = increment;
+  __asm__ __volatile__("lock; xaddl %0,%1"
+                       : "+r" (temp), "+m" (*ptr)
+                       : : "memory");
+  // temp now holds the old value of *ptr
+  if (AtomicOps_Internalx86CPUFeatures.has_amd_lock_mb_bug) {
+    __asm__ __volatile__("lfence" : : : "memory");
+  }
+  return temp + increment;
+}
+
+inline Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr,
+                                       Atomic32 old_value,
+                                       Atomic32 new_value) {
+  Atomic32 x = NoBarrier_CompareAndSwap(ptr, old_value, new_value);
+  if (AtomicOps_Internalx86CPUFeatures.has_amd_lock_mb_bug) {
+    __asm__ __volatile__("lfence" : : : "memory");
+  }
+  return x;
+}
+
+inline Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr,
+                                       Atomic32 old_value,
+                                       Atomic32 new_value) {
+  return NoBarrier_CompareAndSwap(ptr, old_value, new_value);
+}
+
+inline void NoBarrier_Store(volatile Atomic32* ptr, Atomic32 value) {
+  *ptr = value;
+}
+
+#if defined(__x86_64__)
+
+// 64-bit implementations of memory barrier can be simpler, because it
+// "mfence" is guaranteed to exist.
+inline void MemoryBarrierInternal() {
+  __asm__ __volatile__("mfence" : : : "memory");
+}
+
+inline void Acquire_Store(volatile Atomic32* ptr, Atomic32 value) {
+  *ptr = value;
+  MemoryBarrierInternal();
+}
+
+#else
+
+inline void MemoryBarrierInternal() {
+  if (AtomicOps_Internalx86CPUFeatures.has_sse2) {
+    __asm__ __volatile__("mfence" : : : "memory");
+  } else {  // mfence is faster but not present on PIII
+    Atomic32 x = 0;
+    NoBarrier_AtomicExchange(&x, 0);  // acts as a barrier on PIII
+  }
+}
+
+inline void Acquire_Store(volatile Atomic32* ptr, Atomic32 value) {
+  if (AtomicOps_Internalx86CPUFeatures.has_sse2) {
+    *ptr = value;
+    __asm__ __volatile__("mfence" : : : "memory");
+  } else {
+    NoBarrier_AtomicExchange(ptr, value);
+                          // acts as a barrier on PIII
+  }
+}
+#endif
+
+inline void Release_Store(volatile Atomic32* ptr, Atomic32 value) {
+  ATOMICOPS_COMPILER_BARRIER();
+  *ptr = value;  // An x86 store acts as a release barrier.
+  // See comments in Atomic64 version of Release_Store(), below.
+}
+
+inline Atomic32 NoBarrier_Load(volatile const Atomic32* ptr) {
+  return *ptr;
+}
+
+inline Atomic32 Acquire_Load(volatile const Atomic32* ptr) {
+  Atomic32 value = *ptr;  // An x86 load acts as a acquire barrier.
+  // See comments in Atomic64 version of Release_Store(), below.
+  ATOMICOPS_COMPILER_BARRIER();
+  return value;
+}
+
+inline Atomic32 Release_Load(volatile const Atomic32* ptr) {
+  MemoryBarrierInternal();
+  return *ptr;
+}
+
+#if defined(__x86_64__)
+
+// 64-bit low-level operations on 64-bit platform.
+
+inline Atomic64 NoBarrier_CompareAndSwap(volatile Atomic64* ptr,
+                                         Atomic64 old_value,
+                                         Atomic64 new_value) {
+  Atomic64 prev;
+  __asm__ __volatile__("lock; cmpxchgq %1,%2"
+                       : "=a" (prev)
+                       : "q" (new_value), "m" (*ptr), "0" (old_value)
+                       : "memory");
+  return prev;
+}
+
+inline Atomic64 NoBarrier_AtomicExchange(volatile Atomic64* ptr,
+                                         Atomic64 new_value) {
+  __asm__ __volatile__("xchgq %1,%0"  // The lock prefix is implicit for xchg.
+                       : "=r" (new_value)
+                       : "m" (*ptr), "0" (new_value)
+                       : "memory");
+  return new_value;  // Now it's the previous value.
+}
+
+inline Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64* ptr,
+                                          Atomic64 increment) {
+  Atomic64 temp = increment;
+  __asm__ __volatile__("lock; xaddq %0,%1"
+                       : "+r" (temp), "+m" (*ptr)
+                       : : "memory");
+  // temp now contains the previous value of *ptr
+  return temp + increment;
+}
+
+inline Atomic64 Barrier_AtomicIncrement(volatile Atomic64* ptr,
+                                        Atomic64 increment) {
+  Atomic64 temp = increment;
+  __asm__ __volatile__("lock; xaddq %0,%1"
+                       : "+r" (temp), "+m" (*ptr)
+                       : : "memory");
+  // temp now contains the previous value of *ptr
+  if (AtomicOps_Internalx86CPUFeatures.has_amd_lock_mb_bug) {
+    __asm__ __volatile__("lfence" : : : "memory");
+  }
+  return temp + increment;
+}
+
+inline void NoBarrier_Store(volatile Atomic64* ptr, Atomic64 value) {
+  *ptr = value;
+}
+
+inline void Acquire_Store(volatile Atomic64* ptr, Atomic64 value) {
+  *ptr = value;
+  MemoryBarrierInternal();
+}
+
+inline void Release_Store(volatile Atomic64* ptr, Atomic64 value) {
+  ATOMICOPS_COMPILER_BARRIER();
+
+  *ptr = value;  // An x86 store acts as a release barrier
+                 // for current AMD/Intel chips as of Jan 2008.
+                 // See also Acquire_Load(), below.
+
+  // When new chips come out, check:
+  //  IA-32 Intel Architecture Software Developer's Manual, Volume 3:
+  //  System Programming Guide, Chatper 7: Multiple-processor management,
+  //  Section 7.2, Memory Ordering.
+  // Last seen at:
+  //   http://developer.intel.com/design/pentium4/manuals/index_new.htm
+  //
+  // x86 stores/loads fail to act as barriers for a few instructions (clflush
+  // maskmovdqu maskmovq movntdq movnti movntpd movntps movntq) but these are
+  // not generated by the compiler, and are rare.  Users of these instructions
+  // need to know about cache behaviour in any case since all of these involve
+  // either flushing cache lines or non-temporal cache hints.
+}
+
+inline Atomic64 NoBarrier_Load(volatile const Atomic64* ptr) {
+  return *ptr;
+}
+
+inline Atomic64 Acquire_Load(volatile const Atomic64* ptr) {
+  Atomic64 value = *ptr;  // An x86 load acts as a acquire barrier,
+                          // for current AMD/Intel chips as of Jan 2008.
+                          // See also Release_Store(), above.
+  ATOMICOPS_COMPILER_BARRIER();
+  return value;
+}
+
+inline Atomic64 Release_Load(volatile const Atomic64* ptr) {
+  MemoryBarrierInternal();
+  return *ptr;
+}
+
+inline Atomic64 Acquire_CompareAndSwap(volatile Atomic64* ptr,
+                                       Atomic64 old_value,
+                                       Atomic64 new_value) {
+  Atomic64 x = NoBarrier_CompareAndSwap(ptr, old_value, new_value);
+  if (AtomicOps_Internalx86CPUFeatures.has_amd_lock_mb_bug) {
+    __asm__ __volatile__("lfence" : : : "memory");
+  }
+  return x;
+}
+
+inline Atomic64 Release_CompareAndSwap(volatile Atomic64* ptr,
+                                       Atomic64 old_value,
+                                       Atomic64 new_value) {
+  return NoBarrier_CompareAndSwap(ptr, old_value, new_value);
+}
+
+#endif  // defined(__x86_64__)
+
+}  // namespace internal
+}  // namespace protobuf
+}  // namespace google
+
+#undef ATOMICOPS_COMPILER_BARRIER
+
+#endif  // GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_X86_GCC_H_
diff --git a/kortex_api/include/google/protobuf/stubs/atomicops_internals_x86_msvc.h b/kortex_api/include/google/protobuf/stubs/atomicops_internals_x86_msvc.h
new file mode 100644
index 0000000000000000000000000000000000000000..34d60d98e02b339e4728c547ce05dfe787db70cd
--- /dev/null
+++ b/kortex_api/include/google/protobuf/stubs/atomicops_internals_x86_msvc.h
@@ -0,0 +1,150 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2012 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// This file is an internal atomic implementation, use atomicops.h instead.
+
+#ifndef GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_X86_MSVC_H_
+#define GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_X86_MSVC_H_
+
+namespace google {
+namespace protobuf {
+namespace internal {
+
+inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr,
+                                          Atomic32 increment) {
+  return Barrier_AtomicIncrement(ptr, increment);
+}
+
+#if !(defined(_MSC_VER) && _MSC_VER >= 1400)
+#error "We require at least vs2005 for MemoryBarrier"
+#endif
+
+inline Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr,
+                                       Atomic32 old_value,
+                                       Atomic32 new_value) {
+  return NoBarrier_CompareAndSwap(ptr, old_value, new_value);
+}
+
+inline Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr,
+                                       Atomic32 old_value,
+                                       Atomic32 new_value) {
+  return NoBarrier_CompareAndSwap(ptr, old_value, new_value);
+}
+
+inline void NoBarrier_Store(volatile Atomic32* ptr, Atomic32 value) {
+  *ptr = value;
+}
+
+inline void Acquire_Store(volatile Atomic32* ptr, Atomic32 value) {
+  NoBarrier_AtomicExchange(ptr, value);
+              // acts as a barrier in this implementation
+}
+
+inline void Release_Store(volatile Atomic32* ptr, Atomic32 value) {
+  *ptr = value;  // works w/o barrier for current Intel chips as of June 2005
+  // See comments in Atomic64 version of Release_Store() below.
+}
+
+inline Atomic32 NoBarrier_Load(volatile const Atomic32* ptr) {
+  return *ptr;
+}
+
+inline Atomic32 Acquire_Load(volatile const Atomic32* ptr) {
+  Atomic32 value = *ptr;
+  return value;
+}
+
+inline Atomic32 Release_Load(volatile const Atomic32* ptr) {
+  MemoryBarrierInternal();
+  return *ptr;
+}
+
+#if defined(_WIN64)
+
+// 64-bit low-level operations on 64-bit platform.
+
+inline Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64* ptr,
+                                          Atomic64 increment) {
+  return Barrier_AtomicIncrement(ptr, increment);
+}
+
+inline void NoBarrier_Store(volatile Atomic64* ptr, Atomic64 value) {
+  *ptr = value;
+}
+
+inline void Acquire_Store(volatile Atomic64* ptr, Atomic64 value) {
+  NoBarrier_AtomicExchange(ptr, value);
+              // acts as a barrier in this implementation
+}
+
+inline void Release_Store(volatile Atomic64* ptr, Atomic64 value) {
+  *ptr = value;  // works w/o barrier for current Intel chips as of June 2005
+
+  // When new chips come out, check:
+  //  IA-32 Intel Architecture Software Developer's Manual, Volume 3:
+  //  System Programming Guide, Chatper 7: Multiple-processor management,
+  //  Section 7.2, Memory Ordering.
+  // Last seen at:
+  //   http://developer.intel.com/design/pentium4/manuals/index_new.htm
+}
+
+inline Atomic64 NoBarrier_Load(volatile const Atomic64* ptr) {
+  return *ptr;
+}
+
+inline Atomic64 Acquire_Load(volatile const Atomic64* ptr) {
+  Atomic64 value = *ptr;
+  return value;
+}
+
+inline Atomic64 Release_Load(volatile const Atomic64* ptr) {
+  MemoryBarrierInternal();
+  return *ptr;
+}
+
+inline Atomic64 Acquire_CompareAndSwap(volatile Atomic64* ptr,
+                                       Atomic64 old_value,
+                                       Atomic64 new_value) {
+  return NoBarrier_CompareAndSwap(ptr, old_value, new_value);
+}
+
+inline Atomic64 Release_CompareAndSwap(volatile Atomic64* ptr,
+                                       Atomic64 old_value,
+                                       Atomic64 new_value) {
+  return NoBarrier_CompareAndSwap(ptr, old_value, new_value);
+}
+
+#endif  // defined(_WIN64)
+
+}  // namespace internal
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_ATOMICOPS_INTERNALS_X86_MSVC_H_
diff --git a/kortex_api/include/google/protobuf/stubs/bytestream.h b/kortex_api/include/google/protobuf/stubs/bytestream.h
new file mode 100644
index 0000000000000000000000000000000000000000..86510d140bafc8256f894edccac50bef4b72b37f
--- /dev/null
+++ b/kortex_api/include/google/protobuf/stubs/bytestream.h
@@ -0,0 +1,348 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// This file declares the ByteSink and ByteSource abstract interfaces. These
+// interfaces represent objects that consume (ByteSink) or produce (ByteSource)
+// a sequence of bytes. Using these abstract interfaces in your APIs can help
+// make your code work with a variety of input and output types.
+//
+// This file also declares the following commonly used implementations of these
+// interfaces.
+//
+//   ByteSink:
+//      UncheckedArrayByteSink  Writes to an array, without bounds checking
+//      CheckedArrayByteSink    Writes to an array, with bounds checking
+//      GrowingArrayByteSink    Allocates and writes to a growable buffer
+//      StringByteSink          Writes to an STL string
+//      NullByteSink            Consumes a never-ending stream of bytes
+//
+//   ByteSource:
+//      ArrayByteSource         Reads from an array or string/StringPiece
+//      LimitedByteSource       Limits the number of bytes read from an
+
+#ifndef GOOGLE_PROTOBUF_STUBS_BYTESTREAM_H_
+#define GOOGLE_PROTOBUF_STUBS_BYTESTREAM_H_
+
+#include <stddef.h>
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/stringpiece.h>
+
+class CordByteSink;
+class MemBlock;
+
+namespace google {
+namespace protobuf {
+namespace strings {
+
+// An abstract interface for an object that consumes a sequence of bytes. This
+// interface offers a way to append data as well as a Flush() function.
+//
+// Example:
+//
+//   string my_data;
+//   ...
+//   ByteSink* sink = ...
+//   sink->Append(my_data.data(), my_data.size());
+//   sink->Flush();
+//
+class LIBPROTOBUF_EXPORT ByteSink {
+ public:
+  ByteSink() {}
+  virtual ~ByteSink() {}
+
+  // Appends the "n" bytes starting at "bytes".
+  virtual void Append(const char* bytes, size_t n) = 0;
+
+  // Flushes internal buffers. The default implemenation does nothing. ByteSink
+  // subclasses may use internal buffers that require calling Flush() at the end
+  // of the stream.
+  virtual void Flush();
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ByteSink);
+};
+
+// An abstract interface for an object that produces a fixed-size sequence of
+// bytes.
+//
+// Example:
+//
+//   ByteSource* source = ...
+//   while (source->Available() > 0) {
+//     StringPiece data = source->Peek();
+//     ... do something with "data" ...
+//     source->Skip(data.length());
+//   }
+//
+class LIBPROTOBUF_EXPORT ByteSource {
+ public:
+  ByteSource() {}
+  virtual ~ByteSource() {}
+
+  // Returns the number of bytes left to read from the source. Available()
+  // should decrease by N each time Skip(N) is called. Available() may not
+  // increase. Available() returning 0 indicates that the ByteSource is
+  // exhausted.
+  //
+  // Note: Size() may have been a more appropriate name as it's more
+  //       indicative of the fixed-size nature of a ByteSource.
+  virtual size_t Available() const = 0;
+
+  // Returns a StringPiece of the next contiguous region of the source. Does not
+  // reposition the source. The returned region is empty iff Available() == 0.
+  //
+  // The returned region is valid until the next call to Skip() or until this
+  // object is destroyed, whichever occurs first.
+  //
+  // The length of the returned StringPiece will be <= Available().
+  virtual StringPiece Peek() = 0;
+
+  // Skips the next n bytes. Invalidates any StringPiece returned by a previous
+  // call to Peek().
+  //
+  // REQUIRES: Available() >= n
+  virtual void Skip(size_t n) = 0;
+
+  // Writes the next n bytes in this ByteSource to the given ByteSink, and
+  // advances this ByteSource past the copied bytes. The default implementation
+  // of this method just copies the bytes normally, but subclasses might
+  // override CopyTo to optimize certain cases.
+  //
+  // REQUIRES: Available() >= n
+  virtual void CopyTo(ByteSink* sink, size_t n);
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ByteSource);
+};
+
+//
+// Some commonly used implementations of ByteSink
+//
+
+// Implementation of ByteSink that writes to an unsized byte array. No
+// bounds-checking is performed--it is the caller's responsibility to ensure
+// that the destination array is large enough.
+//
+// Example:
+//
+//   char buf[10];
+//   UncheckedArrayByteSink sink(buf);
+//   sink.Append("hi", 2);    // OK
+//   sink.Append(data, 100);  // WOOPS! Overflows buf[10].
+//
+class LIBPROTOBUF_EXPORT UncheckedArrayByteSink : public ByteSink {
+ public:
+  explicit UncheckedArrayByteSink(char* dest) : dest_(dest) {}
+  virtual void Append(const char* data, size_t n);
+
+  // Returns the current output pointer so that a caller can see how many bytes
+  // were produced.
+  //
+  // Note: this method is not part of the ByteSink interface.
+  char* CurrentDestination() const { return dest_; }
+
+ private:
+  char* dest_;
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(UncheckedArrayByteSink);
+};
+
+// Implementation of ByteSink that writes to a sized byte array. This sink will
+// not write more than "capacity" bytes to outbuf. Once "capacity" bytes are
+// appended, subsequent bytes will be ignored and Overflowed() will return true.
+// Overflowed() does not cause a runtime error (i.e., it does not CHECK fail).
+//
+// Example:
+//
+//   char buf[10];
+//   CheckedArrayByteSink sink(buf, 10);
+//   sink.Append("hi", 2);    // OK
+//   sink.Append(data, 100);  // Will only write 8 more bytes
+//
+class LIBPROTOBUF_EXPORT CheckedArrayByteSink : public ByteSink {
+ public:
+  CheckedArrayByteSink(char* outbuf, size_t capacity);
+  virtual void Append(const char* bytes, size_t n);
+
+  // Returns the number of bytes actually written to the sink.
+  size_t NumberOfBytesWritten() const { return size_; }
+
+  // Returns true if any bytes were discarded, i.e., if there was an
+  // attempt to write more than 'capacity' bytes.
+  bool Overflowed() const { return overflowed_; }
+
+ private:
+  char* outbuf_;
+  const size_t capacity_;
+  size_t size_;
+  bool overflowed_;
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(CheckedArrayByteSink);
+};
+
+// Implementation of ByteSink that allocates an internal buffer (a char array)
+// and expands it as needed to accommodate appended data (similar to a string),
+// and allows the caller to take ownership of the internal buffer via the
+// GetBuffer() method. The buffer returned from GetBuffer() must be deleted by
+// the caller with delete[]. GetBuffer() also sets the internal buffer to be
+// empty, and subsequent appends to the sink will create a new buffer. The
+// destructor will free the internal buffer if GetBuffer() was not called.
+//
+// Example:
+//
+//   GrowingArrayByteSink sink(10);
+//   sink.Append("hi", 2);
+//   sink.Append(data, n);
+//   const char* buf = sink.GetBuffer();  // Ownership transferred
+//   delete[] buf;
+//
+class LIBPROTOBUF_EXPORT GrowingArrayByteSink : public strings::ByteSink {
+ public:
+  explicit GrowingArrayByteSink(size_t estimated_size);
+  virtual ~GrowingArrayByteSink();
+  virtual void Append(const char* bytes, size_t n);
+
+  // Returns the allocated buffer, and sets nbytes to its size. The caller takes
+  // ownership of the buffer and must delete it with delete[].
+  char* GetBuffer(size_t* nbytes);
+
+ private:
+  void Expand(size_t amount);
+  void ShrinkToFit();
+
+  size_t capacity_;
+  char* buf_;
+  size_t size_;
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(GrowingArrayByteSink);
+};
+
+// Implementation of ByteSink that appends to the given string.
+// Existing contents of "dest" are not modified; new data is appended.
+//
+// Example:
+//
+//   string dest = "Hello ";
+//   StringByteSink sink(&dest);
+//   sink.Append("World", 5);
+//   assert(dest == "Hello World");
+//
+class LIBPROTOBUF_EXPORT StringByteSink : public ByteSink {
+ public:
+  explicit StringByteSink(string* dest) : dest_(dest) {}
+  virtual void Append(const char* data, size_t n);
+
+ private:
+  string* dest_;
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(StringByteSink);
+};
+
+// Implementation of ByteSink that discards all data.
+//
+// Example:
+//
+//   NullByteSink sink;
+//   sink.Append(data, data.size());  // All data ignored.
+//
+class LIBPROTOBUF_EXPORT NullByteSink : public ByteSink {
+ public:
+  NullByteSink() {}
+  virtual void Append(const char *data, size_t n) {}
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(NullByteSink);
+};
+
+//
+// Some commonly used implementations of ByteSource
+//
+
+// Implementation of ByteSource that reads from a StringPiece.
+//
+// Example:
+//
+//   string data = "Hello";
+//   ArrayByteSource source(data);
+//   assert(source.Available() == 5);
+//   assert(source.Peek() == "Hello");
+//
+class LIBPROTOBUF_EXPORT ArrayByteSource : public ByteSource {
+ public:
+  explicit ArrayByteSource(StringPiece s) : input_(s) {}
+
+  virtual size_t Available() const;
+  virtual StringPiece Peek();
+  virtual void Skip(size_t n);
+
+ private:
+  StringPiece   input_;
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ArrayByteSource);
+};
+
+// Implementation of ByteSource that wraps another ByteSource, limiting the
+// number of bytes returned.
+//
+// The caller maintains ownership of the underlying source, and may not use the
+// underlying source while using the LimitByteSource object.  The underlying
+// source's pointer is advanced by n bytes every time this LimitByteSource
+// object is advanced by n.
+//
+// Example:
+//
+//   string data = "Hello World";
+//   ArrayByteSource abs(data);
+//   assert(abs.Available() == data.size());
+//
+//   LimitByteSource limit(abs, 5);
+//   assert(limit.Available() == 5);
+//   assert(limit.Peek() == "Hello");
+//
+class LIBPROTOBUF_EXPORT LimitByteSource : public ByteSource {
+ public:
+  // Returns at most "limit" bytes from "source".
+  LimitByteSource(ByteSource* source, size_t limit);
+
+  virtual size_t Available() const;
+  virtual StringPiece Peek();
+  virtual void Skip(size_t n);
+
+  // We override CopyTo so that we can forward to the underlying source, in
+  // case it has an efficient implementation of CopyTo.
+  virtual void CopyTo(ByteSink* sink, size_t n);
+
+ private:
+  ByteSource* source_;
+  size_t limit_;
+};
+
+}  // namespace strings
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_STUBS_BYTESTREAM_H_
diff --git a/kortex_api/include/google/protobuf/stubs/callback.h b/kortex_api/include/google/protobuf/stubs/callback.h
new file mode 100644
index 0000000000000000000000000000000000000000..9ec049795579ad3778bda77c0daf51f476576d21
--- /dev/null
+++ b/kortex_api/include/google/protobuf/stubs/callback.h
@@ -0,0 +1,576 @@
+#ifndef GOOGLE_PROTOBUF_STUBS_CALLBACK_H_
+#define GOOGLE_PROTOBUF_STUBS_CALLBACK_H_
+
+#include <google/protobuf/stubs/macros.h>
+#include <google/protobuf/stubs/type_traits.h>
+
+// ===================================================================
+// emulates google3/base/callback.h
+
+namespace google {
+namespace protobuf {
+
+// Abstract interface for a callback.  When calling an RPC, you must provide
+// a Closure to call when the procedure completes.  See the Service interface
+// in service.h.
+//
+// To automatically construct a Closure which calls a particular function or
+// method with a particular set of parameters, use the NewCallback() function.
+// Example:
+//   void FooDone(const FooResponse* response) {
+//     ...
+//   }
+//
+//   void CallFoo() {
+//     ...
+//     // When done, call FooDone() and pass it a pointer to the response.
+//     Closure* callback = NewCallback(&FooDone, response);
+//     // Make the call.
+//     service->Foo(controller, request, response, callback);
+//   }
+//
+// Example that calls a method:
+//   class Handler {
+//    public:
+//     ...
+//
+//     void FooDone(const FooResponse* response) {
+//       ...
+//     }
+//
+//     void CallFoo() {
+//       ...
+//       // When done, call FooDone() and pass it a pointer to the response.
+//       Closure* callback = NewCallback(this, &Handler::FooDone, response);
+//       // Make the call.
+//       service->Foo(controller, request, response, callback);
+//     }
+//   };
+//
+// Currently NewCallback() supports binding zero, one, or two arguments.
+//
+// Callbacks created with NewCallback() automatically delete themselves when
+// executed.  They should be used when a callback is to be called exactly
+// once (usually the case with RPC callbacks).  If a callback may be called
+// a different number of times (including zero), create it with
+// NewPermanentCallback() instead.  You are then responsible for deleting the
+// callback (using the "delete" keyword as normal).
+//
+// Note that NewCallback() is a bit touchy regarding argument types.  Generally,
+// the values you provide for the parameter bindings must exactly match the
+// types accepted by the callback function.  For example:
+//   void Foo(string s);
+//   NewCallback(&Foo, "foo");          // WON'T WORK:  const char* != string
+//   NewCallback(&Foo, string("foo"));  // WORKS
+// Also note that the arguments cannot be references:
+//   void Foo(const string& s);
+//   string my_str;
+//   NewCallback(&Foo, my_str);  // WON'T WORK:  Can't use referecnes.
+// However, correctly-typed pointers will work just fine.
+class LIBPROTOBUF_EXPORT Closure {
+ public:
+  Closure() {}
+  virtual ~Closure();
+
+  virtual void Run() = 0;
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Closure);
+};
+
+template<typename R>
+class ResultCallback {
+ public:
+  ResultCallback() {}
+  virtual ~ResultCallback() {}
+
+  virtual R Run() = 0;
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ResultCallback);
+};
+
+template<typename R, typename A1>
+class LIBPROTOBUF_EXPORT ResultCallback1 {
+ public:
+  ResultCallback1() {}
+  virtual ~ResultCallback1() {}
+
+  virtual R Run(A1) = 0;
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ResultCallback1);
+};
+
+template<typename R, typename A1, typename A2>
+class LIBPROTOBUF_EXPORT ResultCallback2 {
+ public:
+  ResultCallback2() {}
+  virtual ~ResultCallback2() {}
+
+  virtual R Run(A1,A2) = 0;
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ResultCallback2);
+};
+
+namespace internal {
+
+class LIBPROTOBUF_EXPORT FunctionClosure0 : public Closure {
+ public:
+  typedef void (*FunctionType)();
+
+  FunctionClosure0(FunctionType function, bool self_deleting)
+    : function_(function), self_deleting_(self_deleting) {}
+  ~FunctionClosure0();
+
+  void Run() {
+    bool needs_delete = self_deleting_;  // read in case callback deletes
+    function_();
+    if (needs_delete) delete this;
+  }
+
+ private:
+  FunctionType function_;
+  bool self_deleting_;
+};
+
+template <typename Class>
+class MethodClosure0 : public Closure {
+ public:
+  typedef void (Class::*MethodType)();
+
+  MethodClosure0(Class* object, MethodType method, bool self_deleting)
+    : object_(object), method_(method), self_deleting_(self_deleting) {}
+  ~MethodClosure0() {}
+
+  void Run() {
+    bool needs_delete = self_deleting_;  // read in case callback deletes
+    (object_->*method_)();
+    if (needs_delete) delete this;
+  }
+
+ private:
+  Class* object_;
+  MethodType method_;
+  bool self_deleting_;
+};
+
+template <typename Arg1>
+class FunctionClosure1 : public Closure {
+ public:
+  typedef void (*FunctionType)(Arg1 arg1);
+
+  FunctionClosure1(FunctionType function, bool self_deleting,
+                   Arg1 arg1)
+    : function_(function), self_deleting_(self_deleting),
+      arg1_(arg1) {}
+  ~FunctionClosure1() {}
+
+  void Run() {
+    bool needs_delete = self_deleting_;  // read in case callback deletes
+    function_(arg1_);
+    if (needs_delete) delete this;
+  }
+
+ private:
+  FunctionType function_;
+  bool self_deleting_;
+  Arg1 arg1_;
+};
+
+template <typename Class, typename Arg1>
+class MethodClosure1 : public Closure {
+ public:
+  typedef void (Class::*MethodType)(Arg1 arg1);
+
+  MethodClosure1(Class* object, MethodType method, bool self_deleting,
+                 Arg1 arg1)
+    : object_(object), method_(method), self_deleting_(self_deleting),
+      arg1_(arg1) {}
+  ~MethodClosure1() {}
+
+  void Run() {
+    bool needs_delete = self_deleting_;  // read in case callback deletes
+    (object_->*method_)(arg1_);
+    if (needs_delete) delete this;
+  }
+
+ private:
+  Class* object_;
+  MethodType method_;
+  bool self_deleting_;
+  Arg1 arg1_;
+};
+
+template <typename Arg1, typename Arg2>
+class FunctionClosure2 : public Closure {
+ public:
+  typedef void (*FunctionType)(Arg1 arg1, Arg2 arg2);
+
+  FunctionClosure2(FunctionType function, bool self_deleting,
+                   Arg1 arg1, Arg2 arg2)
+    : function_(function), self_deleting_(self_deleting),
+      arg1_(arg1), arg2_(arg2) {}
+  ~FunctionClosure2() {}
+
+  void Run() {
+    bool needs_delete = self_deleting_;  // read in case callback deletes
+    function_(arg1_, arg2_);
+    if (needs_delete) delete this;
+  }
+
+ private:
+  FunctionType function_;
+  bool self_deleting_;
+  Arg1 arg1_;
+  Arg2 arg2_;
+};
+
+template <typename Class, typename Arg1, typename Arg2>
+class MethodClosure2 : public Closure {
+ public:
+  typedef void (Class::*MethodType)(Arg1 arg1, Arg2 arg2);
+
+  MethodClosure2(Class* object, MethodType method, bool self_deleting,
+                 Arg1 arg1, Arg2 arg2)
+    : object_(object), method_(method), self_deleting_(self_deleting),
+      arg1_(arg1), arg2_(arg2) {}
+  ~MethodClosure2() {}
+
+  void Run() {
+    bool needs_delete = self_deleting_;  // read in case callback deletes
+    (object_->*method_)(arg1_, arg2_);
+    if (needs_delete) delete this;
+  }
+
+ private:
+  Class* object_;
+  MethodType method_;
+  bool self_deleting_;
+  Arg1 arg1_;
+  Arg2 arg2_;
+};
+
+template<typename R>
+class FunctionResultCallback_0_0 : public ResultCallback<R> {
+ public:
+  typedef R (*FunctionType)();
+
+  FunctionResultCallback_0_0(FunctionType function, bool self_deleting)
+      : function_(function), self_deleting_(self_deleting) {}
+  ~FunctionResultCallback_0_0() {}
+
+  R Run() {
+    bool needs_delete = self_deleting_;  // read in case callback deletes
+    R result = function_();
+    if (needs_delete) delete this;
+    return result;
+  }
+
+ private:
+  FunctionType function_;
+  bool self_deleting_;
+};
+
+template<typename R, typename P1>
+class FunctionResultCallback_1_0 : public ResultCallback<R> {
+ public:
+  typedef R (*FunctionType)(P1);
+
+  FunctionResultCallback_1_0(FunctionType function, bool self_deleting,
+                             P1 p1)
+      : function_(function), self_deleting_(self_deleting), p1_(p1) {}
+  ~FunctionResultCallback_1_0() {}
+
+  R Run() {
+    bool needs_delete = self_deleting_;  // read in case callback deletes
+    R result = function_(p1_);
+    if (needs_delete) delete this;
+    return result;
+  }
+
+ private:
+  FunctionType function_;
+  bool self_deleting_;
+  P1 p1_;
+};
+
+template<typename R, typename Arg1>
+class FunctionResultCallback_0_1 : public ResultCallback1<R, Arg1> {
+ public:
+  typedef R (*FunctionType)(Arg1 arg1);
+
+  FunctionResultCallback_0_1(FunctionType function, bool self_deleting)
+      : function_(function), self_deleting_(self_deleting) {}
+  ~FunctionResultCallback_0_1() {}
+
+  R Run(Arg1 a1) {
+    bool needs_delete = self_deleting_;  // read in case callback deletes
+    R result = function_(a1);
+    if (needs_delete) delete this;
+    return result;
+  }
+
+ private:
+  FunctionType function_;
+  bool self_deleting_;
+};
+
+template<typename R, typename P1, typename A1>
+class FunctionResultCallback_1_1 : public ResultCallback1<R, A1> {
+ public:
+  typedef R (*FunctionType)(P1, A1);
+
+  FunctionResultCallback_1_1(FunctionType function, bool self_deleting,
+                             P1 p1)
+      : function_(function), self_deleting_(self_deleting), p1_(p1) {}
+  ~FunctionResultCallback_1_1() {}
+
+  R Run(A1 a1) {
+    bool needs_delete = self_deleting_;  // read in case callback deletes
+    R result = function_(p1_, a1);
+    if (needs_delete) delete this;
+    return result;
+  }
+
+ private:
+  FunctionType function_;
+  bool self_deleting_;
+  P1 p1_;
+};
+
+template <typename T>
+struct InternalConstRef {
+  typedef typename remove_reference<T>::type base_type;
+  typedef const base_type& type;
+};
+
+template<typename R, typename T>
+class MethodResultCallback_0_0 : public ResultCallback<R> {
+ public:
+  typedef R (T::*MethodType)();
+  MethodResultCallback_0_0(T* object, MethodType method, bool self_deleting)
+      : object_(object),
+        method_(method),
+        self_deleting_(self_deleting) {}
+  ~MethodResultCallback_0_0() {}
+
+  R Run() {
+    bool needs_delete = self_deleting_;
+    R result = (object_->*method_)();
+    if (needs_delete) delete this;
+    return result;
+  }
+
+ private:
+  T* object_;
+  MethodType method_;
+  bool self_deleting_;
+};
+
+template <typename R, typename T, typename P1, typename P2, typename P3,
+          typename P4, typename P5, typename A1, typename A2>
+class MethodResultCallback_5_2 : public ResultCallback2<R, A1, A2> {
+ public:
+  typedef R (T::*MethodType)(P1, P2, P3, P4, P5, A1, A2);
+  MethodResultCallback_5_2(T* object, MethodType method, bool self_deleting,
+                           P1 p1, P2 p2, P3 p3, P4 p4, P5 p5)
+      : object_(object),
+        method_(method),
+        self_deleting_(self_deleting),
+        p1_(p1),
+        p2_(p2),
+        p3_(p3),
+        p4_(p4),
+        p5_(p5) {}
+  ~MethodResultCallback_5_2() {}
+
+  R Run(A1 a1, A2 a2) {
+    bool needs_delete = self_deleting_;
+    R result = (object_->*method_)(p1_, p2_, p3_, p4_, p5_, a1, a2);
+    if (needs_delete) delete this;
+    return result;
+  }
+
+ private:
+  T* object_;
+  MethodType method_;
+  bool self_deleting_;
+  typename remove_reference<P1>::type p1_;
+  typename remove_reference<P2>::type p2_;
+  typename remove_reference<P3>::type p3_;
+  typename remove_reference<P4>::type p4_;
+  typename remove_reference<P5>::type p5_;
+};
+
+}  // namespace internal
+
+// See Closure.
+inline Closure* NewCallback(void (*function)()) {
+  return new internal::FunctionClosure0(function, true);
+}
+
+// See Closure.
+inline Closure* NewPermanentCallback(void (*function)()) {
+  return new internal::FunctionClosure0(function, false);
+}
+
+// See Closure.
+template <typename Class>
+inline Closure* NewCallback(Class* object, void (Class::*method)()) {
+  return new internal::MethodClosure0<Class>(object, method, true);
+}
+
+// See Closure.
+template <typename Class>
+inline Closure* NewPermanentCallback(Class* object, void (Class::*method)()) {
+  return new internal::MethodClosure0<Class>(object, method, false);
+}
+
+// See Closure.
+template <typename Arg1>
+inline Closure* NewCallback(void (*function)(Arg1),
+                            Arg1 arg1) {
+  return new internal::FunctionClosure1<Arg1>(function, true, arg1);
+}
+
+// See Closure.
+template <typename Arg1>
+inline Closure* NewPermanentCallback(void (*function)(Arg1),
+                                     Arg1 arg1) {
+  return new internal::FunctionClosure1<Arg1>(function, false, arg1);
+}
+
+// See Closure.
+template <typename Class, typename Arg1>
+inline Closure* NewCallback(Class* object, void (Class::*method)(Arg1),
+                            Arg1 arg1) {
+  return new internal::MethodClosure1<Class, Arg1>(object, method, true, arg1);
+}
+
+// See Closure.
+template <typename Class, typename Arg1>
+inline Closure* NewPermanentCallback(Class* object, void (Class::*method)(Arg1),
+                                     Arg1 arg1) {
+  return new internal::MethodClosure1<Class, Arg1>(object, method, false, arg1);
+}
+
+// See Closure.
+template <typename Arg1, typename Arg2>
+inline Closure* NewCallback(void (*function)(Arg1, Arg2),
+                            Arg1 arg1, Arg2 arg2) {
+  return new internal::FunctionClosure2<Arg1, Arg2>(
+    function, true, arg1, arg2);
+}
+
+// See Closure.
+template <typename Arg1, typename Arg2>
+inline Closure* NewPermanentCallback(void (*function)(Arg1, Arg2),
+                                     Arg1 arg1, Arg2 arg2) {
+  return new internal::FunctionClosure2<Arg1, Arg2>(
+    function, false, arg1, arg2);
+}
+
+// See Closure.
+template <typename Class, typename Arg1, typename Arg2>
+inline Closure* NewCallback(Class* object, void (Class::*method)(Arg1, Arg2),
+                            Arg1 arg1, Arg2 arg2) {
+  return new internal::MethodClosure2<Class, Arg1, Arg2>(
+    object, method, true, arg1, arg2);
+}
+
+// See Closure.
+template <typename Class, typename Arg1, typename Arg2>
+inline Closure* NewPermanentCallback(
+    Class* object, void (Class::*method)(Arg1, Arg2),
+    Arg1 arg1, Arg2 arg2) {
+  return new internal::MethodClosure2<Class, Arg1, Arg2>(
+    object, method, false, arg1, arg2);
+}
+
+// See ResultCallback
+template<typename R>
+inline ResultCallback<R>* NewCallback(R (*function)()) {
+  return new internal::FunctionResultCallback_0_0<R>(function, true);
+}
+
+// See ResultCallback
+template<typename R>
+inline ResultCallback<R>* NewPermanentCallback(R (*function)()) {
+  return new internal::FunctionResultCallback_0_0<R>(function, false);
+}
+
+// See ResultCallback
+template<typename R, typename P1>
+inline ResultCallback<R>* NewCallback(R (*function)(P1), P1 p1) {
+  return new internal::FunctionResultCallback_1_0<R, P1>(
+      function, true, p1);
+}
+
+// See ResultCallback
+template<typename R, typename P1>
+inline ResultCallback<R>* NewPermanentCallback(
+    R (*function)(P1), P1 p1) {
+  return new internal::FunctionResultCallback_1_0<R, P1>(
+      function, false, p1);
+}
+
+// See ResultCallback1
+template<typename R, typename A1>
+inline ResultCallback1<R, A1>* NewCallback(R (*function)(A1)) {
+  return new internal::FunctionResultCallback_0_1<R, A1>(function, true);
+}
+
+// See ResultCallback1
+template<typename R, typename A1>
+inline ResultCallback1<R, A1>* NewPermanentCallback(R (*function)(A1)) {
+  return new internal::FunctionResultCallback_0_1<R, A1>(function, false);
+}
+
+// See ResultCallback1
+template<typename R, typename P1, typename A1>
+inline ResultCallback1<R, A1>* NewCallback(R (*function)(P1, A1), P1 p1) {
+  return new internal::FunctionResultCallback_1_1<R, P1, A1>(
+      function, true, p1);
+}
+
+// See ResultCallback1
+template<typename R, typename P1, typename A1>
+inline ResultCallback1<R, A1>* NewPermanentCallback(
+    R (*function)(P1, A1), P1 p1) {
+  return new internal::FunctionResultCallback_1_1<R, P1, A1>(
+      function, false, p1);
+}
+
+// See MethodResultCallback_0_0
+template <typename R, typename T1, typename T2>
+inline ResultCallback<R>* NewPermanentCallback(
+    T1* object, R (T2::*function)()) {
+  return new internal::MethodResultCallback_0_0<R, T1>(object, function, false);
+}
+
+// See MethodResultCallback_5_2
+template <typename R, typename T, typename P1, typename P2, typename P3,
+          typename P4, typename P5, typename A1, typename A2>
+inline ResultCallback2<R, A1, A2>* NewPermanentCallback(
+    T* object, R (T::*function)(P1, P2, P3, P4, P5, A1, A2),
+    typename internal::InternalConstRef<P1>::type p1,
+    typename internal::InternalConstRef<P2>::type p2,
+    typename internal::InternalConstRef<P3>::type p3,
+    typename internal::InternalConstRef<P4>::type p4,
+    typename internal::InternalConstRef<P5>::type p5) {
+  return new internal::MethodResultCallback_5_2<R, T, P1, P2, P3, P4, P5, A1,
+                                                A2>(object, function, false, p1,
+                                                    p2, p3, p4, p5);
+}
+
+// A function which does nothing.  Useful for creating no-op callbacks, e.g.:
+//   Closure* nothing = NewCallback(&DoNothing);
+void LIBPROTOBUF_EXPORT DoNothing();
+
+
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_STUBS_CALLBACK_H_
diff --git a/kortex_api/include/google/protobuf/stubs/casts.h b/kortex_api/include/google/protobuf/stubs/casts.h
new file mode 100644
index 0000000000000000000000000000000000000000..be652849ef14e961d5ec4eace18bf741edd7ccb6
--- /dev/null
+++ b/kortex_api/include/google/protobuf/stubs/casts.h
@@ -0,0 +1,133 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2014 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_CASTS_H__
+#define GOOGLE_PROTOBUF_CASTS_H__
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/type_traits.h>
+
+namespace google {
+namespace protobuf {
+namespace internal {
+// Use implicit_cast as a safe version of static_cast or const_cast
+// for upcasting in the type hierarchy (i.e. casting a pointer to Foo
+// to a pointer to SuperclassOfFoo or casting a pointer to Foo to
+// a const pointer to Foo).
+// When you use implicit_cast, the compiler checks that the cast is safe.
+// Such explicit implicit_casts are necessary in surprisingly many
+// situations where C++ demands an exact type match instead of an
+// argument type convertable to a target type.
+//
+// The From type can be inferred, so the preferred syntax for using
+// implicit_cast is the same as for static_cast etc.:
+//
+//   implicit_cast<ToType>(expr)
+//
+// implicit_cast would have been part of the C++ standard library,
+// but the proposal was submitted too late.  It will probably make
+// its way into the language in the future.
+template<typename To, typename From>
+inline To implicit_cast(From const &f) {
+  return f;
+}
+
+// When you upcast (that is, cast a pointer from type Foo to type
+// SuperclassOfFoo), it's fine to use implicit_cast<>, since upcasts
+// always succeed.  When you downcast (that is, cast a pointer from
+// type Foo to type SubclassOfFoo), static_cast<> isn't safe, because
+// how do you know the pointer is really of type SubclassOfFoo?  It
+// could be a bare Foo, or of type DifferentSubclassOfFoo.  Thus,
+// when you downcast, you should use this macro.  In debug mode, we
+// use dynamic_cast<> to double-check the downcast is legal (we die
+// if it's not).  In normal mode, we do the efficient static_cast<>
+// instead.  Thus, it's important to test in debug mode to make sure
+// the cast is legal!
+//    This is the only place in the code we should use dynamic_cast<>.
+// In particular, you SHOULDN'T be using dynamic_cast<> in order to
+// do RTTI (eg code like this:
+//    if (dynamic_cast<Subclass1>(foo)) HandleASubclass1Object(foo);
+//    if (dynamic_cast<Subclass2>(foo)) HandleASubclass2Object(foo);
+// You should design the code some other way not to need this.
+
+template<typename To, typename From>     // use like this: down_cast<T*>(foo);
+inline To down_cast(From* f) {                   // so we only accept pointers
+  // Ensures that To is a sub-type of From *.  This test is here only
+  // for compile-time type checking, and has no overhead in an
+  // optimized build at run-time, as it will be optimized away
+  // completely.
+  if (false) {
+    implicit_cast<From*, To>(0);
+  }
+
+#if !defined(NDEBUG) && !defined(GOOGLE_PROTOBUF_NO_RTTI)
+  assert(f == NULL || dynamic_cast<To>(f) != NULL);  // RTTI: debug mode only!
+#endif
+  return static_cast<To>(f);
+}
+
+template<typename To, typename From>    // use like this: down_cast<T&>(foo);
+inline To down_cast(From& f) {
+  typedef typename remove_reference<To>::type* ToAsPointer;
+  // Ensures that To is a sub-type of From *.  This test is here only
+  // for compile-time type checking, and has no overhead in an
+  // optimized build at run-time, as it will be optimized away
+  // completely.
+  if (false) {
+    implicit_cast<From*, ToAsPointer>(0);
+  }
+
+#if !defined(NDEBUG) && !defined(GOOGLE_PROTOBUF_NO_RTTI)
+  // RTTI: debug mode only!
+  assert(dynamic_cast<ToAsPointer>(&f) != NULL);
+#endif
+  return *static_cast<ToAsPointer>(&f);
+}
+
+template<typename To, typename From>
+inline To bit_cast(const From& from) {
+  GOOGLE_COMPILE_ASSERT(sizeof(From) == sizeof(To),
+                        bit_cast_with_different_sizes);
+  To dest;
+  memcpy(&dest, &from, sizeof(dest));
+  return dest;
+}
+
+}  // namespace internal
+
+// We made these internal so that they would show up as such in the docs,
+// but we don't want to stick "internal::" in front of them everywhere.
+using internal::implicit_cast;
+using internal::down_cast;
+using internal::bit_cast;
+
+}  // namespace protobuf
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_CASTS_H__
diff --git a/kortex_api/include/google/protobuf/stubs/common.h b/kortex_api/include/google/protobuf/stubs/common.h
new file mode 100644
index 0000000000000000000000000000000000000000..d11b8100d597e0812bb771a6aee47a4d98c0daab
--- /dev/null
+++ b/kortex_api/include/google/protobuf/stubs/common.h
@@ -0,0 +1,242 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda) and others
+//
+// Contains basic types and utilities used by the rest of the library.
+
+#ifndef GOOGLE_PROTOBUF_COMMON_H__
+#define GOOGLE_PROTOBUF_COMMON_H__
+
+#include <algorithm>
+#include <iostream>
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+
+#include <google/protobuf/stubs/port.h>
+#include <google/protobuf/stubs/macros.h>
+#include <google/protobuf/stubs/platform_macros.h>
+
+// TODO(liujisi): Remove the following includes after the include clean-up.
+#include <google/protobuf/stubs/logging.h>
+#include <google/protobuf/stubs/scoped_ptr.h>
+#include <google/protobuf/stubs/mutex.h>
+#include <google/protobuf/stubs/callback.h>
+
+#ifndef PROTOBUF_USE_EXCEPTIONS
+#if defined(_MSC_VER) && defined(_CPPUNWIND)
+  #define PROTOBUF_USE_EXCEPTIONS 1
+#elif defined(__EXCEPTIONS)
+  #define PROTOBUF_USE_EXCEPTIONS 1
+#else
+  #define PROTOBUF_USE_EXCEPTIONS 0
+#endif
+#endif
+
+#if PROTOBUF_USE_EXCEPTIONS
+#include <exception>
+#endif
+#if defined(__APPLE__)
+#include <TargetConditionals.h>  // for TARGET_OS_IPHONE
+#endif
+
+#if defined(__ANDROID__) || defined(GOOGLE_PROTOBUF_OS_ANDROID) || (defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE) || defined(GOOGLE_PROTOBUF_OS_IPHONE)
+#include <pthread.h>
+#endif
+
+#if defined(_WIN32) && defined(GetMessage)
+// Allow GetMessage to be used as a valid method name in protobuf classes.
+// windows.h defines GetMessage() as a macro.  Let's re-define it as an inline
+// function.  The inline function should be equivalent for C++ users.
+inline BOOL GetMessage_Win32(
+    LPMSG lpMsg, HWND hWnd,
+    UINT wMsgFilterMin, UINT wMsgFilterMax) {
+  return GetMessage(lpMsg, hWnd, wMsgFilterMin, wMsgFilterMax);
+}
+#undef GetMessage
+inline BOOL GetMessage(
+    LPMSG lpMsg, HWND hWnd,
+    UINT wMsgFilterMin, UINT wMsgFilterMax) {
+  return GetMessage_Win32(lpMsg, hWnd, wMsgFilterMin, wMsgFilterMax);
+}
+#endif
+
+namespace std {}
+
+namespace google {
+namespace protobuf {
+namespace internal {
+
+// Some of these constants are macros rather than const ints so that they can
+// be used in #if directives.
+
+// The current version, represented as a single integer to make comparison
+// easier:  major * 10^6 + minor * 10^3 + micro
+#define GOOGLE_PROTOBUF_VERSION 3005001
+
+// A suffix string for alpha, beta or rc releases. Empty for stable releases.
+#define GOOGLE_PROTOBUF_VERSION_SUFFIX ""
+
+// The minimum library version which works with the current version of the
+// headers.
+#define GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION 3005000
+
+// The minimum header version which works with the current version of
+// the library.  This constant should only be used by protoc's C++ code
+// generator.
+static const int kMinHeaderVersionForLibrary = 3005000;
+
+// The minimum protoc version which works with the current version of the
+// headers.
+#define GOOGLE_PROTOBUF_MIN_PROTOC_VERSION 3005000
+
+// The minimum header version which works with the current version of
+// protoc.  This constant should only be used in VerifyVersion().
+static const int kMinHeaderVersionForProtoc = 3005000;
+
+// Verifies that the headers and libraries are compatible.  Use the macro
+// below to call this.
+void LIBPROTOBUF_EXPORT VerifyVersion(int headerVersion, int minLibraryVersion,
+                                      const char* filename);
+
+// Converts a numeric version number to a string.
+std::string LIBPROTOBUF_EXPORT VersionString(int version);
+
+}  // namespace internal
+
+// Place this macro in your main() function (or somewhere before you attempt
+// to use the protobuf library) to verify that the version you link against
+// matches the headers you compiled against.  If a version mismatch is
+// detected, the process will abort.
+#define GOOGLE_PROTOBUF_VERIFY_VERSION                                    \
+  ::google::protobuf::internal::VerifyVersion(                            \
+    GOOGLE_PROTOBUF_VERSION, GOOGLE_PROTOBUF_MIN_LIBRARY_VERSION,         \
+    __FILE__)
+
+
+// ===================================================================
+// from google3/util/utf8/public/unilib.h
+
+class StringPiece;
+namespace internal {
+
+// Checks if the buffer contains structurally-valid UTF-8.  Implemented in
+// structurally_valid.cc.
+LIBPROTOBUF_EXPORT bool IsStructurallyValidUTF8(const char* buf, int len);
+
+inline bool IsStructurallyValidUTF8(const std::string& str) {
+  return IsStructurallyValidUTF8(str.data(), static_cast<int>(str.length()));
+}
+
+// Returns initial number of bytes of structually valid UTF-8.
+LIBPROTOBUF_EXPORT int UTF8SpnStructurallyValid(const StringPiece& str);
+
+// Coerce UTF-8 byte string in src_str to be
+// a structurally-valid equal-length string by selectively
+// overwriting illegal bytes with replace_char (typically ' ' or '?').
+// replace_char must be legal printable 7-bit Ascii 0x20..0x7e.
+// src_str is read-only.
+//
+// Returns pointer to output buffer, src_str.data() if no changes were made,
+//  or idst if some bytes were changed. idst is allocated by the caller
+//  and must be at least as big as src_str
+//
+// Optimized for: all structurally valid and no byte copying is done.
+//
+LIBPROTOBUF_EXPORT char* UTF8CoerceToStructurallyValid(
+    const StringPiece& str, char* dst, char replace_char);
+
+}  // namespace internal
+
+
+// ===================================================================
+// Shutdown support.
+
+// Shut down the entire protocol buffers library, deleting all static-duration
+// objects allocated by the library or by generated .pb.cc files.
+//
+// There are two reasons you might want to call this:
+// * You use a draconian definition of "memory leak" in which you expect
+//   every single malloc() to have a corresponding free(), even for objects
+//   which live until program exit.
+// * You are writing a dynamically-loaded library which needs to clean up
+//   after itself when the library is unloaded.
+//
+// It is safe to call this multiple times.  However, it is not safe to use
+// any other part of the protocol buffers library after
+// ShutdownProtobufLibrary() has been called.
+LIBPROTOBUF_EXPORT void ShutdownProtobufLibrary();
+
+namespace internal {
+
+// Register a function to be called when ShutdownProtocolBuffers() is called.
+LIBPROTOBUF_EXPORT void OnShutdown(void (*func)());
+// Destroy the string (call string destructor)
+LIBPROTOBUF_EXPORT void OnShutdownDestroyString(const std::string* ptr);
+// Destroy (not delete) the message
+LIBPROTOBUF_EXPORT void OnShutdownDestroyMessage(const void* ptr);
+
+}  // namespace internal
+
+#if PROTOBUF_USE_EXCEPTIONS
+class FatalException : public std::exception {
+ public:
+  FatalException(const char* filename, int line, const std::string& message)
+      : filename_(filename), line_(line), message_(message) {}
+  virtual ~FatalException() throw();
+
+  virtual const char* what() const throw();
+
+  const char* filename() const { return filename_; }
+  int line() const { return line_; }
+  const std::string& message() const { return message_; }
+
+ private:
+  const char* filename_;
+  const int line_;
+  const std::string message_;
+};
+#endif
+
+// This is at the end of the file instead of the beginning to work around a bug
+// in some versions of MSVC.
+// TODO(acozzette): remove these using statements
+using std::istream;
+using std::ostream;
+using std::pair;
+using std::string;
+using std::vector;
+
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_COMMON_H__
diff --git a/kortex_api/include/google/protobuf/stubs/fastmem.h b/kortex_api/include/google/protobuf/stubs/fastmem.h
new file mode 100644
index 0000000000000000000000000000000000000000..1f1f6ed3df41a71d8f05677b5dde3626dd58563c
--- /dev/null
+++ b/kortex_api/include/google/protobuf/stubs/fastmem.h
@@ -0,0 +1,153 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2014 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Fast memory copying and comparison routines.
+//   strings::fastmemcmp_inlined() replaces memcmp()
+//   strings::memcpy_inlined() replaces memcpy()
+//   strings::memeq(a, b, n) replaces memcmp(a, b, n) == 0
+//
+// strings::*_inlined() routines are inline versions of the
+// routines exported by this module.  Sometimes using the inlined
+// versions is faster.  Measure before using the inlined versions.
+//
+// Performance measurement:
+//   strings::fastmemcmp_inlined
+//     Analysis: memcmp, fastmemcmp_inlined, fastmemcmp
+//     2012-01-30
+
+#ifndef GOOGLE_PROTOBUF_STUBS_FASTMEM_H_
+#define GOOGLE_PROTOBUF_STUBS_FASTMEM_H_
+
+#include <stddef.h>
+#include <stdio.h>
+#include <string.h>
+
+#include <google/protobuf/stubs/common.h>
+
+namespace google {
+namespace protobuf {
+namespace internal {
+
+// Return true if the n bytes at a equal the n bytes at b.
+// The regions are allowed to overlap.
+//
+// The performance is similar to the performance memcmp(), but faster for
+// moderately-sized inputs, or inputs that share a common prefix and differ
+// somewhere in their last 8 bytes. Further optimizations can be added later
+// if it makes sense to do so.:w
+inline bool memeq(const char* a, const char* b, size_t n) {
+  size_t n_rounded_down = n & ~static_cast<size_t>(7);
+  if (GOOGLE_PREDICT_FALSE(n_rounded_down == 0)) {  // n <= 7
+    return memcmp(a, b, n) == 0;
+  }
+  // n >= 8
+  uint64 u = GOOGLE_UNALIGNED_LOAD64(a) ^ GOOGLE_UNALIGNED_LOAD64(b);
+  uint64 v = GOOGLE_UNALIGNED_LOAD64(a + n - 8) ^ GOOGLE_UNALIGNED_LOAD64(b + n - 8);
+  if ((u | v) != 0) {  // The first or last 8 bytes differ.
+    return false;
+  }
+  a += 8;
+  b += 8;
+  n = n_rounded_down - 8;
+  if (n > 128) {
+    // As of 2012, memcmp on x86-64 uses a big unrolled loop with SSE2
+    // instructions, and while we could try to do something faster, it
+    // doesn't seem worth pursuing.
+    return memcmp(a, b, n) == 0;
+  }
+  for (; n >= 16; n -= 16) {
+    uint64 x = GOOGLE_UNALIGNED_LOAD64(a) ^ GOOGLE_UNALIGNED_LOAD64(b);
+    uint64 y = GOOGLE_UNALIGNED_LOAD64(a + 8) ^ GOOGLE_UNALIGNED_LOAD64(b + 8);
+    if ((x | y) != 0) {
+      return false;
+    }
+    a += 16;
+    b += 16;
+  }
+  // n must be 0 or 8 now because it was a multiple of 8 at the top of the loop.
+  return n == 0 || GOOGLE_UNALIGNED_LOAD64(a) == GOOGLE_UNALIGNED_LOAD64(b);
+}
+
+inline int fastmemcmp_inlined(const char *a, const char *b, size_t n) {
+  if (n >= 64) {
+    return memcmp(a, b, n);
+  }
+  const char* a_limit = a + n;
+  while (a + sizeof(uint64) <= a_limit &&
+         GOOGLE_UNALIGNED_LOAD64(a) == GOOGLE_UNALIGNED_LOAD64(b)) {
+    a += sizeof(uint64);
+    b += sizeof(uint64);
+  }
+  if (a + sizeof(uint32) <= a_limit &&
+      GOOGLE_UNALIGNED_LOAD32(a) == GOOGLE_UNALIGNED_LOAD32(b)) {
+    a += sizeof(uint32);
+    b += sizeof(uint32);
+  }
+  while (a < a_limit) {
+    int d =
+        static_cast<int>(static_cast<uint32>(*a++) - static_cast<uint32>(*b++));
+    if (d) return d;
+  }
+  return 0;
+}
+
+// The standard memcpy operation is slow for variable small sizes.
+// This implementation inlines the optimal realization for sizes 1 to 16.
+// To avoid code bloat don't use it in case of not performance-critical spots,
+// nor when you don't expect very frequent values of size <= 16.
+inline void memcpy_inlined(char *dst, const char *src, size_t size) {
+  // Compiler inlines code with minimal amount of data movement when third
+  // parameter of memcpy is a constant.
+  switch (size) {
+    case  1: memcpy(dst, src, 1); break;
+    case  2: memcpy(dst, src, 2); break;
+    case  3: memcpy(dst, src, 3); break;
+    case  4: memcpy(dst, src, 4); break;
+    case  5: memcpy(dst, src, 5); break;
+    case  6: memcpy(dst, src, 6); break;
+    case  7: memcpy(dst, src, 7); break;
+    case  8: memcpy(dst, src, 8); break;
+    case  9: memcpy(dst, src, 9); break;
+    case 10: memcpy(dst, src, 10); break;
+    case 11: memcpy(dst, src, 11); break;
+    case 12: memcpy(dst, src, 12); break;
+    case 13: memcpy(dst, src, 13); break;
+    case 14: memcpy(dst, src, 14); break;
+    case 15: memcpy(dst, src, 15); break;
+    case 16: memcpy(dst, src, 16); break;
+    default: memcpy(dst, src, size); break;
+  }
+}
+
+}  // namespace internal
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_STUBS_FASTMEM_H_
diff --git a/kortex_api/include/google/protobuf/stubs/hash.h b/kortex_api/include/google/protobuf/stubs/hash.h
new file mode 100644
index 0000000000000000000000000000000000000000..36fa9993655805e384daa8f5afcb7cfe5860766c
--- /dev/null
+++ b/kortex_api/include/google/protobuf/stubs/hash.h
@@ -0,0 +1,449 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//
+// Deals with the fact that hash_map is not defined everywhere.
+
+#ifndef GOOGLE_PROTOBUF_STUBS_HASH_H_
+#define GOOGLE_PROTOBUF_STUBS_HASH_H_
+
+#include <cstring>
+#include <google/protobuf/stubs/common.h>
+
+#define GOOGLE_PROTOBUF_HAVE_HASH_MAP 1
+#define GOOGLE_PROTOBUF_HAVE_HASH_SET 1
+
+// Use C++11 unordered_{map|set} if available.
+#if ((defined(_LIBCPP_STD_VER) && _LIBCPP_STD_VER >= 11) || \
+    (((__cplusplus >= 201103L) || defined(__GXX_EXPERIMENTAL_CXX0X)) && \
+    (__GLIBCXX__ > 20090421)))
+# define GOOGLE_PROTOBUF_HAS_CXX11_HASH
+
+// For XCode >= 4.6:  the compiler is clang with libc++.
+// For earlier XCode version: the compiler is gcc-4.2.1 with libstdc++.
+// libc++ provides <unordered_map> and friends even in non C++11 mode,
+// and it does not provide the tr1 library. Therefore the following macro
+// checks against this special case.
+// Note that we should not test the __APPLE_CC__ version number or the
+// __clang__ macro, since the new compiler can still use -stdlib=libstdc++, in
+// which case <unordered_map> is not compilable without -std=c++11
+#elif defined(__APPLE_CC__)
+# if __GNUC__ >= 4
+#  define GOOGLE_PROTOBUF_HAS_TR1
+# else
+// Not tested for gcc < 4... These setting can compile under 4.2.1 though.
+#  define GOOGLE_PROTOBUF_HASH_NAMESPACE __gnu_cxx
+#  include <ext/hash_map>
+#  define GOOGLE_PROTOBUF_HASH_MAP_CLASS hash_map
+#  include <ext/hash_set>
+#  define GOOGLE_PROTOBUF_HASH_SET_CLASS hash_set
+# endif
+
+// Version checks for gcc.
+#elif defined(__GNUC__)
+// For GCC 4.x+, use tr1::unordered_map/set; otherwise, follow the
+// instructions from:
+// https://gcc.gnu.org/onlinedocs/libstdc++/manual/backwards.html
+# if __GNUC__ >= 4
+#  define GOOGLE_PROTOBUF_HAS_TR1
+# elif __GNUC__ >= 3
+#  include <backward/hash_map>
+#  define GOOGLE_PROTOBUF_HASH_MAP_CLASS hash_map
+#  include <backward/hash_set>
+#  define GOOGLE_PROTOBUF_HASH_SET_CLASS hash_set
+#  if __GNUC__ == 3 && __GNUC_MINOR__ == 0
+#   define GOOGLE_PROTOBUF_HASH_NAMESPACE std       // GCC 3.0
+#  else
+#   define GOOGLE_PROTOBUF_HASH_NAMESPACE __gnu_cxx // GCC 3.1 and later
+#  endif
+# else
+#  define GOOGLE_PROTOBUF_HASH_NAMESPACE
+#  include <hash_map>
+#  define GOOGLE_PROTOBUF_HASH_MAP_CLASS hash_map
+#  include <hash_set>
+#  define GOOGLE_PROTOBUF_HASH_SET_CLASS hash_set
+# endif
+
+// GCC <= 4.1 does not define std::tr1::hash for `long long int` or `long long unsigned int`
+# if __GNUC__ == 4 && defined(__GNUC__MINOR__) && __GNUC__MINOR__ <= 1
+#  undef GOOGLE_PROTOBUF_HAS_TR1
+#  undef GOOGLE_PROTOBUF_HAVE_HASH_MAP
+#  undef GOOGLE_PROTOBUF_HAVE_HASH_SET
+# endif
+
+// Version checks for MSC.
+// Apparently Microsoft decided to move hash_map *back* to the std namespace in
+// MSVC 2010:
+// http://blogs.msdn.com/vcblog/archive/2009/05/25/stl-breaking-changes-in-visual-studio-2010-beta-1.aspx
+// And.. they are moved back to stdext in MSVC 2013 (haven't checked 2012). That
+// said, use unordered_map for MSVC 2010 and beyond is our safest bet.
+#elif defined(_MSC_VER)
+# if _MSC_VER >= 1600  // Since Visual Studio 2010
+#  define GOOGLE_PROTOBUF_HAS_CXX11_HASH
+#  define GOOGLE_PROTOBUF_HASH_COMPARE std::unordered_set
+# elif _MSC_VER >= 1500  // Since Visual Studio 2008
+#  define GOOGLE_PROTOBUF_HASH_NAMESPACE stdext
+#  include <hash_map>
+#  define GOOGLE_PROTOBUF_HASH_MAP_CLASS hash_map
+#  include <hash_set>
+#  define GOOGLE_PROTOBUF_HASH_SET_CLASS hash_set
+#  define GOOGLE_PROTOBUF_HASH_COMPARE stdext::hash_compare
+#  define GOOGLE_PROTOBUF_CONTAINERS_NEED_HASH_COMPARE
+# elif _MSC_VER >= 1310
+#  define GOOGLE_PROTOBUF_HASH_NAMESPACE stdext
+#  include <hash_map>
+#  define GOOGLE_PROTOBUF_HASH_MAP_CLASS hash_map
+#  include <hash_set>
+#  define GOOGLE_PROTOBUF_HASH_SET_CLASS hash_set
+#  define GOOGLE_PROTOBUF_HASH_COMPARE stdext::hash_compare
+# else
+#  define GOOGLE_PROTOBUF_HASH_NAMESPACE std
+#  include <hash_map>
+#  define GOOGLE_PROTOBUF_HASH_MAP_CLASS hash_map
+#  include <hash_set>
+#  define GOOGLE_PROTOBUF_HASH_SET_CLASS hash_set
+#  define GOOGLE_PROTOBUF_HASH_COMPARE stdext::hash_compare
+# endif
+
+// **ADD NEW COMPILERS SUPPORT HERE.**
+// For other compilers, undefine the macro and fallback to use std::map, in
+// google/protobuf/stubs/hash.h
+#else
+# undef GOOGLE_PROTOBUF_HAVE_HASH_MAP
+# undef GOOGLE_PROTOBUF_HAVE_HASH_SET
+#endif
+
+#if defined(GOOGLE_PROTOBUF_HAS_CXX11_HASH)
+# define GOOGLE_PROTOBUF_HASH_NAMESPACE std
+# include <unordered_map>
+# define GOOGLE_PROTOBUF_HASH_MAP_CLASS unordered_map
+# include <unordered_set>
+# define GOOGLE_PROTOBUF_HASH_SET_CLASS unordered_set
+#elif defined(GOOGLE_PROTOBUF_HAS_TR1)
+# define GOOGLE_PROTOBUF_HASH_NAMESPACE std::tr1
+# include <tr1/unordered_map>
+# define GOOGLE_PROTOBUF_HASH_MAP_CLASS unordered_map
+# include <tr1/unordered_set>
+# define GOOGLE_PROTOBUF_HASH_SET_CLASS unordered_set
+#endif
+
+# define GOOGLE_PROTOBUF_HASH_NAMESPACE_DECLARATION_START \
+  namespace google {                                      \
+  namespace protobuf {
+# define GOOGLE_PROTOBUF_HASH_NAMESPACE_DECLARATION_END }}
+
+#undef GOOGLE_PROTOBUF_HAS_CXX11_HASH
+#undef GOOGLE_PROTOBUF_HAS_TR1
+
+#if defined(GOOGLE_PROTOBUF_HAVE_HASH_MAP) && \
+    defined(GOOGLE_PROTOBUF_HAVE_HASH_SET)
+#else
+#define GOOGLE_PROTOBUF_MISSING_HASH
+#include <map>
+#include <set>
+#endif
+
+namespace google {
+namespace protobuf {
+
+#ifdef GOOGLE_PROTOBUF_MISSING_HASH
+#undef GOOGLE_PROTOBUF_MISSING_HASH
+
+// This system doesn't have hash_map or hash_set.  Emulate them using map and
+// set.
+
+// Make hash<T> be the same as less<T>.  Note that everywhere where custom
+// hash functions are defined in the protobuf code, they are also defined such
+// that they can be used as "less" functions, which is required by MSVC anyway.
+template <typename Key>
+struct hash {
+  // Dummy, just to make derivative hash functions compile.
+  int operator()(const Key& key) {
+    GOOGLE_LOG(FATAL) << "Should never be called.";
+    return 0;
+  }
+
+  inline bool operator()(const Key& a, const Key& b) const {
+    return a < b;
+  }
+};
+
+// Make sure char* is compared by value.
+template <>
+struct hash<const char*> {
+  // Dummy, just to make derivative hash functions compile.
+  int operator()(const char* key) {
+    GOOGLE_LOG(FATAL) << "Should never be called.";
+    return 0;
+  }
+
+  inline bool operator()(const char* a, const char* b) const {
+    return strcmp(a, b) < 0;
+  }
+};
+
+template <typename Key, typename Data,
+          typename HashFcn = hash<Key>,
+          typename EqualKey = std::equal_to<Key>,
+          typename Alloc = std::allocator< std::pair<const Key, Data> > >
+class hash_map : public std::map<Key, Data, HashFcn, Alloc> {
+  typedef std::map<Key, Data, HashFcn, Alloc> BaseClass;
+
+ public:
+  hash_map(int a = 0, const HashFcn& b = HashFcn(),
+           const EqualKey& c = EqualKey(),
+           const Alloc& d = Alloc()) : BaseClass(b, d) {}
+
+  HashFcn hash_function() const { return HashFcn(); }
+};
+
+template <typename Key,
+          typename HashFcn = hash<Key>,
+          typename EqualKey = std::equal_to<Key> >
+class hash_set : public std::set<Key, HashFcn> {
+ public:
+  hash_set(int = 0) {}
+
+  HashFcn hash_function() const { return HashFcn(); }
+};
+
+#elif defined(_MSC_VER) && !defined(_STLPORT_VERSION)
+
+template <typename Key>
+struct hash : public GOOGLE_PROTOBUF_HASH_COMPARE<Key> {
+};
+
+// MSVC's hash_compare<const char*> hashes based on the string contents but
+// compares based on the string pointer.  WTF?
+class CstringLess {
+ public:
+  inline bool operator()(const char* a, const char* b) const {
+    return strcmp(a, b) < 0;
+  }
+};
+
+  template <>
+  struct hash<const char*> {
+    // Dummy, just to make derivative hash functions compile.
+    int operator()(const char* key) {
+      GOOGLE_LOG(FATAL) << "Should never be called.";
+      return 0;
+    }
+
+    inline bool operator()(const char* a, const char* b) const {
+      return strcmp(a, b) < 0;
+    }
+  };
+
+#ifdef GOOGLE_PROTOBUF_CONTAINERS_NEED_HASH_COMPARE
+
+template <typename Key, typename HashFcn, typename EqualKey>
+struct InternalHashCompare : public GOOGLE_PROTOBUF_HASH_COMPARE<Key> {
+  InternalHashCompare() {}
+  InternalHashCompare(HashFcn hashfcn, EqualKey equalkey)
+      : hashfcn_(hashfcn), equalkey_(equalkey) {}
+  size_t operator()(const Key& key) const { return hashfcn_(key); }
+  bool operator()(const Key& key1, const Key& key2) const {
+    return !equalkey_(key1, key2);
+  }
+  HashFcn hashfcn_;
+  EqualKey equalkey_;
+};
+
+template <typename Key, typename Data,
+          typename HashFcn = hash<Key>,
+          typename EqualKey = std::equal_to<Key>,
+          typename Alloc = std::allocator< std::pair<const Key, Data> > >
+class hash_map
+    : public GOOGLE_PROTOBUF_HASH_NAMESPACE::GOOGLE_PROTOBUF_HASH_MAP_CLASS<
+          Key, Data, InternalHashCompare<Key, HashFcn, EqualKey>, Alloc> {
+  typedef GOOGLE_PROTOBUF_HASH_NAMESPACE::GOOGLE_PROTOBUF_HASH_MAP_CLASS<
+      Key, Data, InternalHashCompare<Key, HashFcn, EqualKey>, Alloc> BaseClass;
+
+ public:
+  hash_map(int a = 0, const HashFcn& b = HashFcn(),
+           const EqualKey& c = EqualKey(), const Alloc& d = Alloc())
+      : BaseClass(InternalHashCompare<Key, HashFcn, EqualKey>(b, c), d) {}
+
+  HashFcn hash_function() const { return HashFcn(); }
+};
+
+template <typename Key, typename HashFcn = hash<Key>,
+          typename EqualKey = std::equal_to<Key> >
+class hash_set
+    : public GOOGLE_PROTOBUF_HASH_NAMESPACE::GOOGLE_PROTOBUF_HASH_SET_CLASS<
+          Key, InternalHashCompare<Key, HashFcn, EqualKey> > {
+ public:
+  hash_set(int = 0) {}
+
+  HashFcn hash_function() const { return HashFcn(); }
+};
+
+#else  // GOOGLE_PROTOBUF_CONTAINERS_NEED_HASH_COMPARE
+
+template <typename Key, typename Data,
+          typename HashFcn = hash<Key>,
+          typename EqualKey = std::equal_to<Key>,
+          typename Alloc = std::allocator< std::pair<const Key, Data> > >
+class hash_map
+    : public GOOGLE_PROTOBUF_HASH_NAMESPACE::GOOGLE_PROTOBUF_HASH_MAP_CLASS<
+          Key, Data, HashFcn, EqualKey, Alloc> {
+  typedef GOOGLE_PROTOBUF_HASH_NAMESPACE::GOOGLE_PROTOBUF_HASH_MAP_CLASS<
+      Key, Data, HashFcn, EqualKey, Alloc> BaseClass;
+
+ public:
+  hash_map(int a = 0, const HashFcn& b = HashFcn(),
+           const EqualKey& c = EqualKey(),
+           const Alloc& d = Alloc()) : BaseClass(a, b, c, d) {}
+
+  HashFcn hash_function() const { return HashFcn(); }
+};
+
+template <typename Key, typename HashFcn = hash<Key>,
+          typename EqualKey = std::equal_to<Key> >
+class hash_set
+    : public GOOGLE_PROTOBUF_HASH_NAMESPACE::GOOGLE_PROTOBUF_HASH_SET_CLASS<
+          Key, HashFcn, EqualKey> {
+ public:
+  hash_set(int = 0) {}
+
+  HashFcn hash_function() const { return HashFcn(); }
+};
+#endif  // GOOGLE_PROTOBUF_CONTAINERS_NEED_HASH_COMPARE
+
+#else  // defined(_MSC_VER) && !defined(_STLPORT_VERSION)
+
+template <typename Key>
+struct hash : public GOOGLE_PROTOBUF_HASH_NAMESPACE::hash<Key> {
+};
+
+template <typename Key>
+struct hash<const Key*> {
+  inline size_t operator()(const Key* key) const {
+    return reinterpret_cast<size_t>(key);
+  }
+};
+
+// Unlike the old SGI version, the TR1 "hash" does not special-case char*.  So,
+// we go ahead and provide our own implementation.
+template <>
+struct hash<const char*> {
+  inline size_t operator()(const char* str) const {
+    size_t result = 0;
+    for (; *str != '\0'; str++) {
+      result = 5 * result + static_cast<size_t>(*str);
+    }
+    return result;
+  }
+};
+
+template<>
+struct hash<bool> {
+  size_t operator()(bool x) const {
+    return static_cast<size_t>(x);
+  }
+};
+
+template <typename Key, typename Data,
+          typename HashFcn = hash<Key>,
+          typename EqualKey = std::equal_to<Key>,
+          typename Alloc = std::allocator< std::pair<const Key, Data> > >
+class hash_map
+    : public GOOGLE_PROTOBUF_HASH_NAMESPACE::GOOGLE_PROTOBUF_HASH_MAP_CLASS<
+          Key, Data, HashFcn, EqualKey, Alloc> {
+  typedef GOOGLE_PROTOBUF_HASH_NAMESPACE::GOOGLE_PROTOBUF_HASH_MAP_CLASS<
+      Key, Data, HashFcn, EqualKey, Alloc> BaseClass;
+
+ public:
+  hash_map(int a = 0, const HashFcn& b = HashFcn(),
+           const EqualKey& c = EqualKey(),
+           const Alloc& d = Alloc()) : BaseClass(a, b, c, d) {}
+
+  HashFcn hash_function() const { return HashFcn(); }
+};
+
+template <typename Key, typename HashFcn = hash<Key>,
+          typename EqualKey = std::equal_to<Key> >
+class hash_set
+    : public GOOGLE_PROTOBUF_HASH_NAMESPACE::GOOGLE_PROTOBUF_HASH_SET_CLASS<
+          Key, HashFcn, EqualKey> {
+ public:
+  hash_set(int = 0) {}
+
+  HashFcn hash_function() const { return HashFcn(); }
+};
+
+#endif  // !GOOGLE_PROTOBUF_MISSING_HASH
+
+template <>
+struct hash<string> {
+  inline size_t operator()(const string& key) const {
+    return hash<const char*>()(key.c_str());
+  }
+
+  static const size_t bucket_size = 4;
+  static const size_t min_buckets = 8;
+  inline bool operator()(const string& a, const string& b) const {
+    return a < b;
+  }
+};
+
+template <typename First, typename Second>
+struct hash<pair<First, Second> > {
+  inline size_t operator()(const pair<First, Second>& key) const {
+    size_t first_hash = hash<First>()(key.first);
+    size_t second_hash = hash<Second>()(key.second);
+
+    // FIXME(kenton):  What is the best way to compute this hash?  I have
+    // no idea!  This seems a bit better than an XOR.
+    return first_hash * ((1 << 16) - 1) + second_hash;
+  }
+
+  static const size_t bucket_size = 4;
+  static const size_t min_buckets = 8;
+  inline bool operator()(const pair<First, Second>& a,
+                           const pair<First, Second>& b) const {
+    return a < b;
+  }
+};
+
+// Used by GCC/SGI STL only.  (Why isn't this provided by the standard
+// library?  :( )
+struct streq {
+  inline bool operator()(const char* a, const char* b) const {
+    return strcmp(a, b) == 0;
+  }
+};
+
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_STUBS_HASH_H__
diff --git a/kortex_api/include/google/protobuf/stubs/logging.h b/kortex_api/include/google/protobuf/stubs/logging.h
new file mode 100644
index 0000000000000000000000000000000000000000..f69605d9f6393735102e69873395f30188a1b2fd
--- /dev/null
+++ b/kortex_api/include/google/protobuf/stubs/logging.h
@@ -0,0 +1,237 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_STUBS_LOGGING_H_
+#define GOOGLE_PROTOBUF_STUBS_LOGGING_H_
+
+#include <google/protobuf/stubs/macros.h>
+#include <google/protobuf/stubs/port.h>
+
+// ===================================================================
+// emulates google3/base/logging.h
+
+namespace google {
+namespace protobuf {
+
+enum LogLevel {
+  LOGLEVEL_INFO,     // Informational.  This is never actually used by
+                     // libprotobuf.
+  LOGLEVEL_WARNING,  // Warns about issues that, although not technically a
+                     // problem now, could cause problems in the future.  For
+                     // example, a // warning will be printed when parsing a
+                     // message that is near the message size limit.
+  LOGLEVEL_ERROR,    // An error occurred which should never happen during
+                     // normal use.
+  LOGLEVEL_FATAL,    // An error occurred from which the library cannot
+                     // recover.  This usually indicates a programming error
+                     // in the code which calls the library, especially when
+                     // compiled in debug mode.
+
+#ifdef NDEBUG
+  LOGLEVEL_DFATAL = LOGLEVEL_ERROR
+#else
+  LOGLEVEL_DFATAL = LOGLEVEL_FATAL
+#endif
+};
+
+class StringPiece;
+namespace util {
+class Status;
+}
+class uint128;
+namespace internal {
+
+class LogFinisher;
+
+class LIBPROTOBUF_EXPORT LogMessage {
+ public:
+  LogMessage(LogLevel level, const char* filename, int line);
+  ~LogMessage();
+
+  LogMessage& operator<<(const std::string& value);
+  LogMessage& operator<<(const char* value);
+  LogMessage& operator<<(char value);
+  LogMessage& operator<<(int value);
+  LogMessage& operator<<(uint value);
+  LogMessage& operator<<(long value);
+  LogMessage& operator<<(unsigned long value);
+  LogMessage& operator<<(long long value);
+  LogMessage& operator<<(unsigned long long value);
+  LogMessage& operator<<(double value);
+  LogMessage& operator<<(void* value);
+  LogMessage& operator<<(const StringPiece& value);
+  LogMessage& operator<<(const ::google::protobuf::util::Status& status);
+  LogMessage& operator<<(const uint128& value);
+
+ private:
+  friend class LogFinisher;
+  void Finish();
+
+  LogLevel level_;
+  const char* filename_;
+  int line_;
+  std::string message_;
+};
+
+// Used to make the entire "LOG(BLAH) << etc." expression have a void return
+// type and print a newline after each message.
+class LIBPROTOBUF_EXPORT LogFinisher {
+ public:
+  void operator=(LogMessage& other);
+};
+
+template<typename T>
+bool IsOk(T status) { return status.ok(); }
+template<>
+inline bool IsOk(bool status) { return status; }
+
+}  // namespace internal
+
+// Undef everything in case we're being mixed with some other Google library
+// which already defined them itself.  Presumably all Google libraries will
+// support the same syntax for these so it should not be a big deal if they
+// end up using our definitions instead.
+#undef GOOGLE_LOG
+#undef GOOGLE_LOG_IF
+
+#undef GOOGLE_CHECK
+#undef GOOGLE_CHECK_OK
+#undef GOOGLE_CHECK_EQ
+#undef GOOGLE_CHECK_NE
+#undef GOOGLE_CHECK_LT
+#undef GOOGLE_CHECK_LE
+#undef GOOGLE_CHECK_GT
+#undef GOOGLE_CHECK_GE
+#undef GOOGLE_CHECK_NOTNULL
+
+#undef GOOGLE_DLOG
+#undef GOOGLE_DCHECK
+#undef GOOGLE_DCHECK_OK
+#undef GOOGLE_DCHECK_EQ
+#undef GOOGLE_DCHECK_NE
+#undef GOOGLE_DCHECK_LT
+#undef GOOGLE_DCHECK_LE
+#undef GOOGLE_DCHECK_GT
+#undef GOOGLE_DCHECK_GE
+
+#define GOOGLE_LOG(LEVEL)                                                 \
+  ::google::protobuf::internal::LogFinisher() =                           \
+    ::google::protobuf::internal::LogMessage(                             \
+      ::google::protobuf::LOGLEVEL_##LEVEL, __FILE__, __LINE__)
+#define GOOGLE_LOG_IF(LEVEL, CONDITION) \
+  !(CONDITION) ? (void)0 : GOOGLE_LOG(LEVEL)
+
+#define GOOGLE_CHECK(EXPRESSION) \
+  GOOGLE_LOG_IF(FATAL, !(EXPRESSION)) << "CHECK failed: " #EXPRESSION ": "
+#define GOOGLE_CHECK_OK(A) GOOGLE_CHECK(::google::protobuf::internal::IsOk(A))
+#define GOOGLE_CHECK_EQ(A, B) GOOGLE_CHECK((A) == (B))
+#define GOOGLE_CHECK_NE(A, B) GOOGLE_CHECK((A) != (B))
+#define GOOGLE_CHECK_LT(A, B) GOOGLE_CHECK((A) <  (B))
+#define GOOGLE_CHECK_LE(A, B) GOOGLE_CHECK((A) <= (B))
+#define GOOGLE_CHECK_GT(A, B) GOOGLE_CHECK((A) >  (B))
+#define GOOGLE_CHECK_GE(A, B) GOOGLE_CHECK((A) >= (B))
+
+namespace internal {
+template<typename T>
+T* CheckNotNull(const char* /* file */, int /* line */,
+                const char* name, T* val) {
+  if (val == NULL) {
+    GOOGLE_LOG(FATAL) << name;
+  }
+  return val;
+}
+}  // namespace internal
+#define GOOGLE_CHECK_NOTNULL(A) \
+  ::google::protobuf::internal::CheckNotNull(\
+      __FILE__, __LINE__, "'" #A "' must not be NULL", (A))
+
+#ifdef NDEBUG
+
+#define GOOGLE_DLOG(LEVEL) GOOGLE_LOG_IF(LEVEL, false)
+
+#define GOOGLE_DCHECK(EXPRESSION) while(false) GOOGLE_CHECK(EXPRESSION)
+#define GOOGLE_DCHECK_OK(E) GOOGLE_DCHECK(::google::protobuf::internal::IsOk(E))
+#define GOOGLE_DCHECK_EQ(A, B) GOOGLE_DCHECK((A) == (B))
+#define GOOGLE_DCHECK_NE(A, B) GOOGLE_DCHECK((A) != (B))
+#define GOOGLE_DCHECK_LT(A, B) GOOGLE_DCHECK((A) <  (B))
+#define GOOGLE_DCHECK_LE(A, B) GOOGLE_DCHECK((A) <= (B))
+#define GOOGLE_DCHECK_GT(A, B) GOOGLE_DCHECK((A) >  (B))
+#define GOOGLE_DCHECK_GE(A, B) GOOGLE_DCHECK((A) >= (B))
+
+#else  // NDEBUG
+
+#define GOOGLE_DLOG GOOGLE_LOG
+
+#define GOOGLE_DCHECK    GOOGLE_CHECK
+#define GOOGLE_DCHECK_OK GOOGLE_CHECK_OK
+#define GOOGLE_DCHECK_EQ GOOGLE_CHECK_EQ
+#define GOOGLE_DCHECK_NE GOOGLE_CHECK_NE
+#define GOOGLE_DCHECK_LT GOOGLE_CHECK_LT
+#define GOOGLE_DCHECK_LE GOOGLE_CHECK_LE
+#define GOOGLE_DCHECK_GT GOOGLE_CHECK_GT
+#define GOOGLE_DCHECK_GE GOOGLE_CHECK_GE
+
+#endif  // !NDEBUG
+
+typedef void LogHandler(LogLevel level, const char* filename, int line,
+                        const std::string& message);
+
+// The protobuf library sometimes writes warning and error messages to
+// stderr.  These messages are primarily useful for developers, but may
+// also help end users figure out a problem.  If you would prefer that
+// these messages be sent somewhere other than stderr, call SetLogHandler()
+// to set your own handler.  This returns the old handler.  Set the handler
+// to NULL to ignore log messages (but see also LogSilencer, below).
+//
+// Obviously, SetLogHandler is not thread-safe.  You should only call it
+// at initialization time, and probably not from library code.  If you
+// simply want to suppress log messages temporarily (e.g. because you
+// have some code that tends to trigger them frequently and you know
+// the warnings are not important to you), use the LogSilencer class
+// below.
+LIBPROTOBUF_EXPORT LogHandler* SetLogHandler(LogHandler* new_func);
+
+// Create a LogSilencer if you want to temporarily suppress all log
+// messages.  As long as any LogSilencer objects exist, non-fatal
+// log messages will be discarded (the current LogHandler will *not*
+// be called).  Constructing a LogSilencer is thread-safe.  You may
+// accidentally suppress log messages occurring in another thread, but
+// since messages are generally for debugging purposes only, this isn't
+// a big deal.  If you want to intercept log messages, use SetLogHandler().
+class LIBPROTOBUF_EXPORT LogSilencer {
+ public:
+  LogSilencer();
+  ~LogSilencer();
+};
+
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_STUBS_LOGGING_H_
diff --git a/kortex_api/include/google/protobuf/stubs/macros.h b/kortex_api/include/google/protobuf/stubs/macros.h
new file mode 100644
index 0000000000000000000000000000000000000000..0e9a9ec198208fd253a48cf01dd87e3fb5f9fe06
--- /dev/null
+++ b/kortex_api/include/google/protobuf/stubs/macros.h
@@ -0,0 +1,168 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_MACROS_H__
+#define GOOGLE_PROTOBUF_MACROS_H__
+
+#include <google/protobuf/stubs/port.h>
+
+namespace google {
+namespace protobuf {
+
+#undef GOOGLE_DISALLOW_EVIL_CONSTRUCTORS
+#define GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(TypeName)    \
+  TypeName(const TypeName&);                           \
+  void operator=(const TypeName&)
+
+#undef GOOGLE_DISALLOW_IMPLICIT_CONSTRUCTORS
+#define GOOGLE_DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \
+  TypeName();                                           \
+  TypeName(const TypeName&);                            \
+  void operator=(const TypeName&)
+
+// ===================================================================
+// from google3/base/basictypes.h
+
+// The GOOGLE_ARRAYSIZE(arr) macro returns the # of elements in an array arr.
+// The expression is a compile-time constant, and therefore can be
+// used in defining new arrays, for example.
+//
+// GOOGLE_ARRAYSIZE catches a few type errors.  If you see a compiler error
+//
+//   "warning: division by zero in ..."
+//
+// when using GOOGLE_ARRAYSIZE, you are (wrongfully) giving it a pointer.
+// You should only use GOOGLE_ARRAYSIZE on statically allocated arrays.
+//
+// The following comments are on the implementation details, and can
+// be ignored by the users.
+//
+// ARRAYSIZE(arr) works by inspecting sizeof(arr) (the # of bytes in
+// the array) and sizeof(*(arr)) (the # of bytes in one array
+// element).  If the former is divisible by the latter, perhaps arr is
+// indeed an array, in which case the division result is the # of
+// elements in the array.  Otherwise, arr cannot possibly be an array,
+// and we generate a compiler error to prevent the code from
+// compiling.
+//
+// Since the size of bool is implementation-defined, we need to cast
+// !(sizeof(a) & sizeof(*(a))) to size_t in order to ensure the final
+// result has type size_t.
+//
+// This macro is not perfect as it wrongfully accepts certain
+// pointers, namely where the pointer size is divisible by the pointee
+// size.  Since all our code has to go through a 32-bit compiler,
+// where a pointer is 4 bytes, this means all pointers to a type whose
+// size is 3 or greater than 4 will be (righteously) rejected.
+//
+// Kudos to Jorg Brown for this simple and elegant implementation.
+
+#undef GOOGLE_ARRAYSIZE
+#define GOOGLE_ARRAYSIZE(a) \
+  ((sizeof(a) / sizeof(*(a))) / \
+   static_cast<size_t>(!(sizeof(a) % sizeof(*(a)))))
+
+// The COMPILE_ASSERT macro can be used to verify that a compile time
+// expression is true. For example, you could use it to verify the
+// size of a static array:
+//
+//   COMPILE_ASSERT(ARRAYSIZE(content_type_names) == CONTENT_NUM_TYPES,
+//                  content_type_names_incorrect_size);
+//
+// or to make sure a struct is smaller than a certain size:
+//
+//   COMPILE_ASSERT(sizeof(foo) < 128, foo_too_large);
+//
+// The second argument to the macro is the name of the variable. If
+// the expression is false, most compilers will issue a warning/error
+// containing the name of the variable.
+
+namespace internal {
+
+template <bool>
+struct CompileAssert {
+};
+
+}  // namespace internal
+
+#undef GOOGLE_COMPILE_ASSERT
+#if __cplusplus >= 201103L
+#define GOOGLE_COMPILE_ASSERT(expr, msg) static_assert(expr, #msg)
+#else
+#define GOOGLE_COMPILE_ASSERT(expr, msg) \
+  ::google::protobuf::internal::CompileAssert<(bool(expr))> \
+          msg[bool(expr) ? 1 : -1]; \
+  (void)msg
+// Implementation details of COMPILE_ASSERT:
+//
+// - COMPILE_ASSERT works by defining an array type that has -1
+//   elements (and thus is invalid) when the expression is false.
+//
+// - The simpler definition
+//
+//     #define COMPILE_ASSERT(expr, msg) typedef char msg[(expr) ? 1 : -1]
+//
+//   does not work, as gcc supports variable-length arrays whose sizes
+//   are determined at run-time (this is gcc's extension and not part
+//   of the C++ standard).  As a result, gcc fails to reject the
+//   following code with the simple definition:
+//
+//     int foo;
+//     COMPILE_ASSERT(foo, msg); // not supposed to compile as foo is
+//                               // not a compile-time constant.
+//
+// - By using the type CompileAssert<(bool(expr))>, we ensures that
+//   expr is a compile-time constant.  (Template arguments must be
+//   determined at compile-time.)
+//
+// - The outter parentheses in CompileAssert<(bool(expr))> are necessary
+//   to work around a bug in gcc 3.4.4 and 4.0.1.  If we had written
+//
+//     CompileAssert<bool(expr)>
+//
+//   instead, these compilers will refuse to compile
+//
+//     COMPILE_ASSERT(5 > 0, some_message);
+//
+//   (They seem to think the ">" in "5 > 0" marks the end of the
+//   template argument list.)
+//
+// - The array size is (bool(expr) ? 1 : -1), instead of simply
+//
+//     ((expr) ? 1 : -1).
+//
+//   This is to avoid running into a bug in MS VC 7.1, which
+//   causes ((0.0) ? 1 : -1) to incorrectly evaluate to 1.
+#endif  // __cplusplus >= 201103L
+
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_MACROS_H__
diff --git a/kortex_api/include/google/protobuf/stubs/mutex.h b/kortex_api/include/google/protobuf/stubs/mutex.h
new file mode 100644
index 0000000000000000000000000000000000000000..174290f6247774ea70c3b7797300a052ffebbc1a
--- /dev/null
+++ b/kortex_api/include/google/protobuf/stubs/mutex.h
@@ -0,0 +1,140 @@
+// Copyright (c) 2006, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_STUBS_MUTEX_H_
+#define GOOGLE_PROTOBUF_STUBS_MUTEX_H_
+
+#ifdef GOOGLE_PROTOBUF_NO_THREADLOCAL
+#include <pthread.h>
+#endif
+
+#include <google/protobuf/stubs/macros.h>
+
+// ===================================================================
+// emulates google3/base/mutex.h
+namespace google {
+namespace protobuf {
+namespace internal {
+
+// A Mutex is a non-reentrant (aka non-recursive) mutex.  At most one thread T
+// may hold a mutex at a given time.  If T attempts to Lock() the same Mutex
+// while holding it, T will deadlock.
+class LIBPROTOBUF_EXPORT Mutex {
+ public:
+  // Create a Mutex that is not held by anybody.
+  Mutex();
+
+  // Destructor
+  ~Mutex();
+
+  // Block if necessary until this Mutex is free, then acquire it exclusively.
+  void Lock();
+
+  // Release this Mutex.  Caller must hold it exclusively.
+  void Unlock();
+
+  // Crash if this Mutex is not held exclusively by this thread.
+  // May fail to crash when it should; will never crash when it should not.
+  void AssertHeld();
+
+ private:
+  struct Internal;
+  Internal* mInternal;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Mutex);
+};
+
+// MutexLock(mu) acquires mu when constructed and releases it when destroyed.
+class LIBPROTOBUF_EXPORT MutexLock {
+ public:
+  explicit MutexLock(Mutex *mu) : mu_(mu) { this->mu_->Lock(); }
+  ~MutexLock() { this->mu_->Unlock(); }
+ private:
+  Mutex *const mu_;
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MutexLock);
+};
+
+// TODO(kenton):  Implement these?  Hard to implement portably.
+typedef MutexLock ReaderMutexLock;
+typedef MutexLock WriterMutexLock;
+
+// MutexLockMaybe is like MutexLock, but is a no-op when mu is NULL.
+class LIBPROTOBUF_EXPORT MutexLockMaybe {
+ public:
+  explicit MutexLockMaybe(Mutex *mu) :
+    mu_(mu) { if (this->mu_ != NULL) { this->mu_->Lock(); } }
+  ~MutexLockMaybe() { if (this->mu_ != NULL) { this->mu_->Unlock(); } }
+ private:
+  Mutex *const mu_;
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MutexLockMaybe);
+};
+
+#if defined(GOOGLE_PROTOBUF_NO_THREADLOCAL)
+template<typename T>
+class ThreadLocalStorage {
+ public:
+  ThreadLocalStorage() {
+    pthread_key_create(&key_, &ThreadLocalStorage::Delete);
+  }
+  ~ThreadLocalStorage() {
+    pthread_key_delete(key_);
+  }
+  T* Get() {
+    T* result = static_cast<T*>(pthread_getspecific(key_));
+    if (result == NULL) {
+      result = new T();
+      pthread_setspecific(key_, result);
+    }
+    return result;
+  }
+ private:
+  static void Delete(void* value) {
+    delete static_cast<T*>(value);
+  }
+  pthread_key_t key_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ThreadLocalStorage);
+};
+#endif
+
+}  // namespace internal
+
+// We made these internal so that they would show up as such in the docs,
+// but we don't want to stick "internal::" in front of them everywhere.
+using internal::Mutex;
+using internal::MutexLock;
+using internal::ReaderMutexLock;
+using internal::WriterMutexLock;
+using internal::MutexLockMaybe;
+
+
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_STUBS_MUTEX_H_
diff --git a/kortex_api/include/google/protobuf/stubs/once.h b/kortex_api/include/google/protobuf/stubs/once.h
new file mode 100644
index 0000000000000000000000000000000000000000..1f082c37e9b1d5eea6f39909f5c6028b88fa1cd3
--- /dev/null
+++ b/kortex_api/include/google/protobuf/stubs/once.h
@@ -0,0 +1,167 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//
+// emulates google3/base/once.h
+//
+// This header is intended to be included only by internal .cc files and
+// generated .pb.cc files.  Users should not use this directly.
+//
+// This is basically a portable version of pthread_once().
+//
+// This header declares:
+// * A type called ProtobufOnceType.
+// * A macro GOOGLE_PROTOBUF_DECLARE_ONCE() which declares a variable of type
+//   ProtobufOnceType.  This is the only legal way to declare such a variable.
+//   The macro may only be used at the global scope (you cannot create local or
+//   class member variables of this type).
+// * A function GoogleOnceInit(ProtobufOnceType* once, void (*init_func)()).
+//   This function, when invoked multiple times given the same ProtobufOnceType
+//   object, will invoke init_func on the first call only, and will make sure
+//   none of the calls return before that first call to init_func has finished.
+// * The user can provide a parameter which GoogleOnceInit() forwards to the
+//   user-provided function when it is called. Usage example:
+//     int a = 10;
+//     GoogleOnceInit(&my_once, &MyFunctionExpectingIntArgument, &a);
+// * This implementation guarantees that ProtobufOnceType is a POD (i.e. no
+//   static initializer generated).
+//
+// This implements a way to perform lazy initialization.  It's more efficient
+// than using mutexes as no lock is needed if initialization has already
+// happened.
+//
+// Example usage:
+//   void Init();
+//   GOOGLE_PROTOBUF_DECLARE_ONCE(once_init);
+//
+//   // Calls Init() exactly once.
+//   void InitOnce() {
+//     GoogleOnceInit(&once_init, &Init);
+//   }
+//
+// Note that if GoogleOnceInit() is called before main() has begun, it must
+// only be called by the thread that will eventually call main() -- that is,
+// the thread that performs dynamic initialization.  In general this is a safe
+// assumption since people don't usually construct threads before main() starts,
+// but it is technically not guaranteed.  Unfortunately, Win32 provides no way
+// whatsoever to statically-initialize its synchronization primitives, so our
+// only choice is to assume that dynamic initialization is single-threaded.
+
+#ifndef GOOGLE_PROTOBUF_STUBS_ONCE_H__
+#define GOOGLE_PROTOBUF_STUBS_ONCE_H__
+
+#include <google/protobuf/stubs/atomicops.h>
+#include <google/protobuf/stubs/callback.h>
+#include <google/protobuf/stubs/common.h>
+
+namespace google {
+namespace protobuf {
+
+#ifdef GOOGLE_PROTOBUF_NO_THREAD_SAFETY
+
+typedef bool ProtobufOnceType;
+
+#define GOOGLE_PROTOBUF_ONCE_INIT false
+
+inline void GoogleOnceInit(ProtobufOnceType* once, void (*init_func)()) {
+  if (!*once) {
+    *once = true;
+    init_func();
+  }
+}
+
+template <typename Arg>
+inline void GoogleOnceInit(ProtobufOnceType* once, void (*init_func)(Arg),
+    Arg arg) {
+  if (!*once) {
+    *once = true;
+    init_func(arg);
+  }
+}
+
+#else
+
+enum {
+  ONCE_STATE_UNINITIALIZED = 0,
+  ONCE_STATE_EXECUTING_CLOSURE = 1,
+  ONCE_STATE_DONE = 2
+};
+
+typedef internal::AtomicWord ProtobufOnceType;
+
+#define GOOGLE_PROTOBUF_ONCE_INIT ::google::protobuf::ONCE_STATE_UNINITIALIZED
+
+LIBPROTOBUF_EXPORT
+void GoogleOnceInitImpl(ProtobufOnceType* once, Closure* closure);
+
+inline void GoogleOnceInit(ProtobufOnceType* once, void (*init_func)()) {
+  if (internal::Acquire_Load(once) != ONCE_STATE_DONE) {
+    internal::FunctionClosure0 func(init_func, false);
+    GoogleOnceInitImpl(once, &func);
+  }
+}
+
+template <typename Arg>
+inline void GoogleOnceInit(ProtobufOnceType* once, void (*init_func)(Arg*),
+    Arg* arg) {
+  if (internal::Acquire_Load(once) != ONCE_STATE_DONE) {
+    internal::FunctionClosure1<Arg*> func(init_func, false, arg);
+    GoogleOnceInitImpl(once, &func);
+  }
+}
+
+#endif  // GOOGLE_PROTOBUF_NO_THREAD_SAFETY
+
+class GoogleOnceDynamic {
+ public:
+  GoogleOnceDynamic() : state_(GOOGLE_PROTOBUF_ONCE_INIT) { }
+
+  // If this->Init() has not been called before by any thread,
+  // execute (*func_with_arg)(arg) then return.
+  // Otherwise, wait until that prior invocation has finished
+  // executing its function, then return.
+  template<typename T>
+  void Init(void (*func_with_arg)(T*), T* arg) {
+    GoogleOnceInit<T>(&this->state_,
+                      func_with_arg,
+                      arg);
+  }
+ private:
+  ProtobufOnceType state_;
+};
+
+#define GOOGLE_PROTOBUF_DECLARE_ONCE(NAME) \
+  ::google::protobuf::ProtobufOnceType NAME = GOOGLE_PROTOBUF_ONCE_INIT
+
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_STUBS_ONCE_H__
diff --git a/kortex_api/include/google/protobuf/stubs/platform_macros.h b/kortex_api/include/google/protobuf/stubs/platform_macros.h
new file mode 100644
index 0000000000000000000000000000000000000000..c3a64dd2b38e6daa0b7546ab4febb46cab3a1ec9
--- /dev/null
+++ b/kortex_api/include/google/protobuf/stubs/platform_macros.h
@@ -0,0 +1,128 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2012 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_PLATFORM_MACROS_H_
+#define GOOGLE_PROTOBUF_PLATFORM_MACROS_H_
+
+#define GOOGLE_PROTOBUF_PLATFORM_ERROR \
+#error "Host platform was not detected as supported by protobuf"
+
+// Processor architecture detection.  For more info on what's defined, see:
+//   http://msdn.microsoft.com/en-us/library/b0084kay.aspx
+//   http://www.agner.org/optimize/calling_conventions.pdf
+//   or with gcc, run: "echo | gcc -E -dM -"
+#if defined(_M_X64) || defined(__x86_64__)
+#define GOOGLE_PROTOBUF_ARCH_X64 1
+#define GOOGLE_PROTOBUF_ARCH_64_BIT 1
+#elif defined(_M_IX86) || defined(__i386__)
+#define GOOGLE_PROTOBUF_ARCH_IA32 1
+#define GOOGLE_PROTOBUF_ARCH_32_BIT 1
+#elif defined(__QNX__)
+#define GOOGLE_PROTOBUF_ARCH_ARM_QNX 1
+#define GOOGLE_PROTOBUF_ARCH_32_BIT 1
+#elif defined(_M_ARM) || defined(__ARMEL__)
+#define GOOGLE_PROTOBUF_ARCH_ARM 1
+#define GOOGLE_PROTOBUF_ARCH_32_BIT 1
+#elif defined(_M_ARM64)
+#define GOOGLE_PROTOBUF_ARCH_ARM 1
+#define GOOGLE_PROTOBUF_ARCH_64_BIT 1
+#elif defined(__aarch64__)
+#define GOOGLE_PROTOBUF_ARCH_AARCH64 1
+#define GOOGLE_PROTOBUF_ARCH_64_BIT 1
+#elif defined(__MIPSEL__)
+#if defined(__LP64__)
+#define GOOGLE_PROTOBUF_ARCH_MIPS64 1
+#define GOOGLE_PROTOBUF_ARCH_64_BIT 1
+#else
+#define GOOGLE_PROTOBUF_ARCH_MIPS 1
+#define GOOGLE_PROTOBUF_ARCH_32_BIT 1
+#endif
+#elif defined(__pnacl__)
+#define GOOGLE_PROTOBUF_ARCH_32_BIT 1
+#elif defined(sparc)
+#define GOOGLE_PROTOBUF_ARCH_SPARC 1
+#if defined(__sparc_v9__) || defined(__sparcv9) || defined(__arch64__)
+#define GOOGLE_PROTOBUF_ARCH_64_BIT 1
+#else
+#define GOOGLE_PROTOBUF_ARCH_32_BIT 1
+#endif
+#elif defined(_POWER) || defined(__powerpc64__) || defined(__PPC64__)
+#define GOOGLE_PROTOBUF_ARCH_POWER 1
+#define GOOGLE_PROTOBUF_ARCH_64_BIT 1
+#elif defined(__PPC__)
+#define GOOGLE_PROTOBUF_ARCH_PPC 1
+#define GOOGLE_PROTOBUF_ARCH_32_BIT 1
+#elif defined(__GNUC__)
+# if (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 7)) || (__GNUC__ > 4))
+// We fallback to the generic Clang/GCC >= 4.7 implementation in atomicops.h
+# elif defined(__clang__)
+#  if !__has_extension(c_atomic)
+GOOGLE_PROTOBUF_PLATFORM_ERROR
+#  endif
+// We fallback to the generic Clang/GCC >= 4.7 implementation in atomicops.h
+# endif
+# if __LP64__
+#  define GOOGLE_PROTOBUF_ARCH_64_BIT 1
+# else
+#  define GOOGLE_PROTOBUF_ARCH_32_BIT 1
+# endif
+#else
+GOOGLE_PROTOBUF_PLATFORM_ERROR
+#endif
+
+#if defined(__APPLE__)
+#define GOOGLE_PROTOBUF_OS_APPLE
+#include <TargetConditionals.h>
+#if TARGET_OS_IPHONE
+#define GOOGLE_PROTOBUF_OS_IPHONE
+#endif
+#elif defined(__EMSCRIPTEN__)
+#define GOOGLE_PROTOBUF_OS_EMSCRIPTEN
+#elif defined(__native_client__)
+#define GOOGLE_PROTOBUF_OS_NACL
+#elif defined(sun)
+#define GOOGLE_PROTOBUF_OS_SOLARIS
+#elif defined(_AIX)
+#define GOOGLE_PROTOBUF_OS_AIX
+#elif defined(__ANDROID__)
+#define GOOGLE_PROTOBUF_OS_ANDROID
+#endif
+
+#undef GOOGLE_PROTOBUF_PLATFORM_ERROR
+
+#if defined(GOOGLE_PROTOBUF_OS_ANDROID) || defined(GOOGLE_PROTOBUF_OS_IPHONE) || defined(__OpenBSD__)
+// Android ndk does not support the __thread keyword very well yet. Here
+// we use pthread_key_create()/pthread_getspecific()/... methods for
+// TLS support on android.
+// iOS and OpenBSD also do not support the __thread keyword.
+#define GOOGLE_PROTOBUF_NO_THREADLOCAL
+#endif
+
+#endif  // GOOGLE_PROTOBUF_PLATFORM_MACROS_H_
diff --git a/kortex_api/include/google/protobuf/stubs/port.h b/kortex_api/include/google/protobuf/stubs/port.h
new file mode 100644
index 0000000000000000000000000000000000000000..cecefdcb3b0c0e374c8f36ecfc88b4fa569320b4
--- /dev/null
+++ b/kortex_api/include/google/protobuf/stubs/port.h
@@ -0,0 +1,525 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_STUBS_PORT_H_
+#define GOOGLE_PROTOBUF_STUBS_PORT_H_
+
+#include <assert.h>
+#include <stdlib.h>
+#include <cstddef>
+#include <string>
+#include <string.h>
+#if defined(__osf__)
+// Tru64 lacks stdint.h, but has inttypes.h which defines a superset of
+// what stdint.h would define.
+#include <inttypes.h>
+#elif !defined(_MSC_VER)
+#include <stdint.h>
+#endif
+
+#include <google/protobuf/stubs/platform_macros.h>
+
+#undef PROTOBUF_LITTLE_ENDIAN
+#ifdef _WIN32
+  // Assuming windows is always little-endian.
+  // TODO(xiaofeng): The PROTOBUF_LITTLE_ENDIAN is not only used for
+  // optimization but also for correctness. We should define an
+  // different macro to test the big-endian code path in coded_stream.
+  #if !defined(PROTOBUF_DISABLE_LITTLE_ENDIAN_OPT_FOR_TEST)
+    #define PROTOBUF_LITTLE_ENDIAN 1
+  #endif
+  #if _MSC_VER >= 1300 && !defined(__INTEL_COMPILER)
+    // If MSVC has "/RTCc" set, it will complain about truncating casts at
+    // runtime.  This file contains some intentional truncating casts.
+    #pragma runtime_checks("c", off)
+  #endif
+#else
+  #include <sys/param.h>   // __BYTE_ORDER
+  #if defined(__OpenBSD__)
+    #include <endian.h>
+  #endif
+  #if ((defined(__LITTLE_ENDIAN__) && !defined(__BIG_ENDIAN__)) || \
+         (defined(__BYTE_ORDER) && __BYTE_ORDER == __LITTLE_ENDIAN) || \
+         (defined(BYTE_ORDER) && BYTE_ORDER == LITTLE_ENDIAN)) && \
+      !defined(PROTOBUF_DISABLE_LITTLE_ENDIAN_OPT_FOR_TEST)
+    #define PROTOBUF_LITTLE_ENDIAN 1
+  #endif
+#endif
+#if defined(_MSC_VER) && defined(PROTOBUF_USE_DLLS)
+  #ifdef LIBPROTOBUF_EXPORTS
+    #define LIBPROTOBUF_EXPORT __declspec(dllexport)
+  #else
+    #define LIBPROTOBUF_EXPORT __declspec(dllimport)
+  #endif
+  #ifdef LIBPROTOC_EXPORTS
+    #define LIBPROTOC_EXPORT   __declspec(dllexport)
+  #else
+    #define LIBPROTOC_EXPORT   __declspec(dllimport)
+  #endif
+#else
+  #define LIBPROTOBUF_EXPORT
+  #define LIBPROTOC_EXPORT
+#endif
+
+// These #includes are for the byte swap functions declared later on.
+#ifdef _MSC_VER
+#include <stdlib.h>  // NOLINT(build/include)
+#elif defined(__APPLE__)
+#include <libkern/OSByteOrder.h>
+#elif defined(__GLIBC__) || defined(__CYGWIN__)
+#include <byteswap.h>  // IWYU pragma: export
+#endif
+
+#define PROTOBUF_RUNTIME_DEPRECATED(message)
+
+// ===================================================================
+// from google3/base/port.h
+
+#if (defined(__GXX_EXPERIMENTAL_CXX0X__) || __cplusplus >= 201103L || \
+     (defined(_MSC_VER) && _MSC_VER >= 1900))
+// Define this to 1 if the code is compiled in C++11 mode; leave it
+// undefined otherwise.  Do NOT define it to 0 -- that causes
+// '#ifdef LANG_CXX11' to behave differently from '#if LANG_CXX11'.
+#define LANG_CXX11 1
+#endif
+
+#if LANG_CXX11 && !defined(__NVCC__)
+#define PROTOBUF_CXX11 1
+#else
+#define PROTOBUF_CXX11 0
+#endif
+
+#if PROTOBUF_CXX11
+#define PROTOBUF_FINAL final
+#else
+#define PROTOBUF_FINAL
+#endif
+
+namespace google {
+namespace protobuf {
+
+typedef unsigned int uint;
+
+#ifdef _MSC_VER
+typedef signed __int8  int8;
+typedef __int16 int16;
+typedef __int32 int32;
+typedef __int64 int64;
+
+typedef unsigned __int8  uint8;
+typedef unsigned __int16 uint16;
+typedef unsigned __int32 uint32;
+typedef unsigned __int64 uint64;
+#else
+typedef int8_t int8;
+typedef int16_t int16;
+typedef int32_t int32;
+typedef int64_t int64;
+
+typedef uint8_t uint8;
+typedef uint16_t uint16;
+typedef uint32_t uint32;
+typedef uint64_t uint64;
+#endif
+
+// long long macros to be used because gcc and vc++ use different suffixes,
+// and different size specifiers in format strings
+#undef GOOGLE_LONGLONG
+#undef GOOGLE_ULONGLONG
+#undef GOOGLE_LL_FORMAT
+
+#ifdef _MSC_VER
+#define GOOGLE_LONGLONG(x) x##I64
+#define GOOGLE_ULONGLONG(x) x##UI64
+#define GOOGLE_LL_FORMAT "I64"  // As in printf("%I64d", ...)
+#else
+// By long long, we actually mean int64.
+#define GOOGLE_LONGLONG(x) x##LL
+#define GOOGLE_ULONGLONG(x) x##ULL
+// Used to format real long long integers.
+#define GOOGLE_LL_FORMAT "ll"  // As in "%lld". Note that "q" is poor form also.
+#endif
+
+static const int32 kint32max = 0x7FFFFFFF;
+static const int32 kint32min = -kint32max - 1;
+static const int64 kint64max = GOOGLE_LONGLONG(0x7FFFFFFFFFFFFFFF);
+static const int64 kint64min = -kint64max - 1;
+static const uint32 kuint32max = 0xFFFFFFFFu;
+static const uint64 kuint64max = GOOGLE_ULONGLONG(0xFFFFFFFFFFFFFFFF);
+
+// -------------------------------------------------------------------
+// Annotations:  Some parts of the code have been annotated in ways that might
+//   be useful to some compilers or tools, but are not supported universally.
+//   You can #define these annotations yourself if the default implementation
+//   is not right for you.
+
+#ifndef GOOGLE_ATTRIBUTE_ALWAYS_INLINE
+#if defined(__GNUC__) && (__GNUC__ > 3 ||(__GNUC__ == 3 && __GNUC_MINOR__ >= 1))
+// For functions we want to force inline.
+// Introduced in gcc 3.1.
+#define GOOGLE_ATTRIBUTE_ALWAYS_INLINE __attribute__ ((always_inline))
+#else
+// Other compilers will have to figure it out for themselves.
+#define GOOGLE_ATTRIBUTE_ALWAYS_INLINE
+#endif
+#endif
+
+#define GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE GOOGLE_ATTRIBUTE_ALWAYS_INLINE
+
+#ifndef GOOGLE_ATTRIBUTE_NOINLINE
+#if defined(__GNUC__) && (__GNUC__ > 3 ||(__GNUC__ == 3 && __GNUC_MINOR__ >= 1))
+// For functions we want to force not inline.
+// Introduced in gcc 3.1.
+#define GOOGLE_ATTRIBUTE_NOINLINE __attribute__ ((noinline))
+#elif defined(_MSC_VER) && (_MSC_VER >= 1400)
+// Seems to have been around since at least Visual Studio 2005
+#define GOOGLE_ATTRIBUTE_NOINLINE __declspec(noinline)
+#else
+// Other compilers will have to figure it out for themselves.
+#define GOOGLE_ATTRIBUTE_NOINLINE
+#endif
+#endif
+
+#define GOOGLE_PROTOBUF_ATTRIBUTE_NOINLINE GOOGLE_ATTRIBUTE_NOINLINE
+
+#ifndef GOOGLE_PREDICT_TRUE
+#ifdef __GNUC__
+// Provided at least since GCC 3.0.
+#define GOOGLE_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
+#else
+#define GOOGLE_PREDICT_TRUE(x) (x)
+#endif
+#endif
+
+#ifndef GOOGLE_PREDICT_FALSE
+#ifdef __GNUC__
+// Provided at least since GCC 3.0.
+#define GOOGLE_PREDICT_FALSE(x) (__builtin_expect(x, 0))
+#else
+#define GOOGLE_PREDICT_FALSE(x) (x)
+#endif
+#endif
+
+// Delimits a block of code which may write to memory which is simultaneously
+// written by other threads, but which has been determined to be thread-safe
+// (e.g. because it is an idempotent write).
+#ifndef GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN
+#define GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN()
+#endif
+#ifndef GOOGLE_SAFE_CONCURRENT_WRITES_END
+#define GOOGLE_SAFE_CONCURRENT_WRITES_END()
+#endif
+
+#if defined(__clang__) && defined(__has_cpp_attribute) \
+    && !defined(GOOGLE_PROTOBUF_OS_APPLE)
+# if defined(GOOGLE_PROTOBUF_OS_NACL) || defined(EMSCRIPTEN) || \
+     __has_cpp_attribute(clang::fallthrough)
+#  define GOOGLE_FALLTHROUGH_INTENDED [[clang::fallthrough]]
+# endif
+#elif defined(__GNUC__) && __GNUC__ > 6
+# define GOOGLE_FALLTHROUGH_INTENDED [[gnu::fallthrough]]
+#endif
+
+#ifndef GOOGLE_FALLTHROUGH_INTENDED
+# define GOOGLE_FALLTHROUGH_INTENDED
+#endif
+
+#define GOOGLE_GUARDED_BY(x)
+#define GOOGLE_ATTRIBUTE_COLD
+
+#ifdef GOOGLE_PROTOBUF_DONT_USE_UNALIGNED
+# define GOOGLE_PROTOBUF_USE_UNALIGNED 0
+#else
+# if defined(_M_X64) || defined(__x86_64__) || defined(_M_IX86) || defined(__i386__)
+#  define GOOGLE_PROTOBUF_USE_UNALIGNED 1
+# else
+#  define GOOGLE_PROTOBUF_USE_UNALIGNED 0
+# endif
+#endif
+
+#define GOOGLE_PROTOBUF_ATTRIBUTE_COLD GOOGLE_ATTRIBUTE_COLD
+
+#if defined(ADDRESS_SANITIZER) || defined(THREAD_SANITIZER) ||\
+    defined(MEMORY_SANITIZER)
+
+#ifdef __cplusplus
+extern "C" {
+#endif  // __cplusplus
+uint16_t __sanitizer_unaligned_load16(const void *p);
+uint32_t __sanitizer_unaligned_load32(const void *p);
+uint64_t __sanitizer_unaligned_load64(const void *p);
+void __sanitizer_unaligned_store16(void *p, uint16_t v);
+void __sanitizer_unaligned_store32(void *p, uint32_t v);
+void __sanitizer_unaligned_store64(void *p, uint64_t v);
+#ifdef __cplusplus
+}  // extern "C"
+#endif  // __cplusplus
+
+inline uint16 GOOGLE_UNALIGNED_LOAD16(const void *p) {
+  return __sanitizer_unaligned_load16(p);
+}
+
+inline uint32 GOOGLE_UNALIGNED_LOAD32(const void *p) {
+  return __sanitizer_unaligned_load32(p);
+}
+
+inline uint64 GOOGLE_UNALIGNED_LOAD64(const void *p) {
+  return __sanitizer_unaligned_load64(p);
+}
+
+inline void GOOGLE_UNALIGNED_STORE16(void *p, uint16 v) {
+  __sanitizer_unaligned_store16(p, v);
+}
+
+inline void GOOGLE_UNALIGNED_STORE32(void *p, uint32 v) {
+  __sanitizer_unaligned_store32(p, v);
+}
+
+inline void GOOGLE_UNALIGNED_STORE64(void *p, uint64 v) {
+  __sanitizer_unaligned_store64(p, v);
+}
+
+#elif GOOGLE_PROTOBUF_USE_UNALIGNED
+
+#define GOOGLE_UNALIGNED_LOAD16(_p) (*reinterpret_cast<const uint16 *>(_p))
+#define GOOGLE_UNALIGNED_LOAD32(_p) (*reinterpret_cast<const uint32 *>(_p))
+#define GOOGLE_UNALIGNED_LOAD64(_p) (*reinterpret_cast<const uint64 *>(_p))
+
+#define GOOGLE_UNALIGNED_STORE16(_p, _val) (*reinterpret_cast<uint16 *>(_p) = (_val))
+#define GOOGLE_UNALIGNED_STORE32(_p, _val) (*reinterpret_cast<uint32 *>(_p) = (_val))
+#define GOOGLE_UNALIGNED_STORE64(_p, _val) (*reinterpret_cast<uint64 *>(_p) = (_val))
+
+#else
+inline uint16 GOOGLE_UNALIGNED_LOAD16(const void *p) {
+  uint16 t;
+  memcpy(&t, p, sizeof t);
+  return t;
+}
+
+inline uint32 GOOGLE_UNALIGNED_LOAD32(const void *p) {
+  uint32 t;
+  memcpy(&t, p, sizeof t);
+  return t;
+}
+
+inline uint64 GOOGLE_UNALIGNED_LOAD64(const void *p) {
+  uint64 t;
+  memcpy(&t, p, sizeof t);
+  return t;
+}
+
+inline void GOOGLE_UNALIGNED_STORE16(void *p, uint16 v) {
+  memcpy(p, &v, sizeof v);
+}
+
+inline void GOOGLE_UNALIGNED_STORE32(void *p, uint32 v) {
+  memcpy(p, &v, sizeof v);
+}
+
+inline void GOOGLE_UNALIGNED_STORE64(void *p, uint64 v) {
+  memcpy(p, &v, sizeof v);
+}
+#endif
+
+#if defined(_MSC_VER)
+#define GOOGLE_THREAD_LOCAL __declspec(thread)
+#else
+#define GOOGLE_THREAD_LOCAL __thread
+#endif
+
+// The following guarantees declaration of the byte swap functions.
+#ifdef _MSC_VER
+#define bswap_16(x) _byteswap_ushort(x)
+#define bswap_32(x) _byteswap_ulong(x)
+#define bswap_64(x) _byteswap_uint64(x)
+
+#elif defined(__APPLE__)
+// Mac OS X / Darwin features
+#define bswap_16(x) OSSwapInt16(x)
+#define bswap_32(x) OSSwapInt32(x)
+#define bswap_64(x) OSSwapInt64(x)
+
+#elif !defined(__GLIBC__) && !defined(__CYGWIN__)
+
+static inline uint16 bswap_16(uint16 x) {
+  return static_cast<uint16>(((x & 0xFF) << 8) | ((x & 0xFF00) >> 8));
+}
+#define bswap_16(x) bswap_16(x)
+static inline uint32 bswap_32(uint32 x) {
+  return (((x & 0xFF) << 24) |
+          ((x & 0xFF00) << 8) |
+          ((x & 0xFF0000) >> 8) |
+          ((x & 0xFF000000) >> 24));
+}
+#define bswap_32(x) bswap_32(x)
+static inline uint64 bswap_64(uint64 x) {
+  return (((x & GOOGLE_ULONGLONG(0xFF)) << 56) |
+          ((x & GOOGLE_ULONGLONG(0xFF00)) << 40) |
+          ((x & GOOGLE_ULONGLONG(0xFF0000)) << 24) |
+          ((x & GOOGLE_ULONGLONG(0xFF000000)) << 8) |
+          ((x & GOOGLE_ULONGLONG(0xFF00000000)) >> 8) |
+          ((x & GOOGLE_ULONGLONG(0xFF0000000000)) >> 24) |
+          ((x & GOOGLE_ULONGLONG(0xFF000000000000)) >> 40) |
+          ((x & GOOGLE_ULONGLONG(0xFF00000000000000)) >> 56));
+}
+#define bswap_64(x) bswap_64(x)
+
+#endif
+
+// ===================================================================
+// from google3/util/bits/bits.h
+
+class Bits {
+ public:
+  static uint32 Log2FloorNonZero(uint32 n) {
+#if defined(__GNUC__)
+  return 31 ^ static_cast<uint32>(__builtin_clz(n));
+#elif defined(COMPILER_MSVC) && defined(_M_IX86)
+  _asm {
+    bsr ebx, n
+    mov n, ebx
+  }
+  return n;
+#else
+  return Log2FloorNonZero_Portable(n);
+#endif
+  }
+
+  static uint32 Log2FloorNonZero64(uint64 n) {
+    // arm-nacl-clang runs into an instruction-selection failure when it
+    // encounters __builtin_clzll:
+    // https://bugs.chromium.org/p/nativeclient/issues/detail?id=4395
+    // To work around this, when we build for NaCl we use the portable
+    // implementation instead.
+#if defined(__GNUC__) && !defined(GOOGLE_PROTOBUF_OS_NACL)
+  return 63 ^ static_cast<uint32>(__builtin_clzll(n));
+#else
+  return Log2FloorNonZero64_Portable(n);
+#endif
+  }
+ private:
+  static int Log2FloorNonZero_Portable(uint32 n) {
+    if (n == 0)
+      return -1;
+    int log = 0;
+    uint32 value = n;
+    for (int i = 4; i >= 0; --i) {
+      int shift = (1 << i);
+      uint32 x = value >> shift;
+      if (x != 0) {
+        value = x;
+        log += shift;
+      }
+    }
+    assert(value == 1);
+    return log;
+  }
+
+  static int Log2FloorNonZero64_Portable(uint64 n) {
+    const uint32 topbits = static_cast<uint32>(n >> 32);
+    if (topbits == 0) {
+      // Top bits are zero, so scan in bottom bits
+      return static_cast<int>(Log2FloorNonZero(static_cast<uint32>(n)));
+    } else {
+      return 32 + static_cast<int>(Log2FloorNonZero(topbits));
+    }
+  }
+};
+
+// ===================================================================
+// from google3/util/endian/endian.h
+LIBPROTOBUF_EXPORT uint32 ghtonl(uint32 x);
+
+class BigEndian {
+ public:
+#ifdef PROTOBUF_LITTLE_ENDIAN
+
+  static uint16 FromHost16(uint16 x) { return bswap_16(x); }
+  static uint16 ToHost16(uint16 x) { return bswap_16(x); }
+
+  static uint32 FromHost32(uint32 x) { return bswap_32(x); }
+  static uint32 ToHost32(uint32 x) { return bswap_32(x); }
+
+  static uint64 FromHost64(uint64 x) { return bswap_64(x); }
+  static uint64 ToHost64(uint64 x) { return bswap_64(x); }
+
+  static bool IsLittleEndian() { return true; }
+
+#else
+
+  static uint16 FromHost16(uint16 x) { return x; }
+  static uint16 ToHost16(uint16 x) { return x; }
+
+  static uint32 FromHost32(uint32 x) { return x; }
+  static uint32 ToHost32(uint32 x) { return x; }
+
+  static uint64 FromHost64(uint64 x) { return x; }
+  static uint64 ToHost64(uint64 x) { return x; }
+
+  static bool IsLittleEndian() { return false; }
+
+#endif /* ENDIAN */
+
+  // Functions to do unaligned loads and stores in big-endian order.
+  static uint16 Load16(const void *p) {
+    return ToHost16(GOOGLE_UNALIGNED_LOAD16(p));
+  }
+
+  static void Store16(void *p, uint16 v) {
+    GOOGLE_UNALIGNED_STORE16(p, FromHost16(v));
+  }
+
+  static uint32 Load32(const void *p) {
+    return ToHost32(GOOGLE_UNALIGNED_LOAD32(p));
+  }
+
+  static void Store32(void *p, uint32 v) {
+    GOOGLE_UNALIGNED_STORE32(p, FromHost32(v));
+  }
+
+  static uint64 Load64(const void *p) {
+    return ToHost64(GOOGLE_UNALIGNED_LOAD64(p));
+  }
+
+  static void Store64(void *p, uint64 v) {
+    GOOGLE_UNALIGNED_STORE64(p, FromHost64(v));
+  }
+};
+
+#ifndef GOOGLE_ATTRIBUTE_SECTION_VARIABLE
+#define GOOGLE_ATTRIBUTE_SECTION_VARIABLE(name)
+#endif
+
+#define GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(name)
+
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_STUBS_PORT_H_
diff --git a/kortex_api/include/google/protobuf/stubs/scoped_ptr.h b/kortex_api/include/google/protobuf/stubs/scoped_ptr.h
new file mode 100644
index 0000000000000000000000000000000000000000..4423c118c40b54a3287f7982542108048c565333
--- /dev/null
+++ b/kortex_api/include/google/protobuf/stubs/scoped_ptr.h
@@ -0,0 +1,236 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef GOOGLE_PROTOBUF_STUBS_SCOPED_PTR_H_
+#define GOOGLE_PROTOBUF_STUBS_SCOPED_PTR_H_
+
+#include <google/protobuf/stubs/port.h>
+
+namespace google {
+namespace protobuf {
+
+// ===================================================================
+// from google3/base/scoped_ptr.h
+
+namespace internal {
+
+//  This is an implementation designed to match the anticipated future TR2
+//  implementation of the scoped_ptr class, and its closely-related brethren,
+//  scoped_array, scoped_ptr_malloc, and make_scoped_ptr.
+
+template <class C> class scoped_ptr;
+template <class C> class scoped_array;
+
+// A scoped_ptr<T> is like a T*, except that the destructor of scoped_ptr<T>
+// automatically deletes the pointer it holds (if any).
+// That is, scoped_ptr<T> owns the T object that it points to.
+// Like a T*, a scoped_ptr<T> may hold either NULL or a pointer to a T object.
+//
+// The size of a scoped_ptr is small:
+// sizeof(scoped_ptr<C>) == sizeof(C*)
+template <class C>
+class scoped_ptr {
+ public:
+
+  // The element type
+  typedef C element_type;
+
+  // Constructor.  Defaults to initializing with NULL.
+  // There is no way to create an uninitialized scoped_ptr.
+  // The input parameter must be allocated with new.
+  explicit scoped_ptr(C* p = NULL) : ptr_(p) { }
+
+  // Destructor.  If there is a C object, delete it.
+  // We don't need to test ptr_ == NULL because C++ does that for us.
+  ~scoped_ptr() {
+    enum { type_must_be_complete = sizeof(C) };
+    delete ptr_;
+  }
+
+  // Reset.  Deletes the current owned object, if any.
+  // Then takes ownership of a new object, if given.
+  // this->reset(this->get()) works.
+  void reset(C* p = NULL) {
+    if (p != ptr_) {
+      enum { type_must_be_complete = sizeof(C) };
+      delete ptr_;
+      ptr_ = p;
+    }
+  }
+
+  // Accessors to get the owned object.
+  // operator* and operator-> will assert() if there is no current object.
+  C& operator*() const {
+    assert(ptr_ != NULL);
+    return *ptr_;
+  }
+  C* operator->() const  {
+    assert(ptr_ != NULL);
+    return ptr_;
+  }
+  C* get() const { return ptr_; }
+
+  // Comparison operators.
+  // These return whether two scoped_ptr refer to the same object, not just to
+  // two different but equal objects.
+  bool operator==(C* p) const { return ptr_ == p; }
+  bool operator!=(C* p) const { return ptr_ != p; }
+
+  // Swap two scoped pointers.
+  void swap(scoped_ptr& p2) {
+    C* tmp = ptr_;
+    ptr_ = p2.ptr_;
+    p2.ptr_ = tmp;
+  }
+
+  // Release a pointer.
+  // The return value is the current pointer held by this object.
+  // If this object holds a NULL pointer, the return value is NULL.
+  // After this operation, this object will hold a NULL pointer,
+  // and will not own the object any more.
+  C* release() {
+    C* retVal = ptr_;
+    ptr_ = NULL;
+    return retVal;
+  }
+
+ private:
+  C* ptr_;
+
+  // Forbid comparison of scoped_ptr types.  If C2 != C, it totally doesn't
+  // make sense, and if C2 == C, it still doesn't make sense because you should
+  // never have the same object owned by two different scoped_ptrs.
+  template <class C2> bool operator==(scoped_ptr<C2> const& p2) const;
+  template <class C2> bool operator!=(scoped_ptr<C2> const& p2) const;
+
+  // Disallow evil constructors
+  scoped_ptr(const scoped_ptr&);
+  void operator=(const scoped_ptr&);
+};
+
+// scoped_array<C> is like scoped_ptr<C>, except that the caller must allocate
+// with new [] and the destructor deletes objects with delete [].
+//
+// As with scoped_ptr<C>, a scoped_array<C> either points to an object
+// or is NULL.  A scoped_array<C> owns the object that it points to.
+//
+// Size: sizeof(scoped_array<C>) == sizeof(C*)
+template <class C>
+class scoped_array {
+ public:
+
+  // The element type
+  typedef C element_type;
+
+  // Constructor.  Defaults to initializing with NULL.
+  // There is no way to create an uninitialized scoped_array.
+  // The input parameter must be allocated with new [].
+  explicit scoped_array(C* p = NULL) : array_(p) { }
+
+  // Destructor.  If there is a C object, delete it.
+  // We don't need to test ptr_ == NULL because C++ does that for us.
+  ~scoped_array() {
+    enum { type_must_be_complete = sizeof(C) };
+    delete[] array_;
+  }
+
+  // Reset.  Deletes the current owned object, if any.
+  // Then takes ownership of a new object, if given.
+  // this->reset(this->get()) works.
+  void reset(C* p = NULL) {
+    if (p != array_) {
+      enum { type_must_be_complete = sizeof(C) };
+      delete[] array_;
+      array_ = p;
+    }
+  }
+
+  // Get one element of the current object.
+  // Will assert() if there is no current object, or index i is negative.
+  C& operator[](std::ptrdiff_t i) const {
+    assert(i >= 0);
+    assert(array_ != NULL);
+    return array_[i];
+  }
+
+  // Get a pointer to the zeroth element of the current object.
+  // If there is no current object, return NULL.
+  C* get() const {
+    return array_;
+  }
+
+  // Comparison operators.
+  // These return whether two scoped_array refer to the same object, not just to
+  // two different but equal objects.
+  bool operator==(C* p) const { return array_ == p; }
+  bool operator!=(C* p) const { return array_ != p; }
+
+  // Swap two scoped arrays.
+  void swap(scoped_array& p2) {
+    C* tmp = array_;
+    array_ = p2.array_;
+    p2.array_ = tmp;
+  }
+
+  // Release an array.
+  // The return value is the current pointer held by this object.
+  // If this object holds a NULL pointer, the return value is NULL.
+  // After this operation, this object will hold a NULL pointer,
+  // and will not own the object any more.
+  C* release() {
+    C* retVal = array_;
+    array_ = NULL;
+    return retVal;
+  }
+
+ private:
+  C* array_;
+
+  // Forbid comparison of different scoped_array types.
+  template <class C2> bool operator==(scoped_array<C2> const& p2) const;
+  template <class C2> bool operator!=(scoped_array<C2> const& p2) const;
+
+  // Disallow evil constructors
+  scoped_array(const scoped_array&);
+  void operator=(const scoped_array&);
+};
+
+}  // namespace internal
+
+// We made these internal so that they would show up as such in the docs,
+// but we don't want to stick "internal::" in front of them everywhere.
+using internal::scoped_ptr;
+using internal::scoped_array;
+
+
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_STUBS_SCOPED_PTR_H_
diff --git a/kortex_api/include/google/protobuf/stubs/shared_ptr.h b/kortex_api/include/google/protobuf/stubs/shared_ptr.h
new file mode 100644
index 0000000000000000000000000000000000000000..7da114e9367a6eb561949dbeb54b2db626ec49ae
--- /dev/null
+++ b/kortex_api/include/google/protobuf/stubs/shared_ptr.h
@@ -0,0 +1,471 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2014 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// from google3/util/gtl/shared_ptr.h
+
+#ifndef GOOGLE_PROTOBUF_STUBS_SHARED_PTR_H__
+#define GOOGLE_PROTOBUF_STUBS_SHARED_PTR_H__
+
+#include <google/protobuf/stubs/atomicops.h>
+
+#include <algorithm>  // for swap
+#include <stddef.h>
+#include <memory>
+
+namespace google {
+namespace protobuf {
+namespace internal {
+
+// Alias to std::shared_ptr for any C++11 platform,
+// and for any supported MSVC compiler.
+#if !defined(UTIL_GTL_USE_STD_SHARED_PTR) && \
+    (defined(COMPILER_MSVC) || defined(LANG_CXX11))
+#define UTIL_GTL_USE_STD_SHARED_PTR 1
+#endif
+
+#if defined(UTIL_GTL_USE_STD_SHARED_PTR) && UTIL_GTL_USE_STD_SHARED_PTR
+
+// These are transitional.  They will be going away soon.
+// Please just #include <memory> and just type std::shared_ptr yourself, instead
+// of relying on this file.
+//
+// Migration doc: http://go/std-shared-ptr-lsc
+using std::enable_shared_from_this;
+using std::shared_ptr;
+using std::static_pointer_cast;
+using std::weak_ptr;
+
+#else  // below, UTIL_GTL_USE_STD_SHARED_PTR not set or set to 0.
+
+// For everything else there is the google3 implementation.
+inline bool RefCountDec(volatile Atomic32 *ptr) {
+  return Barrier_AtomicIncrement(ptr, -1) != 0;
+}
+
+inline void RefCountInc(volatile Atomic32 *ptr) {
+  NoBarrier_AtomicIncrement(ptr, 1);
+}
+
+template <typename T> class shared_ptr;
+template <typename T> class weak_ptr;
+
+// This class is an internal implementation detail for shared_ptr. If two
+// shared_ptrs point to the same object, they also share a control block.
+// An "empty" shared_pointer refers to NULL and also has a NULL control block.
+// It contains all of the state that's needed for reference counting or any
+// other kind of resource management. In this implementation the control block
+// happens to consist of two atomic words, the reference count (the number
+// of shared_ptrs that share ownership of the object) and the weak count
+// (the number of weak_ptrs that observe the object, plus 1 if the
+// refcount is nonzero).
+//
+// The "plus 1" is to prevent a race condition in the shared_ptr and
+// weak_ptr destructors. We need to make sure the control block is
+// only deleted once, so we need to make sure that at most one
+// object sees the weak count decremented from 1 to 0.
+class SharedPtrControlBlock {
+  template <typename T> friend class shared_ptr;
+  template <typename T> friend class weak_ptr;
+ private:
+  SharedPtrControlBlock() : refcount_(1), weak_count_(1) { }
+  Atomic32 refcount_;
+  Atomic32 weak_count_;
+};
+
+// Forward declaration. The class is defined below.
+template <typename T> class enable_shared_from_this;
+
+template <typename T>
+class shared_ptr {
+  template <typename U> friend class weak_ptr;
+ public:
+  typedef T element_type;
+
+  shared_ptr() : ptr_(NULL), control_block_(NULL) {}
+
+  explicit shared_ptr(T* ptr)
+      : ptr_(ptr),
+        control_block_(ptr != NULL ? new SharedPtrControlBlock : NULL) {
+    // If p is non-null and T inherits from enable_shared_from_this, we
+    // set up the data that shared_from_this needs.
+    MaybeSetupWeakThis(ptr);
+  }
+
+  // Copy constructor: makes this object a copy of ptr, and increments
+  // the reference count.
+  template <typename U>
+  shared_ptr(const shared_ptr<U>& ptr)
+      : ptr_(NULL),
+        control_block_(NULL) {
+    Initialize(ptr);
+  }
+  // Need non-templated version to prevent the compiler-generated default
+  shared_ptr(const shared_ptr<T>& ptr)
+      : ptr_(NULL),
+        control_block_(NULL) {
+    Initialize(ptr);
+  }
+
+  // Assignment operator. Replaces the existing shared_ptr with ptr.
+  // Increment ptr's reference count and decrement the one being replaced.
+  template <typename U>
+  shared_ptr<T>& operator=(const shared_ptr<U>& ptr) {
+    if (ptr_ != ptr.ptr_) {
+      shared_ptr<T> me(ptr);   // will hold our previous state to be destroyed.
+      swap(me);
+    }
+    return *this;
+  }
+
+  // Need non-templated version to prevent the compiler-generated default
+  shared_ptr<T>& operator=(const shared_ptr<T>& ptr) {
+    if (ptr_ != ptr.ptr_) {
+      shared_ptr<T> me(ptr);   // will hold our previous state to be destroyed.
+      swap(me);
+    }
+    return *this;
+  }
+
+  // TODO(austern): Consider providing this constructor. The draft C++ standard
+  // (20.8.10.2.1) includes it. However, it says that this constructor throws
+  // a bad_weak_ptr exception when ptr is expired. Is it better to provide this
+  // constructor and make it do something else, like fail with a CHECK, or to
+  // leave this constructor out entirely?
+  //
+  // template <typename U>
+  // shared_ptr(const weak_ptr<U>& ptr);
+
+  ~shared_ptr() {
+    if (ptr_ != NULL) {
+      if (!RefCountDec(&control_block_->refcount_)) {
+        delete ptr_;
+
+        // weak_count_ is defined as the number of weak_ptrs that observe
+        // ptr_, plus 1 if refcount_ is nonzero.
+        if (!RefCountDec(&control_block_->weak_count_)) {
+          delete control_block_;
+        }
+      }
+    }
+  }
+
+  // Replaces underlying raw pointer with the one passed in.  The reference
+  // count is set to one (or zero if the pointer is NULL) for the pointer
+  // being passed in and decremented for the one being replaced.
+  //
+  // If you have a compilation error with this code, make sure you aren't
+  // passing NULL, nullptr, or 0 to this function.  Call reset without an
+  // argument to reset to a null ptr.
+  template <typename Y>
+  void reset(Y* p) {
+    if (p != ptr_) {
+      shared_ptr<T> tmp(p);
+      tmp.swap(*this);
+    }
+  }
+
+  void reset() {
+    reset(static_cast<T*>(NULL));
+  }
+
+  // Exchanges the contents of this with the contents of r.  This function
+  // supports more efficient swapping since it eliminates the need for a
+  // temporary shared_ptr object.
+  void swap(shared_ptr<T>& r) {
+    using std::swap;  // http://go/using-std-swap
+    swap(ptr_, r.ptr_);
+    swap(control_block_, r.control_block_);
+  }
+
+  // The following function is useful for gaining access to the underlying
+  // pointer when a shared_ptr remains in scope so the reference-count is
+  // known to be > 0 (e.g. for parameter passing).
+  T* get() const {
+    return ptr_;
+  }
+
+  T& operator*() const {
+    return *ptr_;
+  }
+
+  T* operator->() const {
+    return ptr_;
+  }
+
+  long use_count() const {
+    return control_block_ ? control_block_->refcount_ : 1;
+  }
+
+  bool unique() const {
+    return use_count() == 1;
+  }
+
+ private:
+  // If r is non-empty, initialize *this to share ownership with r,
+  // increasing the underlying reference count.
+  // If r is empty, *this remains empty.
+  // Requires: this is empty, namely this->ptr_ == NULL.
+  template <typename U>
+  void Initialize(const shared_ptr<U>& r) {
+    // This performs a static_cast on r.ptr_ to U*, which is a no-op since it
+    // is already a U*. So initialization here requires that r.ptr_ is
+    // implicitly convertible to T*.
+    InitializeWithStaticCast<U>(r);
+  }
+
+  // Initializes *this as described in Initialize, but additionally performs a
+  // static_cast from r.ptr_ (V*) to U*.
+  // NOTE(gfc): We'd need a more general form to support const_pointer_cast and
+  // dynamic_pointer_cast, but those operations are sufficiently discouraged
+  // that supporting static_pointer_cast is sufficient.
+  template <typename U, typename V>
+  void InitializeWithStaticCast(const shared_ptr<V>& r) {
+    if (r.control_block_ != NULL) {
+      RefCountInc(&r.control_block_->refcount_);
+
+      ptr_ = static_cast<U*>(r.ptr_);
+      control_block_ = r.control_block_;
+    }
+  }
+
+  // Helper function for the constructor that takes a raw pointer. If T
+  // doesn't inherit from enable_shared_from_this<T> then we have nothing to
+  // do, so this function is trivial and inline. The other version is declared
+  // out of line, after the class definition of enable_shared_from_this.
+  void MaybeSetupWeakThis(enable_shared_from_this<T>* ptr);
+  void MaybeSetupWeakThis(...) { }
+
+  T* ptr_;
+  SharedPtrControlBlock* control_block_;
+
+#ifndef SWIG
+  template <typename U>
+  friend class shared_ptr;
+
+  template <typename U, typename V>
+  friend shared_ptr<U> static_pointer_cast(const shared_ptr<V>& rhs);
+#endif
+};
+
+// Matches the interface of std::swap as an aid to generic programming.
+template <typename T> void swap(shared_ptr<T>& r, shared_ptr<T>& s) {
+  r.swap(s);
+}
+
+template <typename T, typename U>
+shared_ptr<T> static_pointer_cast(const shared_ptr<U>& rhs) {
+  shared_ptr<T> lhs;
+  lhs.template InitializeWithStaticCast<T>(rhs);
+  return lhs;
+}
+
+// See comments at the top of the file for a description of why this
+// class exists, and the draft C++ standard (as of July 2009 the
+// latest draft is N2914) for the detailed specification.
+template <typename T>
+class weak_ptr {
+  template <typename U> friend class weak_ptr;
+ public:
+  typedef T element_type;
+
+  // Create an empty (i.e. already expired) weak_ptr.
+  weak_ptr() : ptr_(NULL), control_block_(NULL) { }
+
+  // Create a weak_ptr that observes the same object that ptr points
+  // to.  Note that there is no race condition here: we know that the
+  // control block can't disappear while we're looking at it because
+  // it is owned by at least one shared_ptr, ptr.
+  template <typename U> weak_ptr(const shared_ptr<U>& ptr) {
+    CopyFrom(ptr.ptr_, ptr.control_block_);
+  }
+
+  // Copy a weak_ptr. The object it points to might disappear, but we
+  // don't care: we're only working with the control block, and it can't
+  // disappear while we're looking at because it's owned by at least one
+  // weak_ptr, ptr.
+  template <typename U> weak_ptr(const weak_ptr<U>& ptr) {
+    CopyFrom(ptr.ptr_, ptr.control_block_);
+  }
+
+  // Need non-templated version to prevent default copy constructor
+  weak_ptr(const weak_ptr& ptr) {
+    CopyFrom(ptr.ptr_, ptr.control_block_);
+  }
+
+  // Destroy the weak_ptr. If no shared_ptr owns the control block, and if
+  // we are the last weak_ptr to own it, then it can be deleted. Note that
+  // weak_count_ is defined as the number of weak_ptrs sharing this control
+  // block, plus 1 if there are any shared_ptrs. We therefore know that it's
+  // safe to delete the control block when weak_count_ reaches 0, without
+  // having to perform any additional tests.
+  ~weak_ptr() {
+    if (control_block_ != NULL &&
+        !RefCountDec(&control_block_->weak_count_)) {
+      delete control_block_;
+    }
+  }
+
+  weak_ptr& operator=(const weak_ptr& ptr) {
+    if (&ptr != this) {
+      weak_ptr tmp(ptr);
+      tmp.swap(*this);
+    }
+    return *this;
+  }
+  template <typename U> weak_ptr& operator=(const weak_ptr<U>& ptr) {
+    weak_ptr tmp(ptr);
+    tmp.swap(*this);
+    return *this;
+  }
+  template <typename U> weak_ptr& operator=(const shared_ptr<U>& ptr) {
+    weak_ptr tmp(ptr);
+    tmp.swap(*this);
+    return *this;
+  }
+
+  void swap(weak_ptr& ptr) {
+    using std::swap;  // http://go/using-std-swap
+    swap(ptr_, ptr.ptr_);
+    swap(control_block_, ptr.control_block_);
+  }
+
+  void reset() {
+    weak_ptr tmp;
+    tmp.swap(*this);
+  }
+
+  // Return the number of shared_ptrs that own the object we are observing.
+  // Note that this number can be 0 (if this pointer has expired).
+  long use_count() const {
+    return control_block_ != NULL ? control_block_->refcount_ : 0;
+  }
+
+  bool expired() const { return use_count() == 0; }
+
+  // Return a shared_ptr that owns the object we are observing. If we
+  // have expired, the shared_ptr will be empty. We have to be careful
+  // about concurrency, though, since some other thread might be
+  // destroying the last owning shared_ptr while we're in this
+  // function.  We want to increment the refcount only if it's nonzero
+  // and get the new value, and we want that whole operation to be
+  // atomic.
+  shared_ptr<T> lock() const {
+    shared_ptr<T> result;
+    if (control_block_ != NULL) {
+      Atomic32 old_refcount;
+      do {
+        old_refcount = control_block_->refcount_;
+        if (old_refcount == 0)
+          break;
+      } while (old_refcount !=
+               NoBarrier_CompareAndSwap(
+                   &control_block_->refcount_, old_refcount,
+                   old_refcount + 1));
+      if (old_refcount > 0) {
+        result.ptr_ = ptr_;
+        result.control_block_ = control_block_;
+      }
+    }
+
+    return result;
+  }
+
+ private:
+  void CopyFrom(T* ptr, SharedPtrControlBlock* control_block) {
+    ptr_ = ptr;
+    control_block_ = control_block;
+    if (control_block_ != NULL)
+      RefCountInc(&control_block_->weak_count_);
+  }
+
+ private:
+  element_type* ptr_;
+  SharedPtrControlBlock* control_block_;
+};
+
+template <typename T> void swap(weak_ptr<T>& r, weak_ptr<T>& s) {
+  r.swap(s);
+}
+
+// See comments at the top of the file for a description of why this class
+// exists, and section 20.8.10.5 of the draft C++ standard (as of July 2009
+// the latest draft is N2914) for the detailed specification.
+template <typename T>
+class enable_shared_from_this {
+  friend class shared_ptr<T>;
+ public:
+  // Precondition: there must be a shared_ptr that owns *this and that was
+  // created, directly or indirectly, from a raw pointer of type T*. (The
+  // latter part of the condition is technical but not quite redundant; it
+  // rules out some complicated uses involving inheritance hierarchies.)
+  shared_ptr<T> shared_from_this() {
+    // Behavior is undefined if the precondition isn't satisfied; we choose
+    // to die with a CHECK failure.
+    GOOGLE_CHECK(!weak_this_.expired()) << "No shared_ptr owns this object";
+    return weak_this_.lock();
+  }
+  shared_ptr<const T> shared_from_this() const {
+    GOOGLE_CHECK(!weak_this_.expired()) << "No shared_ptr owns this object";
+    return weak_this_.lock();
+  }
+
+ protected:
+  enable_shared_from_this() { }
+  enable_shared_from_this(const enable_shared_from_this& other) { }
+  enable_shared_from_this& operator=(const enable_shared_from_this& other) {
+    return *this;
+  }
+  ~enable_shared_from_this() { }
+
+ private:
+  weak_ptr<T> weak_this_;
+};
+
+// This is a helper function called by shared_ptr's constructor from a raw
+// pointer. If T inherits from enable_shared_from_this<T>, it sets up
+// weak_this_ so that shared_from_this works correctly. If T does not inherit
+// from weak_this we get a different overload, defined inline, which does
+// nothing.
+template<typename T>
+void shared_ptr<T>::MaybeSetupWeakThis(enable_shared_from_this<T>* ptr) {
+  if (ptr) {
+    GOOGLE_CHECK(ptr->weak_this_.expired())
+        << "Object already owned by a shared_ptr";
+    ptr->weak_this_ = *this;
+  }
+}
+
+#endif  // UTIL_GTL_USE_STD_SHARED_PTR
+
+}  // internal
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_STUBS_SHARED_PTR_H__
diff --git a/kortex_api/include/google/protobuf/stubs/singleton.h b/kortex_api/include/google/protobuf/stubs/singleton.h
new file mode 100644
index 0000000000000000000000000000000000000000..9301f549b1d6f9eeb038472eb326190d4be0e30d
--- /dev/null
+++ b/kortex_api/include/google/protobuf/stubs/singleton.h
@@ -0,0 +1,68 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2014 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#ifndef GOOGLE_PROTOBUF_STUBS_SINGLETON_H__
+#define GOOGLE_PROTOBUF_STUBS_SINGLETON_H__
+
+#include <google/protobuf/stubs/atomicops.h>
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/once.h>
+
+namespace google {
+namespace protobuf {
+namespace internal {
+template<typename T>
+class Singleton {
+ public:
+  static T* get() {
+    GoogleOnceInit(&once_, &Singleton<T>::Init);
+    return instance_;
+  }
+  static void ShutDown() {
+    delete instance_;
+    instance_ = NULL;
+  }
+ private:
+  static void Init() {
+    instance_ = new T();
+  }
+  static ProtobufOnceType once_;
+  static T* instance_;
+};
+
+template<typename T>
+ProtobufOnceType Singleton<T>::once_;
+
+template<typename T>
+T* Singleton<T>::instance_ = NULL;
+}  // namespace internal
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_STUBS_SINGLETON_H__
diff --git a/kortex_api/include/google/protobuf/stubs/status.h b/kortex_api/include/google/protobuf/stubs/status.h
new file mode 100644
index 0000000000000000000000000000000000000000..614ab9941acab98034576fb5d3c6d63745a0cfda
--- /dev/null
+++ b/kortex_api/include/google/protobuf/stubs/status.h
@@ -0,0 +1,116 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#ifndef GOOGLE_PROTOBUF_STUBS_STATUS_H_
+#define GOOGLE_PROTOBUF_STUBS_STATUS_H_
+
+#include <iosfwd>
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/stringpiece.h>
+
+namespace google {
+namespace protobuf {
+namespace util {
+namespace error {
+// These values must match error codes defined in google/rpc/code.proto.
+enum Code {
+  OK = 0,
+  CANCELLED = 1,
+  UNKNOWN = 2,
+  INVALID_ARGUMENT = 3,
+  DEADLINE_EXCEEDED = 4,
+  NOT_FOUND = 5,
+  ALREADY_EXISTS = 6,
+  PERMISSION_DENIED = 7,
+  UNAUTHENTICATED = 16,
+  RESOURCE_EXHAUSTED = 8,
+  FAILED_PRECONDITION = 9,
+  ABORTED = 10,
+  OUT_OF_RANGE = 11,
+  UNIMPLEMENTED = 12,
+  INTERNAL = 13,
+  UNAVAILABLE = 14,
+  DATA_LOSS = 15,
+};
+}  // namespace error
+
+class LIBPROTOBUF_EXPORT Status {
+ public:
+  // Creates a "successful" status.
+  Status();
+
+  // Create a status in the canonical error space with the specified
+  // code, and error message.  If "code == 0", error_message is
+  // ignored and a Status object identical to Status::OK is
+  // constructed.
+  Status(error::Code error_code, StringPiece error_message);
+  Status(const Status&);
+  Status& operator=(const Status& x);
+  ~Status() {}
+
+  // Some pre-defined Status objects
+  static const Status OK;             // Identical to 0-arg constructor
+  static const Status CANCELLED;
+  static const Status UNKNOWN;
+
+  // Accessor
+  bool ok() const {
+    return error_code_ == error::OK;
+  }
+  int error_code() const {
+    return error_code_;
+  }
+  StringPiece error_message() const {
+    return error_message_;
+  }
+
+  bool operator==(const Status& x) const;
+  bool operator!=(const Status& x) const {
+    return !operator==(x);
+  }
+
+  // Return a combination of the error code name and message.
+  string ToString() const;
+
+ private:
+  error::Code error_code_;
+  string error_message_;
+};
+
+// Prints a human-readable representation of 'x' to 'os'.
+LIBPROTOBUF_EXPORT ostream& operator<<(ostream& os, const Status& x);
+
+#define EXPECT_OK(value) EXPECT_TRUE((value).ok())
+
+}  // namespace util
+}  // namespace protobuf
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_STUBS_STATUS_H_
diff --git a/kortex_api/include/google/protobuf/stubs/stl_util.h b/kortex_api/include/google/protobuf/stubs/stl_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..9e4c82a4c3be35245cbeaf9e97afbdbba8ab4558
--- /dev/null
+++ b/kortex_api/include/google/protobuf/stubs/stl_util.h
@@ -0,0 +1,121 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// from google3/util/gtl/stl_util.h
+
+#ifndef GOOGLE_PROTOBUF_STUBS_STL_UTIL_H__
+#define GOOGLE_PROTOBUF_STUBS_STL_UTIL_H__
+
+#include <google/protobuf/stubs/common.h>
+
+namespace google {
+namespace protobuf {
+
+// STLDeleteContainerPointers()
+//  For a range within a container of pointers, calls delete
+//  (non-array version) on these pointers.
+// NOTE: for these three functions, we could just implement a DeleteObject
+// functor and then call for_each() on the range and functor, but this
+// requires us to pull in all of algorithm.h, which seems expensive.
+// For hash_[multi]set, it is important that this deletes behind the iterator
+// because the hash_set may call the hash function on the iterator when it is
+// advanced, which could result in the hash function trying to deference a
+// stale pointer.
+template <class ForwardIterator>
+void STLDeleteContainerPointers(ForwardIterator begin,
+                                ForwardIterator end) {
+  while (begin != end) {
+    ForwardIterator temp = begin;
+    ++begin;
+    delete *temp;
+  }
+}
+
+// Inside Google, this function implements a horrible, disgusting hack in which
+// we reach into the string's private implementation and resize it without
+// initializing the new bytes.  In some cases doing this can significantly
+// improve performance.  However, since it's totally non-portable it has no
+// place in open source code.  Feel free to fill this function in with your
+// own disgusting hack if you want the perf boost.
+inline void STLStringResizeUninitialized(string* s, size_t new_size) {
+  s->resize(new_size);
+}
+
+// Return a mutable char* pointing to a string's internal buffer,
+// which may not be null-terminated. Writing through this pointer will
+// modify the string.
+//
+// string_as_array(&str)[i] is valid for 0 <= i < str.size() until the
+// next call to a string method that invalidates iterators.
+//
+// As of 2006-04, there is no standard-blessed way of getting a
+// mutable reference to a string's internal buffer. However, issue 530
+// (http://www.open-std.org/JTC1/SC22/WG21/docs/lwg-active.html#530)
+// proposes this as the method. According to Matt Austern, this should
+// already work on all current implementations.
+inline char* string_as_array(string* str) {
+  // DO NOT USE const_cast<char*>(str->data())! See the unittest for why.
+  return str->empty() ? NULL : &*str->begin();
+}
+
+// STLDeleteElements() deletes all the elements in an STL container and clears
+// the container.  This function is suitable for use with a vector, set,
+// hash_set, or any other STL container which defines sensible begin(), end(),
+// and clear() methods.
+//
+// If container is NULL, this function is a no-op.
+//
+// As an alternative to calling STLDeleteElements() directly, consider
+// ElementDeleter (defined below), which ensures that your container's elements
+// are deleted when the ElementDeleter goes out of scope.
+template <class T>
+void STLDeleteElements(T *container) {
+  if (!container) return;
+  STLDeleteContainerPointers(container->begin(), container->end());
+  container->clear();
+}
+
+// Given an STL container consisting of (key, value) pairs, STLDeleteValues
+// deletes all the "value" components and clears the container.  Does nothing
+// in the case it's given a NULL pointer.
+
+template <class T>
+void STLDeleteValues(T *v) {
+  if (!v) return;
+  for (typename T::iterator i = v->begin(); i != v->end(); ++i) {
+    delete i->second;
+  }
+  v->clear();
+}
+
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_STUBS_STL_UTIL_H__
diff --git a/kortex_api/include/google/protobuf/stubs/stringpiece.h b/kortex_api/include/google/protobuf/stubs/stringpiece.h
new file mode 100644
index 0000000000000000000000000000000000000000..563ff75dcf446f69864313643d665a88ac1fc8a9
--- /dev/null
+++ b/kortex_api/include/google/protobuf/stubs/stringpiece.h
@@ -0,0 +1,487 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// A StringPiece points to part or all of a string, Cord, double-quoted string
+// literal, or other string-like object.  A StringPiece does *not* own the
+// string to which it points.  A StringPiece is not null-terminated.
+//
+// You can use StringPiece as a function or method parameter.  A StringPiece
+// parameter can receive a double-quoted string literal argument, a "const
+// char*" argument, a string argument, or a StringPiece argument with no data
+// copying.  Systematic use of StringPiece for arguments reduces data
+// copies and strlen() calls.
+//
+// Prefer passing StringPieces by value:
+//   void MyFunction(StringPiece arg);
+// If circumstances require, you may also pass by const reference:
+//   void MyFunction(const StringPiece& arg);  // not preferred
+// Both of these have the same lifetime semantics.  Passing by value
+// generates slightly smaller code.  For more discussion, see the thread
+// go/stringpiecebyvalue on c-users.
+//
+// StringPiece is also suitable for local variables if you know that
+// the lifetime of the underlying object is longer than the lifetime
+// of your StringPiece variable.
+//
+// Beware of binding a StringPiece to a temporary:
+//   StringPiece sp = obj.MethodReturningString();  // BAD: lifetime problem
+//
+// This code is okay:
+//   string str = obj.MethodReturningString();  // str owns its contents
+//   StringPiece sp(str);  // GOOD, because str outlives sp
+//
+// StringPiece is sometimes a poor choice for a return value and usually a poor
+// choice for a data member.  If you do use a StringPiece this way, it is your
+// responsibility to ensure that the object pointed to by the StringPiece
+// outlives the StringPiece.
+//
+// A StringPiece may represent just part of a string; thus the name "Piece".
+// For example, when splitting a string, vector<StringPiece> is a natural data
+// type for the output.  For another example, a Cord is a non-contiguous,
+// potentially very long string-like object.  The Cord class has an interface
+// that iteratively provides StringPiece objects that point to the
+// successive pieces of a Cord object.
+//
+// A StringPiece is not null-terminated.  If you write code that scans a
+// StringPiece, you must check its length before reading any characters.
+// Common idioms that work on null-terminated strings do not work on
+// StringPiece objects.
+//
+// There are several ways to create a null StringPiece:
+//   StringPiece()
+//   StringPiece(NULL)
+//   StringPiece(NULL, 0)
+// For all of the above, sp.data() == NULL, sp.length() == 0,
+// and sp.empty() == true.  Also, if you create a StringPiece with
+// a non-NULL pointer then sp.data() != NULL.  Once created,
+// sp.data() will stay either NULL or not-NULL, except if you call
+// sp.clear() or sp.set().
+//
+// Thus, you can use StringPiece(NULL) to signal an out-of-band value
+// that is different from other StringPiece values.  This is similar
+// to the way that const char* p1 = NULL; is different from
+// const char* p2 = "";.
+//
+// There are many ways to create an empty StringPiece:
+//   StringPiece()
+//   StringPiece(NULL)
+//   StringPiece(NULL, 0)
+//   StringPiece("")
+//   StringPiece("", 0)
+//   StringPiece("abcdef", 0)
+//   StringPiece("abcdef"+6, 0)
+// For all of the above, sp.length() will be 0 and sp.empty() will be true.
+// For some empty StringPiece values, sp.data() will be NULL.
+// For some empty StringPiece values, sp.data() will not be NULL.
+//
+// Be careful not to confuse: null StringPiece and empty StringPiece.
+// The set of empty StringPieces properly includes the set of null StringPieces.
+// That is, every null StringPiece is an empty StringPiece,
+// but some non-null StringPieces are empty Stringpieces too.
+//
+// All empty StringPiece values compare equal to each other.
+// Even a null StringPieces compares equal to a non-null empty StringPiece:
+//  StringPiece() == StringPiece("", 0)
+//  StringPiece(NULL) == StringPiece("abc", 0)
+//  StringPiece(NULL, 0) == StringPiece("abcdef"+6, 0)
+//
+// Look carefully at this example:
+//   StringPiece("") == NULL
+// True or false?  TRUE, because StringPiece::operator== converts
+// the right-hand side from NULL to StringPiece(NULL),
+// and then compares two zero-length spans of characters.
+// However, we are working to make this example produce a compile error.
+//
+// Suppose you want to write:
+//   bool TestWhat?(StringPiece sp) { return sp == NULL; }  // BAD
+// Do not do that.  Write one of these instead:
+//   bool TestNull(StringPiece sp) { return sp.data() == NULL; }
+//   bool TestEmpty(StringPiece sp) { return sp.empty(); }
+// The intent of TestWhat? is unclear.  Did you mean TestNull or TestEmpty?
+// Right now, TestWhat? behaves likes TestEmpty.
+// We are working to make TestWhat? produce a compile error.
+// TestNull is good to test for an out-of-band signal.
+// TestEmpty is good to test for an empty StringPiece.
+//
+// Caveats (again):
+// (1) The lifetime of the pointed-to string (or piece of a string)
+//     must be longer than the lifetime of the StringPiece.
+// (2) There may or may not be a '\0' character after the end of
+//     StringPiece data.
+// (3) A null StringPiece is empty.
+//     An empty StringPiece may or may not be a null StringPiece.
+
+#ifndef GOOGLE_PROTOBUF_STUBS_STRINGPIECE_H_
+#define GOOGLE_PROTOBUF_STUBS_STRINGPIECE_H_
+
+#include <assert.h>
+#include <stddef.h>
+#include <string.h>
+#include <iosfwd>
+#include <limits>
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/hash.h>
+
+namespace google {
+namespace protobuf {
+// StringPiece has *two* size types.
+// StringPiece::size_type
+//   is unsigned
+//   is 32 bits in LP32, 64 bits in LP64, 64 bits in LLP64
+//   no future changes intended
+// stringpiece_ssize_type
+//   is signed
+//   is 32 bits in LP32, 64 bits in LP64, 64 bits in LLP64
+//   future changes intended: http://go/64BitStringPiece
+//
+typedef string::difference_type stringpiece_ssize_type;
+
+// STRINGPIECE_CHECK_SIZE protects us from 32-bit overflows.
+// TODO(mec): delete this after stringpiece_ssize_type goes 64 bit.
+#if !defined(NDEBUG)
+#define STRINGPIECE_CHECK_SIZE 1
+#elif defined(_FORTIFY_SOURCE) && _FORTIFY_SOURCE > 0
+#define STRINGPIECE_CHECK_SIZE 1
+#else
+#define STRINGPIECE_CHECK_SIZE 0
+#endif
+
+class LIBPROTOBUF_EXPORT StringPiece {
+ private:
+  const char* ptr_;
+  stringpiece_ssize_type length_;
+
+  // Prevent overflow in debug mode or fortified mode.
+  // sizeof(stringpiece_ssize_type) may be smaller than sizeof(size_t).
+  static stringpiece_ssize_type CheckedSsizeTFromSizeT(size_t size) {
+#if STRINGPIECE_CHECK_SIZE > 0
+#ifdef max
+#undef max
+#endif
+    if (size > static_cast<size_t>(
+        std::numeric_limits<stringpiece_ssize_type>::max())) {
+      // Some people grep for this message in logs
+      // so take care if you ever change it.
+      LogFatalSizeTooBig(size, "size_t to int conversion");
+    }
+#endif
+    return static_cast<stringpiece_ssize_type>(size);
+  }
+
+  // Out-of-line error path.
+  static void LogFatalSizeTooBig(size_t size, const char* details);
+
+ public:
+  // We provide non-explicit singleton constructors so users can pass
+  // in a "const char*" or a "string" wherever a "StringPiece" is
+  // expected.
+  //
+  // Style guide exception granted:
+  // http://goto/style-guide-exception-20978288
+  StringPiece() : ptr_(NULL), length_(0) {}
+
+  StringPiece(const char* str)  // NOLINT(runtime/explicit)
+      : ptr_(str), length_(0) {
+    if (str != NULL) {
+      length_ = CheckedSsizeTFromSizeT(strlen(str));
+    }
+  }
+
+  template <class Allocator>
+  StringPiece(  // NOLINT(runtime/explicit)
+      const std::basic_string<char, std::char_traits<char>, Allocator>& str)
+      : ptr_(str.data()), length_(0) {
+    length_ = CheckedSsizeTFromSizeT(str.size());
+  }
+
+  StringPiece(const char* offset, stringpiece_ssize_type len)
+      : ptr_(offset), length_(len) {
+    assert(len >= 0);
+  }
+
+  // Substring of another StringPiece.
+  // pos must be non-negative and <= x.length().
+  StringPiece(StringPiece x, stringpiece_ssize_type pos);
+  // Substring of another StringPiece.
+  // pos must be non-negative and <= x.length().
+  // len must be non-negative and will be pinned to at most x.length() - pos.
+  StringPiece(StringPiece x,
+              stringpiece_ssize_type pos,
+              stringpiece_ssize_type len);
+
+  // data() may return a pointer to a buffer with embedded NULs, and the
+  // returned buffer may or may not be null terminated.  Therefore it is
+  // typically a mistake to pass data() to a routine that expects a NUL
+  // terminated string.
+  const char* data() const { return ptr_; }
+  stringpiece_ssize_type size() const { return length_; }
+  stringpiece_ssize_type length() const { return length_; }
+  bool empty() const { return length_ == 0; }
+
+  void clear() {
+    ptr_ = NULL;
+    length_ = 0;
+  }
+
+  void set(const char* data, stringpiece_ssize_type len) {
+    assert(len >= 0);
+    ptr_ = data;
+    length_ = len;
+  }
+
+  void set(const char* str) {
+    ptr_ = str;
+    if (str != NULL)
+      length_ = CheckedSsizeTFromSizeT(strlen(str));
+    else
+      length_ = 0;
+  }
+
+  void set(const void* data, stringpiece_ssize_type len) {
+    ptr_ = reinterpret_cast<const char*>(data);
+    length_ = len;
+  }
+
+  char operator[](stringpiece_ssize_type i) const {
+    assert(0 <= i);
+    assert(i < length_);
+    return ptr_[i];
+  }
+
+  void remove_prefix(stringpiece_ssize_type n) {
+    assert(length_ >= n);
+    ptr_ += n;
+    length_ -= n;
+  }
+
+  void remove_suffix(stringpiece_ssize_type n) {
+    assert(length_ >= n);
+    length_ -= n;
+  }
+
+  // returns {-1, 0, 1}
+  int compare(StringPiece x) const {
+    const stringpiece_ssize_type min_size =
+        length_ < x.length_ ? length_ : x.length_;
+    int r = memcmp(ptr_, x.ptr_, static_cast<size_t>(min_size));
+    if (r < 0) return -1;
+    if (r > 0) return 1;
+    if (length_ < x.length_) return -1;
+    if (length_ > x.length_) return 1;
+    return 0;
+  }
+
+  string as_string() const {
+    return ToString();
+  }
+  // We also define ToString() here, since many other string-like
+  // interfaces name the routine that converts to a C++ string
+  // "ToString", and it's confusing to have the method that does that
+  // for a StringPiece be called "as_string()".  We also leave the
+  // "as_string()" method defined here for existing code.
+  string ToString() const {
+    if (ptr_ == NULL) return string();
+    return string(data(), static_cast<size_type>(size()));
+  }
+
+  operator string() const {
+    return ToString();
+  }
+
+  void CopyToString(string* target) const;
+  void AppendToString(string* target) const;
+
+  bool starts_with(StringPiece x) const {
+    return (length_ >= x.length_) &&
+           (memcmp(ptr_, x.ptr_, static_cast<size_t>(x.length_)) == 0);
+  }
+
+  bool ends_with(StringPiece x) const {
+    return ((length_ >= x.length_) &&
+            (memcmp(ptr_ + (length_-x.length_), x.ptr_,
+                 static_cast<size_t>(x.length_)) == 0));
+  }
+
+  // Checks whether StringPiece starts with x and if so advances the beginning
+  // of it to past the match.  It's basically a shortcut for starts_with
+  // followed by remove_prefix.
+  bool Consume(StringPiece x);
+  // Like above but for the end of the string.
+  bool ConsumeFromEnd(StringPiece x);
+
+  // standard STL container boilerplate
+  typedef char value_type;
+  typedef const char* pointer;
+  typedef const char& reference;
+  typedef const char& const_reference;
+  typedef size_t size_type;
+  typedef ptrdiff_t difference_type;
+  static const size_type npos;
+  typedef const char* const_iterator;
+  typedef const char* iterator;
+  typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+  typedef std::reverse_iterator<iterator> reverse_iterator;
+  iterator begin() const { return ptr_; }
+  iterator end() const { return ptr_ + length_; }
+  const_reverse_iterator rbegin() const {
+    return const_reverse_iterator(ptr_ + length_);
+  }
+  const_reverse_iterator rend() const {
+    return const_reverse_iterator(ptr_);
+  }
+  stringpiece_ssize_type max_size() const { return length_; }
+  stringpiece_ssize_type capacity() const { return length_; }
+
+  // cpplint.py emits a false positive [build/include_what_you_use]
+  stringpiece_ssize_type copy(char* buf, size_type n, size_type pos = 0) const;  // NOLINT
+
+  bool contains(StringPiece s) const;
+
+  stringpiece_ssize_type find(StringPiece s, size_type pos = 0) const;
+  stringpiece_ssize_type find(char c, size_type pos = 0) const;
+  stringpiece_ssize_type rfind(StringPiece s, size_type pos = npos) const;
+  stringpiece_ssize_type rfind(char c, size_type pos = npos) const;
+
+  stringpiece_ssize_type find_first_of(StringPiece s, size_type pos = 0) const;
+  stringpiece_ssize_type find_first_of(char c, size_type pos = 0) const {
+    return find(c, pos);
+  }
+  stringpiece_ssize_type find_first_not_of(StringPiece s,
+                                           size_type pos = 0) const;
+  stringpiece_ssize_type find_first_not_of(char c, size_type pos = 0) const;
+  stringpiece_ssize_type find_last_of(StringPiece s,
+                                      size_type pos = npos) const;
+  stringpiece_ssize_type find_last_of(char c, size_type pos = npos) const {
+    return rfind(c, pos);
+  }
+  stringpiece_ssize_type find_last_not_of(StringPiece s,
+                                          size_type pos = npos) const;
+  stringpiece_ssize_type find_last_not_of(char c, size_type pos = npos) const;
+
+  StringPiece substr(size_type pos, size_type n = npos) const;
+};
+
+// This large function is defined inline so that in a fairly common case where
+// one of the arguments is a literal, the compiler can elide a lot of the
+// following comparisons.
+inline bool operator==(StringPiece x, StringPiece y) {
+  stringpiece_ssize_type len = x.size();
+  if (len != y.size()) {
+    return false;
+  }
+
+  return x.data() == y.data() || len <= 0 ||
+      memcmp(x.data(), y.data(), static_cast<size_t>(len)) == 0;
+}
+
+inline bool operator!=(StringPiece x, StringPiece y) {
+  return !(x == y);
+}
+
+inline bool operator<(StringPiece x, StringPiece y) {
+  const stringpiece_ssize_type min_size =
+      x.size() < y.size() ? x.size() : y.size();
+  const int r = memcmp(x.data(), y.data(), static_cast<size_t>(min_size));
+  return (r < 0) || (r == 0 && x.size() < y.size());
+}
+
+inline bool operator>(StringPiece x, StringPiece y) {
+  return y < x;
+}
+
+inline bool operator<=(StringPiece x, StringPiece y) {
+  return !(x > y);
+}
+
+inline bool operator>=(StringPiece x, StringPiece y) {
+  return !(x < y);
+}
+
+// allow StringPiece to be logged
+extern std::ostream& operator<<(std::ostream& o, StringPiece piece);
+
+namespace internal {
+// StringPiece is not a POD and can not be used in an union (pre C++11). We
+// need a POD version of it.
+struct StringPiecePod {
+  // Create from a StringPiece.
+  static StringPiecePod CreateFromStringPiece(StringPiece str) {
+    StringPiecePod pod;
+    pod.data_ = str.data();
+    pod.size_ = str.size();
+    return pod;
+  }
+
+  // Cast to StringPiece.
+  operator StringPiece() const { return StringPiece(data_, size_); }
+
+  bool operator==(const char* value) const {
+    return StringPiece(data_, size_) == StringPiece(value);
+  }
+
+  char operator[](stringpiece_ssize_type i) const {
+    assert(0 <= i);
+    assert(i < size_);
+    return data_[i];
+  }
+
+  const char* data() const { return data_; }
+
+  stringpiece_ssize_type size() const {
+    return size_;
+  }
+
+  std::string ToString() const {
+    return std::string(data_, static_cast<size_t>(size_));
+  }
+ private:
+  const char* data_;
+  stringpiece_ssize_type size_;
+};
+
+}  // namespace internal
+}  // namespace protobuf
+}  // namespace google
+
+GOOGLE_PROTOBUF_HASH_NAMESPACE_DECLARATION_START
+template<> struct hash<StringPiece> {
+  size_t operator()(const StringPiece& s) const {
+    size_t result = 0;
+    for (const char *str = s.data(), *end = str + s.size(); str < end; str++) {  
+      result = 5 * result + static_cast<size_t>(*str);
+    }
+    return result;
+  }
+};
+GOOGLE_PROTOBUF_HASH_NAMESPACE_DECLARATION_END
+
+#endif  // STRINGS_STRINGPIECE_H_
diff --git a/kortex_api/include/google/protobuf/stubs/template_util.h b/kortex_api/include/google/protobuf/stubs/template_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..feef904beaa58f3ec06c553a25e318ea35bf0d0b
--- /dev/null
+++ b/kortex_api/include/google/protobuf/stubs/template_util.h
@@ -0,0 +1,138 @@
+// Copyright 2005 Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// ----
+// Author: lar@google.com (Laramie Leavitt)
+//
+// Template metaprogramming utility functions.
+//
+// This code is compiled directly on many platforms, including client
+// platforms like Windows, Mac, and embedded systems.  Before making
+// any changes here, make sure that you're not breaking any platforms.
+//
+//
+// The names chosen here reflect those used in tr1 and the boost::mpl
+// library, there are similar operations used in the Loki library as
+// well.  I prefer the boost names for 2 reasons:
+// 1.  I think that portions of the Boost libraries are more likely to
+// be included in the c++ standard.
+// 2.  It is not impossible that some of the boost libraries will be
+// included in our own build in the future.
+// Both of these outcomes means that we may be able to directly replace
+// some of these with boost equivalents.
+//
+#ifndef GOOGLE_PROTOBUF_TEMPLATE_UTIL_H_
+#define GOOGLE_PROTOBUF_TEMPLATE_UTIL_H_
+
+namespace google {
+namespace protobuf {
+namespace internal {
+
+// Types small_ and big_ are guaranteed such that sizeof(small_) <
+// sizeof(big_)
+typedef char small_;
+
+struct big_ {
+  char dummy[2];
+};
+
+// Identity metafunction.
+template <class T>
+struct identity_ {
+  typedef T type;
+};
+
+// integral_constant, defined in tr1, is a wrapper for an integer
+// value. We don't really need this generality; we could get away
+// with hardcoding the integer type to bool. We use the fully
+// general integer_constant for compatibility with tr1.
+
+template<class T, T v>
+struct integral_constant {
+  static const T value = v;
+  typedef T value_type;
+  typedef integral_constant<T, v> type;
+};
+
+template <class T, T v> const T integral_constant<T, v>::value;
+
+
+// Abbreviations: true_type and false_type are structs that represent boolean
+// true and false values. Also define the boost::mpl versions of those names,
+// true_ and false_.
+typedef integral_constant<bool, true>  true_type;
+typedef integral_constant<bool, false> false_type;
+typedef true_type  true_;
+typedef false_type false_;
+
+// if_ is a templatized conditional statement.
+// if_<cond, A, B> is a compile time evaluation of cond.
+// if_<>::type contains A if cond is true, B otherwise.
+template<bool cond, typename A, typename B>
+struct if_{
+  typedef A type;
+};
+
+template<typename A, typename B>
+struct if_<false, A, B> {
+  typedef B type;
+};
+
+
+// type_equals_ is a template type comparator, similar to Loki IsSameType.
+// type_equals_<A, B>::value is true iff "A" is the same type as "B".
+//
+// New code should prefer base::is_same, defined in base/type_traits.h.
+// It is functionally identical, but is_same is the standard spelling.
+template<typename A, typename B>
+struct type_equals_ : public false_ {
+};
+
+template<typename A>
+struct type_equals_<A, A> : public true_ {
+};
+
+// and_ is a template && operator.
+// and_<A, B>::value evaluates "A::value && B::value".
+template<typename A, typename B>
+struct and_ : public integral_constant<bool, (A::value && B::value)> {
+};
+
+// or_ is a template || operator.
+// or_<A, B>::value evaluates "A::value || B::value".
+template<typename A, typename B>
+struct or_ : public integral_constant<bool, (A::value || B::value)> {
+};
+
+
+}  // namespace internal
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_TEMPLATE_UTIL_H_
diff --git a/kortex_api/include/google/protobuf/stubs/type_traits.h b/kortex_api/include/google/protobuf/stubs/type_traits.h
new file mode 100644
index 0000000000000000000000000000000000000000..3ab5ea7d4eab50da566e855c729ae3d9b447c6ac
--- /dev/null
+++ b/kortex_api/include/google/protobuf/stubs/type_traits.h
@@ -0,0 +1,364 @@
+// Copyright (c) 2006, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// ----
+// Author: Matt Austern
+//
+// This code is compiled directly on many platforms, including client
+// platforms like Windows, Mac, and embedded systems.  Before making
+// any changes here, make sure that you're not breaking any platforms.
+//
+// Define a small subset of tr1 type traits. The traits we define are:
+//   enable_if
+//   is_integral
+//   is_floating_point
+//   is_pointer
+//   is_enum
+//   is_reference
+//   is_pod
+//   has_trivial_constructor
+//   has_trivial_copy
+//   has_trivial_assign
+//   has_trivial_destructor
+//   remove_const
+//   remove_volatile
+//   remove_cv
+//   remove_reference
+//   add_reference
+//   remove_pointer
+//   is_same
+//   is_convertible
+// We can add more type traits as required.
+
+#ifndef GOOGLE_PROTOBUF_TYPE_TRAITS_H_
+#define GOOGLE_PROTOBUF_TYPE_TRAITS_H_
+
+#include <cstddef>                  // for NULL
+#include <utility>                  // For pair
+
+#include <google/protobuf/stubs/template_util.h>  // For true_type and false_type
+
+namespace google {
+namespace protobuf {
+namespace internal {
+
+template<typename B, typename D>
+struct is_base_of {
+  typedef char (&yes)[1];
+  typedef char (&no)[2];
+
+  // BEGIN GOOGLE LOCAL MODIFICATION -- check is a #define on Mac.
+  #undef check
+  // END GOOGLE LOCAL MODIFICATION
+
+  static yes check(const B*);
+  static no check(const void*);
+
+  enum {
+    value = sizeof(check(static_cast<const D*>(NULL))) == sizeof(yes),
+  };
+};
+
+template <bool cond, class T = void> struct enable_if;
+template <class T> struct is_integral;
+template <class T> struct is_floating_point;
+template <class T> struct is_pointer;
+// MSVC can't compile this correctly, and neither can gcc 3.3.5 (at least)
+#if !defined(_MSC_VER) && !(defined(__GNUC__) && __GNUC__ <= 3)
+// is_enum uses is_convertible, which is not available on MSVC.
+template <class T> struct is_enum;
+#endif
+template <class T> struct is_reference;
+template <class T> struct is_pod;
+template <class T> struct has_trivial_constructor;
+template <class T> struct has_trivial_copy;
+template <class T> struct has_trivial_assign;
+template <class T> struct has_trivial_destructor;
+template <class T> struct remove_const;
+template <class T> struct remove_volatile;
+template <class T> struct remove_cv;
+template <class T> struct remove_reference;
+template <class T> struct add_reference;
+template <class T> struct remove_pointer;
+template <class T, class U> struct is_same;
+#if !(defined(__GNUC__) && __GNUC__ <= 3)
+template <class From, class To> struct is_convertible;
+#endif
+
+// enable_if, equivalent semantics to c++11 std::enable_if, specifically:
+//   "If B is true, the member typedef type shall equal T; otherwise, there
+//    shall be no member typedef type."
+// Specified by 20.9.7.6 [Other transformations]
+
+template<bool cond, class T> struct enable_if { typedef T type; };
+template<class T> struct enable_if<false, T> {};
+// is_integral is false except for the built-in integer types. A
+// cv-qualified type is integral if and only if the underlying type is.
+template <class T> struct is_integral : false_type { };
+template<> struct is_integral<bool> : true_type { };
+template<> struct is_integral<char> : true_type { };
+template<> struct is_integral<unsigned char> : true_type { };
+template<> struct is_integral<signed char> : true_type { };
+#if defined(_MSC_VER)
+// wchar_t is not by default a distinct type from unsigned short in
+// Microsoft C.
+// See http://msdn2.microsoft.com/en-us/library/dh8che7s(VS.80).aspx
+template<> struct is_integral<__wchar_t> : true_type { };
+#else
+template<> struct is_integral<wchar_t> : true_type { };
+#endif
+template<> struct is_integral<short> : true_type { };
+template<> struct is_integral<unsigned short> : true_type { };
+template<> struct is_integral<int> : true_type { };
+template<> struct is_integral<unsigned int> : true_type { };
+template<> struct is_integral<long> : true_type { };
+template<> struct is_integral<unsigned long> : true_type { };
+#if defined(HAVE_LONG_LONG) || defined(_MSC_VER)
+template<> struct is_integral<long long> : true_type { };
+template<> struct is_integral<unsigned long long> : true_type { };
+#endif
+template <class T> struct is_integral<const T> : is_integral<T> { };
+template <class T> struct is_integral<volatile T> : is_integral<T> { };
+template <class T> struct is_integral<const volatile T> : is_integral<T> { };
+
+// is_floating_point is false except for the built-in floating-point types.
+// A cv-qualified type is integral if and only if the underlying type is.
+template <class T> struct is_floating_point : false_type { };
+template<> struct is_floating_point<float> : true_type { };
+template<> struct is_floating_point<double> : true_type { };
+template<> struct is_floating_point<long double> : true_type { };
+template <class T> struct is_floating_point<const T>
+    : is_floating_point<T> { };
+template <class T> struct is_floating_point<volatile T>
+    : is_floating_point<T> { };
+template <class T> struct is_floating_point<const volatile T>
+    : is_floating_point<T> { };
+
+// is_pointer is false except for pointer types. A cv-qualified type (e.g.
+// "int* const", as opposed to "int const*") is cv-qualified if and only if
+// the underlying type is.
+template <class T> struct is_pointer : false_type { };
+template <class T> struct is_pointer<T*> : true_type { };
+template <class T> struct is_pointer<const T> : is_pointer<T> { };
+template <class T> struct is_pointer<volatile T> : is_pointer<T> { };
+template <class T> struct is_pointer<const volatile T> : is_pointer<T> { };
+
+#if !defined(_MSC_VER) && !(defined(__GNUC__) && __GNUC__ <= 3)
+
+namespace type_traits_internal {
+
+template <class T> struct is_class_or_union {
+  template <class U> static small_ tester(void (U::*)());
+  template <class U> static big_ tester(...);
+  static const bool value = sizeof(tester<T>(0)) == sizeof(small_);
+};
+
+// is_convertible chokes if the first argument is an array. That's why
+// we use add_reference here.
+template <bool NotUnum, class T> struct is_enum_impl
+    : is_convertible<typename add_reference<T>::type, int> { };
+
+template <class T> struct is_enum_impl<true, T> : false_type { };
+
+}  // namespace type_traits_internal
+
+// Specified by TR1 [4.5.1] primary type categories.
+
+// Implementation note:
+//
+// Each type is either void, integral, floating point, array, pointer,
+// reference, member object pointer, member function pointer, enum,
+// union or class. Out of these, only integral, floating point, reference,
+// class and enum types are potentially convertible to int. Therefore,
+// if a type is not a reference, integral, floating point or class and
+// is convertible to int, it's a enum. Adding cv-qualification to a type
+// does not change whether it's an enum.
+//
+// Is-convertible-to-int check is done only if all other checks pass,
+// because it can't be used with some types (e.g. void or classes with
+// inaccessible conversion operators).
+template <class T> struct is_enum
+    : type_traits_internal::is_enum_impl<
+          is_same<T, void>::value ||
+              is_integral<T>::value ||
+              is_floating_point<T>::value ||
+              is_reference<T>::value ||
+              type_traits_internal::is_class_or_union<T>::value,
+          T> { };
+
+template <class T> struct is_enum<const T> : is_enum<T> { };
+template <class T> struct is_enum<volatile T> : is_enum<T> { };
+template <class T> struct is_enum<const volatile T> : is_enum<T> { };
+
+#endif
+
+// is_reference is false except for reference types.
+template<typename T> struct is_reference : false_type {};
+template<typename T> struct is_reference<T&> : true_type {};
+
+
+// We can't get is_pod right without compiler help, so fail conservatively.
+// We will assume it's false except for arithmetic types, enumerations,
+// pointers and cv-qualified versions thereof. Note that std::pair<T,U>
+// is not a POD even if T and U are PODs.
+template <class T> struct is_pod
+ : integral_constant<bool, (is_integral<T>::value ||
+                            is_floating_point<T>::value ||
+#if !defined(_MSC_VER) && !(defined(__GNUC__) && __GNUC__ <= 3)
+                            // is_enum is not available on MSVC.
+                            is_enum<T>::value ||
+#endif
+                            is_pointer<T>::value)> { };
+template <class T> struct is_pod<const T> : is_pod<T> { };
+template <class T> struct is_pod<volatile T> : is_pod<T> { };
+template <class T> struct is_pod<const volatile T> : is_pod<T> { };
+
+
+// We can't get has_trivial_constructor right without compiler help, so
+// fail conservatively. We will assume it's false except for: (1) types
+// for which is_pod is true. (2) std::pair of types with trivial
+// constructors. (3) array of a type with a trivial constructor.
+// (4) const versions thereof.
+template <class T> struct has_trivial_constructor : is_pod<T> { };
+template <class T, class U> struct has_trivial_constructor<std::pair<T, U> >
+  : integral_constant<bool,
+                      (has_trivial_constructor<T>::value &&
+                       has_trivial_constructor<U>::value)> { };
+template <class A, int N> struct has_trivial_constructor<A[N]>
+  : has_trivial_constructor<A> { };
+template <class T> struct has_trivial_constructor<const T>
+  : has_trivial_constructor<T> { };
+
+// We can't get has_trivial_copy right without compiler help, so fail
+// conservatively. We will assume it's false except for: (1) types
+// for which is_pod is true. (2) std::pair of types with trivial copy
+// constructors. (3) array of a type with a trivial copy constructor.
+// (4) const versions thereof.
+template <class T> struct has_trivial_copy : is_pod<T> { };
+template <class T, class U> struct has_trivial_copy<std::pair<T, U> >
+  : integral_constant<bool,
+                      (has_trivial_copy<T>::value &&
+                       has_trivial_copy<U>::value)> { };
+template <class A, int N> struct has_trivial_copy<A[N]>
+  : has_trivial_copy<A> { };
+template <class T> struct has_trivial_copy<const T> : has_trivial_copy<T> { };
+
+// We can't get has_trivial_assign right without compiler help, so fail
+// conservatively. We will assume it's false except for: (1) types
+// for which is_pod is true. (2) std::pair of types with trivial copy
+// constructors. (3) array of a type with a trivial assign constructor.
+template <class T> struct has_trivial_assign : is_pod<T> { };
+template <class T, class U> struct has_trivial_assign<std::pair<T, U> >
+  : integral_constant<bool,
+                      (has_trivial_assign<T>::value &&
+                       has_trivial_assign<U>::value)> { };
+template <class A, int N> struct has_trivial_assign<A[N]>
+  : has_trivial_assign<A> { };
+
+// We can't get has_trivial_destructor right without compiler help, so
+// fail conservatively. We will assume it's false except for: (1) types
+// for which is_pod is true. (2) std::pair of types with trivial
+// destructors. (3) array of a type with a trivial destructor.
+// (4) const versions thereof.
+template <class T> struct has_trivial_destructor : is_pod<T> { };
+template <class T, class U> struct has_trivial_destructor<std::pair<T, U> >
+  : integral_constant<bool,
+                      (has_trivial_destructor<T>::value &&
+                       has_trivial_destructor<U>::value)> { };
+template <class A, int N> struct has_trivial_destructor<A[N]>
+  : has_trivial_destructor<A> { };
+template <class T> struct has_trivial_destructor<const T>
+  : has_trivial_destructor<T> { };
+
+// Specified by TR1 [4.7.1]
+template<typename T> struct remove_const { typedef T type; };
+template<typename T> struct remove_const<T const> { typedef T type; };
+template<typename T> struct remove_volatile { typedef T type; };
+template<typename T> struct remove_volatile<T volatile> { typedef T type; };
+template<typename T> struct remove_cv {
+  typedef typename remove_const<typename remove_volatile<T>::type>::type type;
+};
+
+
+// Specified by TR1 [4.7.2] Reference modifications.
+template<typename T> struct remove_reference { typedef T type; };
+template<typename T> struct remove_reference<T&> { typedef T type; };
+
+template <typename T> struct add_reference { typedef T& type; };
+template <typename T> struct add_reference<T&> { typedef T& type; };
+
+// Specified by TR1 [4.7.4] Pointer modifications.
+template<typename T> struct remove_pointer { typedef T type; };
+template<typename T> struct remove_pointer<T*> { typedef T type; };
+template<typename T> struct remove_pointer<T* const> { typedef T type; };
+template<typename T> struct remove_pointer<T* volatile> { typedef T type; };
+template<typename T> struct remove_pointer<T* const volatile> {
+  typedef T type; };
+
+// Specified by TR1 [4.6] Relationships between types
+template<typename T, typename U> struct is_same : public false_type { };
+template<typename T> struct is_same<T, T> : public true_type { };
+
+// Specified by TR1 [4.6] Relationships between types
+#if !(defined(__GNUC__) && __GNUC__ <= 3)
+namespace type_traits_internal {
+
+// This class is an implementation detail for is_convertible, and you
+// don't need to know how it works to use is_convertible. For those
+// who care: we declare two different functions, one whose argument is
+// of type To and one with a variadic argument list. We give them
+// return types of different size, so we can use sizeof to trick the
+// compiler into telling us which function it would have chosen if we
+// had called it with an argument of type From.  See Alexandrescu's
+// _Modern C++ Design_ for more details on this sort of trick.
+
+template <typename From, typename To>
+struct ConvertHelper {
+  static small_ Test(To);
+  static big_ Test(...);
+  static From Create();
+  enum {
+    value = sizeof(Test(Create())) == sizeof(small_)
+  };
+};
+}  // namespace type_traits_internal
+
+// Inherits from true_type if From is convertible to To, false_type otherwise.
+template <typename From, typename To>
+struct is_convertible
+    : integral_constant<bool,
+                        type_traits_internal::ConvertHelper<From, To>::value> {
+};
+#endif
+
+}  // namespace internal
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_TYPE_TRAITS_H_
diff --git a/kortex_api/include/google/protobuf/text_format.h b/kortex_api/include/google/protobuf/text_format.h
new file mode 100644
index 0000000000000000000000000000000000000000..a2670d6bb405027799a95a3f7a9cfe958d5c5f20
--- /dev/null
+++ b/kortex_api/include/google/protobuf/text_format.h
@@ -0,0 +1,568 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: jschorr@google.com (Joseph Schorr)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// Utilities for printing and parsing protocol messages in a human-readable,
+// text-based format.
+
+#ifndef GOOGLE_PROTOBUF_TEXT_FORMAT_H__
+#define GOOGLE_PROTOBUF_TEXT_FORMAT_H__
+
+#include <map>
+#include <memory>
+#ifndef _SHARED_PTR_H
+#include <google/protobuf/stubs/shared_ptr.h>
+#endif
+#include <string>
+#include <vector>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/message_lite.h>
+
+namespace google {
+namespace protobuf {
+
+namespace io {
+  class ErrorCollector;      // tokenizer.h
+}
+
+// This class implements protocol buffer text format.  Printing and parsing
+// protocol messages in text format is useful for debugging and human editing
+// of messages.
+//
+// This class is really a namespace that contains only static methods.
+class LIBPROTOBUF_EXPORT TextFormat {
+ public:
+  // Outputs a textual representation of the given message to the given
+  // output stream. Returns false if printing fails.
+  static bool Print(const Message& message, io::ZeroCopyOutputStream* output);
+
+  // Print the fields in an UnknownFieldSet.  They are printed by tag number
+  // only.  Embedded messages are heuristically identified by attempting to
+  // parse them. Returns false if printing fails.
+  static bool PrintUnknownFields(const UnknownFieldSet& unknown_fields,
+                                 io::ZeroCopyOutputStream* output);
+
+  // Like Print(), but outputs directly to a string.
+  // Note: output will be cleared prior to printing, and will be left empty
+  // even if printing fails. Returns false if printing fails.
+  static bool PrintToString(const Message& message, string* output);
+
+  // Like PrintUnknownFields(), but outputs directly to a string. Returns false
+  // if printing fails.
+  static bool PrintUnknownFieldsToString(const UnknownFieldSet& unknown_fields,
+                                         string* output);
+
+  // Outputs a textual representation of the value of the field supplied on
+  // the message supplied. For non-repeated fields, an index of -1 must
+  // be supplied. Note that this method will print the default value for a
+  // field if it is not set.
+  static void PrintFieldValueToString(const Message& message,
+                                      const FieldDescriptor* field,
+                                      int index,
+                                      string* output);
+
+  class LIBPROTOBUF_EXPORT BaseTextGenerator {
+   public:
+    virtual ~BaseTextGenerator();
+    // Print text to the output stream.
+    virtual void Print(const char* text, size_t size) = 0;
+
+    void PrintString(const string& str) { Print(str.data(), str.size()); }
+
+    template <size_t n>
+    void PrintLiteral(const char (&text)[n]) {
+      Print(text, n - 1);  // n includes the terminating zero character.
+    }
+  };
+
+  // The default printer that converts scalar values from fields into their
+  // string representation.
+  // You can derive from this FastFieldValuePrinter if you want to have fields
+  // to be printed in a different way and register it at the Printer.
+  class LIBPROTOBUF_EXPORT FastFieldValuePrinter {
+   public:
+    FastFieldValuePrinter();
+    virtual ~FastFieldValuePrinter();
+    virtual void PrintBool(bool val, BaseTextGenerator* generator) const;
+    virtual void PrintInt32(int32 val, BaseTextGenerator* generator) const;
+    virtual void PrintUInt32(uint32 val, BaseTextGenerator* generator) const;
+    virtual void PrintInt64(int64 val, BaseTextGenerator* generator) const;
+    virtual void PrintUInt64(uint64 val, BaseTextGenerator* generator) const;
+    virtual void PrintFloat(float val, BaseTextGenerator* generator) const;
+    virtual void PrintDouble(double val, BaseTextGenerator* generator) const;
+    virtual void PrintString(const string& val,
+                             BaseTextGenerator* generator) const;
+    virtual void PrintBytes(const string& val,
+                            BaseTextGenerator* generator) const;
+    virtual void PrintEnum(int32 val, const string& name,
+                           BaseTextGenerator* generator) const;
+    virtual void PrintFieldName(const Message& message,
+                                const Reflection* reflection,
+                                const FieldDescriptor* field,
+                                BaseTextGenerator* generator) const;
+    virtual void PrintMessageStart(const Message& message, int field_index,
+                                   int field_count, bool single_line_mode,
+                                   BaseTextGenerator* generator) const;
+    virtual void PrintMessageEnd(const Message& message, int field_index,
+                                 int field_count, bool single_line_mode,
+                                 BaseTextGenerator* generator) const;
+
+   private:
+    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(FastFieldValuePrinter);
+  };
+
+  class LIBPROTOBUF_EXPORT PROTOBUF_RUNTIME_DEPRECATED("Please use FastFieldValuePrinter")
+      FieldValuePrinter {
+   public:
+    FieldValuePrinter();
+    virtual ~FieldValuePrinter();
+    virtual string PrintBool(bool val) const;
+    virtual string PrintInt32(int32 val) const;
+    virtual string PrintUInt32(uint32 val) const;
+    virtual string PrintInt64(int64 val) const;
+    virtual string PrintUInt64(uint64 val) const;
+    virtual string PrintFloat(float val) const;
+    virtual string PrintDouble(double val) const;
+    virtual string PrintString(const string& val) const;
+    virtual string PrintBytes(const string& val) const;
+    virtual string PrintEnum(int32 val, const string& name) const;
+    virtual string PrintFieldName(const Message& message,
+                                  const Reflection* reflection,
+                                  const FieldDescriptor* field) const;
+    virtual string PrintMessageStart(const Message& message,
+                                     int field_index,
+                                     int field_count,
+                                     bool single_line_mode) const;
+    virtual string PrintMessageEnd(const Message& message,
+                                   int field_index,
+                                   int field_count,
+                                   bool single_line_mode) const;
+
+   private:
+    FastFieldValuePrinter delegate_;
+    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(FieldValuePrinter);
+  };
+
+  // Class for those users which require more fine-grained control over how
+  // a protobuffer message is printed out.
+  class LIBPROTOBUF_EXPORT Printer {
+   public:
+    Printer();
+    ~Printer();
+
+    // Like TextFormat::Print
+    bool Print(const Message& message, io::ZeroCopyOutputStream* output) const;
+    // Like TextFormat::PrintUnknownFields
+    bool PrintUnknownFields(const UnknownFieldSet& unknown_fields,
+                            io::ZeroCopyOutputStream* output) const;
+    // Like TextFormat::PrintToString
+    bool PrintToString(const Message& message, string* output) const;
+    // Like TextFormat::PrintUnknownFieldsToString
+    bool PrintUnknownFieldsToString(const UnknownFieldSet& unknown_fields,
+                                    string* output) const;
+    // Like TextFormat::PrintFieldValueToString
+    void PrintFieldValueToString(const Message& message,
+                                 const FieldDescriptor* field,
+                                 int index,
+                                 string* output) const;
+
+    // Adjust the initial indent level of all output.  Each indent level is
+    // equal to two spaces.
+    void SetInitialIndentLevel(int indent_level) {
+      initial_indent_level_ = indent_level;
+    }
+
+    // If printing in single line mode, then the entire message will be output
+    // on a single line with no line breaks.
+    void SetSingleLineMode(bool single_line_mode) {
+      single_line_mode_ = single_line_mode;
+    }
+
+    bool IsInSingleLineMode() const {
+      return single_line_mode_;
+    }
+
+    // If use_field_number is true, uses field number instead of field name.
+    void SetUseFieldNumber(bool use_field_number) {
+      use_field_number_ = use_field_number;
+    }
+
+    // Set true to print repeated primitives in a format like:
+    //   field_name: [1, 2, 3, 4]
+    // instead of printing each value on its own line.  Short format applies
+    // only to primitive values -- i.e. everything except strings and
+    // sub-messages/groups.
+    void SetUseShortRepeatedPrimitives(bool use_short_repeated_primitives) {
+      use_short_repeated_primitives_ = use_short_repeated_primitives;
+    }
+
+    // Set true to output UTF-8 instead of ASCII.  The only difference
+    // is that bytes >= 0x80 in string fields will not be escaped,
+    // because they are assumed to be part of UTF-8 multi-byte
+    // sequences. This will change the default FastFieldValuePrinter.
+    void SetUseUtf8StringEscaping(bool as_utf8);
+
+    // Set the default (Fast)FieldValuePrinter that is used for all fields that
+    // don't have a field-specific printer registered.
+    // Takes ownership of the printer.
+    void SetDefaultFieldValuePrinter(const FastFieldValuePrinter* printer);
+    void SetDefaultFieldValuePrinter(const FieldValuePrinter* printer);
+
+    // Sets whether we want to hide unknown fields or not.
+    // Usually unknown fields are printed in a generic way that includes the
+    // tag number of the field instead of field name. However, sometimes it
+    // is useful to be able to print the message without unknown fields (e.g.
+    // for the python protobuf version to maintain consistency between its pure
+    // python and c++ implementations).
+    void SetHideUnknownFields(bool hide) {
+      hide_unknown_fields_ = hide;
+    }
+
+    // If print_message_fields_in_index_order is true, print fields of a proto
+    // message using the order defined in source code instead of the field
+    // number. By default, use the field number order.
+    void SetPrintMessageFieldsInIndexOrder(
+        bool print_message_fields_in_index_order) {
+      print_message_fields_in_index_order_ =
+          print_message_fields_in_index_order;
+    }
+
+    // If expand==true, expand google.protobuf.Any payloads. The output
+    // will be of form
+    //    [type_url] { <value_printed_in_text> }
+    //
+    // If expand==false, print Any using the default printer. The output will
+    // look like
+    //    type_url: "<type_url>"  value: "serialized_content"
+    void SetExpandAny(bool expand) {
+      expand_any_ = expand;
+    }
+
+    // If non-zero, we truncate all string fields that are  longer than this
+    // threshold.  This is useful when the proto message has very long strings,
+    // e.g., dump of encoded image file.
+    //
+    // NOTE(hfgong):  Setting a non-zero value breaks round-trip safe
+    // property of TextFormat::Printer.  That is, from the printed message, we
+    // cannot fully recover the original string field any more.
+    void SetTruncateStringFieldLongerThan(
+        const int64 truncate_string_field_longer_than) {
+      truncate_string_field_longer_than_ = truncate_string_field_longer_than;
+    }
+
+    // Register a custom field-specific (Fast)FieldValuePrinter for fields
+    // with a particular FieldDescriptor.
+    // Returns "true" if the registration succeeded, or "false", if there is
+    // already a printer for that FieldDescriptor.
+    // Takes ownership of the printer on successful registration.
+    bool RegisterFieldValuePrinter(const FieldDescriptor* field,
+                                   const FieldValuePrinter* printer);
+    bool RegisterFieldValuePrinter(const FieldDescriptor* field,
+                                   const FastFieldValuePrinter* printer);
+
+   private:
+    // Forward declaration of an internal class used to print the text
+    // output to the OutputStream (see text_format.cc for implementation).
+    class TextGenerator;
+
+    // Internal Print method, used for writing to the OutputStream via
+    // the TextGenerator class.
+    void Print(const Message& message, TextGenerator* generator) const;
+
+    // Print a single field.
+    void PrintField(const Message& message, const Reflection* reflection,
+                    const FieldDescriptor* field,
+                    TextGenerator* generator) const;
+
+    // Print a repeated primitive field in short form.
+    void PrintShortRepeatedField(const Message& message,
+                                 const Reflection* reflection,
+                                 const FieldDescriptor* field,
+                                 TextGenerator* generator) const;
+
+    // Print the name of a field -- i.e. everything that comes before the
+    // ':' for a single name/value pair.
+    void PrintFieldName(const Message& message, const Reflection* reflection,
+                        const FieldDescriptor* field,
+                        TextGenerator* generator) const;
+
+    // Outputs a textual representation of the value of the field supplied on
+    // the message supplied or the default value if not set.
+    void PrintFieldValue(const Message& message, const Reflection* reflection,
+                         const FieldDescriptor* field, int index,
+                         TextGenerator* generator) const;
+
+    // Print the fields in an UnknownFieldSet.  They are printed by tag number
+    // only.  Embedded messages are heuristically identified by attempting to
+    // parse them.
+    void PrintUnknownFields(const UnknownFieldSet& unknown_fields,
+                            TextGenerator* generator) const;
+
+    bool PrintAny(const Message& message, TextGenerator* generator) const;
+
+    int initial_indent_level_;
+
+    bool single_line_mode_;
+
+    bool use_field_number_;
+
+    bool use_short_repeated_primitives_;
+
+    bool hide_unknown_fields_;
+
+    bool print_message_fields_in_index_order_;
+
+    bool expand_any_;
+
+    int64 truncate_string_field_longer_than_;
+
+    google::protobuf::scoped_ptr<const FastFieldValuePrinter> default_field_value_printer_;
+    typedef std::map<const FieldDescriptor*, const FastFieldValuePrinter*>
+        CustomPrinterMap;
+    CustomPrinterMap custom_printers_;
+  };
+
+  // Parses a text-format protocol message from the given input stream to
+  // the given message object. This function parses the human-readable format
+  // written by Print(). Returns true on success. The message is cleared first,
+  // even if the function fails -- See Merge() to avoid this behavior.
+  //
+  // Example input: "user {\n id: 123 extra { gender: MALE language: 'en' }\n}"
+  //
+  // One use for this function is parsing handwritten strings in test code.
+  // Another use is to parse the output from google::protobuf::Message::DebugString()
+  // (or ShortDebugString()), because these functions output using
+  // google::protobuf::TextFormat::Print().
+  //
+  // If you would like to read a protocol buffer serialized in the
+  // (non-human-readable) binary wire format, see
+  // google::protobuf::MessageLite::ParseFromString().
+  static bool Parse(io::ZeroCopyInputStream* input, Message* output);
+  // Like Parse(), but reads directly from a string.
+  static bool ParseFromString(const string& input, Message* output);
+
+  // Like Parse(), but the data is merged into the given message, as if
+  // using Message::MergeFrom().
+  static bool Merge(io::ZeroCopyInputStream* input, Message* output);
+  // Like Merge(), but reads directly from a string.
+  static bool MergeFromString(const string& input, Message* output);
+
+  // Parse the given text as a single field value and store it into the
+  // given field of the given message. If the field is a repeated field,
+  // the new value will be added to the end
+  static bool ParseFieldValueFromString(const string& input,
+                                        const FieldDescriptor* field,
+                                        Message* message);
+
+  // Interface that TextFormat::Parser can use to find extensions.
+  // This class may be extended in the future to find more information
+  // like fields, etc.
+  class LIBPROTOBUF_EXPORT Finder {
+   public:
+    virtual ~Finder();
+
+    // Try to find an extension of *message by fully-qualified field
+    // name.  Returns NULL if no extension is known for this name or number.
+    virtual const FieldDescriptor* FindExtension(
+        Message* message,
+        const string& name) const = 0;
+  };
+
+  // A location in the parsed text.
+  struct ParseLocation {
+    int line;
+    int column;
+
+    ParseLocation() : line(-1), column(-1) {}
+    ParseLocation(int line_param, int column_param)
+        : line(line_param), column(column_param) {}
+  };
+
+  // Data structure which is populated with the locations of each field
+  // value parsed from the text.
+  class LIBPROTOBUF_EXPORT ParseInfoTree {
+   public:
+    ParseInfoTree();
+    ~ParseInfoTree();
+
+    // Returns the parse location for index-th value of the field in the parsed
+    // text. If none exists, returns a location with line = -1. Index should be
+    // -1 for not-repeated fields.
+    ParseLocation GetLocation(const FieldDescriptor* field, int index) const;
+
+    // Returns the parse info tree for the given field, which must be a message
+    // type. The nested information tree is owned by the root tree and will be
+    // deleted when it is deleted.
+    ParseInfoTree* GetTreeForNested(const FieldDescriptor* field,
+                                    int index) const;
+
+   private:
+    // Allow the text format parser to record information into the tree.
+    friend class TextFormat;
+
+    // Records the starting location of a single value for a field.
+    void RecordLocation(const FieldDescriptor* field, ParseLocation location);
+
+    // Create and records a nested tree for a nested message field.
+    ParseInfoTree* CreateNested(const FieldDescriptor* field);
+
+    // Defines the map from the index-th field descriptor to its parse location.
+    typedef std::map<const FieldDescriptor*,
+                     std::vector<ParseLocation> > LocationMap;
+
+    // Defines the map from the index-th field descriptor to the nested parse
+    // info tree.
+    typedef std::map<const FieldDescriptor*,
+                     std::vector<ParseInfoTree*> > NestedMap;
+
+    LocationMap locations_;
+    NestedMap nested_;
+
+    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ParseInfoTree);
+  };
+
+  // For more control over parsing, use this class.
+  class LIBPROTOBUF_EXPORT Parser {
+   public:
+    Parser();
+    ~Parser();
+
+    // Like TextFormat::Parse().
+    bool Parse(io::ZeroCopyInputStream* input, Message* output);
+    // Like TextFormat::ParseFromString().
+    bool ParseFromString(const string& input, Message* output);
+    // Like TextFormat::Merge().
+    bool Merge(io::ZeroCopyInputStream* input, Message* output);
+    // Like TextFormat::MergeFromString().
+    bool MergeFromString(const string& input, Message* output);
+
+    // Set where to report parse errors.  If NULL (the default), errors will
+    // be printed to stderr.
+    void RecordErrorsTo(io::ErrorCollector* error_collector) {
+      error_collector_ = error_collector;
+    }
+
+    // Set how parser finds extensions.  If NULL (the default), the
+    // parser will use the standard Reflection object associated with
+    // the message being parsed.
+    void SetFinder(Finder* finder) {
+      finder_ = finder;
+    }
+
+    // Sets where location information about the parse will be written. If NULL
+    // (the default), then no location will be written.
+    void WriteLocationsTo(ParseInfoTree* tree) {
+      parse_info_tree_ = tree;
+    }
+
+    // Normally parsing fails if, after parsing, output->IsInitialized()
+    // returns false.  Call AllowPartialMessage(true) to skip this check.
+    void AllowPartialMessage(bool allow) {
+      allow_partial_ = allow;
+    }
+
+    // Allow field names to be matched case-insensitively.
+    // This is not advisable if there are fields that only differ in case, or
+    // if you want to enforce writing in the canonical form.
+    // This is 'false' by default.
+    void AllowCaseInsensitiveField(bool allow) {
+      allow_case_insensitive_field_ = allow;
+    }
+
+    // Like TextFormat::ParseFieldValueFromString
+    bool ParseFieldValueFromString(const string& input,
+                                   const FieldDescriptor* field,
+                                   Message* output);
+
+
+    void AllowFieldNumber(bool allow) {
+      allow_field_number_ = allow;
+    }
+
+   private:
+    // Forward declaration of an internal class used to parse text
+    // representations (see text_format.cc for implementation).
+    class ParserImpl;
+
+    // Like TextFormat::Merge().  The provided implementation is used
+    // to do the parsing.
+    bool MergeUsingImpl(io::ZeroCopyInputStream* input,
+                        Message* output,
+                        ParserImpl* parser_impl);
+
+    io::ErrorCollector* error_collector_;
+    Finder* finder_;
+    ParseInfoTree* parse_info_tree_;
+    bool allow_partial_;
+    bool allow_case_insensitive_field_;
+    bool allow_unknown_field_;
+    bool allow_unknown_enum_;
+    bool allow_field_number_;
+    bool allow_relaxed_whitespace_;
+    bool allow_singular_overwrites_;
+  };
+
+
+ private:
+  // Hack: ParseInfoTree declares TextFormat as a friend which should extend
+  // the friendship to TextFormat::Parser::ParserImpl, but unfortunately some
+  // old compilers (e.g. GCC 3.4.6) don't implement this correctly. We provide
+  // helpers for ParserImpl to call methods of ParseInfoTree.
+  static inline void RecordLocation(ParseInfoTree* info_tree,
+                                    const FieldDescriptor* field,
+                                    ParseLocation location);
+  static inline ParseInfoTree* CreateNested(ParseInfoTree* info_tree,
+                                            const FieldDescriptor* field);
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(TextFormat);
+};
+
+inline void TextFormat::RecordLocation(ParseInfoTree* info_tree,
+                                       const FieldDescriptor* field,
+                                       ParseLocation location) {
+  info_tree->RecordLocation(field, location);
+}
+
+
+inline TextFormat::ParseInfoTree* TextFormat::CreateNested(
+    ParseInfoTree* info_tree, const FieldDescriptor* field) {
+  return info_tree->CreateNested(field);
+}
+
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_TEXT_FORMAT_H__
diff --git a/kortex_api/include/google/protobuf/timestamp.pb.h b/kortex_api/include/google/protobuf/timestamp.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..6c7136e2c3b6ead557afa0f37885742878f53672
--- /dev/null
+++ b/kortex_api/include/google/protobuf/timestamp.pb.h
@@ -0,0 +1,232 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: google/protobuf/timestamp.proto
+
+#ifndef PROTOBUF_google_2fprotobuf_2ftimestamp_2eproto__INCLUDED
+#define PROTOBUF_google_2fprotobuf_2ftimestamp_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 3005000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 3005001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+// @@protoc_insertion_point(includes)
+
+namespace protobuf_google_2fprotobuf_2ftimestamp_2eproto {
+// Internal implementation detail -- do not use these members.
+struct LIBPROTOBUF_EXPORT TableStruct {
+  static const ::google::protobuf::internal::ParseTableField entries[];
+  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
+  static const ::google::protobuf::internal::ParseTable schema[1];
+  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
+  static const ::google::protobuf::internal::SerializationTable serialization_table[];
+  static const ::google::protobuf::uint32 offsets[];
+};
+void LIBPROTOBUF_EXPORT AddDescriptors();
+void LIBPROTOBUF_EXPORT InitDefaultsTimestampImpl();
+void LIBPROTOBUF_EXPORT InitDefaultsTimestamp();
+inline void LIBPROTOBUF_EXPORT InitDefaults() {
+  InitDefaultsTimestamp();
+}
+}  // namespace protobuf_google_2fprotobuf_2ftimestamp_2eproto
+namespace google {
+namespace protobuf {
+class Timestamp;
+class TimestampDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern TimestampDefaultTypeInternal _Timestamp_default_instance_;
+}  // namespace protobuf
+}  // namespace google
+namespace google {
+namespace protobuf {
+
+// ===================================================================
+
+class LIBPROTOBUF_EXPORT Timestamp : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Timestamp) */ {
+ public:
+  Timestamp();
+  virtual ~Timestamp();
+
+  Timestamp(const Timestamp& from);
+
+  inline Timestamp& operator=(const Timestamp& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Timestamp(Timestamp&& from) noexcept
+    : Timestamp() {
+    *this = ::std::move(from);
+  }
+
+  inline Timestamp& operator=(Timestamp&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
+    return GetArenaNoVirtual();
+  }
+  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
+    return MaybeArenaPtr();
+  }
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Timestamp& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Timestamp* internal_default_instance() {
+    return reinterpret_cast<const Timestamp*>(
+               &_Timestamp_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    0;
+
+  void UnsafeArenaSwap(Timestamp* other);
+  void Swap(Timestamp* other);
+  friend void swap(Timestamp& a, Timestamp& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Timestamp* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Timestamp* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Timestamp& from);
+  void MergeFrom(const Timestamp& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Timestamp* other);
+  protected:
+  explicit Timestamp(::google::protobuf::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return _internal_metadata_.arena();
+  }
+  inline void* MaybeArenaPtr() const {
+    return _internal_metadata_.raw_arena_ptr();
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // int64 seconds = 1;
+  void clear_seconds();
+  static const int kSecondsFieldNumber = 1;
+  ::google::protobuf::int64 seconds() const;
+  void set_seconds(::google::protobuf::int64 value);
+
+  // int32 nanos = 2;
+  void clear_nanos();
+  static const int kNanosFieldNumber = 2;
+  ::google::protobuf::int32 nanos() const;
+  void set_nanos(::google::protobuf::int32 value);
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.Timestamp)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::google::protobuf::int64 seconds_;
+  ::google::protobuf::int32 nanos_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_google_2fprotobuf_2ftimestamp_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2ftimestamp_2eproto::InitDefaultsTimestampImpl();
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// Timestamp
+
+// int64 seconds = 1;
+inline void Timestamp::clear_seconds() {
+  seconds_ = GOOGLE_LONGLONG(0);
+}
+inline ::google::protobuf::int64 Timestamp::seconds() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Timestamp.seconds)
+  return seconds_;
+}
+inline void Timestamp::set_seconds(::google::protobuf::int64 value) {
+  
+  seconds_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.Timestamp.seconds)
+}
+
+// int32 nanos = 2;
+inline void Timestamp::clear_nanos() {
+  nanos_ = 0;
+}
+inline ::google::protobuf::int32 Timestamp::nanos() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Timestamp.nanos)
+  return nanos_;
+}
+inline void Timestamp::set_nanos(::google::protobuf::int32 value) {
+  
+  nanos_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.Timestamp.nanos)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace protobuf
+}  // namespace google
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_google_2fprotobuf_2ftimestamp_2eproto__INCLUDED
diff --git a/kortex_api/include/google/protobuf/type.pb.h b/kortex_api/include/google/protobuf/type.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..8ee74a1269d96764a37189ba5f2150ba2fa372af
--- /dev/null
+++ b/kortex_api/include/google/protobuf/type.pb.h
@@ -0,0 +1,2383 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: google/protobuf/type.proto
+
+#ifndef PROTOBUF_google_2fprotobuf_2ftype_2eproto__INCLUDED
+#define PROTOBUF_google_2fprotobuf_2ftype_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 3005000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 3005001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+#include <google/protobuf/any.pb.h>
+#include <google/protobuf/source_context.pb.h>
+// @@protoc_insertion_point(includes)
+
+namespace protobuf_google_2fprotobuf_2ftype_2eproto {
+// Internal implementation detail -- do not use these members.
+struct LIBPROTOBUF_EXPORT TableStruct {
+  static const ::google::protobuf::internal::ParseTableField entries[];
+  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
+  static const ::google::protobuf::internal::ParseTable schema[5];
+  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
+  static const ::google::protobuf::internal::SerializationTable serialization_table[];
+  static const ::google::protobuf::uint32 offsets[];
+};
+void LIBPROTOBUF_EXPORT AddDescriptors();
+void LIBPROTOBUF_EXPORT InitDefaultsTypeImpl();
+void LIBPROTOBUF_EXPORT InitDefaultsType();
+void LIBPROTOBUF_EXPORT InitDefaultsFieldImpl();
+void LIBPROTOBUF_EXPORT InitDefaultsField();
+void LIBPROTOBUF_EXPORT InitDefaultsEnumImpl();
+void LIBPROTOBUF_EXPORT InitDefaultsEnum();
+void LIBPROTOBUF_EXPORT InitDefaultsEnumValueImpl();
+void LIBPROTOBUF_EXPORT InitDefaultsEnumValue();
+void LIBPROTOBUF_EXPORT InitDefaultsOptionImpl();
+void LIBPROTOBUF_EXPORT InitDefaultsOption();
+inline void LIBPROTOBUF_EXPORT InitDefaults() {
+  InitDefaultsType();
+  InitDefaultsField();
+  InitDefaultsEnum();
+  InitDefaultsEnumValue();
+  InitDefaultsOption();
+}
+}  // namespace protobuf_google_2fprotobuf_2ftype_2eproto
+namespace google {
+namespace protobuf {
+class Enum;
+class EnumDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern EnumDefaultTypeInternal _Enum_default_instance_;
+class EnumValue;
+class EnumValueDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern EnumValueDefaultTypeInternal _EnumValue_default_instance_;
+class Field;
+class FieldDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern FieldDefaultTypeInternal _Field_default_instance_;
+class Option;
+class OptionDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern OptionDefaultTypeInternal _Option_default_instance_;
+class Type;
+class TypeDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern TypeDefaultTypeInternal _Type_default_instance_;
+}  // namespace protobuf
+}  // namespace google
+namespace google {
+namespace protobuf {
+
+enum Field_Kind {
+  Field_Kind_TYPE_UNKNOWN = 0,
+  Field_Kind_TYPE_DOUBLE = 1,
+  Field_Kind_TYPE_FLOAT = 2,
+  Field_Kind_TYPE_INT64 = 3,
+  Field_Kind_TYPE_UINT64 = 4,
+  Field_Kind_TYPE_INT32 = 5,
+  Field_Kind_TYPE_FIXED64 = 6,
+  Field_Kind_TYPE_FIXED32 = 7,
+  Field_Kind_TYPE_BOOL = 8,
+  Field_Kind_TYPE_STRING = 9,
+  Field_Kind_TYPE_GROUP = 10,
+  Field_Kind_TYPE_MESSAGE = 11,
+  Field_Kind_TYPE_BYTES = 12,
+  Field_Kind_TYPE_UINT32 = 13,
+  Field_Kind_TYPE_ENUM = 14,
+  Field_Kind_TYPE_SFIXED32 = 15,
+  Field_Kind_TYPE_SFIXED64 = 16,
+  Field_Kind_TYPE_SINT32 = 17,
+  Field_Kind_TYPE_SINT64 = 18,
+  Field_Kind_Field_Kind_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  Field_Kind_Field_Kind_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+LIBPROTOBUF_EXPORT bool Field_Kind_IsValid(int value);
+const Field_Kind Field_Kind_Kind_MIN = Field_Kind_TYPE_UNKNOWN;
+const Field_Kind Field_Kind_Kind_MAX = Field_Kind_TYPE_SINT64;
+const int Field_Kind_Kind_ARRAYSIZE = Field_Kind_Kind_MAX + 1;
+
+LIBPROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor* Field_Kind_descriptor();
+inline const ::std::string& Field_Kind_Name(Field_Kind value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    Field_Kind_descriptor(), value);
+}
+inline bool Field_Kind_Parse(
+    const ::std::string& name, Field_Kind* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<Field_Kind>(
+    Field_Kind_descriptor(), name, value);
+}
+enum Field_Cardinality {
+  Field_Cardinality_CARDINALITY_UNKNOWN = 0,
+  Field_Cardinality_CARDINALITY_OPTIONAL = 1,
+  Field_Cardinality_CARDINALITY_REQUIRED = 2,
+  Field_Cardinality_CARDINALITY_REPEATED = 3,
+  Field_Cardinality_Field_Cardinality_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  Field_Cardinality_Field_Cardinality_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+LIBPROTOBUF_EXPORT bool Field_Cardinality_IsValid(int value);
+const Field_Cardinality Field_Cardinality_Cardinality_MIN = Field_Cardinality_CARDINALITY_UNKNOWN;
+const Field_Cardinality Field_Cardinality_Cardinality_MAX = Field_Cardinality_CARDINALITY_REPEATED;
+const int Field_Cardinality_Cardinality_ARRAYSIZE = Field_Cardinality_Cardinality_MAX + 1;
+
+LIBPROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor* Field_Cardinality_descriptor();
+inline const ::std::string& Field_Cardinality_Name(Field_Cardinality value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    Field_Cardinality_descriptor(), value);
+}
+inline bool Field_Cardinality_Parse(
+    const ::std::string& name, Field_Cardinality* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<Field_Cardinality>(
+    Field_Cardinality_descriptor(), name, value);
+}
+enum Syntax {
+  SYNTAX_PROTO2 = 0,
+  SYNTAX_PROTO3 = 1,
+  Syntax_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  Syntax_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+LIBPROTOBUF_EXPORT bool Syntax_IsValid(int value);
+const Syntax Syntax_MIN = SYNTAX_PROTO2;
+const Syntax Syntax_MAX = SYNTAX_PROTO3;
+const int Syntax_ARRAYSIZE = Syntax_MAX + 1;
+
+LIBPROTOBUF_EXPORT const ::google::protobuf::EnumDescriptor* Syntax_descriptor();
+inline const ::std::string& Syntax_Name(Syntax value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    Syntax_descriptor(), value);
+}
+inline bool Syntax_Parse(
+    const ::std::string& name, Syntax* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<Syntax>(
+    Syntax_descriptor(), name, value);
+}
+// ===================================================================
+
+class LIBPROTOBUF_EXPORT Type : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Type) */ {
+ public:
+  Type();
+  virtual ~Type();
+
+  Type(const Type& from);
+
+  inline Type& operator=(const Type& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Type(Type&& from) noexcept
+    : Type() {
+    *this = ::std::move(from);
+  }
+
+  inline Type& operator=(Type&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
+    return GetArenaNoVirtual();
+  }
+  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
+    return MaybeArenaPtr();
+  }
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Type& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Type* internal_default_instance() {
+    return reinterpret_cast<const Type*>(
+               &_Type_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    0;
+
+  void UnsafeArenaSwap(Type* other);
+  void Swap(Type* other);
+  friend void swap(Type& a, Type& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Type* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Type* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Type& from);
+  void MergeFrom(const Type& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Type* other);
+  protected:
+  explicit Type(::google::protobuf::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return _internal_metadata_.arena();
+  }
+  inline void* MaybeArenaPtr() const {
+    return _internal_metadata_.raw_arena_ptr();
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .google.protobuf.Field fields = 2;
+  int fields_size() const;
+  void clear_fields();
+  static const int kFieldsFieldNumber = 2;
+  const ::google::protobuf::Field& fields(int index) const;
+  ::google::protobuf::Field* mutable_fields(int index);
+  ::google::protobuf::Field* add_fields();
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::Field >*
+      mutable_fields();
+  const ::google::protobuf::RepeatedPtrField< ::google::protobuf::Field >&
+      fields() const;
+
+  // repeated string oneofs = 3;
+  int oneofs_size() const;
+  void clear_oneofs();
+  static const int kOneofsFieldNumber = 3;
+  const ::std::string& oneofs(int index) const;
+  ::std::string* mutable_oneofs(int index);
+  void set_oneofs(int index, const ::std::string& value);
+  #if LANG_CXX11
+  void set_oneofs(int index, ::std::string&& value);
+  #endif
+  void set_oneofs(int index, const char* value);
+  void set_oneofs(int index, const char* value, size_t size);
+  ::std::string* add_oneofs();
+  void add_oneofs(const ::std::string& value);
+  #if LANG_CXX11
+  void add_oneofs(::std::string&& value);
+  #endif
+  void add_oneofs(const char* value);
+  void add_oneofs(const char* value, size_t size);
+  const ::google::protobuf::RepeatedPtrField< ::std::string>& oneofs() const;
+  ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_oneofs();
+
+  // repeated .google.protobuf.Option options = 4;
+  int options_size() const;
+  void clear_options();
+  static const int kOptionsFieldNumber = 4;
+  const ::google::protobuf::Option& options(int index) const;
+  ::google::protobuf::Option* mutable_options(int index);
+  ::google::protobuf::Option* add_options();
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::Option >*
+      mutable_options();
+  const ::google::protobuf::RepeatedPtrField< ::google::protobuf::Option >&
+      options() const;
+
+  // string name = 1;
+  void clear_name();
+  static const int kNameFieldNumber = 1;
+  const ::std::string& name() const;
+  void set_name(const ::std::string& value);
+  #if LANG_CXX11
+  void set_name(::std::string&& value);
+  #endif
+  void set_name(const char* value);
+  void set_name(const char* value, size_t size);
+  ::std::string* mutable_name();
+  ::std::string* release_name();
+  void set_allocated_name(::std::string* name);
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  ::std::string* unsafe_arena_release_name();
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  void unsafe_arena_set_allocated_name(
+      ::std::string* name);
+
+  // .google.protobuf.SourceContext source_context = 5;
+  bool has_source_context() const;
+  void clear_source_context();
+  static const int kSourceContextFieldNumber = 5;
+  private:
+  void _slow_mutable_source_context();
+  public:
+  const ::google::protobuf::SourceContext& source_context() const;
+  ::google::protobuf::SourceContext* release_source_context();
+  ::google::protobuf::SourceContext* mutable_source_context();
+  void set_allocated_source_context(::google::protobuf::SourceContext* source_context);
+  void unsafe_arena_set_allocated_source_context(
+      ::google::protobuf::SourceContext* source_context);
+  ::google::protobuf::SourceContext* unsafe_arena_release_source_context();
+
+  // .google.protobuf.Syntax syntax = 6;
+  void clear_syntax();
+  static const int kSyntaxFieldNumber = 6;
+  ::google::protobuf::Syntax syntax() const;
+  void set_syntax(::google::protobuf::Syntax value);
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.Type)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::Field > fields_;
+  ::google::protobuf::RepeatedPtrField< ::std::string> oneofs_;
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::Option > options_;
+  ::google::protobuf::internal::ArenaStringPtr name_;
+  ::google::protobuf::SourceContext* source_context_;
+  int syntax_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_google_2fprotobuf_2ftype_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2ftype_2eproto::InitDefaultsTypeImpl();
+};
+// -------------------------------------------------------------------
+
+class LIBPROTOBUF_EXPORT Field : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Field) */ {
+ public:
+  Field();
+  virtual ~Field();
+
+  Field(const Field& from);
+
+  inline Field& operator=(const Field& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Field(Field&& from) noexcept
+    : Field() {
+    *this = ::std::move(from);
+  }
+
+  inline Field& operator=(Field&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
+    return GetArenaNoVirtual();
+  }
+  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
+    return MaybeArenaPtr();
+  }
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Field& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Field* internal_default_instance() {
+    return reinterpret_cast<const Field*>(
+               &_Field_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    1;
+
+  void UnsafeArenaSwap(Field* other);
+  void Swap(Field* other);
+  friend void swap(Field& a, Field& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Field* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Field* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Field& from);
+  void MergeFrom(const Field& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Field* other);
+  protected:
+  explicit Field(::google::protobuf::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return _internal_metadata_.arena();
+  }
+  inline void* MaybeArenaPtr() const {
+    return _internal_metadata_.raw_arena_ptr();
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  typedef Field_Kind Kind;
+  static const Kind TYPE_UNKNOWN =
+    Field_Kind_TYPE_UNKNOWN;
+  static const Kind TYPE_DOUBLE =
+    Field_Kind_TYPE_DOUBLE;
+  static const Kind TYPE_FLOAT =
+    Field_Kind_TYPE_FLOAT;
+  static const Kind TYPE_INT64 =
+    Field_Kind_TYPE_INT64;
+  static const Kind TYPE_UINT64 =
+    Field_Kind_TYPE_UINT64;
+  static const Kind TYPE_INT32 =
+    Field_Kind_TYPE_INT32;
+  static const Kind TYPE_FIXED64 =
+    Field_Kind_TYPE_FIXED64;
+  static const Kind TYPE_FIXED32 =
+    Field_Kind_TYPE_FIXED32;
+  static const Kind TYPE_BOOL =
+    Field_Kind_TYPE_BOOL;
+  static const Kind TYPE_STRING =
+    Field_Kind_TYPE_STRING;
+  static const Kind TYPE_GROUP =
+    Field_Kind_TYPE_GROUP;
+  static const Kind TYPE_MESSAGE =
+    Field_Kind_TYPE_MESSAGE;
+  static const Kind TYPE_BYTES =
+    Field_Kind_TYPE_BYTES;
+  static const Kind TYPE_UINT32 =
+    Field_Kind_TYPE_UINT32;
+  static const Kind TYPE_ENUM =
+    Field_Kind_TYPE_ENUM;
+  static const Kind TYPE_SFIXED32 =
+    Field_Kind_TYPE_SFIXED32;
+  static const Kind TYPE_SFIXED64 =
+    Field_Kind_TYPE_SFIXED64;
+  static const Kind TYPE_SINT32 =
+    Field_Kind_TYPE_SINT32;
+  static const Kind TYPE_SINT64 =
+    Field_Kind_TYPE_SINT64;
+  static inline bool Kind_IsValid(int value) {
+    return Field_Kind_IsValid(value);
+  }
+  static const Kind Kind_MIN =
+    Field_Kind_Kind_MIN;
+  static const Kind Kind_MAX =
+    Field_Kind_Kind_MAX;
+  static const int Kind_ARRAYSIZE =
+    Field_Kind_Kind_ARRAYSIZE;
+  static inline const ::google::protobuf::EnumDescriptor*
+  Kind_descriptor() {
+    return Field_Kind_descriptor();
+  }
+  static inline const ::std::string& Kind_Name(Kind value) {
+    return Field_Kind_Name(value);
+  }
+  static inline bool Kind_Parse(const ::std::string& name,
+      Kind* value) {
+    return Field_Kind_Parse(name, value);
+  }
+
+  typedef Field_Cardinality Cardinality;
+  static const Cardinality CARDINALITY_UNKNOWN =
+    Field_Cardinality_CARDINALITY_UNKNOWN;
+  static const Cardinality CARDINALITY_OPTIONAL =
+    Field_Cardinality_CARDINALITY_OPTIONAL;
+  static const Cardinality CARDINALITY_REQUIRED =
+    Field_Cardinality_CARDINALITY_REQUIRED;
+  static const Cardinality CARDINALITY_REPEATED =
+    Field_Cardinality_CARDINALITY_REPEATED;
+  static inline bool Cardinality_IsValid(int value) {
+    return Field_Cardinality_IsValid(value);
+  }
+  static const Cardinality Cardinality_MIN =
+    Field_Cardinality_Cardinality_MIN;
+  static const Cardinality Cardinality_MAX =
+    Field_Cardinality_Cardinality_MAX;
+  static const int Cardinality_ARRAYSIZE =
+    Field_Cardinality_Cardinality_ARRAYSIZE;
+  static inline const ::google::protobuf::EnumDescriptor*
+  Cardinality_descriptor() {
+    return Field_Cardinality_descriptor();
+  }
+  static inline const ::std::string& Cardinality_Name(Cardinality value) {
+    return Field_Cardinality_Name(value);
+  }
+  static inline bool Cardinality_Parse(const ::std::string& name,
+      Cardinality* value) {
+    return Field_Cardinality_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  // repeated .google.protobuf.Option options = 9;
+  int options_size() const;
+  void clear_options();
+  static const int kOptionsFieldNumber = 9;
+  const ::google::protobuf::Option& options(int index) const;
+  ::google::protobuf::Option* mutable_options(int index);
+  ::google::protobuf::Option* add_options();
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::Option >*
+      mutable_options();
+  const ::google::protobuf::RepeatedPtrField< ::google::protobuf::Option >&
+      options() const;
+
+  // string name = 4;
+  void clear_name();
+  static const int kNameFieldNumber = 4;
+  const ::std::string& name() const;
+  void set_name(const ::std::string& value);
+  #if LANG_CXX11
+  void set_name(::std::string&& value);
+  #endif
+  void set_name(const char* value);
+  void set_name(const char* value, size_t size);
+  ::std::string* mutable_name();
+  ::std::string* release_name();
+  void set_allocated_name(::std::string* name);
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  ::std::string* unsafe_arena_release_name();
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  void unsafe_arena_set_allocated_name(
+      ::std::string* name);
+
+  // string type_url = 6;
+  void clear_type_url();
+  static const int kTypeUrlFieldNumber = 6;
+  const ::std::string& type_url() const;
+  void set_type_url(const ::std::string& value);
+  #if LANG_CXX11
+  void set_type_url(::std::string&& value);
+  #endif
+  void set_type_url(const char* value);
+  void set_type_url(const char* value, size_t size);
+  ::std::string* mutable_type_url();
+  ::std::string* release_type_url();
+  void set_allocated_type_url(::std::string* type_url);
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  ::std::string* unsafe_arena_release_type_url();
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  void unsafe_arena_set_allocated_type_url(
+      ::std::string* type_url);
+
+  // string json_name = 10;
+  void clear_json_name();
+  static const int kJsonNameFieldNumber = 10;
+  const ::std::string& json_name() const;
+  void set_json_name(const ::std::string& value);
+  #if LANG_CXX11
+  void set_json_name(::std::string&& value);
+  #endif
+  void set_json_name(const char* value);
+  void set_json_name(const char* value, size_t size);
+  ::std::string* mutable_json_name();
+  ::std::string* release_json_name();
+  void set_allocated_json_name(::std::string* json_name);
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  ::std::string* unsafe_arena_release_json_name();
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  void unsafe_arena_set_allocated_json_name(
+      ::std::string* json_name);
+
+  // string default_value = 11;
+  void clear_default_value();
+  static const int kDefaultValueFieldNumber = 11;
+  const ::std::string& default_value() const;
+  void set_default_value(const ::std::string& value);
+  #if LANG_CXX11
+  void set_default_value(::std::string&& value);
+  #endif
+  void set_default_value(const char* value);
+  void set_default_value(const char* value, size_t size);
+  ::std::string* mutable_default_value();
+  ::std::string* release_default_value();
+  void set_allocated_default_value(::std::string* default_value);
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  ::std::string* unsafe_arena_release_default_value();
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  void unsafe_arena_set_allocated_default_value(
+      ::std::string* default_value);
+
+  // .google.protobuf.Field.Kind kind = 1;
+  void clear_kind();
+  static const int kKindFieldNumber = 1;
+  ::google::protobuf::Field_Kind kind() const;
+  void set_kind(::google::protobuf::Field_Kind value);
+
+  // .google.protobuf.Field.Cardinality cardinality = 2;
+  void clear_cardinality();
+  static const int kCardinalityFieldNumber = 2;
+  ::google::protobuf::Field_Cardinality cardinality() const;
+  void set_cardinality(::google::protobuf::Field_Cardinality value);
+
+  // int32 number = 3;
+  void clear_number();
+  static const int kNumberFieldNumber = 3;
+  ::google::protobuf::int32 number() const;
+  void set_number(::google::protobuf::int32 value);
+
+  // int32 oneof_index = 7;
+  void clear_oneof_index();
+  static const int kOneofIndexFieldNumber = 7;
+  ::google::protobuf::int32 oneof_index() const;
+  void set_oneof_index(::google::protobuf::int32 value);
+
+  // bool packed = 8;
+  void clear_packed();
+  static const int kPackedFieldNumber = 8;
+  bool packed() const;
+  void set_packed(bool value);
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.Field)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::Option > options_;
+  ::google::protobuf::internal::ArenaStringPtr name_;
+  ::google::protobuf::internal::ArenaStringPtr type_url_;
+  ::google::protobuf::internal::ArenaStringPtr json_name_;
+  ::google::protobuf::internal::ArenaStringPtr default_value_;
+  int kind_;
+  int cardinality_;
+  ::google::protobuf::int32 number_;
+  ::google::protobuf::int32 oneof_index_;
+  bool packed_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_google_2fprotobuf_2ftype_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2ftype_2eproto::InitDefaultsFieldImpl();
+};
+// -------------------------------------------------------------------
+
+class LIBPROTOBUF_EXPORT Enum : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Enum) */ {
+ public:
+  Enum();
+  virtual ~Enum();
+
+  Enum(const Enum& from);
+
+  inline Enum& operator=(const Enum& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Enum(Enum&& from) noexcept
+    : Enum() {
+    *this = ::std::move(from);
+  }
+
+  inline Enum& operator=(Enum&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
+    return GetArenaNoVirtual();
+  }
+  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
+    return MaybeArenaPtr();
+  }
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Enum& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Enum* internal_default_instance() {
+    return reinterpret_cast<const Enum*>(
+               &_Enum_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    2;
+
+  void UnsafeArenaSwap(Enum* other);
+  void Swap(Enum* other);
+  friend void swap(Enum& a, Enum& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Enum* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Enum* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Enum& from);
+  void MergeFrom(const Enum& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Enum* other);
+  protected:
+  explicit Enum(::google::protobuf::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return _internal_metadata_.arena();
+  }
+  inline void* MaybeArenaPtr() const {
+    return _internal_metadata_.raw_arena_ptr();
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .google.protobuf.EnumValue enumvalue = 2;
+  int enumvalue_size() const;
+  void clear_enumvalue();
+  static const int kEnumvalueFieldNumber = 2;
+  const ::google::protobuf::EnumValue& enumvalue(int index) const;
+  ::google::protobuf::EnumValue* mutable_enumvalue(int index);
+  ::google::protobuf::EnumValue* add_enumvalue();
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumValue >*
+      mutable_enumvalue();
+  const ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumValue >&
+      enumvalue() const;
+
+  // repeated .google.protobuf.Option options = 3;
+  int options_size() const;
+  void clear_options();
+  static const int kOptionsFieldNumber = 3;
+  const ::google::protobuf::Option& options(int index) const;
+  ::google::protobuf::Option* mutable_options(int index);
+  ::google::protobuf::Option* add_options();
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::Option >*
+      mutable_options();
+  const ::google::protobuf::RepeatedPtrField< ::google::protobuf::Option >&
+      options() const;
+
+  // string name = 1;
+  void clear_name();
+  static const int kNameFieldNumber = 1;
+  const ::std::string& name() const;
+  void set_name(const ::std::string& value);
+  #if LANG_CXX11
+  void set_name(::std::string&& value);
+  #endif
+  void set_name(const char* value);
+  void set_name(const char* value, size_t size);
+  ::std::string* mutable_name();
+  ::std::string* release_name();
+  void set_allocated_name(::std::string* name);
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  ::std::string* unsafe_arena_release_name();
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  void unsafe_arena_set_allocated_name(
+      ::std::string* name);
+
+  // .google.protobuf.SourceContext source_context = 4;
+  bool has_source_context() const;
+  void clear_source_context();
+  static const int kSourceContextFieldNumber = 4;
+  private:
+  void _slow_mutable_source_context();
+  public:
+  const ::google::protobuf::SourceContext& source_context() const;
+  ::google::protobuf::SourceContext* release_source_context();
+  ::google::protobuf::SourceContext* mutable_source_context();
+  void set_allocated_source_context(::google::protobuf::SourceContext* source_context);
+  void unsafe_arena_set_allocated_source_context(
+      ::google::protobuf::SourceContext* source_context);
+  ::google::protobuf::SourceContext* unsafe_arena_release_source_context();
+
+  // .google.protobuf.Syntax syntax = 5;
+  void clear_syntax();
+  static const int kSyntaxFieldNumber = 5;
+  ::google::protobuf::Syntax syntax() const;
+  void set_syntax(::google::protobuf::Syntax value);
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.Enum)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumValue > enumvalue_;
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::Option > options_;
+  ::google::protobuf::internal::ArenaStringPtr name_;
+  ::google::protobuf::SourceContext* source_context_;
+  int syntax_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_google_2fprotobuf_2ftype_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2ftype_2eproto::InitDefaultsEnumImpl();
+};
+// -------------------------------------------------------------------
+
+class LIBPROTOBUF_EXPORT EnumValue : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.EnumValue) */ {
+ public:
+  EnumValue();
+  virtual ~EnumValue();
+
+  EnumValue(const EnumValue& from);
+
+  inline EnumValue& operator=(const EnumValue& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  EnumValue(EnumValue&& from) noexcept
+    : EnumValue() {
+    *this = ::std::move(from);
+  }
+
+  inline EnumValue& operator=(EnumValue&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
+    return GetArenaNoVirtual();
+  }
+  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
+    return MaybeArenaPtr();
+  }
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const EnumValue& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const EnumValue* internal_default_instance() {
+    return reinterpret_cast<const EnumValue*>(
+               &_EnumValue_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    3;
+
+  void UnsafeArenaSwap(EnumValue* other);
+  void Swap(EnumValue* other);
+  friend void swap(EnumValue& a, EnumValue& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline EnumValue* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  EnumValue* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const EnumValue& from);
+  void MergeFrom(const EnumValue& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(EnumValue* other);
+  protected:
+  explicit EnumValue(::google::protobuf::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return _internal_metadata_.arena();
+  }
+  inline void* MaybeArenaPtr() const {
+    return _internal_metadata_.raw_arena_ptr();
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .google.protobuf.Option options = 3;
+  int options_size() const;
+  void clear_options();
+  static const int kOptionsFieldNumber = 3;
+  const ::google::protobuf::Option& options(int index) const;
+  ::google::protobuf::Option* mutable_options(int index);
+  ::google::protobuf::Option* add_options();
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::Option >*
+      mutable_options();
+  const ::google::protobuf::RepeatedPtrField< ::google::protobuf::Option >&
+      options() const;
+
+  // string name = 1;
+  void clear_name();
+  static const int kNameFieldNumber = 1;
+  const ::std::string& name() const;
+  void set_name(const ::std::string& value);
+  #if LANG_CXX11
+  void set_name(::std::string&& value);
+  #endif
+  void set_name(const char* value);
+  void set_name(const char* value, size_t size);
+  ::std::string* mutable_name();
+  ::std::string* release_name();
+  void set_allocated_name(::std::string* name);
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  ::std::string* unsafe_arena_release_name();
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  void unsafe_arena_set_allocated_name(
+      ::std::string* name);
+
+  // int32 number = 2;
+  void clear_number();
+  static const int kNumberFieldNumber = 2;
+  ::google::protobuf::int32 number() const;
+  void set_number(::google::protobuf::int32 value);
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.EnumValue)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::google::protobuf::RepeatedPtrField< ::google::protobuf::Option > options_;
+  ::google::protobuf::internal::ArenaStringPtr name_;
+  ::google::protobuf::int32 number_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_google_2fprotobuf_2ftype_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2ftype_2eproto::InitDefaultsEnumValueImpl();
+};
+// -------------------------------------------------------------------
+
+class LIBPROTOBUF_EXPORT Option : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Option) */ {
+ public:
+  Option();
+  virtual ~Option();
+
+  Option(const Option& from);
+
+  inline Option& operator=(const Option& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Option(Option&& from) noexcept
+    : Option() {
+    *this = ::std::move(from);
+  }
+
+  inline Option& operator=(Option&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
+    return GetArenaNoVirtual();
+  }
+  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
+    return MaybeArenaPtr();
+  }
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Option& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Option* internal_default_instance() {
+    return reinterpret_cast<const Option*>(
+               &_Option_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    4;
+
+  void UnsafeArenaSwap(Option* other);
+  void Swap(Option* other);
+  friend void swap(Option& a, Option& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Option* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Option* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Option& from);
+  void MergeFrom(const Option& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Option* other);
+  protected:
+  explicit Option(::google::protobuf::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return _internal_metadata_.arena();
+  }
+  inline void* MaybeArenaPtr() const {
+    return _internal_metadata_.raw_arena_ptr();
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // string name = 1;
+  void clear_name();
+  static const int kNameFieldNumber = 1;
+  const ::std::string& name() const;
+  void set_name(const ::std::string& value);
+  #if LANG_CXX11
+  void set_name(::std::string&& value);
+  #endif
+  void set_name(const char* value);
+  void set_name(const char* value, size_t size);
+  ::std::string* mutable_name();
+  ::std::string* release_name();
+  void set_allocated_name(::std::string* name);
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  ::std::string* unsafe_arena_release_name();
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  void unsafe_arena_set_allocated_name(
+      ::std::string* name);
+
+  // .google.protobuf.Any value = 2;
+  bool has_value() const;
+  void clear_value();
+  static const int kValueFieldNumber = 2;
+  private:
+  void _slow_mutable_value();
+  public:
+  const ::google::protobuf::Any& value() const;
+  ::google::protobuf::Any* release_value();
+  ::google::protobuf::Any* mutable_value();
+  void set_allocated_value(::google::protobuf::Any* value);
+  void unsafe_arena_set_allocated_value(
+      ::google::protobuf::Any* value);
+  ::google::protobuf::Any* unsafe_arena_release_value();
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.Option)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::google::protobuf::internal::ArenaStringPtr name_;
+  ::google::protobuf::Any* value_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_google_2fprotobuf_2ftype_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2ftype_2eproto::InitDefaultsOptionImpl();
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// Type
+
+// string name = 1;
+inline void Type::clear_name() {
+  name_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline const ::std::string& Type::name() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Type.name)
+  return name_.Get();
+}
+inline void Type::set_name(const ::std::string& value) {
+  
+  name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set:google.protobuf.Type.name)
+}
+#if LANG_CXX11
+inline void Type::set_name(::std::string&& value) {
+  
+  name_.Set(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.Type.name)
+}
+#endif
+inline void Type::set_name(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
+              GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_char:google.protobuf.Type.name)
+}
+inline void Type::set_name(const char* value,
+    size_t size) {
+  
+  name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
+      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.Type.name)
+}
+inline ::std::string* Type::mutable_name() {
+  
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Type.name)
+  return name_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline ::std::string* Type::release_name() {
+  // @@protoc_insertion_point(field_release:google.protobuf.Type.name)
+  
+  return name_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline void Type::set_allocated_name(::std::string* name) {
+  if (name != NULL) {
+    
+  } else {
+    
+  }
+  name_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name,
+      GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Type.name)
+}
+inline ::std::string* Type::unsafe_arena_release_name() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.Type.name)
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  
+  return name_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      GetArenaNoVirtual());
+}
+inline void Type::unsafe_arena_set_allocated_name(
+    ::std::string* name) {
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  if (name != NULL) {
+    
+  } else {
+    
+  }
+  name_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      name, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.Type.name)
+}
+
+// repeated .google.protobuf.Field fields = 2;
+inline int Type::fields_size() const {
+  return fields_.size();
+}
+inline void Type::clear_fields() {
+  fields_.Clear();
+}
+inline const ::google::protobuf::Field& Type::fields(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Type.fields)
+  return fields_.Get(index);
+}
+inline ::google::protobuf::Field* Type::mutable_fields(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Type.fields)
+  return fields_.Mutable(index);
+}
+inline ::google::protobuf::Field* Type::add_fields() {
+  // @@protoc_insertion_point(field_add:google.protobuf.Type.fields)
+  return fields_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::Field >*
+Type::mutable_fields() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.Type.fields)
+  return &fields_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::Field >&
+Type::fields() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.Type.fields)
+  return fields_;
+}
+
+// repeated string oneofs = 3;
+inline int Type::oneofs_size() const {
+  return oneofs_.size();
+}
+inline void Type::clear_oneofs() {
+  oneofs_.Clear();
+}
+inline const ::std::string& Type::oneofs(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Type.oneofs)
+  return oneofs_.Get(index);
+}
+inline ::std::string* Type::mutable_oneofs(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Type.oneofs)
+  return oneofs_.Mutable(index);
+}
+inline void Type::set_oneofs(int index, const ::std::string& value) {
+  // @@protoc_insertion_point(field_set:google.protobuf.Type.oneofs)
+  oneofs_.Mutable(index)->assign(value);
+}
+#if LANG_CXX11
+inline void Type::set_oneofs(int index, ::std::string&& value) {
+  // @@protoc_insertion_point(field_set:google.protobuf.Type.oneofs)
+  oneofs_.Mutable(index)->assign(std::move(value));
+}
+#endif
+inline void Type::set_oneofs(int index, const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  oneofs_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:google.protobuf.Type.oneofs)
+}
+inline void Type::set_oneofs(int index, const char* value, size_t size) {
+  oneofs_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.Type.oneofs)
+}
+inline ::std::string* Type::add_oneofs() {
+  // @@protoc_insertion_point(field_add_mutable:google.protobuf.Type.oneofs)
+  return oneofs_.Add();
+}
+inline void Type::add_oneofs(const ::std::string& value) {
+  oneofs_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:google.protobuf.Type.oneofs)
+}
+#if LANG_CXX11
+inline void Type::add_oneofs(::std::string&& value) {
+  oneofs_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:google.protobuf.Type.oneofs)
+}
+#endif
+inline void Type::add_oneofs(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  oneofs_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:google.protobuf.Type.oneofs)
+}
+inline void Type::add_oneofs(const char* value, size_t size) {
+  oneofs_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:google.protobuf.Type.oneofs)
+}
+inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
+Type::oneofs() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.Type.oneofs)
+  return oneofs_;
+}
+inline ::google::protobuf::RepeatedPtrField< ::std::string>*
+Type::mutable_oneofs() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.Type.oneofs)
+  return &oneofs_;
+}
+
+// repeated .google.protobuf.Option options = 4;
+inline int Type::options_size() const {
+  return options_.size();
+}
+inline void Type::clear_options() {
+  options_.Clear();
+}
+inline const ::google::protobuf::Option& Type::options(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Type.options)
+  return options_.Get(index);
+}
+inline ::google::protobuf::Option* Type::mutable_options(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Type.options)
+  return options_.Mutable(index);
+}
+inline ::google::protobuf::Option* Type::add_options() {
+  // @@protoc_insertion_point(field_add:google.protobuf.Type.options)
+  return options_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::Option >*
+Type::mutable_options() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.Type.options)
+  return &options_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::Option >&
+Type::options() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.Type.options)
+  return options_;
+}
+
+// .google.protobuf.SourceContext source_context = 5;
+inline bool Type::has_source_context() const {
+  return this != internal_default_instance() && source_context_ != NULL;
+}
+inline const ::google::protobuf::SourceContext& Type::source_context() const {
+  const ::google::protobuf::SourceContext* p = source_context_;
+  // @@protoc_insertion_point(field_get:google.protobuf.Type.source_context)
+  return p != NULL ? *p : *reinterpret_cast<const ::google::protobuf::SourceContext*>(
+      &::google::protobuf::_SourceContext_default_instance_);
+}
+inline ::google::protobuf::SourceContext* Type::release_source_context() {
+  // @@protoc_insertion_point(field_release:google.protobuf.Type.source_context)
+  
+  ::google::protobuf::SourceContext* temp = source_context_;
+  if (GetArenaNoVirtual() != NULL) {
+    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp, NULL);
+  }
+  source_context_ = NULL;
+  return temp;
+}
+inline ::google::protobuf::SourceContext* Type::unsafe_arena_release_source_context() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.Type.source_context)
+  
+  ::google::protobuf::SourceContext* temp = source_context_;
+  source_context_ = NULL;
+  return temp;
+}
+inline ::google::protobuf::SourceContext* Type::mutable_source_context() {
+  
+  if (source_context_ == NULL) {
+    _slow_mutable_source_context();
+  }
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Type.source_context)
+  return source_context_;
+}
+inline void Type::set_allocated_source_context(::google::protobuf::SourceContext* source_context) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(source_context_);
+  }
+  if (source_context) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      source_context = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, source_context, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  source_context_ = source_context;
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Type.source_context)
+}
+
+// .google.protobuf.Syntax syntax = 6;
+inline void Type::clear_syntax() {
+  syntax_ = 0;
+}
+inline ::google::protobuf::Syntax Type::syntax() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Type.syntax)
+  return static_cast< ::google::protobuf::Syntax >(syntax_);
+}
+inline void Type::set_syntax(::google::protobuf::Syntax value) {
+  
+  syntax_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.Type.syntax)
+}
+
+// -------------------------------------------------------------------
+
+// Field
+
+// .google.protobuf.Field.Kind kind = 1;
+inline void Field::clear_kind() {
+  kind_ = 0;
+}
+inline ::google::protobuf::Field_Kind Field::kind() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Field.kind)
+  return static_cast< ::google::protobuf::Field_Kind >(kind_);
+}
+inline void Field::set_kind(::google::protobuf::Field_Kind value) {
+  
+  kind_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.Field.kind)
+}
+
+// .google.protobuf.Field.Cardinality cardinality = 2;
+inline void Field::clear_cardinality() {
+  cardinality_ = 0;
+}
+inline ::google::protobuf::Field_Cardinality Field::cardinality() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Field.cardinality)
+  return static_cast< ::google::protobuf::Field_Cardinality >(cardinality_);
+}
+inline void Field::set_cardinality(::google::protobuf::Field_Cardinality value) {
+  
+  cardinality_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.Field.cardinality)
+}
+
+// int32 number = 3;
+inline void Field::clear_number() {
+  number_ = 0;
+}
+inline ::google::protobuf::int32 Field::number() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Field.number)
+  return number_;
+}
+inline void Field::set_number(::google::protobuf::int32 value) {
+  
+  number_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.Field.number)
+}
+
+// string name = 4;
+inline void Field::clear_name() {
+  name_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline const ::std::string& Field::name() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Field.name)
+  return name_.Get();
+}
+inline void Field::set_name(const ::std::string& value) {
+  
+  name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set:google.protobuf.Field.name)
+}
+#if LANG_CXX11
+inline void Field::set_name(::std::string&& value) {
+  
+  name_.Set(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.Field.name)
+}
+#endif
+inline void Field::set_name(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
+              GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_char:google.protobuf.Field.name)
+}
+inline void Field::set_name(const char* value,
+    size_t size) {
+  
+  name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
+      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.Field.name)
+}
+inline ::std::string* Field::mutable_name() {
+  
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Field.name)
+  return name_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline ::std::string* Field::release_name() {
+  // @@protoc_insertion_point(field_release:google.protobuf.Field.name)
+  
+  return name_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline void Field::set_allocated_name(::std::string* name) {
+  if (name != NULL) {
+    
+  } else {
+    
+  }
+  name_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name,
+      GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Field.name)
+}
+inline ::std::string* Field::unsafe_arena_release_name() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.Field.name)
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  
+  return name_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      GetArenaNoVirtual());
+}
+inline void Field::unsafe_arena_set_allocated_name(
+    ::std::string* name) {
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  if (name != NULL) {
+    
+  } else {
+    
+  }
+  name_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      name, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.Field.name)
+}
+
+// string type_url = 6;
+inline void Field::clear_type_url() {
+  type_url_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline const ::std::string& Field::type_url() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Field.type_url)
+  return type_url_.Get();
+}
+inline void Field::set_type_url(const ::std::string& value) {
+  
+  type_url_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set:google.protobuf.Field.type_url)
+}
+#if LANG_CXX11
+inline void Field::set_type_url(::std::string&& value) {
+  
+  type_url_.Set(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.Field.type_url)
+}
+#endif
+inline void Field::set_type_url(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  type_url_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
+              GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_char:google.protobuf.Field.type_url)
+}
+inline void Field::set_type_url(const char* value,
+    size_t size) {
+  
+  type_url_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
+      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.Field.type_url)
+}
+inline ::std::string* Field::mutable_type_url() {
+  
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Field.type_url)
+  return type_url_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline ::std::string* Field::release_type_url() {
+  // @@protoc_insertion_point(field_release:google.protobuf.Field.type_url)
+  
+  return type_url_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline void Field::set_allocated_type_url(::std::string* type_url) {
+  if (type_url != NULL) {
+    
+  } else {
+    
+  }
+  type_url_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), type_url,
+      GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Field.type_url)
+}
+inline ::std::string* Field::unsafe_arena_release_type_url() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.Field.type_url)
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  
+  return type_url_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      GetArenaNoVirtual());
+}
+inline void Field::unsafe_arena_set_allocated_type_url(
+    ::std::string* type_url) {
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  if (type_url != NULL) {
+    
+  } else {
+    
+  }
+  type_url_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      type_url, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.Field.type_url)
+}
+
+// int32 oneof_index = 7;
+inline void Field::clear_oneof_index() {
+  oneof_index_ = 0;
+}
+inline ::google::protobuf::int32 Field::oneof_index() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Field.oneof_index)
+  return oneof_index_;
+}
+inline void Field::set_oneof_index(::google::protobuf::int32 value) {
+  
+  oneof_index_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.Field.oneof_index)
+}
+
+// bool packed = 8;
+inline void Field::clear_packed() {
+  packed_ = false;
+}
+inline bool Field::packed() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Field.packed)
+  return packed_;
+}
+inline void Field::set_packed(bool value) {
+  
+  packed_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.Field.packed)
+}
+
+// repeated .google.protobuf.Option options = 9;
+inline int Field::options_size() const {
+  return options_.size();
+}
+inline void Field::clear_options() {
+  options_.Clear();
+}
+inline const ::google::protobuf::Option& Field::options(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Field.options)
+  return options_.Get(index);
+}
+inline ::google::protobuf::Option* Field::mutable_options(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Field.options)
+  return options_.Mutable(index);
+}
+inline ::google::protobuf::Option* Field::add_options() {
+  // @@protoc_insertion_point(field_add:google.protobuf.Field.options)
+  return options_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::Option >*
+Field::mutable_options() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.Field.options)
+  return &options_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::Option >&
+Field::options() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.Field.options)
+  return options_;
+}
+
+// string json_name = 10;
+inline void Field::clear_json_name() {
+  json_name_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline const ::std::string& Field::json_name() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Field.json_name)
+  return json_name_.Get();
+}
+inline void Field::set_json_name(const ::std::string& value) {
+  
+  json_name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set:google.protobuf.Field.json_name)
+}
+#if LANG_CXX11
+inline void Field::set_json_name(::std::string&& value) {
+  
+  json_name_.Set(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.Field.json_name)
+}
+#endif
+inline void Field::set_json_name(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  json_name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
+              GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_char:google.protobuf.Field.json_name)
+}
+inline void Field::set_json_name(const char* value,
+    size_t size) {
+  
+  json_name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
+      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.Field.json_name)
+}
+inline ::std::string* Field::mutable_json_name() {
+  
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Field.json_name)
+  return json_name_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline ::std::string* Field::release_json_name() {
+  // @@protoc_insertion_point(field_release:google.protobuf.Field.json_name)
+  
+  return json_name_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline void Field::set_allocated_json_name(::std::string* json_name) {
+  if (json_name != NULL) {
+    
+  } else {
+    
+  }
+  json_name_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), json_name,
+      GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Field.json_name)
+}
+inline ::std::string* Field::unsafe_arena_release_json_name() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.Field.json_name)
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  
+  return json_name_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      GetArenaNoVirtual());
+}
+inline void Field::unsafe_arena_set_allocated_json_name(
+    ::std::string* json_name) {
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  if (json_name != NULL) {
+    
+  } else {
+    
+  }
+  json_name_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      json_name, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.Field.json_name)
+}
+
+// string default_value = 11;
+inline void Field::clear_default_value() {
+  default_value_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline const ::std::string& Field::default_value() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Field.default_value)
+  return default_value_.Get();
+}
+inline void Field::set_default_value(const ::std::string& value) {
+  
+  default_value_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set:google.protobuf.Field.default_value)
+}
+#if LANG_CXX11
+inline void Field::set_default_value(::std::string&& value) {
+  
+  default_value_.Set(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.Field.default_value)
+}
+#endif
+inline void Field::set_default_value(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  default_value_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
+              GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_char:google.protobuf.Field.default_value)
+}
+inline void Field::set_default_value(const char* value,
+    size_t size) {
+  
+  default_value_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
+      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.Field.default_value)
+}
+inline ::std::string* Field::mutable_default_value() {
+  
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Field.default_value)
+  return default_value_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline ::std::string* Field::release_default_value() {
+  // @@protoc_insertion_point(field_release:google.protobuf.Field.default_value)
+  
+  return default_value_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline void Field::set_allocated_default_value(::std::string* default_value) {
+  if (default_value != NULL) {
+    
+  } else {
+    
+  }
+  default_value_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), default_value,
+      GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Field.default_value)
+}
+inline ::std::string* Field::unsafe_arena_release_default_value() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.Field.default_value)
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  
+  return default_value_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      GetArenaNoVirtual());
+}
+inline void Field::unsafe_arena_set_allocated_default_value(
+    ::std::string* default_value) {
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  if (default_value != NULL) {
+    
+  } else {
+    
+  }
+  default_value_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      default_value, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.Field.default_value)
+}
+
+// -------------------------------------------------------------------
+
+// Enum
+
+// string name = 1;
+inline void Enum::clear_name() {
+  name_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline const ::std::string& Enum::name() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Enum.name)
+  return name_.Get();
+}
+inline void Enum::set_name(const ::std::string& value) {
+  
+  name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set:google.protobuf.Enum.name)
+}
+#if LANG_CXX11
+inline void Enum::set_name(::std::string&& value) {
+  
+  name_.Set(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.Enum.name)
+}
+#endif
+inline void Enum::set_name(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
+              GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_char:google.protobuf.Enum.name)
+}
+inline void Enum::set_name(const char* value,
+    size_t size) {
+  
+  name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
+      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.Enum.name)
+}
+inline ::std::string* Enum::mutable_name() {
+  
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Enum.name)
+  return name_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline ::std::string* Enum::release_name() {
+  // @@protoc_insertion_point(field_release:google.protobuf.Enum.name)
+  
+  return name_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline void Enum::set_allocated_name(::std::string* name) {
+  if (name != NULL) {
+    
+  } else {
+    
+  }
+  name_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name,
+      GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Enum.name)
+}
+inline ::std::string* Enum::unsafe_arena_release_name() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.Enum.name)
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  
+  return name_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      GetArenaNoVirtual());
+}
+inline void Enum::unsafe_arena_set_allocated_name(
+    ::std::string* name) {
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  if (name != NULL) {
+    
+  } else {
+    
+  }
+  name_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      name, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.Enum.name)
+}
+
+// repeated .google.protobuf.EnumValue enumvalue = 2;
+inline int Enum::enumvalue_size() const {
+  return enumvalue_.size();
+}
+inline void Enum::clear_enumvalue() {
+  enumvalue_.Clear();
+}
+inline const ::google::protobuf::EnumValue& Enum::enumvalue(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Enum.enumvalue)
+  return enumvalue_.Get(index);
+}
+inline ::google::protobuf::EnumValue* Enum::mutable_enumvalue(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Enum.enumvalue)
+  return enumvalue_.Mutable(index);
+}
+inline ::google::protobuf::EnumValue* Enum::add_enumvalue() {
+  // @@protoc_insertion_point(field_add:google.protobuf.Enum.enumvalue)
+  return enumvalue_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumValue >*
+Enum::mutable_enumvalue() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.Enum.enumvalue)
+  return &enumvalue_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::EnumValue >&
+Enum::enumvalue() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.Enum.enumvalue)
+  return enumvalue_;
+}
+
+// repeated .google.protobuf.Option options = 3;
+inline int Enum::options_size() const {
+  return options_.size();
+}
+inline void Enum::clear_options() {
+  options_.Clear();
+}
+inline const ::google::protobuf::Option& Enum::options(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Enum.options)
+  return options_.Get(index);
+}
+inline ::google::protobuf::Option* Enum::mutable_options(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Enum.options)
+  return options_.Mutable(index);
+}
+inline ::google::protobuf::Option* Enum::add_options() {
+  // @@protoc_insertion_point(field_add:google.protobuf.Enum.options)
+  return options_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::Option >*
+Enum::mutable_options() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.Enum.options)
+  return &options_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::Option >&
+Enum::options() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.Enum.options)
+  return options_;
+}
+
+// .google.protobuf.SourceContext source_context = 4;
+inline bool Enum::has_source_context() const {
+  return this != internal_default_instance() && source_context_ != NULL;
+}
+inline const ::google::protobuf::SourceContext& Enum::source_context() const {
+  const ::google::protobuf::SourceContext* p = source_context_;
+  // @@protoc_insertion_point(field_get:google.protobuf.Enum.source_context)
+  return p != NULL ? *p : *reinterpret_cast<const ::google::protobuf::SourceContext*>(
+      &::google::protobuf::_SourceContext_default_instance_);
+}
+inline ::google::protobuf::SourceContext* Enum::release_source_context() {
+  // @@protoc_insertion_point(field_release:google.protobuf.Enum.source_context)
+  
+  ::google::protobuf::SourceContext* temp = source_context_;
+  if (GetArenaNoVirtual() != NULL) {
+    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp, NULL);
+  }
+  source_context_ = NULL;
+  return temp;
+}
+inline ::google::protobuf::SourceContext* Enum::unsafe_arena_release_source_context() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.Enum.source_context)
+  
+  ::google::protobuf::SourceContext* temp = source_context_;
+  source_context_ = NULL;
+  return temp;
+}
+inline ::google::protobuf::SourceContext* Enum::mutable_source_context() {
+  
+  if (source_context_ == NULL) {
+    _slow_mutable_source_context();
+  }
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Enum.source_context)
+  return source_context_;
+}
+inline void Enum::set_allocated_source_context(::google::protobuf::SourceContext* source_context) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(source_context_);
+  }
+  if (source_context) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      source_context = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, source_context, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  source_context_ = source_context;
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Enum.source_context)
+}
+
+// .google.protobuf.Syntax syntax = 5;
+inline void Enum::clear_syntax() {
+  syntax_ = 0;
+}
+inline ::google::protobuf::Syntax Enum::syntax() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Enum.syntax)
+  return static_cast< ::google::protobuf::Syntax >(syntax_);
+}
+inline void Enum::set_syntax(::google::protobuf::Syntax value) {
+  
+  syntax_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.Enum.syntax)
+}
+
+// -------------------------------------------------------------------
+
+// EnumValue
+
+// string name = 1;
+inline void EnumValue::clear_name() {
+  name_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline const ::std::string& EnumValue::name() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.EnumValue.name)
+  return name_.Get();
+}
+inline void EnumValue::set_name(const ::std::string& value) {
+  
+  name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set:google.protobuf.EnumValue.name)
+}
+#if LANG_CXX11
+inline void EnumValue::set_name(::std::string&& value) {
+  
+  name_.Set(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.EnumValue.name)
+}
+#endif
+inline void EnumValue::set_name(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
+              GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_char:google.protobuf.EnumValue.name)
+}
+inline void EnumValue::set_name(const char* value,
+    size_t size) {
+  
+  name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
+      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.EnumValue.name)
+}
+inline ::std::string* EnumValue::mutable_name() {
+  
+  // @@protoc_insertion_point(field_mutable:google.protobuf.EnumValue.name)
+  return name_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline ::std::string* EnumValue::release_name() {
+  // @@protoc_insertion_point(field_release:google.protobuf.EnumValue.name)
+  
+  return name_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline void EnumValue::set_allocated_name(::std::string* name) {
+  if (name != NULL) {
+    
+  } else {
+    
+  }
+  name_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name,
+      GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.EnumValue.name)
+}
+inline ::std::string* EnumValue::unsafe_arena_release_name() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.EnumValue.name)
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  
+  return name_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      GetArenaNoVirtual());
+}
+inline void EnumValue::unsafe_arena_set_allocated_name(
+    ::std::string* name) {
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  if (name != NULL) {
+    
+  } else {
+    
+  }
+  name_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      name, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.EnumValue.name)
+}
+
+// int32 number = 2;
+inline void EnumValue::clear_number() {
+  number_ = 0;
+}
+inline ::google::protobuf::int32 EnumValue::number() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.EnumValue.number)
+  return number_;
+}
+inline void EnumValue::set_number(::google::protobuf::int32 value) {
+  
+  number_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.EnumValue.number)
+}
+
+// repeated .google.protobuf.Option options = 3;
+inline int EnumValue::options_size() const {
+  return options_.size();
+}
+inline void EnumValue::clear_options() {
+  options_.Clear();
+}
+inline const ::google::protobuf::Option& EnumValue::options(int index) const {
+  // @@protoc_insertion_point(field_get:google.protobuf.EnumValue.options)
+  return options_.Get(index);
+}
+inline ::google::protobuf::Option* EnumValue::mutable_options(int index) {
+  // @@protoc_insertion_point(field_mutable:google.protobuf.EnumValue.options)
+  return options_.Mutable(index);
+}
+inline ::google::protobuf::Option* EnumValue::add_options() {
+  // @@protoc_insertion_point(field_add:google.protobuf.EnumValue.options)
+  return options_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::google::protobuf::Option >*
+EnumValue::mutable_options() {
+  // @@protoc_insertion_point(field_mutable_list:google.protobuf.EnumValue.options)
+  return &options_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::google::protobuf::Option >&
+EnumValue::options() const {
+  // @@protoc_insertion_point(field_list:google.protobuf.EnumValue.options)
+  return options_;
+}
+
+// -------------------------------------------------------------------
+
+// Option
+
+// string name = 1;
+inline void Option::clear_name() {
+  name_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline const ::std::string& Option::name() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Option.name)
+  return name_.Get();
+}
+inline void Option::set_name(const ::std::string& value) {
+  
+  name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set:google.protobuf.Option.name)
+}
+#if LANG_CXX11
+inline void Option::set_name(::std::string&& value) {
+  
+  name_.Set(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.Option.name)
+}
+#endif
+inline void Option::set_name(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
+              GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_char:google.protobuf.Option.name)
+}
+inline void Option::set_name(const char* value,
+    size_t size) {
+  
+  name_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
+      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.Option.name)
+}
+inline ::std::string* Option::mutable_name() {
+  
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Option.name)
+  return name_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline ::std::string* Option::release_name() {
+  // @@protoc_insertion_point(field_release:google.protobuf.Option.name)
+  
+  return name_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline void Option::set_allocated_name(::std::string* name) {
+  if (name != NULL) {
+    
+  } else {
+    
+  }
+  name_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name,
+      GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Option.name)
+}
+inline ::std::string* Option::unsafe_arena_release_name() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.Option.name)
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  
+  return name_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      GetArenaNoVirtual());
+}
+inline void Option::unsafe_arena_set_allocated_name(
+    ::std::string* name) {
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  if (name != NULL) {
+    
+  } else {
+    
+  }
+  name_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      name, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.Option.name)
+}
+
+// .google.protobuf.Any value = 2;
+inline bool Option::has_value() const {
+  return this != internal_default_instance() && value_ != NULL;
+}
+inline const ::google::protobuf::Any& Option::value() const {
+  const ::google::protobuf::Any* p = value_;
+  // @@protoc_insertion_point(field_get:google.protobuf.Option.value)
+  return p != NULL ? *p : *reinterpret_cast<const ::google::protobuf::Any*>(
+      &::google::protobuf::_Any_default_instance_);
+}
+inline ::google::protobuf::Any* Option::release_value() {
+  // @@protoc_insertion_point(field_release:google.protobuf.Option.value)
+  
+  ::google::protobuf::Any* temp = value_;
+  if (GetArenaNoVirtual() != NULL) {
+    temp = ::google::protobuf::internal::DuplicateIfNonNull(temp, NULL);
+  }
+  value_ = NULL;
+  return temp;
+}
+inline ::google::protobuf::Any* Option::unsafe_arena_release_value() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.Option.value)
+  
+  ::google::protobuf::Any* temp = value_;
+  value_ = NULL;
+  return temp;
+}
+inline ::google::protobuf::Any* Option::mutable_value() {
+  
+  if (value_ == NULL) {
+    _slow_mutable_value();
+  }
+  // @@protoc_insertion_point(field_mutable:google.protobuf.Option.value)
+  return value_;
+}
+inline void Option::set_allocated_value(::google::protobuf::Any* value) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(value_);
+  }
+  if (value) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      value = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, value, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  value_ = value;
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.Option.value)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace protobuf
+}  // namespace google
+
+namespace google {
+namespace protobuf {
+
+template <> struct is_proto_enum< ::google::protobuf::Field_Kind> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::google::protobuf::Field_Kind>() {
+  return ::google::protobuf::Field_Kind_descriptor();
+}
+template <> struct is_proto_enum< ::google::protobuf::Field_Cardinality> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::google::protobuf::Field_Cardinality>() {
+  return ::google::protobuf::Field_Cardinality_descriptor();
+}
+template <> struct is_proto_enum< ::google::protobuf::Syntax> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::google::protobuf::Syntax>() {
+  return ::google::protobuf::Syntax_descriptor();
+}
+
+}  // namespace protobuf
+}  // namespace google
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_google_2fprotobuf_2ftype_2eproto__INCLUDED
diff --git a/kortex_api/include/google/protobuf/unknown_field_set.h b/kortex_api/include/google/protobuf/unknown_field_set.h
new file mode 100644
index 0000000000000000000000000000000000000000..619855ed0aab7321c0e2db05b491b016462e4de1
--- /dev/null
+++ b/kortex_api/include/google/protobuf/unknown_field_set.h
@@ -0,0 +1,363 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// Contains classes used to keep track of unrecognized fields seen while
+// parsing a protocol message.
+
+#ifndef GOOGLE_PROTOBUF_UNKNOWN_FIELD_SET_H__
+#define GOOGLE_PROTOBUF_UNKNOWN_FIELD_SET_H__
+
+#include <assert.h>
+#include <string>
+#include <vector>
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/logging.h>
+#include <google/protobuf/message_lite.h>
+
+namespace google {
+namespace protobuf {
+  namespace io {
+    class CodedInputStream;         // coded_stream.h
+    class CodedOutputStream;        // coded_stream.h
+    class ZeroCopyInputStream;      // zero_copy_stream.h
+  }
+  namespace internal {
+    class InternalMetadataWithArena;  // metadata.h
+    class WireFormat;               // wire_format.h
+    class MessageSetFieldSkipperUsingCord;
+                                    // extension_set_heavy.cc
+  }
+
+class Message;                      // message.h
+class UnknownField;                 // below
+
+// An UnknownFieldSet contains fields that were encountered while parsing a
+// message but were not defined by its type.  Keeping track of these can be
+// useful, especially in that they may be written if the message is serialized
+// again without being cleared in between.  This means that software which
+// simply receives messages and forwards them to other servers does not need
+// to be updated every time a new field is added to the message definition.
+//
+// To get the UnknownFieldSet attached to any message, call
+// Reflection::GetUnknownFields().
+//
+// This class is necessarily tied to the protocol buffer wire format, unlike
+// the Reflection interface which is independent of any serialization scheme.
+class LIBPROTOBUF_EXPORT UnknownFieldSet {
+ public:
+  UnknownFieldSet();
+  ~UnknownFieldSet();
+
+  // Remove all fields.
+  inline void Clear();
+
+  // Remove all fields and deallocate internal data objects
+  void ClearAndFreeMemory();
+
+  // Is this set empty?
+  inline bool empty() const;
+
+  // Merge the contents of some other UnknownFieldSet with this one.
+  void MergeFrom(const UnknownFieldSet& other);
+
+  // Similar to above, but this function will destroy the contents of other.
+  void MergeFromAndDestroy(UnknownFieldSet* other);
+
+  // Merge the contents an UnknownFieldSet with the UnknownFieldSet in
+  // *metadata, if there is one.  If *metadata doesn't have an UnknownFieldSet
+  // then add one to it and make it be a copy of the first arg.
+  static void MergeToInternalMetdata(
+      const UnknownFieldSet& other,
+      internal::InternalMetadataWithArena* metadata);
+
+  // Swaps the contents of some other UnknownFieldSet with this one.
+  inline void Swap(UnknownFieldSet* x);
+
+  // Computes (an estimate of) the total number of bytes currently used for
+  // storing the unknown fields in memory. Does NOT include
+  // sizeof(*this) in the calculation.
+  size_t SpaceUsedExcludingSelfLong() const;
+
+  int SpaceUsedExcludingSelf() const {
+    return internal::ToIntSize(SpaceUsedExcludingSelfLong());
+  }
+
+  // Version of SpaceUsed() including sizeof(*this).
+  size_t SpaceUsedLong() const;
+
+  int SpaceUsed() const {
+    return internal::ToIntSize(SpaceUsedLong());
+  }
+
+  // Returns the number of fields present in the UnknownFieldSet.
+  inline int field_count() const;
+  // Get a field in the set, where 0 <= index < field_count().  The fields
+  // appear in the order in which they were added.
+  inline const UnknownField& field(int index) const;
+  // Get a mutable pointer to a field in the set, where
+  // 0 <= index < field_count().  The fields appear in the order in which
+  // they were added.
+  inline UnknownField* mutable_field(int index);
+
+  // Adding fields ---------------------------------------------------
+
+  void AddVarint(int number, uint64 value);
+  void AddFixed32(int number, uint32 value);
+  void AddFixed64(int number, uint64 value);
+  void AddLengthDelimited(int number, const string& value);
+  string* AddLengthDelimited(int number);
+  UnknownFieldSet* AddGroup(int number);
+
+  // Adds an unknown field from another set.
+  void AddField(const UnknownField& field);
+
+  // Delete fields with indices in the range [start .. start+num-1].
+  // Caution: implementation moves all fields with indices [start+num .. ].
+  void DeleteSubrange(int start, int num);
+
+  // Delete all fields with a specific field number. The order of left fields
+  // is preserved.
+  // Caution: implementation moves all fields after the first deleted field.
+  void DeleteByNumber(int number);
+
+  // Parsing helpers -------------------------------------------------
+  // These work exactly like the similarly-named methods of Message.
+
+  bool MergeFromCodedStream(io::CodedInputStream* input);
+  bool ParseFromCodedStream(io::CodedInputStream* input);
+  bool ParseFromZeroCopyStream(io::ZeroCopyInputStream* input);
+  bool ParseFromArray(const void* data, int size);
+  inline bool ParseFromString(const string& data) {
+    return ParseFromArray(data.data(), static_cast<int>(data.size()));
+  }
+
+  static const UnknownFieldSet* default_instance();
+ private:
+  // For InternalMergeFrom
+  friend class UnknownField;
+  // Merges from other UnknownFieldSet. This method assumes, that this object
+  // is newly created and has fields_ == NULL;
+  void InternalMergeFrom(const UnknownFieldSet& other);
+  void ClearFallback();
+
+  // fields_ is either NULL, or a pointer to a vector that is *non-empty*. We
+  // never hold the empty vector because we want the 'do we have any unknown
+  // fields' check to be fast, and avoid a cache miss: the UFS instance gets
+  // embedded in the message object, so 'fields_ != NULL' tests a member
+  // variable hot in the cache, without the need to go touch a vector somewhere
+  // else in memory.
+  std::vector<UnknownField>* fields_;
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(UnknownFieldSet);
+};
+
+// Represents one field in an UnknownFieldSet.
+class LIBPROTOBUF_EXPORT UnknownField {
+ public:
+  enum Type {
+    TYPE_VARINT,
+    TYPE_FIXED32,
+    TYPE_FIXED64,
+    TYPE_LENGTH_DELIMITED,
+    TYPE_GROUP
+  };
+
+  // The field's field number, as seen on the wire.
+  inline int number() const;
+
+  // The field type.
+  inline Type type() const;
+
+  // Accessors -------------------------------------------------------
+  // Each method works only for UnknownFields of the corresponding type.
+
+  inline uint64 varint() const;
+  inline uint32 fixed32() const;
+  inline uint64 fixed64() const;
+  inline const string& length_delimited() const;
+  inline const UnknownFieldSet& group() const;
+
+  inline void set_varint(uint64 value);
+  inline void set_fixed32(uint32 value);
+  inline void set_fixed64(uint64 value);
+  inline void set_length_delimited(const string& value);
+  inline string* mutable_length_delimited();
+  inline UnknownFieldSet* mutable_group();
+
+  // Serialization API.
+  // These methods can take advantage of the underlying implementation and may
+  // archieve a better performance than using getters to retrieve the data and
+  // do the serialization yourself.
+  void SerializeLengthDelimitedNoTag(io::CodedOutputStream* output) const;
+  uint8* SerializeLengthDelimitedNoTagToArray(uint8* target) const;
+
+  inline size_t GetLengthDelimitedSize() const;
+
+
+  // If this UnknownField contains a pointer, delete it.
+  void Delete();
+
+  // Reset all the underlying pointers to NULL. A special function to be only
+  // used while merging from a temporary UFS.
+  void Reset();
+
+  // Make a deep copy of any pointers in this UnknownField.
+  void DeepCopy(const UnknownField& other);
+
+  // Set the wire type of this UnknownField. Should only be used when this
+  // UnknownField is being created.
+  inline void SetType(Type type);
+
+  union LengthDelimited {
+    string* string_value_;
+  };
+
+  uint32 number_;
+  uint32 type_;
+  union {
+    uint64 varint_;
+    uint32 fixed32_;
+    uint64 fixed64_;
+    mutable union LengthDelimited length_delimited_;
+    UnknownFieldSet* group_;
+  } data_;
+};
+
+// ===================================================================
+// inline implementations
+
+inline UnknownFieldSet::UnknownFieldSet() : fields_(NULL) {}
+
+inline UnknownFieldSet::~UnknownFieldSet() { Clear(); }
+
+inline void UnknownFieldSet::ClearAndFreeMemory() { Clear(); }
+
+inline void UnknownFieldSet::Clear() {
+  if (fields_ != NULL) {
+    ClearFallback();
+  }
+}
+
+inline bool UnknownFieldSet::empty() const {
+  // Invariant: fields_ is never empty if present.
+  return !fields_;
+}
+
+inline void UnknownFieldSet::Swap(UnknownFieldSet* x) {
+  std::swap(fields_, x->fields_);
+}
+
+inline int UnknownFieldSet::field_count() const {
+  return fields_ ? static_cast<int>(fields_->size()) : 0;
+}
+inline const UnknownField& UnknownFieldSet::field(int index) const {
+  GOOGLE_DCHECK(fields_ != NULL);
+  return (*fields_)[static_cast<size_t>(index)];
+}
+inline UnknownField* UnknownFieldSet::mutable_field(int index) {
+  return &(*fields_)[static_cast<size_t>(index)];
+}
+
+inline void UnknownFieldSet::AddLengthDelimited(
+    int number, const string& value) {
+  AddLengthDelimited(number)->assign(value);
+}
+
+
+
+
+inline int UnknownField::number() const { return static_cast<int>(number_); }
+inline UnknownField::Type UnknownField::type() const {
+  return static_cast<Type>(type_);
+}
+
+inline uint64 UnknownField::varint() const {
+  assert(type() == TYPE_VARINT);
+  return data_.varint_;
+}
+inline uint32 UnknownField::fixed32() const {
+  assert(type() == TYPE_FIXED32);
+  return data_.fixed32_;
+}
+inline uint64 UnknownField::fixed64() const {
+  assert(type() == TYPE_FIXED64);
+  return data_.fixed64_;
+}
+inline const string& UnknownField::length_delimited() const {
+  assert(type() == TYPE_LENGTH_DELIMITED);
+  return *data_.length_delimited_.string_value_;
+}
+inline const UnknownFieldSet& UnknownField::group() const {
+  assert(type() == TYPE_GROUP);
+  return *data_.group_;
+}
+
+inline void UnknownField::set_varint(uint64 value) {
+  assert(type() == TYPE_VARINT);
+  data_.varint_ = value;
+}
+inline void UnknownField::set_fixed32(uint32 value) {
+  assert(type() == TYPE_FIXED32);
+  data_.fixed32_ = value;
+}
+inline void UnknownField::set_fixed64(uint64 value) {
+  assert(type() == TYPE_FIXED64);
+  data_.fixed64_ = value;
+}
+inline void UnknownField::set_length_delimited(const string& value) {
+  assert(type() == TYPE_LENGTH_DELIMITED);
+  data_.length_delimited_.string_value_->assign(value);
+}
+inline string* UnknownField::mutable_length_delimited() {
+  assert(type() == TYPE_LENGTH_DELIMITED);
+  return data_.length_delimited_.string_value_;
+}
+inline UnknownFieldSet* UnknownField::mutable_group() {
+  assert(type() == TYPE_GROUP);
+  return data_.group_;
+}
+
+inline size_t UnknownField::GetLengthDelimitedSize() const {
+  GOOGLE_DCHECK_EQ(TYPE_LENGTH_DELIMITED, type());
+  return data_.length_delimited_.string_value_->size();
+}
+
+inline void UnknownField::SetType(Type type) {
+  type_ = type;
+}
+
+
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_UNKNOWN_FIELD_SET_H__
diff --git a/kortex_api/include/google/protobuf/util/delimited_message_util.h b/kortex_api/include/google/protobuf/util/delimited_message_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..302d4781b3e53cd1d47e260ab72de7ef3a6cc407
--- /dev/null
+++ b/kortex_api/include/google/protobuf/util/delimited_message_util.h
@@ -0,0 +1,66 @@
+// Adapted from the patch of kenton@google.com (Kenton Varda)
+// See https://github.com/google/protobuf/pull/710 for details.
+
+#ifndef GOOGLE_PROTOBUF_UTIL_DELIMITED_MESSAGE_UTIL_H__
+#define GOOGLE_PROTOBUF_UTIL_DELIMITED_MESSAGE_UTIL_H__
+
+#include <ostream>
+
+#include <google/protobuf/message_lite.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/io/zero_copy_stream_impl.h>
+
+namespace google {
+namespace protobuf {
+namespace util {
+
+// Write a single size-delimited message from the given stream. Delimited
+// format allows a single file or stream to contain multiple messages,
+// whereas normally writing multiple non-delimited messages to the same
+// stream would cause them to be merged. A delimited message is a varint
+// encoding the message size followed by a message of exactly that size.
+//
+// Note that if you want to *read* a delimited message from a file descriptor
+// or istream, you will need to construct an io::FileInputStream or
+// io::OstreamInputStream (implementations of io::ZeroCopyStream) and use the
+// utility function ParseDelimitedFromZeroCopyStream(). You must then
+// continue to use the same ZeroCopyInputStream to read all further data from
+// the stream until EOF. This is because these ZeroCopyInputStream
+// implementations are buffered: they read a big chunk of data at a time,
+// then parse it. As a result, they may read past the end of the delimited
+// message. There is no way for them to push the extra data back into the
+// underlying source, so instead you must keep using the same stream object.
+bool LIBPROTOBUF_EXPORT SerializeDelimitedToFileDescriptor(const MessageLite& message, int file_descriptor);
+
+bool LIBPROTOBUF_EXPORT SerializeDelimitedToOstream(const MessageLite& message, ostream* output);
+
+// Read a single size-delimited message from the given stream. Delimited
+// format allows a single file or stream to contain multiple messages,
+// whereas normally parsing consumes the entire input. A delimited message
+// is a varint encoding the message size followed by a message of exactly
+// that size.
+//
+// If |clean_eof| is not NULL, then it will be set to indicate whether the
+// stream ended cleanly. That is, if the stream ends without this method
+// having read any data at all from it, then *clean_eof will be set true,
+// otherwise it will be set false. Note that these methods return false
+// on EOF, but they also return false on other errors, so |clean_eof| is
+// needed to distinguish a clean end from errors.
+bool LIBPROTOBUF_EXPORT ParseDelimitedFromZeroCopyStream(MessageLite* message, io::ZeroCopyInputStream* input, bool* clean_eof);
+
+bool LIBPROTOBUF_EXPORT ParseDelimitedFromCodedStream(MessageLite* message, io::CodedInputStream* input, bool* clean_eof);
+
+// Write a single size-delimited message from the given stream. Delimited
+// format allows a single file or stream to contain multiple messages,
+// whereas normally writing multiple non-delimited messages to the same
+// stream would cause them to be merged. A delimited message is a varint
+// encoding the message size followed by a message of exactly that size.
+bool LIBPROTOBUF_EXPORT SerializeDelimitedToZeroCopyStream(const MessageLite& message, io::ZeroCopyOutputStream* output);
+
+bool LIBPROTOBUF_EXPORT SerializeDelimitedToCodedStream(const MessageLite& message, io::CodedOutputStream* output);
+
+}  // namespace util
+}  // namespace protobuf
+}  // namespace google
+
+#endif  // GOOGLE_PROTOBUF_UTIL_DELIMITED_MESSAGE_UTIL_H__
diff --git a/kortex_api/include/google/protobuf/util/field_comparator.h b/kortex_api/include/google/protobuf/util/field_comparator.h
new file mode 100644
index 0000000000000000000000000000000000000000..26a7ba4d975a5dc2d371f77a97b99d482119d3cb
--- /dev/null
+++ b/kortex_api/include/google/protobuf/util/field_comparator.h
@@ -0,0 +1,259 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Defines classes for field comparison.
+
+#ifndef GOOGLE_PROTOBUF_UTIL_FIELD_COMPARATOR_H__
+#define GOOGLE_PROTOBUF_UTIL_FIELD_COMPARATOR_H__
+
+#include <map>
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+namespace google {
+namespace protobuf {
+
+class Message;
+class EnumValueDescriptor;
+class FieldDescriptor;
+
+namespace util {
+
+class FieldContext;
+
+// Base class specifying the interface for comparing protocol buffer fields.
+// Regular users should consider using or subclassing DefaultFieldComparator
+// rather than this interface.
+// Currently, this does not support comparing unknown fields.
+class LIBPROTOBUF_EXPORT FieldComparator {
+ public:
+  FieldComparator();
+  virtual ~FieldComparator();
+
+  enum ComparisonResult {
+    SAME,       // Compared fields are equal. In case of comparing submessages,
+                // user should not recursively compare their contents.
+    DIFFERENT,  // Compared fields are different. In case of comparing
+                // submessages, user should not recursively compare their
+                // contents.
+    RECURSE,    // Compared submessages need to be compared recursively.
+                // FieldComparator does not specify the semantics of recursive
+                // comparison. This value should not be returned for simple
+                // values.
+  };
+
+  // Compares the values of a field in two protocol buffer messages.
+  // Returns SAME or DIFFERENT for simple values, and SAME, DIFFERENT or RECURSE
+  // for submessages. Returning RECURSE for fields not being submessages is
+  // illegal.
+  // In case the given FieldDescriptor points to a repeated field, the indices
+  // need to be valid. Otherwise they should be ignored.
+  //
+  // FieldContext contains information about the specific instances of the
+  // fields being compared, versus FieldDescriptor which only contains general
+  // type information about the fields.
+  virtual ComparisonResult Compare(
+      const google::protobuf::Message& message_1,
+      const google::protobuf::Message& message_2,
+      const google::protobuf::FieldDescriptor* field,
+      int index_1, int index_2,
+      const google::protobuf::util::FieldContext* field_context) = 0;
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(FieldComparator);
+};
+
+// Basic implementation of FieldComparator.  Supports three modes of floating
+// point value comparison: exact, approximate using MathUtil::AlmostEqual
+// method, and arbitrarily precise using MathUtil::WithinFractionOrMargin.
+class LIBPROTOBUF_EXPORT DefaultFieldComparator : public FieldComparator {
+ public:
+  enum FloatComparison {
+     EXACT,               // Floats and doubles are compared exactly.
+     APPROXIMATE,         // Floats and doubles are compared using the
+                          // MathUtil::AlmostEqual method or
+                          // MathUtil::WithinFractionOrMargin method.
+     // TODO(ksroka): Introduce third value to differenciate uses of AlmostEqual
+     //               and WithinFractionOrMargin.
+  };
+
+  // Creates new comparator with float comparison set to EXACT.
+  DefaultFieldComparator();
+
+  virtual ~DefaultFieldComparator();
+
+  virtual ComparisonResult Compare(
+      const google::protobuf::Message& message_1,
+      const google::protobuf::Message& message_2,
+      const google::protobuf::FieldDescriptor* field,
+      int index_1, int index_2,
+      const google::protobuf::util::FieldContext* field_context);
+
+  void set_float_comparison(FloatComparison float_comparison) {
+    float_comparison_ = float_comparison;
+  }
+
+  FloatComparison float_comparison() const {
+    return float_comparison_;
+  }
+
+  // Set whether the FieldComparator shall treat floats or doubles that are both
+  // NaN as equal (treat_nan_as_equal = true) or as different
+  // (treat_nan_as_equal = false). Default is treating NaNs always as different.
+  void set_treat_nan_as_equal(bool treat_nan_as_equal) {
+    treat_nan_as_equal_ = treat_nan_as_equal;
+  }
+
+  bool treat_nan_as_equal() const {
+    return treat_nan_as_equal_;
+  }
+
+  // Sets the fraction and margin for the float comparison of a given field.
+  // Uses MathUtil::WithinFractionOrMargin to compare the values.
+  //
+  // REQUIRES: field->cpp_type == FieldDescriptor::CPPTYPE_DOUBLE or
+  //           field->cpp_type == FieldDescriptor::CPPTYPE_FLOAT
+  // REQUIRES: float_comparison_ == APPROXIMATE
+  void SetFractionAndMargin(const FieldDescriptor* field, double fraction,
+                            double margin);
+
+  // Sets the fraction and margin for the float comparison of all float and
+  // double fields, unless a field has been given a specific setting via
+  // SetFractionAndMargin() above.
+  // Uses MathUtil::WithinFractionOrMargin to compare the values.
+  //
+  // REQUIRES: float_comparison_ == APPROXIMATE
+  void SetDefaultFractionAndMargin(double fraction, double margin);
+
+ private:
+  // Defines the tolerance for floating point comparison (fraction and margin).
+  struct Tolerance {
+    double fraction;
+    double margin;
+    Tolerance()
+        : fraction(0.0),
+          margin(0.0) {}
+    Tolerance(double f, double m)
+        : fraction(f),
+          margin(m) {}
+  };
+
+  // Defines the map to store the tolerances for floating point comparison.
+  typedef std::map<const FieldDescriptor*, Tolerance> ToleranceMap;
+
+  // The following methods get executed when CompareFields is called for the
+  // basic types (instead of submessages). They return true on success. One
+  // can use ResultFromBoolean() to convert that boolean to a ComparisonResult
+  // value.
+  bool CompareBool(const google::protobuf::FieldDescriptor& field,
+                   bool value_1, bool value_2) {
+    return value_1 == value_2;
+  }
+
+  // Uses CompareDoubleOrFloat, a helper function used by both CompareDouble and
+  // CompareFloat.
+  bool CompareDouble(const google::protobuf::FieldDescriptor& field,
+                     double value_1, double value_2);
+
+  bool CompareEnum(const google::protobuf::FieldDescriptor& field,
+                   const EnumValueDescriptor* value_1,
+                   const EnumValueDescriptor* value_2);
+
+  // Uses CompareDoubleOrFloat, a helper function used by both CompareDouble and
+  // CompareFloat.
+  bool CompareFloat(const google::protobuf::FieldDescriptor& field,
+                    float value_1, float value_2);
+
+  bool CompareInt32(const google::protobuf::FieldDescriptor& field,
+                    int32 value_1, int32 value_2) {
+    return value_1 == value_2;
+  }
+
+  bool CompareInt64(const google::protobuf::FieldDescriptor& field,
+                    int64 value_1, int64 value_2) {
+    return value_1 == value_2;
+  }
+
+  bool CompareString(const google::protobuf::FieldDescriptor& field,
+                     const string& value_1, const string& value_2) {
+    return value_1 == value_2;
+  }
+
+  bool CompareUInt32(const google::protobuf::FieldDescriptor& field,
+                     uint32 value_1, uint32 value_2) {
+    return value_1 == value_2;
+  }
+
+  bool CompareUInt64(const google::protobuf::FieldDescriptor& field,
+                     uint64 value_1, uint64 value_2) {
+    return value_1 == value_2;
+  }
+
+  // This function is used by CompareDouble and CompareFloat to avoid code
+  // duplication. There are no checks done against types of the values passed,
+  // but it's likely to fail if passed non-numeric arguments.
+  template<typename T>
+  bool CompareDoubleOrFloat(const google::protobuf::FieldDescriptor& field,
+                            T value_1, T value_2);
+
+  // Returns FieldComparator::SAME if boolean_result is true and
+  // FieldComparator::DIFFERENT otherwise.
+  ComparisonResult ResultFromBoolean(bool boolean_result) const;
+
+  FloatComparison float_comparison_;
+
+  // If true, floats and doubles that are both NaN are considered to be
+  // equal. Otherwise, two floats or doubles that are NaN are considered to be
+  // different.
+  bool treat_nan_as_equal_;
+
+  // True iff default_tolerance_ has been explicitly set.
+  //
+  // If false, then the default tolerance for floats and doubles is that which
+  // is used by MathUtil::AlmostEquals().
+  bool has_default_tolerance_;
+
+  // Default float/double tolerance. Only meaningful if
+  // has_default_tolerance_ == true.
+  Tolerance default_tolerance_;
+
+  // Field-specific float/double tolerances, which override any default for
+  // those particular fields.
+  ToleranceMap map_tolerance_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(DefaultFieldComparator);
+};
+
+}  // namespace util
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_UTIL_FIELD_COMPARATOR_H__
diff --git a/kortex_api/include/google/protobuf/util/field_mask_util.h b/kortex_api/include/google/protobuf/util/field_mask_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..01642c6feec67a810c29a1a8a2748ba114fbec62
--- /dev/null
+++ b/kortex_api/include/google/protobuf/util/field_mask_util.h
@@ -0,0 +1,236 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Defines utilities for the FieldMask well known type.
+
+#ifndef GOOGLE_PROTOBUF_UTIL_FIELD_MASK_UTIL_H__
+#define GOOGLE_PROTOBUF_UTIL_FIELD_MASK_UTIL_H__
+
+#include <string>
+
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/field_mask.pb.h>
+#include <google/protobuf/stubs/stringpiece.h>
+
+namespace google {
+namespace protobuf {
+namespace util {
+
+class LIBPROTOBUF_EXPORT FieldMaskUtil {
+  typedef google::protobuf::FieldMask FieldMask;
+
+ public:
+  // Converts FieldMask to/from string, formatted by separating each path
+  // with a comma (e.g., "foo_bar,baz.quz").
+  static string ToString(const FieldMask& mask);
+  static void FromString(StringPiece str, FieldMask* out);
+
+  // Converts FieldMask to/from string, formatted according to proto3 JSON
+  // spec for FieldMask (e.g., "fooBar,baz.quz"). If the field name is not
+  // style conforming (i.e., not snake_case when converted to string, or not
+  // camelCase when converted from string), the conversion will fail.
+  static bool ToJsonString(const FieldMask& mask, string* out);
+  static bool FromJsonString(StringPiece str, FieldMask* out);
+
+  // Get the descriptors of the fields which the given path from the message
+  // descriptor traverses, if field_descriptors is not null.
+  // Return false if the path is not valid, and the content of field_descriptors
+  // is unspecified.
+  static bool GetFieldDescriptors(
+      const Descriptor* descriptor, StringPiece path,
+      std::vector<const FieldDescriptor*>* field_descriptors);
+
+  // Checks whether the given path is valid for type T.
+  template <typename T>
+  static bool IsValidPath(StringPiece path) {
+    return GetFieldDescriptors(T::descriptor(), path, NULL);
+  }
+
+  // Checks whether the given FieldMask is valid for type T.
+  template <typename T>
+  static bool IsValidFieldMask(const FieldMask& mask) {
+    for (int i = 0; i < mask.paths_size(); ++i) {
+      if (!GetFieldDescriptors(T::descriptor(), mask.paths(i), NULL))
+        return false;
+    }
+    return true;
+  }
+
+  // Adds a path to FieldMask after checking whether the given path is valid.
+  // This method check-fails if the path is not a valid path for type T.
+  template <typename T>
+  static void AddPathToFieldMask(StringPiece path, FieldMask* mask) {
+    GOOGLE_CHECK(IsValidPath<T>(path));
+    mask->add_paths(path);
+  }
+
+  // Creates a FieldMask with all fields of type T. This FieldMask only
+  // contains fields of T but not any sub-message fields.
+  template <typename T>
+  static void GetFieldMaskForAllFields(FieldMask* out) {
+    InternalGetFieldMaskForAllFields(T::descriptor(), out);
+  }
+
+  // Converts a FieldMask to the canonical form. It will:
+  //   1. Remove paths that are covered by another path. For example,
+  //      "foo.bar" is covered by "foo" and will be removed if "foo"
+  //      is also in the FieldMask.
+  //   2. Sort all paths in alphabetical order.
+  static void ToCanonicalForm(const FieldMask& mask, FieldMask* out);
+
+  // Creates an union of two FieldMasks.
+  static void Union(const FieldMask& mask1, const FieldMask& mask2,
+                    FieldMask* out);
+
+  // Creates an intersection of two FieldMasks.
+  static void Intersect(const FieldMask& mask1, const FieldMask& mask2,
+                        FieldMask* out);
+
+  // Subtracts mask2 from mask1 base of type T.
+  template <typename T>
+  static void Subtract(const FieldMask& mask1, const FieldMask& mask2,
+                       FieldMask* out) {
+    InternalSubtract(T::descriptor(), mask1, mask2, out);
+  }
+
+  // Returns true if path is covered by the given FieldMask. Note that path
+  // "foo.bar" covers all paths like "foo.bar.baz", "foo.bar.quz.x", etc.
+  static bool IsPathInFieldMask(StringPiece path, const FieldMask& mask);
+
+  class MergeOptions;
+  // Merges fields specified in a FieldMask into another message. See the
+  // comments in MergeOptions regarding compatibility with
+  // google/protobuf/field_mask.proto
+  static void MergeMessageTo(const Message& source, const FieldMask& mask,
+                             const MergeOptions& options, Message* destination);
+
+  class TrimOptions;
+  // Removes from 'message' any field that is not represented in the given
+  // FieldMask. If the FieldMask is empty, does nothing.
+  static void TrimMessage(const FieldMask& mask, Message* message);
+
+  // Removes from 'message' any field that is not represented in the given
+  // FieldMask with customized TrimOptions.
+  // If the FieldMask is empty, does nothing.
+  static void TrimMessage(const FieldMask& mask, Message* message,
+                          const TrimOptions& options);
+
+ private:
+  friend class SnakeCaseCamelCaseTest;
+  // Converts a field name from snake_case to camelCase:
+  //   1. Every character after "_" will be converted to uppercase.
+  //   2. All "_"s are removed.
+  // The conversion will fail if:
+  //   1. The field name contains uppercase letters.
+  //   2. Any character after a "_" is not a lowercase letter.
+  // If the conversion succeeds, it's guaranteed that the resulted
+  // camelCase name will yield the original snake_case name when
+  // converted using CamelCaseToSnakeCase().
+  //
+  // Note that the input can contain characters not allowed in C identifiers.
+  // For example, "foo_bar,baz_quz" will be converted to "fooBar,bazQuz"
+  // successfully.
+  static bool SnakeCaseToCamelCase(StringPiece input, string* output);
+  // Converts a field name from camelCase to snake_case:
+  //   1. Every uppercase letter is converted to lowercase with a additional
+  //      preceding "-".
+  // The conversion will fail if:
+  //   1. The field name contains "_"s.
+  // If the conversion succeeds, it's guaranteed that the resulted
+  // snake_case name will yield the original camelCase name when
+  // converted using SnakeCaseToCamelCase().
+  //
+  // Note that the input can contain characters not allowed in C identifiers.
+  // For example, "fooBar,bazQuz" will be converted to "foo_bar,baz_quz"
+  // successfully.
+  static bool CamelCaseToSnakeCase(StringPiece input, string* output);
+
+  static void InternalGetFieldMaskForAllFields(const Descriptor* descriptor,
+                                               FieldMask* out);
+
+  static void InternalSubtract(const Descriptor* descriptor,
+                               const FieldMask& mask1, const FieldMask& mask2,
+                               FieldMask* out);
+};
+
+// Note that for compatibility with the defined behaviour for FieldMask in
+// google/protobuf/field_mask.proto, set replace_message_fields and
+// replace_repeated_fields to 'true'. The default options are not compatible
+// with google/protobuf/field_mask.proto.
+class LIBPROTOBUF_EXPORT FieldMaskUtil::MergeOptions {
+ public:
+  MergeOptions()
+      : replace_message_fields_(false), replace_repeated_fields_(false) {}
+  // When merging message fields, the default behavior is to merge the
+  // content of two message fields together. If you instead want to use
+  // the field from the source message to replace the corresponding field
+  // in the destination message, set this flag to true. When this flag is set,
+  // specified submessage fields that are missing in source will be cleared in
+  // destination.
+  void set_replace_message_fields(bool value) {
+    replace_message_fields_ = value;
+  }
+  bool replace_message_fields() const { return replace_message_fields_; }
+  // The default merging behavior will append entries from the source
+  // repeated field to the destination repeated field. If you only want
+  // to keep the entries from the source repeated field, set this flag
+  // to true.
+  void set_replace_repeated_fields(bool value) {
+    replace_repeated_fields_ = value;
+  }
+  bool replace_repeated_fields() const { return replace_repeated_fields_; }
+
+ private:
+  bool replace_message_fields_;
+  bool replace_repeated_fields_;
+};
+
+class LIBPROTOBUF_EXPORT FieldMaskUtil::TrimOptions {
+ public:
+  TrimOptions()
+      : keep_required_fields_(false) {}
+  // When trimming message fields, the default behavior is to trim required
+  // fields of the present message if they are not specified in the field mask.
+  // If you instead want to keep required fields of the present message even
+  // they are not speicifed in the field mask, set this flag to true.
+  void set_keep_required_fields(bool value) {
+    keep_required_fields_ = value;
+  }
+  bool keep_required_fields() const { return keep_required_fields_; }
+
+ private:
+  bool keep_required_fields_;
+};
+
+}  // namespace util
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_UTIL_FIELD_MASK_UTIL_H__
diff --git a/kortex_api/include/google/protobuf/util/json_util.h b/kortex_api/include/google/protobuf/util/json_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..dee3ddba99e2553aeead9b9bf72be5b09a9b3f6f
--- /dev/null
+++ b/kortex_api/include/google/protobuf/util/json_util.h
@@ -0,0 +1,200 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Utility functions to convert between protobuf binary format and proto3 JSON
+// format.
+#ifndef GOOGLE_PROTOBUF_UTIL_JSON_UTIL_H__
+#define GOOGLE_PROTOBUF_UTIL_JSON_UTIL_H__
+
+#include <google/protobuf/message.h>
+#include <google/protobuf/util/type_resolver.h>
+#include <google/protobuf/stubs/bytestream.h>
+
+namespace google {
+namespace protobuf {
+namespace io {
+class ZeroCopyInputStream;
+class ZeroCopyOutputStream;
+}  // namespace io
+namespace util {
+
+struct JsonParseOptions {
+  // Whether to ignore unknown JSON fields during parsing
+  bool ignore_unknown_fields;
+
+  JsonParseOptions() : ignore_unknown_fields(false) {}
+};
+
+struct JsonPrintOptions {
+  // Whether to add spaces, line breaks and indentation to make the JSON output
+  // easy to read.
+  bool add_whitespace;
+  // Whether to always print primitive fields. By default primitive fields with
+  // default values will be omitted in JSON joutput. For example, an int32 field
+  // set to 0 will be omitted. Set this flag to true will override the default
+  // behavior and print primitive fields regardless of their values.
+  bool always_print_primitive_fields;
+  // Whether to always print enums as ints. By default they are rendered as
+  // strings.
+  bool always_print_enums_as_ints;
+  // Whether to preserve proto field names
+  bool preserve_proto_field_names;
+
+  JsonPrintOptions()
+      : add_whitespace(false),
+        always_print_primitive_fields(false),
+        always_print_enums_as_ints(false),
+        preserve_proto_field_names(false) {}
+};
+
+// DEPRECATED. Use JsonPrintOptions instead.
+typedef JsonPrintOptions JsonOptions;
+
+// Converts from protobuf message to JSON. This is a simple wrapper of
+// BinaryToJsonString(). It will use the DescriptorPool of the passed-in
+// message to resolve Any types.
+LIBPROTOBUF_EXPORT util::Status MessageToJsonString(const Message& message,
+                                   string* output,
+                                   const JsonOptions& options);
+
+inline util::Status MessageToJsonString(const Message& message,
+                                          string* output) {
+  return MessageToJsonString(message, output, JsonOptions());
+}
+
+// Converts from JSON to protobuf message. This is a simple wrapper of
+// JsonStringToBinary(). It will use the DescriptorPool of the passed-in
+// message to resolve Any types.
+LIBPROTOBUF_EXPORT util::Status JsonStringToMessage(const string& input,
+                                   Message* message,
+                                   const JsonParseOptions& options);
+
+inline util::Status JsonStringToMessage(const string& input,
+                                          Message* message) {
+  return JsonStringToMessage(input, message, JsonParseOptions());
+}
+
+// Converts protobuf binary data to JSON.
+// The conversion will fail if:
+//   1. TypeResolver fails to resolve a type.
+//   2. input is not valid protobuf wire format, or conflicts with the type
+//      information returned by TypeResolver.
+// Note that unknown fields will be discarded silently.
+LIBPROTOBUF_EXPORT util::Status BinaryToJsonStream(
+    TypeResolver* resolver,
+    const string& type_url,
+    io::ZeroCopyInputStream* binary_input,
+    io::ZeroCopyOutputStream* json_output,
+    const JsonPrintOptions& options);
+
+inline util::Status BinaryToJsonStream(
+    TypeResolver* resolver, const string& type_url,
+    io::ZeroCopyInputStream* binary_input,
+    io::ZeroCopyOutputStream* json_output) {
+  return BinaryToJsonStream(resolver, type_url, binary_input, json_output,
+                            JsonPrintOptions());
+}
+
+LIBPROTOBUF_EXPORT util::Status BinaryToJsonString(
+    TypeResolver* resolver,
+    const string& type_url,
+    const string& binary_input,
+    string* json_output,
+    const JsonPrintOptions& options);
+
+inline util::Status BinaryToJsonString(TypeResolver* resolver,
+                                         const string& type_url,
+                                         const string& binary_input,
+                                         string* json_output) {
+  return BinaryToJsonString(resolver, type_url, binary_input, json_output,
+                            JsonPrintOptions());
+}
+
+// Converts JSON data to protobuf binary format.
+// The conversion will fail if:
+//   1. TypeResolver fails to resolve a type.
+//   2. input is not valid JSON format, or conflicts with the type
+//      information returned by TypeResolver.
+LIBPROTOBUF_EXPORT util::Status JsonToBinaryStream(
+    TypeResolver* resolver,
+    const string& type_url,
+    io::ZeroCopyInputStream* json_input,
+    io::ZeroCopyOutputStream* binary_output,
+    const JsonParseOptions& options);
+
+inline util::Status JsonToBinaryStream(
+    TypeResolver* resolver,
+    const string& type_url,
+    io::ZeroCopyInputStream* json_input,
+    io::ZeroCopyOutputStream* binary_output) {
+  return JsonToBinaryStream(resolver, type_url, json_input, binary_output,
+                            JsonParseOptions());
+}
+
+LIBPROTOBUF_EXPORT util::Status JsonToBinaryString(
+    TypeResolver* resolver,
+    const string& type_url,
+    const string& json_input,
+    string* binary_output,
+    const JsonParseOptions& options);
+
+inline util::Status JsonToBinaryString(
+    TypeResolver* resolver,
+    const string& type_url,
+    const string& json_input,
+    string* binary_output) {
+  return JsonToBinaryString(resolver, type_url, json_input, binary_output,
+                            JsonParseOptions());
+}
+
+namespace internal {
+// Internal helper class. Put in the header so we can write unit-tests for it.
+class LIBPROTOBUF_EXPORT ZeroCopyStreamByteSink : public strings::ByteSink {
+ public:
+  explicit ZeroCopyStreamByteSink(io::ZeroCopyOutputStream* stream)
+      : stream_(stream), buffer_(NULL), buffer_size_(0) {}
+  ~ZeroCopyStreamByteSink();
+
+  virtual void Append(const char* bytes, size_t len);
+
+ private:
+  io::ZeroCopyOutputStream* stream_;
+  void* buffer_;
+  int buffer_size_;
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(ZeroCopyStreamByteSink);
+};
+}  // namespace internal
+
+}  // namespace util
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_UTIL_JSON_UTIL_H__
diff --git a/kortex_api/include/google/protobuf/util/message_differencer.h b/kortex_api/include/google/protobuf/util/message_differencer.h
new file mode 100644
index 0000000000000000000000000000000000000000..b7d4de00ab89e5eb5549c25ede063eb27d5d9eee
--- /dev/null
+++ b/kortex_api/include/google/protobuf/util/message_differencer.h
@@ -0,0 +1,879 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: jschorr@google.com (Joseph Schorr)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// This file defines static methods and classes for comparing Protocol
+// Messages.
+//
+// Aug. 2008: Added Unknown Fields Comparison for messages.
+// Aug. 2009: Added different options to compare repeated fields.
+// Apr. 2010: Moved field comparison to FieldComparator.
+
+#ifndef GOOGLE_PROTOBUF_UTIL_MESSAGE_DIFFERENCER_H__
+#define GOOGLE_PROTOBUF_UTIL_MESSAGE_DIFFERENCER_H__
+
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+#include <google/protobuf/descriptor.h>  // FieldDescriptor
+#include <google/protobuf/message.h>  // Message
+#include <google/protobuf/unknown_field_set.h>
+#include <google/protobuf/util/field_comparator.h>
+
+namespace google {
+namespace protobuf {
+
+class DynamicMessageFactory;
+class FieldDescriptor;
+
+namespace io {
+class ZeroCopyOutputStream;
+class Printer;
+}
+
+namespace util {
+
+class FieldContext;  // declared below MessageDifferencer
+
+// A basic differencer that can be used to determine
+// the differences between two specified Protocol Messages. If any differences
+// are found, the Compare method will return false, and any differencer reporter
+// specified via ReportDifferencesTo will have its reporting methods called (see
+// below for implementation of the report). Based off of the original
+// ProtocolDifferencer implementation in //net/proto/protocol-differencer.h
+// (Thanks Todd!).
+//
+// MessageDifferencer REQUIRES that compared messages be the same type, defined
+// as messages that share the same descriptor.  If not, the behavior of this
+// class is undefined.
+//
+// People disagree on what MessageDifferencer should do when asked to compare
+// messages with different descriptors.  Some people think it should always
+// return false.  Others expect it to try to look for similar fields and
+// compare them anyway -- especially if the descriptors happen to be identical.
+// If we chose either of these behaviors, some set of people would find it
+// surprising, and could end up writing code expecting the other behavior
+// without realizing their error.  Therefore, we forbid that usage.
+//
+// This class is implemented based on the proto2 reflection. The performance
+// should be good enough for normal usages. However, for places where the
+// performance is extremely sensitive, there are several alternatives:
+// - Comparing serialized string
+// Downside: false negatives (there are messages that are the same but their
+// serialized strings are different).
+// - Equals code generator by compiler plugin (net/proto2/contrib/equals_plugin)
+// Downside: more generated code; maintenance overhead for the additional rule
+// (must be in sync with the original proto_library).
+//
+// Note on handling of google.protobuf.Any: MessageDifferencer automatically
+// unpacks Any::value into a Message and compares its individual fields.
+// Messages encoded in a repeated Any cannot be compared using TreatAsMap.
+//
+//
+// Note on thread-safety: MessageDifferencer is *not* thread-safe. You need to
+// guard it with a lock to use the same MessageDifferencer instance from
+// multiple threads. Note that it's fine to call static comparison methods
+// (like MessageDifferencer::Equals) concurrently.
+class LIBPROTOBUF_EXPORT MessageDifferencer {
+ public:
+  // Determines whether the supplied messages are equal. Equality is defined as
+  // all fields within the two messages being set to the same value. Primitive
+  // fields and strings are compared by value while embedded messages/groups
+  // are compared as if via a recursive call. Use IgnoreField() and Compare()
+  // if some fields should be ignored in the comparison.
+  //
+  // This method REQUIRES that the two messages have the same
+  // Descriptor (message1.GetDescriptor() == message2.GetDescriptor()).
+  static bool Equals(const Message& message1, const Message& message2);
+
+  // Determines whether the supplied messages are equivalent. Equivalency is
+  // defined as all fields within the two messages having the same value. This
+  // differs from the Equals method above in that fields with default values
+  // are considered set to said value automatically. For details on how default
+  // values are defined for each field type, see http://shortn/_x2Gv6XFrWt.
+  // Also, Equivalent() ignores unknown fields. Use IgnoreField() and Compare()
+  // if some fields should be ignored in the comparison.
+  //
+  // This method REQUIRES that the two messages have the same
+  // Descriptor (message1.GetDescriptor() == message2.GetDescriptor()).
+  static bool Equivalent(const Message& message1, const Message& message2);
+
+  // Determines whether the supplied messages are approximately equal.
+  // Approximate equality is defined as all fields within the two messages
+  // being approximately equal.  Primitive (non-float) fields and strings are
+  // compared by value, floats are compared using MathUtil::AlmostEquals() and
+  // embedded messages/groups are compared as if via a recursive call. Use
+  // IgnoreField() and Compare() if some fields should be ignored in the
+  // comparison.
+  //
+  // This method REQUIRES that the two messages have the same
+  // Descriptor (message1.GetDescriptor() == message2.GetDescriptor()).
+  static bool ApproximatelyEquals(const Message& message1,
+                                  const Message& message2);
+
+  // Determines whether the supplied messages are approximately equivalent.
+  // Approximate equivalency is defined as all fields within the two messages
+  // being approximately equivalent. As in
+  // MessageDifferencer::ApproximatelyEquals, primitive (non-float) fields and
+  // strings are compared by value, floats are compared using
+  // MathUtil::AlmostEquals() and embedded messages/groups are compared as if
+  // via a recursive call. However, fields with default values are considered
+  // set to said value, as per MessageDiffencer::Equivalent. Use IgnoreField()
+  // and Compare() if some fields should be ignored in the comparison.
+  //
+  // This method REQUIRES that the two messages have the same
+  // Descriptor (message1.GetDescriptor() == message2.GetDescriptor()).
+  static bool ApproximatelyEquivalent(const Message& message1,
+                                      const Message& message2);
+
+  // Identifies an individual field in a message instance.  Used for field_path,
+  // below.
+  struct SpecificField {
+    // For known fields, "field" is filled in and "unknown_field_number" is -1.
+    // For unknown fields, "field" is NULL, "unknown_field_number" is the field
+    // number, and "unknown_field_type" is its type.
+    const FieldDescriptor* field;
+    int unknown_field_number;
+    UnknownField::Type unknown_field_type;
+
+    // If this a repeated field, "index" is the index within it.  For unknown
+    // fields, this is the index of the field among all unknown fields of the
+    // same field number and type.
+    int index;
+
+    // If "field" is a repeated field which is being treated as a map or
+    // a set (see TreatAsMap() and TreatAsSet(), below), new_index indicates
+    // the index the position to which the element has moved.  This only
+    // applies to ReportMoved() and (in the case of TreatAsMap())
+    // ReportModified().  In all other cases, "new_index" will have the same
+    // value as "index".
+    int new_index;
+
+    // For unknown fields, these are the pointers to the UnknownFieldSet
+    // containing the unknown fields. In certain cases (e.g. proto1's
+    // MessageSet, or nested groups of unknown fields), these may differ from
+    // the messages' internal UnknownFieldSets.
+    const UnknownFieldSet* unknown_field_set1;
+    const UnknownFieldSet* unknown_field_set2;
+
+    // For unknown fields, these are the index of the field within the
+    // UnknownFieldSets. One or the other will be -1 when
+    // reporting an addition or deletion.
+    int unknown_field_index1;
+    int unknown_field_index2;
+
+    SpecificField()
+        : field(NULL),
+          unknown_field_number(-1),
+          index(-1),
+          new_index(-1),
+          unknown_field_set1(NULL),
+          unknown_field_set2(NULL),
+          unknown_field_index1(-1),
+          unknown_field_index2(-1) {}
+  };
+
+  // Abstract base class from which all MessageDifferencer
+  // reporters derive. The five Report* methods below will be called when
+  // a field has been added, deleted, modified, moved, or matched. The third
+  // argument is a vector of FieldDescriptor pointers which describes the chain
+  // of fields that was taken to find the current field. For example, for a
+  // field found in an embedded message, the vector will contain two
+  // FieldDescriptors. The first will be the field of the embedded message
+  // itself and the second will be the actual field in the embedded message
+  // that was added/deleted/modified.
+  class LIBPROTOBUF_EXPORT Reporter {
+   public:
+    Reporter();
+    virtual ~Reporter();
+
+    // Reports that a field has been added into Message2.
+    virtual void ReportAdded(
+        const Message& message1, const Message& message2,
+        const std::vector<SpecificField>& field_path) = 0;
+
+    // Reports that a field has been deleted from Message1.
+    virtual void ReportDeleted(
+        const Message& message1,
+        const Message& message2,
+        const std::vector<SpecificField>& field_path) = 0;
+
+    // Reports that the value of a field has been modified.
+    virtual void ReportModified(
+        const Message& message1,
+        const Message& message2,
+        const std::vector<SpecificField>& field_path) = 0;
+
+    // Reports that a repeated field has been moved to another location.  This
+    // only applies when using TreatAsSet or TreatAsMap()  -- see below. Also
+    // note that for any given field, ReportModified and ReportMoved are
+    // mutually exclusive. If a field has been both moved and modified, then
+    // only ReportModified will be called.
+    virtual void ReportMoved(
+        const Message& /* message1 */,
+        const Message& /* message2 */,
+        const std::vector<SpecificField>& /* field_path */) { }
+
+    // Reports that two fields match. Useful for doing side-by-side diffs.
+    // This function is mutually exclusive with ReportModified and ReportMoved.
+    // Note that you must call set_report_matches(true) before calling Compare
+    // to make use of this function.
+    virtual void ReportMatched(
+        const Message& /* message1 */,
+        const Message& /* message2 */,
+        const std::vector<SpecificField>& /* field_path */) { }
+
+    // Reports that two fields would have been compared, but the
+    // comparison has been skipped because the field was marked as
+    // 'ignored' using IgnoreField().  This function is mutually
+    // exclusive with all the other Report() functions.
+    //
+    // The contract of ReportIgnored is slightly different than the
+    // other Report() functions, in that |field_path.back().index| is
+    // always equal to -1, even if the last field is repeated. This is
+    // because while the other Report() functions indicate where in a
+    // repeated field the action (Addition, Deletion, etc...)
+    // happened, when a repeated field is 'ignored', the differencer
+    // simply calls ReportIgnored on the repeated field as a whole and
+    // moves on without looking at its individual elements.
+    //
+    // Furthermore, ReportIgnored() does not indicate whether the
+    // fields were in fact equal or not, as Compare() does not inspect
+    // these fields at all. It is up to the Reporter to decide whether
+    // the fields are equal or not (perhaps with a second call to
+    // Compare()), if it cares.
+    virtual void ReportIgnored(
+        const Message& /* message1 */,
+        const Message& /* message2 */,
+        const std::vector<SpecificField>& /* field_path */) { }
+
+    // Report that an unknown field is ignored. (see comment above).
+    // Note this is a different function since the last SpecificField in field
+    // path has a null field.  This could break existing Reporter.
+    virtual void ReportUnknownFieldIgnored(
+        const Message& /* message1 */, const Message& /* message2 */,
+        const std::vector<SpecificField>& /* field_path */) {}
+
+   private:
+    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(Reporter);
+  };
+
+  // MapKeyComparator is used to determine if two elements have the same key
+  // when comparing elements of a repeated field as a map.
+  class LIBPROTOBUF_EXPORT MapKeyComparator {
+   public:
+    MapKeyComparator();
+    virtual ~MapKeyComparator();
+
+    virtual bool IsMatch(
+        const Message& /* message1 */,
+        const Message& /* message2 */,
+        const std::vector<SpecificField>& /* parent_fields */) const {
+      GOOGLE_CHECK(false) << "IsMatch() is not implemented.";
+      return false;
+    }
+
+   private:
+    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MapKeyComparator);
+  };
+
+  // Abstract base class from which all IgnoreCriteria derive.
+  // By adding IgnoreCriteria more complex ignore logic can be implemented.
+  // IgnoreCriteria are registed with AddIgnoreCriteria. For each compared
+  // field IsIgnored is called on each added IgnoreCriteria until one returns
+  // true or all return false.
+  // IsIgnored is called for fields where at least one side has a value.
+  class LIBPROTOBUF_EXPORT IgnoreCriteria {
+   public:
+    IgnoreCriteria();
+    virtual ~IgnoreCriteria();
+
+    // Returns true if the field should be ignored.
+    virtual bool IsIgnored(
+        const Message& /* message1 */,
+        const Message& /* message2 */,
+        const FieldDescriptor* /* field */,
+        const std::vector<SpecificField>& /* parent_fields */) = 0;
+
+    // Returns true if the unknown field should be ignored.
+    // Note: This will be called for unknown fields as well in which case
+    //       field.field will be null.
+    virtual bool IsUnknownFieldIgnored(
+        const Message& /* message1 */, const Message& /* message2 */,
+        const SpecificField& /* field */,
+        const std::vector<SpecificField>& /* parent_fields */) {
+      return false;
+    }
+  };
+
+  // To add a Reporter, construct default here, then use ReportDifferencesTo or
+  // ReportDifferencesToString.
+  explicit MessageDifferencer();
+
+  ~MessageDifferencer();
+
+  enum MessageFieldComparison {
+    EQUAL,       // Fields must be present in both messages
+                 // for the messages to be considered the same.
+    EQUIVALENT,  // Fields with default values are considered set
+                 // for comparison purposes even if not explicitly
+                 // set in the messages themselves.  Unknown fields
+                 // are ignored.
+  };
+
+  enum Scope {
+    FULL,    // All fields of both messages are considered in the comparison.
+    PARTIAL  // Only fields present in the first message are considered; fields
+             // set only in the second message will be skipped during
+             // comparison.
+  };
+
+  // DEPRECATED. Use FieldComparator::FloatComparison instead.
+  enum FloatComparison {
+    EXACT,       // Floats and doubles are compared exactly.
+    APPROXIMATE  // Floats and doubles are compared using the
+                 // MathUtil::AlmostEquals method.
+  };
+
+  enum RepeatedFieldComparison {
+    AS_LIST,     // Repeated fields are compared in order.  Differing values at
+                 // the same index are reported using ReportModified().  If the
+                 // repeated fields have different numbers of elements, the
+                 // unpaired elements are reported using ReportAdded() or
+                 // ReportDeleted().
+    AS_SET,      // Treat all the repeated fields as sets by default.
+                 // See TreatAsSet(), as below.
+  };
+
+  // The elements of the given repeated field will be treated as a set for
+  // diffing purposes, so different orderings of the same elements will be
+  // considered equal.  Elements which are present on both sides of the
+  // comparison but which have changed position will be reported with
+  // ReportMoved().  Elements which only exist on one side or the other are
+  // reported with ReportAdded() and ReportDeleted() regardless of their
+  // positions.  ReportModified() is never used for this repeated field.  If
+  // the only differences between the compared messages is that some fields
+  // have been moved, then the comparison returns true.
+  //
+  // If the scope of comparison is set to PARTIAL, then in addition to what's
+  // above, extra values added to repeated fields of the second message will
+  // not cause the comparison to fail.
+  //
+  // Note that set comparison is currently O(k * n^2) (where n is the total
+  // number of elements, and k is the average size of each element). In theory
+  // it could be made O(n * k) with a more complex hashing implementation. Feel
+  // free to contribute one if the current implementation is too slow for you.
+  // If partial matching is also enabled, the time complexity will be O(k * n^2
+  // + n^3) in which n^3 is the time complexity of the maximum matching
+  // algorithm.
+  //
+  // REQUIRES:  field->is_repeated() and field not registered with TreatAsList
+  void TreatAsSet(const FieldDescriptor* field);
+
+  // The elements of the given repeated field will be treated as a list for
+  // diffing purposes, so different orderings of the same elements will NOT be
+  // considered equal.
+  //
+  // REQUIRED: field->is_repeated() and field not registered with TreatAsSet
+  void TreatAsList(const FieldDescriptor* field);
+
+  // The elements of the given repeated field will be treated as a map for
+  // diffing purposes, with |key| being the map key.  Thus, elements with the
+  // same key will be compared even if they do not appear at the same index.
+  // Differences are reported similarly to TreatAsSet(), except that
+  // ReportModified() is used to report elements with the same key but
+  // different values.  Note that if an element is both moved and modified,
+  // only ReportModified() will be called.  As with TreatAsSet, if the only
+  // differences between the compared messages is that some fields have been
+  // moved, then the comparison returns true. See TreatAsSet for notes on
+  // performance.
+  //
+  // REQUIRES:  field->is_repeated()
+  // REQUIRES:  field->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE
+  // REQUIRES:  key->containing_type() == field->message_type()
+  void TreatAsMap(const FieldDescriptor* field, const FieldDescriptor* key);
+  // Same as TreatAsMap except that this method will use multiple fields as
+  // the key in comparison. All specified fields in 'key_fields' should be
+  // present in the compared elements. Two elements will be treated as having
+  // the same key iff they have the same value for every specified field. There
+  // are two steps in the comparison process. The first one is key matching.
+  // Every element from one message will be compared to every element from
+  // the other message. Only fields in 'key_fields' are compared in this step
+  // to decide if two elements have the same key. The second step is value
+  // comparison. Those pairs of elements with the same key (with equal value
+  // for every field in 'key_fields') will be compared in this step.
+  // Time complexity of the first step is O(s * m * n ^ 2) where s is the
+  // average size of the fields specified in 'key_fields', m is the number of
+  // fields in 'key_fields' and n is the number of elements. If partial
+  // matching is enabled, an extra O(n^3) will be incured by the maximum
+  // matching algorithm. The second step is O(k * n) where k is the average
+  // size of each element.
+  void TreatAsMapWithMultipleFieldsAsKey(
+      const FieldDescriptor* field,
+      const std::vector<const FieldDescriptor*>& key_fields);
+  // Same as TreatAsMapWithMultipleFieldsAsKey, except that each of the field
+  // do not necessarily need to be a direct subfield. Each element in
+  // key_field_paths indicate a path from the message being compared, listing
+  // successive subfield to reach the key field.
+  //
+  // REQUIRES:
+  //   for key_field_path in key_field_paths:
+  //     key_field_path[0]->containing_type() == field->message_type()
+  //     for i in [0, key_field_path.size() - 1):
+  //       key_field_path[i+1]->containing_type() ==
+  //           key_field_path[i]->message_type()
+  //       key_field_path[i]->cpp_type() == FieldDescriptor::CPPTYPE_MESSAGE
+  //       !key_field_path[i]->is_repeated()
+  void TreatAsMapWithMultipleFieldPathsAsKey(
+      const FieldDescriptor* field,
+      const std::vector<std::vector<const FieldDescriptor*> >& key_field_paths);
+
+  // Uses a custom MapKeyComparator to determine if two elements have the same
+  // key when comparing a repeated field as a map.
+  // The caller is responsible to delete the key_comparator.
+  // This method varies from TreatAsMapWithMultipleFieldsAsKey only in the
+  // first key matching step. Rather than comparing some specified fields, it
+  // will invoke the IsMatch method of the given 'key_comparator' to decide if
+  // two elements have the same key.
+  void TreatAsMapUsingKeyComparator(
+      const FieldDescriptor* field,
+      const MapKeyComparator* key_comparator);
+
+  // Add a custom ignore criteria that is evaluated in addition to the
+  // ignored fields added with IgnoreField.
+  // Takes ownership of ignore_criteria.
+  void AddIgnoreCriteria(IgnoreCriteria* ignore_criteria);
+
+  // Indicates that any field with the given descriptor should be
+  // ignored for the purposes of comparing two messages. This applies
+  // to fields nested in the message structure as well as top level
+  // ones. When the MessageDifferencer encounters an ignored field,
+  // ReportIgnored is called on the reporter, if one is specified.
+  //
+  // The only place where the field's 'ignored' status is not applied is when
+  // it is being used as a key in a field passed to TreatAsMap or is one of
+  // the fields passed to TreatAsMapWithMultipleFieldsAsKey.
+  // In this case it is compared in key matching but after that it's ignored
+  // in value comparison.
+  void IgnoreField(const FieldDescriptor* field);
+
+  // Sets the field comparator used to determine differences between protocol
+  // buffer fields. By default it's set to a DefaultFieldComparator instance.
+  // MessageDifferencer doesn't take ownership over the passed object.
+  // Note that this method must be called before Compare for the comparator to
+  // be used.
+  void set_field_comparator(FieldComparator* comparator);
+
+  // DEPRECATED. Pass a DefaultFieldComparator instance instead.
+  // Sets the fraction and margin for the float comparison of a given field.
+  // Uses MathUtil::WithinFractionOrMargin to compare the values.
+  // NOTE: this method does nothing if differencer's field comparator has been
+  //       set to a custom object.
+  //
+  // REQUIRES: field->cpp_type == FieldDescriptor::CPPTYPE_DOUBLE or
+  //           field->cpp_type == FieldDescriptor::CPPTYPE_FLOAT
+  // REQUIRES: float_comparison_ == APPROXIMATE
+  void SetFractionAndMargin(const FieldDescriptor* field, double fraction,
+                            double margin);
+
+  // Sets the type of comparison (as defined in the MessageFieldComparison
+  // enumeration above) that is used by this differencer when determining how
+  // to compare fields in messages.
+  void set_message_field_comparison(MessageFieldComparison comparison);
+
+  // Tells the differencer whether or not to report matches. This method must
+  // be called before Compare. The default for a new differencer is false.
+  void set_report_matches(bool report_matches) {
+    report_matches_ = report_matches;
+  }
+
+  // Tells the differencer whether or not to report moves (in a set or map
+  // repeated field). This method must be called before Compare. The default for
+  // a new differencer is true.
+  void set_report_moves(bool report_moves) {
+    report_moves_ = report_moves;
+  }
+
+  // Sets the scope of the comparison (as defined in the Scope enumeration
+  // above) that is used by this differencer when determining which fields to
+  // compare between the messages.
+  void set_scope(Scope scope);
+
+  // Returns the current scope used by this differencer.
+  Scope scope();
+
+  // DEPRECATED. Pass a DefaultFieldComparator instance instead.
+  // Sets the type of comparison (as defined in the FloatComparison enumeration
+  // above) that is used by this differencer when comparing float (and double)
+  // fields in messages.
+  // NOTE: this method does nothing if differencer's field comparator has been
+  //       set to a custom object.
+  void set_float_comparison(FloatComparison comparison);
+
+  // Sets the type of comparison for repeated field (as defined in the
+  // RepeatedFieldComparison enumeration above) that is used by this
+  // differencer when compare repeated fields in messages.
+  void set_repeated_field_comparison(RepeatedFieldComparison comparison);
+
+  // Compares the two specified messages, returning true if they are the same,
+  // false otherwise. If this method returns false, any changes between the
+  // two messages will be reported if a Reporter was specified via
+  // ReportDifferencesTo (see also ReportDifferencesToString).
+  //
+  // This method REQUIRES that the two messages have the same
+  // Descriptor (message1.GetDescriptor() == message2.GetDescriptor()).
+  bool Compare(const Message& message1, const Message& message2);
+
+  // Same as above, except comparing only the list of fields specified by the
+  // two vectors of FieldDescriptors.
+  bool CompareWithFields(
+      const Message& message1, const Message& message2,
+      const std::vector<const FieldDescriptor*>& message1_fields,
+      const std::vector<const FieldDescriptor*>& message2_fields);
+
+  // Automatically creates a reporter that will output the differences
+  // found (if any) to the specified output string pointer. Note that this
+  // method must be called before Compare.
+  void ReportDifferencesToString(string* output);
+
+  // Tells the MessageDifferencer to report differences via the specified
+  // reporter. Note that this method must be called before Compare for
+  // the reporter to be used. It is the responsibility of the caller to delete
+  // this object.
+  // If the provided pointer equals NULL, the MessageDifferencer stops reporting
+  // differences to any previously set reporters or output strings.
+  void ReportDifferencesTo(Reporter* reporter);
+
+  // An implementation of the MessageDifferencer Reporter that outputs
+  // any differences found in human-readable form to the supplied
+  // ZeroCopyOutputStream or Printer. If a printer is used, the delimiter
+  // *must* be '$'.
+  //
+  // WARNING: this reporter does not necessarily flush its output until it is
+  // destroyed. As a result, it is not safe to assume the output is valid or
+  // complete until after you destroy the reporter. For example, if you use a
+  // StreamReporter to write to a StringOutputStream, the target string may
+  // contain uninitialized data until the reporter is destroyed.
+  class LIBPROTOBUF_EXPORT StreamReporter : public Reporter {
+   public:
+    explicit StreamReporter(io::ZeroCopyOutputStream* output);
+    explicit StreamReporter(io::Printer* printer);  // delimiter '$'
+    virtual ~StreamReporter();
+
+    // When set to true, the stream reporter will also output aggregates nodes
+    // (i.e. messages and groups) whose subfields have been modified. When
+    // false, will only report the individual subfields. Defaults to false.
+    void set_report_modified_aggregates(bool report) {
+      report_modified_aggregates_ = report;
+    }
+
+    // The following are implementations of the methods described above.
+    virtual void ReportAdded(const Message& message1, const Message& message2,
+                             const std::vector<SpecificField>& field_path);
+
+    virtual void ReportDeleted(const Message& message1,
+                               const Message& message2,
+                               const std::vector<SpecificField>& field_path);
+
+    virtual void ReportModified(const Message& message1,
+                                const Message& message2,
+                                const std::vector<SpecificField>& field_path);
+
+    virtual void ReportMoved(const Message& message1,
+                             const Message& message2,
+                             const std::vector<SpecificField>& field_path);
+
+    virtual void ReportMatched(const Message& message1,
+                               const Message& message2,
+                               const std::vector<SpecificField>& field_path);
+
+    virtual void ReportIgnored(const Message& message1,
+                               const Message& message2,
+                               const std::vector<SpecificField>& field_path);
+
+    virtual void ReportUnknownFieldIgnored(
+        const Message& message1, const Message& message2,
+        const std::vector<SpecificField>& field_path);
+
+   protected:
+    // Prints the specified path of fields to the buffer.  message is used to
+    // print map keys.
+    virtual void PrintPath(const std::vector<SpecificField>& field_path,
+                           bool left_side, const Message& message);
+
+    // Prints the specified path of fields to the buffer.
+    virtual void PrintPath(const std::vector<SpecificField>& field_path,
+                           bool left_side);
+
+    // Prints the value of fields to the buffer.  left_side is true if the
+    // given message is from the left side of the comparison, false if it
+    // was the right.  This is relevant only to decide whether to follow
+    // unknown_field_index1 or unknown_field_index2 when an unknown field
+    // is encountered in field_path.
+    virtual void PrintValue(const Message& message,
+                            const std::vector<SpecificField>& field_path,
+                            bool left_side);
+
+    // Prints the specified path of unknown fields to the buffer.
+    virtual void PrintUnknownFieldValue(const UnknownField* unknown_field);
+
+    // Just print a string
+    void Print(const string& str);
+
+   private:
+    io::Printer* printer_;
+    bool delete_printer_;
+    bool report_modified_aggregates_;
+
+    GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(StreamReporter);
+  };
+
+ private:
+  // A MapKeyComparator to be used in TreatAsMapUsingKeyComparator.
+  // Implementation of this class needs to do field value comparison which
+  // relies on some private methods of MessageDifferencer. That's why this
+  // class is declared as a nested class of MessageDifferencer.
+  class MultipleFieldsMapKeyComparator;
+
+  // A MapKeyComparator for use with map_entries.
+  class LIBPROTOBUF_EXPORT MapEntryKeyComparator : public MapKeyComparator {
+   public:
+    explicit MapEntryKeyComparator(MessageDifferencer* message_differencer);
+    virtual bool IsMatch(const Message& message1, const Message& message2,
+                         const std::vector<SpecificField>& parent_fields) const;
+
+   private:
+    MessageDifferencer* message_differencer_;
+  };
+
+  // Returns true if field1's number() is less than field2's.
+  static bool FieldBefore(const FieldDescriptor* field1,
+                          const FieldDescriptor* field2);
+
+  // Combine the two lists of fields into the combined_fields output vector.
+  // All fields present in both lists will always be included in the combined
+  // list.  Fields only present in one of the lists will only appear in the
+  // combined list if the corresponding fields_scope option is set to FULL.
+  void CombineFields(const std::vector<const FieldDescriptor*>& fields1,
+                     Scope fields1_scope,
+                     const std::vector<const FieldDescriptor*>& fields2,
+                     Scope fields2_scope,
+                     std::vector<const FieldDescriptor*>* combined_fields);
+
+  // Internal version of the Compare method which performs the actual
+  // comparison. The parent_fields vector is a vector containing field
+  // descriptors of all fields accessed to get to this comparison operation
+  // (i.e. if the current message is an embedded message, the parent_fields
+  // vector will contain the field that has this embedded message).
+  bool Compare(const Message& message1, const Message& message2,
+               std::vector<SpecificField>* parent_fields);
+
+  // Compares all the unknown fields in two messages.
+  bool CompareUnknownFields(const Message& message1, const Message& message2,
+                            const google::protobuf::UnknownFieldSet&,
+                            const google::protobuf::UnknownFieldSet&,
+                            std::vector<SpecificField>* parent_fields);
+
+  // Compares the specified messages for the requested field lists. The field
+  // lists are modified depending on comparison settings, and then passed to
+  // CompareWithFieldsInternal.
+  bool CompareRequestedFieldsUsingSettings(
+      const Message& message1, const Message& message2,
+      const std::vector<const FieldDescriptor*>& message1_fields,
+      const std::vector<const FieldDescriptor*>& message2_fields,
+      std::vector<SpecificField>* parent_fields);
+
+  // Compares the specified messages with the specified field lists.
+  bool CompareWithFieldsInternal(
+      const Message& message1, const Message& message2,
+      const std::vector<const FieldDescriptor*>& message1_fields,
+      const std::vector<const FieldDescriptor*>& message2_fields,
+      std::vector<SpecificField>* parent_fields);
+
+  // Compares the repeated fields, and report the error.
+  bool CompareRepeatedField(const Message& message1, const Message& message2,
+                            const FieldDescriptor* field,
+                            std::vector<SpecificField>* parent_fields);
+
+  // Shorthand for CompareFieldValueUsingParentFields with NULL parent_fields.
+  bool CompareFieldValue(const Message& message1,
+                         const Message& message2,
+                         const FieldDescriptor* field,
+                         int index1,
+                         int index2);
+
+  // Compares the specified field on the two messages, returning
+  // true if they are the same, false otherwise. For repeated fields,
+  // this method only compares the value in the specified index. This method
+  // uses Compare functions to recurse into submessages.
+  // The parent_fields vector is used in calls to a Reporter instance calls.
+  // It can be NULL, in which case the MessageDifferencer will create new
+  // list of parent messages if it needs to recursively compare the given field.
+  // To avoid confusing users you should not set it to NULL unless you modified
+  // Reporter to handle the change of parent_fields correctly.
+  bool CompareFieldValueUsingParentFields(
+      const Message& message1,
+      const Message& message2,
+      const FieldDescriptor* field,
+      int index1,
+      int index2,
+      std::vector<SpecificField>* parent_fields);
+
+  // Compares the specified field on the two messages, returning comparison
+  // result, as returned by appropriate FieldComparator.
+  FieldComparator::ComparisonResult GetFieldComparisonResult(
+      const Message& message1, const Message& message2,
+      const FieldDescriptor* field, int index1, int index2,
+      const FieldContext* field_context);
+
+  // Check if the two elements in the repeated field are match to each other.
+  // if the key_comprator is NULL, this function returns true when the two
+  // elements are equal.
+  bool IsMatch(const FieldDescriptor* repeated_field,
+               const MapKeyComparator* key_comparator,
+               const Message* message1, const Message* message2,
+               const std::vector<SpecificField>& parent_fields,
+               int index1, int index2);
+
+  // Returns true when this repeated field has been configured to be treated
+  // as a set.
+  bool IsTreatedAsSet(const FieldDescriptor* field);
+
+  // Returns true when this repeated field is to be compared as a subset, ie.
+  // has been configured to be treated as a set or map and scope is set to
+  // PARTIAL.
+  bool IsTreatedAsSubset(const FieldDescriptor* field);
+
+  // Returns true if this field is to be ignored when this
+  // MessageDifferencer compares messages.
+  bool IsIgnored(
+      const Message& message1,
+      const Message& message2,
+      const FieldDescriptor* field,
+      const std::vector<SpecificField>& parent_fields);
+
+  // Returns true if this unknown field is to be ignored when this
+  // MessageDifferencer compares messages.
+  bool IsUnknownFieldIgnored(const Message& message1, const Message& message2,
+                             const SpecificField& field,
+                             const std::vector<SpecificField>& parent_fields);
+
+  // Returns MapKeyComparator* when this field has been configured to be treated
+  // as a map or its is_map() return true.  If not, returns NULL.
+  const MapKeyComparator* GetMapKeyComparator(
+      const FieldDescriptor* field) const;
+
+  // Attempts to match indices of a repeated field, so that the contained values
+  // match. Clears output vectors and sets their values to indices of paired
+  // messages, ie. if message1[0] matches message2[1], then match_list1[0] == 1
+  // and match_list2[1] == 0. The unmatched indices are indicated by -1.
+  // This method returns false if the match failed. However, it doesn't mean
+  // that the comparison succeeds when this method returns true (you need to
+  // double-check in this case).
+  bool MatchRepeatedFieldIndices(
+      const Message& message1,
+      const Message& message2,
+      const FieldDescriptor* repeated_field,
+      const std::vector<SpecificField>& parent_fields,
+      std::vector<int>* match_list1,
+      std::vector<int>* match_list2);
+
+  // If "any" is of type google.protobuf.Any, extract its payload using
+  // DynamicMessageFactory and store in "data".
+  bool UnpackAny(const Message& any, google::protobuf::scoped_ptr<Message>* data);
+
+  // Checks if index is equal to new_index in all the specific fields.
+  static bool CheckPathChanged(const std::vector<SpecificField>& parent_fields);
+
+  // Defines a map between field descriptors and their MapKeyComparators.
+  // Used for repeated fields when they are configured as TreatAsMap.
+  typedef std::map<const FieldDescriptor*,
+              const MapKeyComparator*> FieldKeyComparatorMap;
+
+  // Defines a set to store field descriptors.  Used for repeated fields when
+  // they are configured as TreatAsSet.
+  typedef std::set<const FieldDescriptor*> FieldSet;
+
+  Reporter* reporter_;
+  DefaultFieldComparator default_field_comparator_;
+  FieldComparator* field_comparator_;
+  MessageFieldComparison message_field_comparison_;
+  Scope scope_;
+  RepeatedFieldComparison repeated_field_comparison_;
+
+  FieldSet set_fields_;
+  FieldSet list_fields_;
+  // Keeps track of MapKeyComparators that are created within
+  // MessageDifferencer. These MapKeyComparators should be deleted
+  // before MessageDifferencer is destroyed.
+  // When TreatAsMap or TreatAsMapWithMultipleFieldsAsKey is called, we don't
+  // store the supplied FieldDescriptors directly. Instead, a new
+  // MapKeyComparator is created for comparison purpose.
+  std::vector<MapKeyComparator*> owned_key_comparators_;
+  FieldKeyComparatorMap map_field_key_comparator_;
+  MapEntryKeyComparator map_entry_key_comparator_;
+  std::vector<IgnoreCriteria*> ignore_criteria_;
+
+  FieldSet ignored_fields_;
+
+  bool report_matches_;
+  bool report_moves_;
+
+  string* output_string_;
+
+  google::protobuf::scoped_ptr<DynamicMessageFactory> dynamic_message_factory_;
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(MessageDifferencer);
+};
+
+// This class provides extra information to the FieldComparator::Compare
+// function.
+class LIBPROTOBUF_EXPORT FieldContext {
+ public:
+  explicit FieldContext(
+      std::vector<MessageDifferencer::SpecificField>* parent_fields)
+      : parent_fields_(parent_fields) {}
+
+  std::vector<MessageDifferencer::SpecificField>* parent_fields() const {
+    return parent_fields_;
+  }
+
+ private:
+  std::vector<MessageDifferencer::SpecificField>* parent_fields_;
+};
+
+}
+}
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_UTIL_MESSAGE_DIFFERENCER_H__
diff --git a/kortex_api/include/google/protobuf/util/time_util.h b/kortex_api/include/google/protobuf/util/time_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..b8846935a7887f4877af4a6818163dedc03190f4
--- /dev/null
+++ b/kortex_api/include/google/protobuf/util/time_util.h
@@ -0,0 +1,296 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Defines utilities for the Timestamp and Duration well known types.
+
+#ifndef GOOGLE_PROTOBUF_UTIL_TIME_UTIL_H__
+#define GOOGLE_PROTOBUF_UTIL_TIME_UTIL_H__
+
+#include <ctime>
+#include <ostream>
+#include <string>
+#ifdef _MSC_VER
+#include <winsock2.h>
+#else
+#include <sys/time.h>
+#endif
+
+#include <google/protobuf/duration.pb.h>
+#include <google/protobuf/timestamp.pb.h>
+
+namespace google {
+namespace protobuf {
+namespace util {
+
+// Utility functions for Timestamp and Duration.
+class LIBPROTOBUF_EXPORT TimeUtil {
+  typedef google::protobuf::Timestamp Timestamp;
+  typedef google::protobuf::Duration Duration;
+
+ public:
+  // The min/max Timestamp/Duration values we support.
+  //
+  // For "0001-01-01T00:00:00Z".
+  static const int64 kTimestampMinSeconds = -62135596800LL;
+  // For "9999-12-31T23:59:59.999999999Z".
+  static const int64 kTimestampMaxSeconds = 253402300799LL;
+  static const int64 kDurationMinSeconds = -315576000000LL;
+  static const int64 kDurationMaxSeconds = 315576000000LL;
+
+  // Converts Timestamp to/from RFC 3339 date string format.
+  // Generated output will always be Z-normalized and uses 3, 6 or 9
+  // fractional digits as required to represent the exact time. When
+  // parsing, any fractional digits (or none) and any offset are
+  // accepted as long as they fit into nano-seconds precision.
+  // Note that Timestamp can only represent time from
+  // 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z. Converting
+  // a Timestamp outside of this range is undefined behavior.
+  // See https://www.ietf.org/rfc/rfc3339.txt
+  //
+  // Example of generated format:
+  //   "1972-01-01T10:00:20.021Z"
+  //
+  // Example of accepted format:
+  //   "1972-01-01T10:00:20.021-05:00"
+  static string ToString(const Timestamp& timestamp);
+  static bool FromString(const string& value, Timestamp* timestamp);
+
+  // Converts Duration to/from string format. The string format will contains
+  // 3, 6, or 9 fractional digits depending on the precision required to
+  // represent the exact Duration value. For example:
+  //   "1s", "1.010s", "1.000000100s", "-3.100s"
+  // The range that can be represented by Duration is from -315,576,000,000
+  // to +315,576,000,000 inclusive (in seconds).
+  static string ToString(const Duration& duration);
+  static bool FromString(const string& value, Duration* timestamp);
+
+#ifdef GetCurrentTime
+#undef GetCurrentTime  // Visual Studio has macro GetCurrentTime
+#endif
+  // Gets the current UTC time.
+  static Timestamp GetCurrentTime();
+  // Returns the Time representing "1970-01-01 00:00:00".
+  static Timestamp GetEpoch();
+
+  // Converts between Duration and integer types. The behavior is undefined if
+  // the input value is not in the valid range of Duration.
+  static Duration NanosecondsToDuration(int64 nanos);
+  static Duration MicrosecondsToDuration(int64 micros);
+  static Duration MillisecondsToDuration(int64 millis);
+  static Duration SecondsToDuration(int64 seconds);
+  static Duration MinutesToDuration(int64 minutes);
+  static Duration HoursToDuration(int64 hours);
+  // Result will be truncated towards zero. For example, "-1.5s" will be
+  // truncated to "-1s", and "1.5s" to "1s" when converting to seconds.
+  // It's undefined behavior if the input duration is not valid or the result
+  // exceeds the range of int64. A duration is not valid if it's not in the
+  // valid range of Duration, or have an invalid nanos value (i.e., larger
+  // than 999999999, less than -999999999, or have a different sign from the
+  // seconds part).
+  static int64 DurationToNanoseconds(const Duration& duration);
+  static int64 DurationToMicroseconds(const Duration& duration);
+  static int64 DurationToMilliseconds(const Duration& duration);
+  static int64 DurationToSeconds(const Duration& duration);
+  static int64 DurationToMinutes(const Duration& duration);
+  static int64 DurationToHours(const Duration& duration);
+  // Creates Timestamp from integer types. The integer value indicates the
+  // time elapsed from Epoch time. The behavior is undefined if the input
+  // value is not in the valid range of Timestamp.
+  static Timestamp NanosecondsToTimestamp(int64 nanos);
+  static Timestamp MicrosecondsToTimestamp(int64 micros);
+  static Timestamp MillisecondsToTimestamp(int64 millis);
+  static Timestamp SecondsToTimestamp(int64 seconds);
+  // Result will be truncated down to the nearest integer value. For example,
+  // with "1969-12-31T23:59:59.9Z", TimestampToMilliseconds() returns -100
+  // and TimestampToSeconds() returns -1. It's undefined behavior if the input
+  // Timestamp is not valid (i.e., its seconds part or nanos part does not fall
+  // in the valid range) or the return value doesn't fit into int64.
+  static int64 TimestampToNanoseconds(const Timestamp& timestamp);
+  static int64 TimestampToMicroseconds(const Timestamp& timestamp);
+  static int64 TimestampToMilliseconds(const Timestamp& timestamp);
+  static int64 TimestampToSeconds(const Timestamp& timestamp);
+
+  // Conversion to/from other time/date types. Note that these types may
+  // have a different precision and time range from Timestamp/Duration.
+  // When converting to a lower precision type, the value will be truncated
+  // to the nearest value that can be represented. If the value is
+  // out of the range of the result type, the return value is undefined.
+  //
+  // Conversion to/from time_t
+  static Timestamp TimeTToTimestamp(time_t value);
+  static time_t TimestampToTimeT(const Timestamp& value);
+
+  // Conversion to/from timeval
+  static Timestamp TimevalToTimestamp(const timeval& value);
+  static timeval TimestampToTimeval(const Timestamp& value);
+  static Duration TimevalToDuration(const timeval& value);
+  static timeval DurationToTimeval(const Duration& value);
+};
+
+}  // namespace util
+}  // namespace protobuf
+
+
+namespace protobuf {
+// Overloaded operators for Duration.
+//
+// Assignment operators.
+LIBPROTOBUF_EXPORT Duration& operator+=(Duration& d1, const Duration& d2);  // NOLINT
+LIBPROTOBUF_EXPORT Duration& operator-=(Duration& d1, const Duration& d2);  // NOLINT
+LIBPROTOBUF_EXPORT Duration& operator*=(Duration& d, int64 r);  // NOLINT
+LIBPROTOBUF_EXPORT Duration& operator*=(Duration& d, double r);  // NOLINT
+LIBPROTOBUF_EXPORT Duration& operator/=(Duration& d, int64 r);  // NOLINT
+LIBPROTOBUF_EXPORT Duration& operator/=(Duration& d, double r);  // NOLINT
+// Overload for other integer types.
+template <typename T>
+Duration& operator*=(Duration& d, T r) {  // NOLINT
+  int64 x = r;
+  return d *= x;
+}
+template <typename T>
+Duration& operator/=(Duration& d, T r) {  // NOLINT
+  int64 x = r;
+  return d /= x;
+}
+LIBPROTOBUF_EXPORT Duration& operator%=(Duration& d1, const Duration& d2);  // NOLINT
+// Relational operators.
+inline bool operator<(const Duration& d1, const Duration& d2) {
+  if (d1.seconds() == d2.seconds()) {
+    return d1.nanos() < d2.nanos();
+  }
+  return d1.seconds() < d2.seconds();
+}
+inline bool operator>(const Duration& d1, const Duration& d2) {
+  return d2 < d1;
+}
+inline bool operator>=(const Duration& d1, const Duration& d2) {
+  return !(d1 < d2);
+}
+inline bool operator<=(const Duration& d1, const Duration& d2) {
+  return !(d2 < d1);
+}
+inline bool operator==(const Duration& d1, const Duration& d2) {
+  return d1.seconds() == d2.seconds() && d1.nanos() == d2.nanos();
+}
+inline bool operator!=(const Duration& d1, const Duration& d2) {
+  return !(d1 == d2);
+}
+// Additive operators
+inline Duration operator-(const Duration& d) {
+  Duration result;
+  result.set_seconds(-d.seconds());
+  result.set_nanos(-d.nanos());
+  return result;
+}
+inline Duration operator+(const Duration& d1, const Duration& d2) {
+  Duration result = d1;
+  return result += d2;
+}
+inline Duration operator-(const Duration& d1, const Duration& d2) {
+  Duration result = d1;
+  return result -= d2;
+}
+// Multiplicative operators
+template<typename T>
+inline Duration operator*(Duration d, T r) {
+  return d *= r;
+}
+template<typename T>
+inline Duration operator*(T r, Duration d) {
+  return d *= r;
+}
+template<typename T>
+inline Duration operator/(Duration d, T r) {
+  return d /= r;
+}
+LIBPROTOBUF_EXPORT int64 operator/(const Duration& d1, const Duration& d2);
+
+inline Duration operator%(const Duration& d1, const Duration& d2) {
+  Duration result = d1;
+  return result %= d2;
+}
+
+inline std::ostream& operator<<(std::ostream& out, const Duration& d) {
+  out << google::protobuf::util::TimeUtil::ToString(d);
+  return out;
+}
+
+// Overloaded operators for Timestamp
+//
+// Assignement operators.
+LIBPROTOBUF_EXPORT Timestamp& operator+=(Timestamp& t, const Duration& d);  // NOLINT
+LIBPROTOBUF_EXPORT Timestamp& operator-=(Timestamp& t, const Duration& d);  // NOLINT
+// Relational operators.
+inline bool operator<(const Timestamp& t1, const Timestamp& t2) {
+  if (t1.seconds() == t2.seconds()) {
+    return t1.nanos() < t2.nanos();
+  }
+  return t1.seconds() < t2.seconds();
+}
+inline bool operator>(const Timestamp& t1, const Timestamp& t2) {
+  return t2 < t1;
+}
+inline bool operator>=(const Timestamp& t1, const Timestamp& t2) {
+  return !(t1 < t2);
+}
+inline bool operator<=(const Timestamp& t1, const Timestamp& t2) {
+  return !(t2 < t1);
+}
+inline bool operator==(const Timestamp& t1, const Timestamp& t2) {
+  return t1.seconds() == t2.seconds() && t1.nanos() == t2.nanos();
+}
+inline bool operator!=(const Timestamp& t1, const Timestamp& t2) {
+  return !(t1 == t2);
+}
+// Additive operators.
+inline Timestamp operator+(const Timestamp& t, const Duration& d) {
+  Timestamp result = t;
+  return result += d;
+}
+inline Timestamp operator+(const Duration& d, const Timestamp& t) {
+  Timestamp result = t;
+  return result += d;
+}
+inline Timestamp operator-(const Timestamp& t, const Duration& d) {
+  Timestamp result = t;
+  return result -= d;
+}
+LIBPROTOBUF_EXPORT Duration operator-(const Timestamp& t1, const Timestamp& t2);
+
+inline std::ostream& operator<<(std::ostream& out, const Timestamp& t) {
+  out << google::protobuf::util::TimeUtil::ToString(t);
+  return out;
+}
+
+}  // namespace protobuf
+
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_UTIL_TIME_UTIL_H__
diff --git a/kortex_api/include/google/protobuf/util/type_resolver.h b/kortex_api/include/google/protobuf/util/type_resolver.h
new file mode 100644
index 0000000000000000000000000000000000000000..959f3c79330b271fcf9fb869e205c26b14c37224
--- /dev/null
+++ b/kortex_api/include/google/protobuf/util/type_resolver.h
@@ -0,0 +1,77 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Defines a TypeResolver for the Any message.
+
+#ifndef GOOGLE_PROTOBUF_UTIL_TYPE_RESOLVER_H__
+#define GOOGLE_PROTOBUF_UTIL_TYPE_RESOLVER_H__
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/status.h>
+
+
+namespace google {
+namespace protobuf {
+class Type;
+class Enum;
+}  // namespace protobuf
+
+
+namespace protobuf {
+class DescriptorPool;
+namespace util {
+
+// Abstract interface for a type resovler.
+//
+// Implementations of this interface must be thread-safe.
+class LIBPROTOBUF_EXPORT TypeResolver {
+ public:
+  TypeResolver() {}
+  virtual ~TypeResolver() {}
+
+  // Resolves a type url for a message type.
+  virtual util::Status ResolveMessageType(
+      const string& type_url, google::protobuf::Type* message_type) = 0;
+
+  // Resolves a type url for an enum type.
+  virtual util::Status ResolveEnumType(const string& type_url,
+                                         google::protobuf::Enum* enum_type) = 0;
+
+ private:
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(TypeResolver);
+};
+
+}  // namespace util
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_UTIL_TYPE_RESOLVER_H__
diff --git a/kortex_api/include/google/protobuf/util/type_resolver_util.h b/kortex_api/include/google/protobuf/util/type_resolver_util.h
new file mode 100644
index 0000000000000000000000000000000000000000..c17366fc793c44d56d8d71f2f5787a8baed81c2f
--- /dev/null
+++ b/kortex_api/include/google/protobuf/util/type_resolver_util.h
@@ -0,0 +1,54 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Defines utilities for the TypeResolver.
+
+#ifndef GOOGLE_PROTOBUF_UTIL_TYPE_RESOLVER_UTIL_H__
+#define GOOGLE_PROTOBUF_UTIL_TYPE_RESOLVER_UTIL_H__
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+namespace google {
+namespace protobuf {
+class DescriptorPool;
+namespace util {
+class TypeResolver;
+
+// Creates a TypeResolver that serves type information in the given descriptor
+// pool. Caller takes ownership of the returned TypeResolver.
+LIBPROTOBUF_EXPORT TypeResolver* NewTypeResolverForDescriptorPool(
+    const string& url_prefix, const DescriptorPool* pool);
+
+}  // namespace util
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_UTIL_TYPE_RESOLVER_UTIL_H__
diff --git a/kortex_api/include/google/protobuf/wire_format.h b/kortex_api/include/google/protobuf/wire_format.h
new file mode 100644
index 0000000000000000000000000000000000000000..d602d214be2645dc05d0927e2951551871534538
--- /dev/null
+++ b/kortex_api/include/google/protobuf/wire_format.h
@@ -0,0 +1,335 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//         atenasio@google.com (Chris Atenasio) (ZigZag transform)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// This header is logically internal, but is made public because it is used
+// from protocol-compiler-generated code, which may reside in other components.
+
+#ifndef GOOGLE_PROTOBUF_WIRE_FORMAT_H__
+#define GOOGLE_PROTOBUF_WIRE_FORMAT_H__
+
+#include <string>
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/wire_format_lite.h>
+
+namespace google {
+namespace protobuf {
+  namespace io {
+    class CodedInputStream;      // coded_stream.h
+    class CodedOutputStream;     // coded_stream.h
+  }
+  class UnknownFieldSet;         // unknown_field_set.h
+}
+
+namespace protobuf {
+namespace internal {
+
+// This class is for internal use by the protocol buffer library and by
+// protocol-complier-generated message classes.  It must not be called
+// directly by clients.
+//
+// This class contains code for implementing the binary protocol buffer
+// wire format via reflection.  The WireFormatLite class implements the
+// non-reflection based routines.
+//
+// This class is really a namespace that contains only static methods
+class LIBPROTOBUF_EXPORT WireFormat {
+ public:
+
+  // Given a field return its WireType
+  static inline WireFormatLite::WireType WireTypeForField(
+      const FieldDescriptor* field);
+
+  // Given a FieldDescriptor::Type return its WireType
+  static inline WireFormatLite::WireType WireTypeForFieldType(
+      FieldDescriptor::Type type);
+
+  // Compute the byte size of a tag.  For groups, this includes both the start
+  // and end tags.
+  static inline size_t TagSize(int field_number, FieldDescriptor::Type type);
+
+  // These procedures can be used to implement the methods of Message which
+  // handle parsing and serialization of the protocol buffer wire format
+  // using only the Reflection interface.  When you ask the protocol
+  // compiler to optimize for code size rather than speed, it will implement
+  // those methods in terms of these procedures.  Of course, these are much
+  // slower than the specialized implementations which the protocol compiler
+  // generates when told to optimize for speed.
+
+  // Read a message in protocol buffer wire format.
+  //
+  // This procedure reads either to the end of the input stream or through
+  // a WIRETYPE_END_GROUP tag ending the message, whichever comes first.
+  // It returns false if the input is invalid.
+  //
+  // Required fields are NOT checked by this method.  You must call
+  // IsInitialized() on the resulting message yourself.
+  static bool ParseAndMergePartial(io::CodedInputStream* input,
+                                   Message* message);
+
+  // Serialize a message in protocol buffer wire format.
+  //
+  // Any embedded messages within the message must have their correct sizes
+  // cached.  However, the top-level message need not; its size is passed as
+  // a parameter to this procedure.
+  //
+  // These return false iff the underlying stream returns a write error.
+  static void SerializeWithCachedSizes(
+      const Message& message,
+      int size, io::CodedOutputStream* output);
+
+  // Implements Message::ByteSize() via reflection.  WARNING:  The result
+  // of this method is *not* cached anywhere.  However, all embedded messages
+  // will have their ByteSize() methods called, so their sizes will be cached.
+  // Therefore, calling this method is sufficient to allow you to call
+  // WireFormat::SerializeWithCachedSizes() on the same object.
+  static size_t ByteSize(const Message& message);
+
+  // -----------------------------------------------------------------
+  // Helpers for dealing with unknown fields
+
+  // Skips a field value of the given WireType.  The input should start
+  // positioned immediately after the tag.  If unknown_fields is non-NULL,
+  // the contents of the field will be added to it.
+  static bool SkipField(io::CodedInputStream* input, uint32 tag,
+                        UnknownFieldSet* unknown_fields);
+
+  // Reads and ignores a message from the input.  If unknown_fields is non-NULL,
+  // the contents will be added to it.
+  static bool SkipMessage(io::CodedInputStream* input,
+                          UnknownFieldSet* unknown_fields);
+
+  // Read a packed enum field. If the is_valid function is not NULL, values for
+  // which is_valid(value) returns false are appended to unknown_fields_stream.
+  static bool ReadPackedEnumPreserveUnknowns(io::CodedInputStream* input,
+                                             uint32 field_number,
+                                             bool (*is_valid)(int),
+                                             UnknownFieldSet* unknown_fields,
+                                             RepeatedField<int>* values);
+
+  // Write the contents of an UnknownFieldSet to the output.
+  static void SerializeUnknownFields(const UnknownFieldSet& unknown_fields,
+                                     io::CodedOutputStream* output);
+  // Same as above, except writing directly to the provided buffer.
+  // Requires that the buffer have sufficient capacity for
+  // ComputeUnknownFieldsSize(unknown_fields).
+  //
+  // Returns a pointer past the last written byte.
+  static uint8* SerializeUnknownFieldsToArray(
+      const UnknownFieldSet& unknown_fields,
+      uint8* target);
+
+  // Same thing except for messages that have the message_set_wire_format
+  // option.
+  static void SerializeUnknownMessageSetItems(
+      const UnknownFieldSet& unknown_fields,
+      io::CodedOutputStream* output);
+  // Same as above, except writing directly to the provided buffer.
+  // Requires that the buffer have sufficient capacity for
+  // ComputeUnknownMessageSetItemsSize(unknown_fields).
+  //
+  // Returns a pointer past the last written byte.
+  static uint8* SerializeUnknownMessageSetItemsToArray(
+      const UnknownFieldSet& unknown_fields,
+      uint8* target);
+
+  // Compute the size of the UnknownFieldSet on the wire.
+  static size_t ComputeUnknownFieldsSize(const UnknownFieldSet& unknown_fields);
+
+  // Same thing except for messages that have the message_set_wire_format
+  // option.
+  static size_t ComputeUnknownMessageSetItemsSize(
+      const UnknownFieldSet& unknown_fields);
+
+
+  // Helper functions for encoding and decoding tags.  (Inlined below and in
+  // _inl.h)
+  //
+  // This is different from MakeTag(field->number(), field->type()) in the case
+  // of packed repeated fields.
+  static uint32 MakeTag(const FieldDescriptor* field);
+
+  // Parse a single field.  The input should start out positioned immediately
+  // after the tag.
+  static bool ParseAndMergeField(
+      uint32 tag,
+      const FieldDescriptor* field,        // May be NULL for unknown
+      Message* message,
+      io::CodedInputStream* input);
+
+  // Serialize a single field.
+  static void SerializeFieldWithCachedSizes(
+      const FieldDescriptor* field,        // Cannot be NULL
+      const Message& message,
+      io::CodedOutputStream* output);
+
+  // Compute size of a single field.  If the field is a message type, this
+  // will call ByteSize() for the embedded message, insuring that it caches
+  // its size.
+  static size_t FieldByteSize(
+      const FieldDescriptor* field,        // Cannot be NULL
+      const Message& message);
+
+  // Parse/serialize a MessageSet::Item group.  Used with messages that use
+  // opion message_set_wire_format = true.
+  static bool ParseAndMergeMessageSetItem(
+      io::CodedInputStream* input,
+      Message* message);
+  static void SerializeMessageSetItemWithCachedSizes(
+      const FieldDescriptor* field,
+      const Message& message,
+      io::CodedOutputStream* output);
+  static size_t MessageSetItemByteSize(
+      const FieldDescriptor* field,
+      const Message& message);
+
+  // Computes the byte size of a field, excluding tags. For packed fields, it
+  // only includes the size of the raw data, and not the size of the total
+  // length, but for other length-delimited types, the size of the length is
+  // included.
+  static size_t FieldDataOnlyByteSize(
+      const FieldDescriptor* field,        // Cannot be NULL
+      const Message& message);
+
+  enum Operation {
+    PARSE = 0,
+    SERIALIZE = 1,
+  };
+
+  // Verifies that a string field is valid UTF8, logging an error if not.
+  // This function will not be called by newly generated protobuf code
+  // but remains present to support existing code.
+  static void VerifyUTF8String(const char* data, int size, Operation op);
+  // The NamedField variant takes a field name in order to produce an
+  // informative error message if verification fails.
+  static void VerifyUTF8StringNamedField(const char* data,
+                                         int size,
+                                         Operation op,
+                                         const char* field_name);
+
+ private:
+  // Skip a MessageSet field.
+  static bool SkipMessageSetField(io::CodedInputStream* input,
+                                  uint32 field_number,
+                                  UnknownFieldSet* unknown_fields);
+
+  // Parse a MessageSet field.
+  static bool ParseAndMergeMessageSetField(uint32 field_number,
+                                           const FieldDescriptor* field,
+                                           Message* message,
+                                           io::CodedInputStream* input);
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(WireFormat);
+};
+
+// Subclass of FieldSkipper which saves skipped fields to an UnknownFieldSet.
+class LIBPROTOBUF_EXPORT UnknownFieldSetFieldSkipper : public FieldSkipper {
+ public:
+  UnknownFieldSetFieldSkipper(UnknownFieldSet* unknown_fields)
+      : unknown_fields_(unknown_fields) {}
+  virtual ~UnknownFieldSetFieldSkipper() {}
+
+  // implements FieldSkipper -----------------------------------------
+  virtual bool SkipField(io::CodedInputStream* input, uint32 tag);
+  virtual bool SkipMessage(io::CodedInputStream* input);
+  virtual void SkipUnknownEnum(int field_number, int value);
+
+ protected:
+  UnknownFieldSet* unknown_fields_;
+};
+
+// inline methods ====================================================
+
+inline WireFormatLite::WireType WireFormat::WireTypeForField(
+    const FieldDescriptor* field) {
+  if (field->is_packed()) {
+    return WireFormatLite::WIRETYPE_LENGTH_DELIMITED;
+  } else {
+    return WireTypeForFieldType(field->type());
+  }
+}
+
+inline WireFormatLite::WireType WireFormat::WireTypeForFieldType(
+    FieldDescriptor::Type type) {
+  // Some compilers don't like enum -> enum casts, so we implicit_cast to
+  // int first.
+  return WireFormatLite::WireTypeForFieldType(
+      static_cast<WireFormatLite::FieldType>(
+        implicit_cast<int>(type)));
+}
+
+inline uint32 WireFormat::MakeTag(const FieldDescriptor* field) {
+  return WireFormatLite::MakeTag(field->number(), WireTypeForField(field));
+}
+
+inline size_t WireFormat::TagSize(int field_number,
+                                  FieldDescriptor::Type type) {
+  // Some compilers don't like enum -> enum casts, so we implicit_cast to
+  // int first.
+  return WireFormatLite::TagSize(field_number,
+      static_cast<WireFormatLite::FieldType>(
+        implicit_cast<int>(type)));
+}
+
+inline void WireFormat::VerifyUTF8String(const char* data, int size,
+    WireFormat::Operation op) {
+#ifdef GOOGLE_PROTOBUF_UTF8_VALIDATION_ENABLED
+  WireFormatLite::VerifyUtf8String(
+      data, size, static_cast<WireFormatLite::Operation>(op), NULL);
+#else
+  // Avoid the compiler warning about unused variables.
+  (void)data; (void)size; (void)op;
+#endif
+}
+
+inline void WireFormat::VerifyUTF8StringNamedField(
+    const char* data, int size, WireFormat::Operation op,
+    const char* field_name) {
+#ifdef GOOGLE_PROTOBUF_UTF8_VALIDATION_ENABLED
+  WireFormatLite::VerifyUtf8String(
+      data, size, static_cast<WireFormatLite::Operation>(op), field_name);
+#else
+  // Avoid the compiler warning about unused variables.
+  (void)data; (void)size; (void)op; (void)field_name;
+#endif
+}
+
+
+}  // namespace internal
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_WIRE_FORMAT_H__
diff --git a/kortex_api/include/google/protobuf/wire_format_lite.h b/kortex_api/include/google/protobuf/wire_format_lite.h
new file mode 100644
index 0000000000000000000000000000000000000000..cf614c02a425e97aadab9d17bde6061548e1e932
--- /dev/null
+++ b/kortex_api/include/google/protobuf/wire_format_lite.h
@@ -0,0 +1,894 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//         atenasio@google.com (Chris Atenasio) (ZigZag transform)
+//         wink@google.com (Wink Saville) (refactored from wire_format.h)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+//
+// This header is logically internal, but is made public because it is used
+// from protocol-compiler-generated code, which may reside in other components.
+
+#ifndef GOOGLE_PROTOBUF_WIRE_FORMAT_LITE_H__
+#define GOOGLE_PROTOBUF_WIRE_FORMAT_LITE_H__
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/message_lite.h>
+#include <google/protobuf/stubs/port.h>
+#include <google/protobuf/repeated_field.h>
+
+// Do UTF-8 validation on string type in Debug build only
+#ifndef NDEBUG
+#define GOOGLE_PROTOBUF_UTF8_VALIDATION_ENABLED
+#endif
+
+// Avoid conflict with iOS where <ConditionalMacros.h> #defines TYPE_BOOL.
+//
+// If some one needs the macro TYPE_BOOL in a file that includes this header, it's
+// possible to bring it back using push/pop_macro as follows.
+//
+// #pragma push_macro("TYPE_BOOL")
+// #include this header and/or all headers that need the macro to be undefined.
+// #pragma pop_macro("TYPE_BOOL")
+#undef TYPE_BOOL
+
+namespace google {
+
+namespace protobuf {
+  template <typename T> class RepeatedField;  // repeated_field.h
+}
+
+namespace protobuf {
+namespace internal {
+
+class StringPieceField;
+
+// This class is for internal use by the protocol buffer library and by
+// protocol-complier-generated message classes.  It must not be called
+// directly by clients.
+//
+// This class contains helpers for implementing the binary protocol buffer
+// wire format without the need for reflection. Use WireFormat when using
+// reflection.
+//
+// This class is really a namespace that contains only static methods.
+class LIBPROTOBUF_EXPORT WireFormatLite {
+ public:
+
+  // -----------------------------------------------------------------
+  // Helper constants and functions related to the format.  These are
+  // mostly meant for internal and generated code to use.
+
+  // The wire format is composed of a sequence of tag/value pairs, each
+  // of which contains the value of one field (or one element of a repeated
+  // field).  Each tag is encoded as a varint.  The lower bits of the tag
+  // identify its wire type, which specifies the format of the data to follow.
+  // The rest of the bits contain the field number.  Each type of field (as
+  // declared by FieldDescriptor::Type, in descriptor.h) maps to one of
+  // these wire types.  Immediately following each tag is the field's value,
+  // encoded in the format specified by the wire type.  Because the tag
+  // identifies the encoding of this data, it is possible to skip
+  // unrecognized fields for forwards compatibility.
+
+  enum WireType {
+    WIRETYPE_VARINT           = 0,
+    WIRETYPE_FIXED64          = 1,
+    WIRETYPE_LENGTH_DELIMITED = 2,
+    WIRETYPE_START_GROUP      = 3,
+    WIRETYPE_END_GROUP        = 4,
+    WIRETYPE_FIXED32          = 5,
+  };
+
+  // Lite alternative to FieldDescriptor::Type.  Must be kept in sync.
+  enum FieldType {
+    TYPE_DOUBLE         = 1,
+    TYPE_FLOAT          = 2,
+    TYPE_INT64          = 3,
+    TYPE_UINT64         = 4,
+    TYPE_INT32          = 5,
+    TYPE_FIXED64        = 6,
+    TYPE_FIXED32        = 7,
+    TYPE_BOOL           = 8,
+    TYPE_STRING         = 9,
+    TYPE_GROUP          = 10,
+    TYPE_MESSAGE        = 11,
+    TYPE_BYTES          = 12,
+    TYPE_UINT32         = 13,
+    TYPE_ENUM           = 14,
+    TYPE_SFIXED32       = 15,
+    TYPE_SFIXED64       = 16,
+    TYPE_SINT32         = 17,
+    TYPE_SINT64         = 18,
+    MAX_FIELD_TYPE      = 18,
+  };
+
+  // Lite alternative to FieldDescriptor::CppType.  Must be kept in sync.
+  enum CppType {
+    CPPTYPE_INT32       = 1,
+    CPPTYPE_INT64       = 2,
+    CPPTYPE_UINT32      = 3,
+    CPPTYPE_UINT64      = 4,
+    CPPTYPE_DOUBLE      = 5,
+    CPPTYPE_FLOAT       = 6,
+    CPPTYPE_BOOL        = 7,
+    CPPTYPE_ENUM        = 8,
+    CPPTYPE_STRING      = 9,
+    CPPTYPE_MESSAGE     = 10,
+    MAX_CPPTYPE         = 10,
+  };
+
+  // Helper method to get the CppType for a particular Type.
+  static CppType FieldTypeToCppType(FieldType type);
+
+  // Given a FieldDescriptor::Type return its WireType
+  static inline WireFormatLite::WireType WireTypeForFieldType(
+      WireFormatLite::FieldType type) {
+    return kWireTypeForFieldType[type];
+  }
+
+  // Number of bits in a tag which identify the wire type.
+  static const int kTagTypeBits = 3;
+  // Mask for those bits.
+  static const uint32 kTagTypeMask = (1 << kTagTypeBits) - 1;
+
+  // Helper functions for encoding and decoding tags.  (Inlined below and in
+  // _inl.h)
+  //
+  // This is different from MakeTag(field->number(), field->type()) in the case
+  // of packed repeated fields.
+  static uint32 MakeTag(int field_number, WireType type);
+  static WireType GetTagWireType(uint32 tag);
+  static int GetTagFieldNumber(uint32 tag);
+
+  // Compute the byte size of a tag.  For groups, this includes both the start
+  // and end tags.
+  static inline size_t TagSize(int field_number,
+                               WireFormatLite::FieldType type);
+
+  // Skips a field value with the given tag.  The input should start
+  // positioned immediately after the tag.  Skipped values are simply discarded,
+  // not recorded anywhere.  See WireFormat::SkipField() for a version that
+  // records to an UnknownFieldSet.
+  static bool SkipField(io::CodedInputStream* input, uint32 tag);
+
+  // Skips a field value with the given tag.  The input should start
+  // positioned immediately after the tag. Skipped values are recorded to a
+  // CodedOutputStream.
+  static bool SkipField(io::CodedInputStream* input, uint32 tag,
+                        io::CodedOutputStream* output);
+
+  // Reads and ignores a message from the input.  Skipped values are simply
+  // discarded, not recorded anywhere.  See WireFormat::SkipMessage() for a
+  // version that records to an UnknownFieldSet.
+  static bool SkipMessage(io::CodedInputStream* input);
+
+  // Reads and ignores a message from the input.  Skipped values are recorded
+  // to a CodedOutputStream.
+  static bool SkipMessage(io::CodedInputStream* input,
+                          io::CodedOutputStream* output);
+
+// This macro does the same thing as WireFormatLite::MakeTag(), but the
+// result is usable as a compile-time constant, which makes it usable
+// as a switch case or a template input.  WireFormatLite::MakeTag() is more
+// type-safe, though, so prefer it if possible.
+#define GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(FIELD_NUMBER, TYPE)                  \
+  static_cast<uint32>(                                                   \
+    (static_cast<uint32>(FIELD_NUMBER) << ::google::protobuf::internal::WireFormatLite::kTagTypeBits) \
+      | (TYPE))
+
+  // These are the tags for the old MessageSet format, which was defined as:
+  //   message MessageSet {
+  //     repeated group Item = 1 {
+  //       required int32 type_id = 2;
+  //       required string message = 3;
+  //     }
+  //   }
+  static const int kMessageSetItemNumber = 1;
+  static const int kMessageSetTypeIdNumber = 2;
+  static const int kMessageSetMessageNumber = 3;
+  static const int kMessageSetItemStartTag =
+    GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(kMessageSetItemNumber,
+                                WireFormatLite::WIRETYPE_START_GROUP);
+  static const int kMessageSetItemEndTag =
+    GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(kMessageSetItemNumber,
+                                WireFormatLite::WIRETYPE_END_GROUP);
+  static const int kMessageSetTypeIdTag =
+    GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(kMessageSetTypeIdNumber,
+                                WireFormatLite::WIRETYPE_VARINT);
+  static const int kMessageSetMessageTag =
+    GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(kMessageSetMessageNumber,
+                                WireFormatLite::WIRETYPE_LENGTH_DELIMITED);
+
+  // Byte size of all tags of a MessageSet::Item combined.
+  static const size_t kMessageSetItemTagsSize;
+
+  // Helper functions for converting between floats/doubles and IEEE-754
+  // uint32s/uint64s so that they can be written.  (Assumes your platform
+  // uses IEEE-754 floats.)
+  static uint32 EncodeFloat(float value);
+  static float DecodeFloat(uint32 value);
+  static uint64 EncodeDouble(double value);
+  static double DecodeDouble(uint64 value);
+
+  // Helper functions for mapping signed integers to unsigned integers in
+  // such a way that numbers with small magnitudes will encode to smaller
+  // varints.  If you simply static_cast a negative number to an unsigned
+  // number and varint-encode it, it will always take 10 bytes, defeating
+  // the purpose of varint.  So, for the "sint32" and "sint64" field types,
+  // we ZigZag-encode the values.
+  static uint32 ZigZagEncode32(int32 n);
+  static int32  ZigZagDecode32(uint32 n);
+  static uint64 ZigZagEncode64(int64 n);
+  static int64  ZigZagDecode64(uint64 n);
+
+  // =================================================================
+  // Methods for reading/writing individual field.  The implementations
+  // of these methods are defined in wire_format_lite_inl.h; you must #include
+  // that file to use these.
+
+#ifdef NDEBUG
+#define INL GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+#else
+// Avoid excessive inlining in non-optimized builds. Without other optimizations
+// the inlining is not going to provide benefits anyway and the huge resulting
+// functions, especially in the proto-generated serialization functions, produce
+// stack frames so large that many tests run into stack overflows (b/32192897).
+#define INL
+#endif
+
+  // Read fields, not including tags.  The assumption is that you already
+  // read the tag to determine what field to read.
+
+  // For primitive fields, we just use a templatized routine parameterized by
+  // the represented type and the FieldType. These are specialized with the
+  // appropriate definition for each declared type.
+  template <typename CType, enum FieldType DeclaredType>
+  INL static bool ReadPrimitive(io::CodedInputStream* input, CType* value);
+
+  // Reads repeated primitive values, with optimizations for repeats.
+  // tag_size and tag should both be compile-time constants provided by the
+  // protocol compiler.
+  template <typename CType, enum FieldType DeclaredType>
+  INL static bool ReadRepeatedPrimitive(int tag_size, uint32 tag,
+                                        io::CodedInputStream* input,
+                                        RepeatedField<CType>* value);
+
+  // Identical to ReadRepeatedPrimitive, except will not inline the
+  // implementation.
+  template <typename CType, enum FieldType DeclaredType>
+  static bool ReadRepeatedPrimitiveNoInline(int tag_size, uint32 tag,
+                                            io::CodedInputStream* input,
+                                            RepeatedField<CType>* value);
+
+  // Reads a primitive value directly from the provided buffer. It returns a
+  // pointer past the segment of data that was read.
+  //
+  // This is only implemented for the types with fixed wire size, e.g.
+  // float, double, and the (s)fixed* types.
+  template <typename CType, enum FieldType DeclaredType> INL
+  static const uint8* ReadPrimitiveFromArray(const uint8* buffer, CType* value);
+
+  // Reads a primitive packed field.
+  //
+  // This is only implemented for packable types.
+  template <typename CType, enum FieldType DeclaredType>
+  INL static bool ReadPackedPrimitive(io::CodedInputStream* input,
+                                      RepeatedField<CType>* value);
+
+  // Identical to ReadPackedPrimitive, except will not inline the
+  // implementation.
+  template <typename CType, enum FieldType DeclaredType>
+  static bool ReadPackedPrimitiveNoInline(io::CodedInputStream* input,
+                                          RepeatedField<CType>* value);
+
+  // Read a packed enum field. If the is_valid function is not NULL, values for
+  // which is_valid(value) returns false are silently dropped.
+  static bool ReadPackedEnumNoInline(io::CodedInputStream* input,
+                                     bool (*is_valid)(int),
+                                     RepeatedField<int>* values);
+
+  // Read a packed enum field. If the is_valid function is not NULL, values for
+  // which is_valid(value) returns false are appended to unknown_fields_stream.
+  static bool ReadPackedEnumPreserveUnknowns(
+      io::CodedInputStream* input, int field_number, bool (*is_valid)(int),
+      io::CodedOutputStream* unknown_fields_stream, RepeatedField<int>* values);
+
+  // Read a string.  ReadString(..., string* value) requires an existing string.
+  static inline bool ReadString(io::CodedInputStream* input, string* value);
+  // ReadString(..., string** p) is internal-only, and should only be called
+  // from generated code. It starts by setting *p to "new string"
+  // if *p == &GetEmptyStringAlreadyInited().  It then invokes
+  // ReadString(io::CodedInputStream* input, *p).  This is useful for reducing
+  // code size.
+  static inline bool ReadString(io::CodedInputStream* input, string** p);
+  // Analogous to ReadString().
+  static bool ReadBytes(io::CodedInputStream* input, string* value);
+  static bool ReadBytes(io::CodedInputStream* input, string** p);
+
+  enum Operation {
+    PARSE = 0,
+    SERIALIZE = 1,
+  };
+
+  // Returns true if the data is valid UTF-8.
+  static bool VerifyUtf8String(const char* data, int size,
+                               Operation op,
+                               const char* field_name);
+
+  static inline bool ReadGroup(int field_number, io::CodedInputStream* input,
+                               MessageLite* value);
+  static inline bool ReadMessage(io::CodedInputStream* input,
+                                 MessageLite* value);
+
+  // Like above, but de-virtualize the call to MergePartialFromCodedStream().
+  // The pointer must point at an instance of MessageType, *not* a subclass (or
+  // the subclass must not override MergePartialFromCodedStream()).
+  template <typename MessageType>
+  static inline bool ReadGroupNoVirtual(int field_number,
+                                        io::CodedInputStream* input,
+                                        MessageType* value);
+  template<typename MessageType>
+  static inline bool ReadMessageNoVirtual(io::CodedInputStream* input,
+                                          MessageType* value);
+
+  // The same, but do not modify input's recursion depth.  This is useful
+  // when reading a bunch of groups or messages in a loop, because then the
+  // recursion depth can be incremented before the loop and decremented after.
+  template<typename MessageType>
+  static inline bool ReadGroupNoVirtualNoRecursionDepth(
+      int field_number, io::CodedInputStream* input, MessageType* value);
+
+  template<typename MessageType>
+  static inline bool ReadMessageNoVirtualNoRecursionDepth(
+      io::CodedInputStream* input, MessageType* value);
+
+  // Write a tag.  The Write*() functions typically include the tag, so
+  // normally there's no need to call this unless using the Write*NoTag()
+  // variants.
+  INL static void WriteTag(int field_number, WireType type,
+                           io::CodedOutputStream* output);
+
+  // Write fields, without tags.
+  INL static void WriteInt32NoTag(int32 value, io::CodedOutputStream* output);
+  INL static void WriteInt64NoTag(int64 value, io::CodedOutputStream* output);
+  INL static void WriteUInt32NoTag(uint32 value, io::CodedOutputStream* output);
+  INL static void WriteUInt64NoTag(uint64 value, io::CodedOutputStream* output);
+  INL static void WriteSInt32NoTag(int32 value, io::CodedOutputStream* output);
+  INL static void WriteSInt64NoTag(int64 value, io::CodedOutputStream* output);
+  INL static void WriteFixed32NoTag(uint32 value,
+                                    io::CodedOutputStream* output);
+  INL static void WriteFixed64NoTag(uint64 value,
+                                    io::CodedOutputStream* output);
+  INL static void WriteSFixed32NoTag(int32 value,
+                                     io::CodedOutputStream* output);
+  INL static void WriteSFixed64NoTag(int64 value,
+                                     io::CodedOutputStream* output);
+  INL static void WriteFloatNoTag(float value, io::CodedOutputStream* output);
+  INL static void WriteDoubleNoTag(double value, io::CodedOutputStream* output);
+  INL static void WriteBoolNoTag(bool value, io::CodedOutputStream* output);
+  INL static void WriteEnumNoTag(int value, io::CodedOutputStream* output);
+
+  // Write array of primitive fields, without tags
+  static void WriteFloatArray(const float* a, int n,
+                              io::CodedOutputStream* output);
+  static void WriteDoubleArray(const double* a, int n,
+                               io::CodedOutputStream* output);
+  static void WriteFixed32Array(const uint32* a, int n,
+                                io::CodedOutputStream* output);
+  static void WriteFixed64Array(const uint64* a, int n,
+                                io::CodedOutputStream* output);
+  static void WriteSFixed32Array(const int32* a, int n,
+                                 io::CodedOutputStream* output);
+  static void WriteSFixed64Array(const int64* a, int n,
+                                 io::CodedOutputStream* output);
+  static void WriteBoolArray(const bool* a, int n,
+                             io::CodedOutputStream* output);
+
+  // Write fields, including tags.
+  static void WriteInt32(int field_number, int32 value,
+                         io::CodedOutputStream* output);
+  static void WriteInt64(int field_number, int64 value,
+                         io::CodedOutputStream* output);
+  static void WriteUInt32(int field_number, uint32 value,
+                          io::CodedOutputStream* output);
+  static void WriteUInt64(int field_number, uint64 value,
+                          io::CodedOutputStream* output);
+  static void WriteSInt32(int field_number, int32 value,
+                          io::CodedOutputStream* output);
+  static void WriteSInt64(int field_number, int64 value,
+                          io::CodedOutputStream* output);
+  static void WriteFixed32(int field_number, uint32 value,
+                           io::CodedOutputStream* output);
+  static void WriteFixed64(int field_number, uint64 value,
+                           io::CodedOutputStream* output);
+  static void WriteSFixed32(int field_number, int32 value,
+                            io::CodedOutputStream* output);
+  static void WriteSFixed64(int field_number, int64 value,
+                            io::CodedOutputStream* output);
+  static void WriteFloat(int field_number, float value,
+                         io::CodedOutputStream* output);
+  static void WriteDouble(int field_number, double value,
+                          io::CodedOutputStream* output);
+  static void WriteBool(int field_number, bool value,
+                        io::CodedOutputStream* output);
+  static void WriteEnum(int field_number, int value,
+                        io::CodedOutputStream* output);
+
+  static void WriteString(int field_number, const string& value,
+                          io::CodedOutputStream* output);
+  static void WriteBytes(int field_number, const string& value,
+                         io::CodedOutputStream* output);
+  static void WriteStringMaybeAliased(int field_number, const string& value,
+                                      io::CodedOutputStream* output);
+  static void WriteBytesMaybeAliased(int field_number, const string& value,
+                                     io::CodedOutputStream* output);
+
+  static void WriteGroup(int field_number, const MessageLite& value,
+                         io::CodedOutputStream* output);
+  static void WriteMessage(int field_number, const MessageLite& value,
+                           io::CodedOutputStream* output);
+  // Like above, but these will check if the output stream has enough
+  // space to write directly to a flat array.
+  static void WriteGroupMaybeToArray(int field_number, const MessageLite& value,
+                                     io::CodedOutputStream* output);
+  static void WriteMessageMaybeToArray(int field_number,
+                                       const MessageLite& value,
+                                       io::CodedOutputStream* output);
+
+  // Like above, but de-virtualize the call to SerializeWithCachedSizes().  The
+  // pointer must point at an instance of MessageType, *not* a subclass (or
+  // the subclass must not override SerializeWithCachedSizes()).
+  template <typename MessageType>
+  static inline void WriteGroupNoVirtual(int field_number,
+                                         const MessageType& value,
+                                         io::CodedOutputStream* output);
+  template <typename MessageType>
+  static inline void WriteMessageNoVirtual(int field_number,
+                                           const MessageType& value,
+                                           io::CodedOutputStream* output);
+
+  // Like above, but use only *ToArray methods of CodedOutputStream.
+  INL static uint8* WriteTagToArray(int field_number, WireType type,
+                                    uint8* target);
+
+  // Write fields, without tags.
+  INL static uint8* WriteInt32NoTagToArray(int32 value, uint8* target);
+  INL static uint8* WriteInt64NoTagToArray(int64 value, uint8* target);
+  INL static uint8* WriteUInt32NoTagToArray(uint32 value, uint8* target);
+  INL static uint8* WriteUInt64NoTagToArray(uint64 value, uint8* target);
+  INL static uint8* WriteSInt32NoTagToArray(int32 value, uint8* target);
+  INL static uint8* WriteSInt64NoTagToArray(int64 value, uint8* target);
+  INL static uint8* WriteFixed32NoTagToArray(uint32 value, uint8* target);
+  INL static uint8* WriteFixed64NoTagToArray(uint64 value, uint8* target);
+  INL static uint8* WriteSFixed32NoTagToArray(int32 value, uint8* target);
+  INL static uint8* WriteSFixed64NoTagToArray(int64 value, uint8* target);
+  INL static uint8* WriteFloatNoTagToArray(float value, uint8* target);
+  INL static uint8* WriteDoubleNoTagToArray(double value, uint8* target);
+  INL static uint8* WriteBoolNoTagToArray(bool value, uint8* target);
+  INL static uint8* WriteEnumNoTagToArray(int value, uint8* target);
+
+  // Write fields, without tags.  These require that value.size() > 0.
+  template<typename T>
+  INL static uint8* WritePrimitiveNoTagToArray(
+      const RepeatedField<T>& value,
+      uint8* (*Writer)(T, uint8*), uint8* target);
+  template<typename T>
+  INL static uint8* WriteFixedNoTagToArray(
+      const RepeatedField<T>& value,
+      uint8* (*Writer)(T, uint8*), uint8* target);
+
+  INL static uint8* WriteInt32NoTagToArray(
+      const RepeatedField< int32>& value, uint8* output);
+  INL static uint8* WriteInt64NoTagToArray(
+      const RepeatedField< int64>& value, uint8* output);
+  INL static uint8* WriteUInt32NoTagToArray(
+      const RepeatedField<uint32>& value, uint8* output);
+  INL static uint8* WriteUInt64NoTagToArray(
+      const RepeatedField<uint64>& value, uint8* output);
+  INL static uint8* WriteSInt32NoTagToArray(
+      const RepeatedField< int32>& value, uint8* output);
+  INL static uint8* WriteSInt64NoTagToArray(
+      const RepeatedField< int64>& value, uint8* output);
+  INL static uint8* WriteFixed32NoTagToArray(
+      const RepeatedField<uint32>& value, uint8* output);
+  INL static uint8* WriteFixed64NoTagToArray(
+      const RepeatedField<uint64>& value, uint8* output);
+  INL static uint8* WriteSFixed32NoTagToArray(
+      const RepeatedField< int32>& value, uint8* output);
+  INL static uint8* WriteSFixed64NoTagToArray(
+      const RepeatedField< int64>& value, uint8* output);
+  INL static uint8* WriteFloatNoTagToArray(
+      const RepeatedField< float>& value, uint8* output);
+  INL static uint8* WriteDoubleNoTagToArray(
+      const RepeatedField<double>& value, uint8* output);
+  INL static uint8* WriteBoolNoTagToArray(
+      const RepeatedField<  bool>& value, uint8* output);
+  INL static uint8* WriteEnumNoTagToArray(
+      const RepeatedField<   int>& value, uint8* output);
+
+  // Write fields, including tags.
+  INL static uint8* WriteInt32ToArray(int field_number, int32 value,
+                                      uint8* target);
+  INL static uint8* WriteInt64ToArray(int field_number, int64 value,
+                                      uint8* target);
+  INL static uint8* WriteUInt32ToArray(int field_number, uint32 value,
+                                       uint8* target);
+  INL static uint8* WriteUInt64ToArray(int field_number, uint64 value,
+                                       uint8* target);
+  INL static uint8* WriteSInt32ToArray(int field_number, int32 value,
+                                       uint8* target);
+  INL static uint8* WriteSInt64ToArray(int field_number, int64 value,
+                                       uint8* target);
+  INL static uint8* WriteFixed32ToArray(int field_number, uint32 value,
+                                        uint8* target);
+  INL static uint8* WriteFixed64ToArray(int field_number, uint64 value,
+                                        uint8* target);
+  INL static uint8* WriteSFixed32ToArray(int field_number, int32 value,
+                                         uint8* target);
+  INL static uint8* WriteSFixed64ToArray(int field_number, int64 value,
+                                         uint8* target);
+  INL static uint8* WriteFloatToArray(int field_number, float value,
+                                      uint8* target);
+  INL static uint8* WriteDoubleToArray(int field_number, double value,
+                                       uint8* target);
+  INL static uint8* WriteBoolToArray(int field_number, bool value,
+                                     uint8* target);
+  INL static uint8* WriteEnumToArray(int field_number, int value,
+                                     uint8* target);
+
+  template<typename T>
+  INL static uint8* WritePrimitiveToArray(
+      int field_number,
+      const RepeatedField<T>& value,
+      uint8* (*Writer)(int, T, uint8*), uint8* target);
+
+  INL static uint8* WriteInt32ToArray(
+      int field_number, const RepeatedField< int32>& value, uint8* output);
+  INL static uint8* WriteInt64ToArray(
+      int field_number, const RepeatedField< int64>& value, uint8* output);
+  INL static uint8* WriteUInt32ToArray(
+      int field_number, const RepeatedField<uint32>& value, uint8* output);
+  INL static uint8* WriteUInt64ToArray(
+      int field_number, const RepeatedField<uint64>& value, uint8* output);
+  INL static uint8* WriteSInt32ToArray(
+      int field_number, const RepeatedField< int32>& value, uint8* output);
+  INL static uint8* WriteSInt64ToArray(
+      int field_number, const RepeatedField< int64>& value, uint8* output);
+  INL static uint8* WriteFixed32ToArray(
+      int field_number, const RepeatedField<uint32>& value, uint8* output);
+  INL static uint8* WriteFixed64ToArray(
+      int field_number, const RepeatedField<uint64>& value, uint8* output);
+  INL static uint8* WriteSFixed32ToArray(
+      int field_number, const RepeatedField< int32>& value, uint8* output);
+  INL static uint8* WriteSFixed64ToArray(
+      int field_number, const RepeatedField< int64>& value, uint8* output);
+  INL static uint8* WriteFloatToArray(
+      int field_number, const RepeatedField< float>& value, uint8* output);
+  INL static uint8* WriteDoubleToArray(
+      int field_number, const RepeatedField<double>& value, uint8* output);
+  INL static uint8* WriteBoolToArray(
+      int field_number, const RepeatedField<  bool>& value, uint8* output);
+  INL static uint8* WriteEnumToArray(
+      int field_number, const RepeatedField<   int>& value, uint8* output);
+
+  INL static uint8* WriteStringToArray(int field_number, const string& value,
+                                       uint8* target);
+  INL static uint8* WriteBytesToArray(int field_number, const string& value,
+                                      uint8* target);
+
+  // Whether to serialize deterministically (e.g., map keys are
+  // sorted) is a property of a CodedOutputStream, and in the process
+  // of serialization, the "ToArray" variants may be invoked.  But they don't
+  // have a CodedOutputStream available, so they get an additional parameter
+  // telling them whether to serialize deterministically.
+  INL static uint8* InternalWriteGroupToArray(int field_number,
+                                              const MessageLite& value,
+                                              bool deterministic,
+                                              uint8* target);
+  INL static uint8* InternalWriteMessageToArray(int field_number,
+                                                const MessageLite& value,
+                                                bool deterministic,
+                                                uint8* target);
+
+  // Like above, but de-virtualize the call to SerializeWithCachedSizes().  The
+  // pointer must point at an instance of MessageType, *not* a subclass (or
+  // the subclass must not override SerializeWithCachedSizes()).
+  template <typename MessageType>
+  INL static uint8* InternalWriteGroupNoVirtualToArray(int field_number,
+                                                       const MessageType& value,
+                                                       bool deterministic,
+                                                       uint8* target);
+  template <typename MessageType>
+  INL static uint8* InternalWriteMessageNoVirtualToArray(
+      int field_number, const MessageType& value, bool deterministic,
+      uint8* target);
+
+  // For backward-compatibility, the last four methods also have versions
+  // that are non-deterministic always.
+  INL static uint8* WriteGroupToArray(int field_number,
+                                      const MessageLite& value, uint8* target) {
+    return InternalWriteGroupToArray(field_number, value, false, target);
+  }
+  INL static uint8* WriteMessageToArray(int field_number,
+                                        const MessageLite& value,
+                                        uint8* target) {
+    return InternalWriteMessageToArray(field_number, value, false, target);
+  }
+  template <typename MessageType>
+  INL static uint8* WriteGroupNoVirtualToArray(int field_number,
+                                               const MessageType& value,
+                                               uint8* target) {
+    return InternalWriteGroupNoVirtualToArray(field_number, value, false,
+                                              target);
+  }
+  template <typename MessageType>
+  INL static uint8* WriteMessageNoVirtualToArray(int field_number,
+                                                 const MessageType& value,
+                                                 uint8* target) {
+    return InternalWriteMessageNoVirtualToArray(field_number, value, false,
+                                                target);
+  }
+
+#undef INL
+
+  // Compute the byte size of a field.  The XxSize() functions do NOT include
+  // the tag, so you must also call TagSize().  (This is because, for repeated
+  // fields, you should only call TagSize() once and multiply it by the element
+  // count, but you may have to call XxSize() for each individual element.)
+  static inline size_t Int32Size   ( int32 value);
+  static inline size_t Int64Size   ( int64 value);
+  static inline size_t UInt32Size  (uint32 value);
+  static inline size_t UInt64Size  (uint64 value);
+  static inline size_t SInt32Size  ( int32 value);
+  static inline size_t SInt64Size  ( int64 value);
+  static inline size_t EnumSize    (   int value);
+
+  static        size_t Int32Size (const RepeatedField< int32>& value);
+  static inline size_t Int64Size (const RepeatedField< int64>& value);
+  static        size_t UInt32Size(const RepeatedField<uint32>& value);
+  static inline size_t UInt64Size(const RepeatedField<uint64>& value);
+  static        size_t SInt32Size(const RepeatedField< int32>& value);
+  static inline size_t SInt64Size(const RepeatedField< int64>& value);
+  static        size_t EnumSize  (const RepeatedField<   int>& value);
+
+  // These types always have the same size.
+  static const size_t kFixed32Size  = 4;
+  static const size_t kFixed64Size  = 8;
+  static const size_t kSFixed32Size = 4;
+  static const size_t kSFixed64Size = 8;
+  static const size_t kFloatSize    = 4;
+  static const size_t kDoubleSize   = 8;
+  static const size_t kBoolSize     = 1;
+
+  static inline size_t StringSize(const string& value);
+  static inline size_t BytesSize (const string& value);
+
+  static inline size_t GroupSize  (const MessageLite& value);
+  static inline size_t MessageSize(const MessageLite& value);
+
+  // Like above, but de-virtualize the call to ByteSize().  The
+  // pointer must point at an instance of MessageType, *not* a subclass (or
+  // the subclass must not override ByteSize()).
+  template<typename MessageType>
+  static inline size_t GroupSizeNoVirtual  (const MessageType& value);
+  template<typename MessageType>
+  static inline size_t MessageSizeNoVirtual(const MessageType& value);
+
+  // Given the length of data, calculate the byte size of the data on the
+  // wire if we encode the data as a length delimited field.
+  static inline size_t LengthDelimitedSize(size_t length);
+
+ private:
+  // A helper method for the repeated primitive reader. This method has
+  // optimizations for primitive types that have fixed size on the wire, and
+  // can be read using potentially faster paths.
+  template <typename CType, enum FieldType DeclaredType>
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  static bool ReadRepeatedFixedSizePrimitive(
+      int tag_size,
+      uint32 tag,
+      google::protobuf::io::CodedInputStream* input,
+      RepeatedField<CType>* value);
+
+  // Like ReadRepeatedFixedSizePrimitive but for packed primitive fields.
+  template <typename CType, enum FieldType DeclaredType>
+  GOOGLE_PROTOBUF_ATTRIBUTE_ALWAYS_INLINE
+  static bool ReadPackedFixedSizePrimitive(
+      google::protobuf::io::CodedInputStream* input, RepeatedField<CType>* value);
+
+  static const CppType kFieldTypeToCppTypeMap[];
+  static const WireFormatLite::WireType kWireTypeForFieldType[];
+
+  GOOGLE_DISALLOW_EVIL_CONSTRUCTORS(WireFormatLite);
+};
+
+// A class which deals with unknown values.  The default implementation just
+// discards them.  WireFormat defines a subclass which writes to an
+// UnknownFieldSet.  This class is used by ExtensionSet::ParseField(), since
+// ExtensionSet is part of the lite library but UnknownFieldSet is not.
+class LIBPROTOBUF_EXPORT FieldSkipper {
+ public:
+  FieldSkipper() {}
+  virtual ~FieldSkipper() {}
+
+  // Skip a field whose tag has already been consumed.
+  virtual bool SkipField(io::CodedInputStream* input, uint32 tag);
+
+  // Skip an entire message or group, up to an end-group tag (which is consumed)
+  // or end-of-stream.
+  virtual bool SkipMessage(io::CodedInputStream* input);
+
+  // Deal with an already-parsed unrecognized enum value.  The default
+  // implementation does nothing, but the UnknownFieldSet-based implementation
+  // saves it as an unknown varint.
+  virtual void SkipUnknownEnum(int field_number, int value);
+};
+
+// Subclass of FieldSkipper which saves skipped fields to a CodedOutputStream.
+
+class LIBPROTOBUF_EXPORT CodedOutputStreamFieldSkipper : public FieldSkipper {
+ public:
+  explicit CodedOutputStreamFieldSkipper(io::CodedOutputStream* unknown_fields)
+      : unknown_fields_(unknown_fields) {}
+  virtual ~CodedOutputStreamFieldSkipper() {}
+
+  // implements FieldSkipper -----------------------------------------
+  virtual bool SkipField(io::CodedInputStream* input, uint32 tag);
+  virtual bool SkipMessage(io::CodedInputStream* input);
+  virtual void SkipUnknownEnum(int field_number, int value);
+
+ protected:
+  io::CodedOutputStream* unknown_fields_;
+};
+
+
+// inline methods ====================================================
+
+inline WireFormatLite::CppType
+WireFormatLite::FieldTypeToCppType(FieldType type) {
+  return kFieldTypeToCppTypeMap[type];
+}
+
+inline uint32 WireFormatLite::MakeTag(int field_number, WireType type) {
+  return GOOGLE_PROTOBUF_WIRE_FORMAT_MAKE_TAG(field_number, type);
+}
+
+inline WireFormatLite::WireType WireFormatLite::GetTagWireType(uint32 tag) {
+  return static_cast<WireType>(tag & kTagTypeMask);
+}
+
+inline int WireFormatLite::GetTagFieldNumber(uint32 tag) {
+  return static_cast<int>(tag >> kTagTypeBits);
+}
+
+inline size_t WireFormatLite::TagSize(int field_number,
+                                      WireFormatLite::FieldType type) {
+  size_t result = io::CodedOutputStream::VarintSize32(
+    static_cast<uint32>(field_number << kTagTypeBits));
+  if (type == TYPE_GROUP) {
+    // Groups have both a start and an end tag.
+    return result * 2;
+  } else {
+    return result;
+  }
+}
+
+inline uint32 WireFormatLite::EncodeFloat(float value) {
+  union {float f; uint32 i;};
+  f = value;
+  return i;
+}
+
+inline float WireFormatLite::DecodeFloat(uint32 value) {
+  union {float f; uint32 i;};
+  i = value;
+  return f;
+}
+
+inline uint64 WireFormatLite::EncodeDouble(double value) {
+  union {double f; uint64 i;};
+  f = value;
+  return i;
+}
+
+inline double WireFormatLite::DecodeDouble(uint64 value) {
+  union {double f; uint64 i;};
+  i = value;
+  return f;
+}
+
+// ZigZag Transform:  Encodes signed integers so that they can be
+// effectively used with varint encoding.
+//
+// varint operates on unsigned integers, encoding smaller numbers into
+// fewer bytes.  If you try to use it on a signed integer, it will treat
+// this number as a very large unsigned integer, which means that even
+// small signed numbers like -1 will take the maximum number of bytes
+// (10) to encode.  ZigZagEncode() maps signed integers to unsigned
+// in such a way that those with a small absolute value will have smaller
+// encoded values, making them appropriate for encoding using varint.
+//
+//       int32 ->     uint32
+// -------------------------
+//           0 ->          0
+//          -1 ->          1
+//           1 ->          2
+//          -2 ->          3
+//         ... ->        ...
+//  2147483647 -> 4294967294
+// -2147483648 -> 4294967295
+//
+//        >> encode >>
+//        << decode <<
+
+inline uint32 WireFormatLite::ZigZagEncode32(int32 n) {
+  // Note:  the right-shift must be arithmetic
+  // Note:  left shift must be unsigned because of overflow
+  return (static_cast<uint32>(n) << 1) ^ static_cast<uint32>(n >> 31);
+}
+
+inline int32 WireFormatLite::ZigZagDecode32(uint32 n) {
+  // Note:  Using unsigned types prevent undefined behavior
+  return static_cast<int32>((n >> 1) ^ -(n & 1));
+}
+
+inline uint64 WireFormatLite::ZigZagEncode64(int64 n) {
+  // Note:  the right-shift must be arithmetic
+  // Note:  left shift must be unsigned because of overflow
+  return (static_cast<uint64>(n) << 1) ^ static_cast<uint64>(n >> 63);
+}
+
+inline int64 WireFormatLite::ZigZagDecode64(uint64 n) {
+  // Note:  Using unsigned types prevent undefined behavior
+  return static_cast<int64>((n >> 1) ^ -(n & 1));
+}
+
+// String is for UTF-8 text only, but, even so, ReadString() can simply
+// call ReadBytes().
+
+inline bool WireFormatLite::ReadString(io::CodedInputStream* input,
+                                       string* value) {
+  return ReadBytes(input, value);
+}
+
+inline bool WireFormatLite::ReadString(io::CodedInputStream* input,
+                                       string** p) {
+  return ReadBytes(input, p);
+}
+
+}  // namespace internal
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_WIRE_FORMAT_LITE_H__
diff --git a/kortex_api/include/google/protobuf/wire_format_lite_inl.h b/kortex_api/include/google/protobuf/wire_format_lite_inl.h
new file mode 100644
index 0000000000000000000000000000000000000000..b264bd7ea1e0d32a693fbd7305b684124cba3fdc
--- /dev/null
+++ b/kortex_api/include/google/protobuf/wire_format_lite_inl.h
@@ -0,0 +1,1077 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Author: kenton@google.com (Kenton Varda)
+//         wink@google.com (Wink Saville) (refactored from wire_format.h)
+//  Based on original Protocol Buffers design by
+//  Sanjay Ghemawat, Jeff Dean, and others.
+
+#ifndef GOOGLE_PROTOBUF_WIRE_FORMAT_LITE_INL_H__
+#define GOOGLE_PROTOBUF_WIRE_FORMAT_LITE_INL_H__
+
+#include <algorithm>
+#include <string>
+#include <google/protobuf/stubs/common.h>
+#include <google/protobuf/stubs/logging.h>
+#include <google/protobuf/message_lite.h>
+#include <google/protobuf/repeated_field.h>
+#include <google/protobuf/wire_format_lite.h>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arenastring.h>
+
+
+namespace google {
+namespace protobuf {
+namespace internal {
+
+// Implementation details of ReadPrimitive.
+
+template <>
+inline bool WireFormatLite::ReadPrimitive<int32, WireFormatLite::TYPE_INT32>(
+    io::CodedInputStream* input,
+    int32* value) {
+  uint32 temp;
+  if (!input->ReadVarint32(&temp)) return false;
+  *value = static_cast<int32>(temp);
+  return true;
+}
+template <>
+inline bool WireFormatLite::ReadPrimitive<int64, WireFormatLite::TYPE_INT64>(
+    io::CodedInputStream* input,
+    int64* value) {
+  uint64 temp;
+  if (!input->ReadVarint64(&temp)) return false;
+  *value = static_cast<int64>(temp);
+  return true;
+}
+template <>
+inline bool WireFormatLite::ReadPrimitive<uint32, WireFormatLite::TYPE_UINT32>(
+    io::CodedInputStream* input,
+    uint32* value) {
+  return input->ReadVarint32(value);
+}
+template <>
+inline bool WireFormatLite::ReadPrimitive<uint64, WireFormatLite::TYPE_UINT64>(
+    io::CodedInputStream* input,
+    uint64* value) {
+  return input->ReadVarint64(value);
+}
+template <>
+inline bool WireFormatLite::ReadPrimitive<int32, WireFormatLite::TYPE_SINT32>(
+    io::CodedInputStream* input,
+    int32* value) {
+  uint32 temp;
+  if (!input->ReadVarint32(&temp)) return false;
+  *value = ZigZagDecode32(temp);
+  return true;
+}
+template <>
+inline bool WireFormatLite::ReadPrimitive<int64, WireFormatLite::TYPE_SINT64>(
+    io::CodedInputStream* input,
+    int64* value) {
+  uint64 temp;
+  if (!input->ReadVarint64(&temp)) return false;
+  *value = ZigZagDecode64(temp);
+  return true;
+}
+template <>
+inline bool WireFormatLite::ReadPrimitive<uint32, WireFormatLite::TYPE_FIXED32>(
+    io::CodedInputStream* input,
+    uint32* value) {
+  return input->ReadLittleEndian32(value);
+}
+template <>
+inline bool WireFormatLite::ReadPrimitive<uint64, WireFormatLite::TYPE_FIXED64>(
+    io::CodedInputStream* input,
+    uint64* value) {
+  return input->ReadLittleEndian64(value);
+}
+template <>
+inline bool WireFormatLite::ReadPrimitive<int32, WireFormatLite::TYPE_SFIXED32>(
+    io::CodedInputStream* input,
+    int32* value) {
+  uint32 temp;
+  if (!input->ReadLittleEndian32(&temp)) return false;
+  *value = static_cast<int32>(temp);
+  return true;
+}
+template <>
+inline bool WireFormatLite::ReadPrimitive<int64, WireFormatLite::TYPE_SFIXED64>(
+    io::CodedInputStream* input,
+    int64* value) {
+  uint64 temp;
+  if (!input->ReadLittleEndian64(&temp)) return false;
+  *value = static_cast<int64>(temp);
+  return true;
+}
+template <>
+inline bool WireFormatLite::ReadPrimitive<float, WireFormatLite::TYPE_FLOAT>(
+    io::CodedInputStream* input,
+    float* value) {
+  uint32 temp;
+  if (!input->ReadLittleEndian32(&temp)) return false;
+  *value = DecodeFloat(temp);
+  return true;
+}
+template <>
+inline bool WireFormatLite::ReadPrimitive<double, WireFormatLite::TYPE_DOUBLE>(
+    io::CodedInputStream* input,
+    double* value) {
+  uint64 temp;
+  if (!input->ReadLittleEndian64(&temp)) return false;
+  *value = DecodeDouble(temp);
+  return true;
+}
+template <>
+inline bool WireFormatLite::ReadPrimitive<bool, WireFormatLite::TYPE_BOOL>(
+    io::CodedInputStream* input,
+    bool* value) {
+  uint64 temp;
+  if (!input->ReadVarint64(&temp)) return false;
+  *value = temp != 0;
+  return true;
+}
+template <>
+inline bool WireFormatLite::ReadPrimitive<int, WireFormatLite::TYPE_ENUM>(
+    io::CodedInputStream* input,
+    int* value) {
+  uint32 temp;
+  if (!input->ReadVarint32(&temp)) return false;
+  *value = static_cast<int>(temp);
+  return true;
+}
+
+template <>
+inline const uint8* WireFormatLite::ReadPrimitiveFromArray<
+  uint32, WireFormatLite::TYPE_FIXED32>(
+    const uint8* buffer,
+    uint32* value) {
+  return io::CodedInputStream::ReadLittleEndian32FromArray(buffer, value);
+}
+template <>
+inline const uint8* WireFormatLite::ReadPrimitiveFromArray<
+  uint64, WireFormatLite::TYPE_FIXED64>(
+    const uint8* buffer,
+    uint64* value) {
+  return io::CodedInputStream::ReadLittleEndian64FromArray(buffer, value);
+}
+template <>
+inline const uint8* WireFormatLite::ReadPrimitiveFromArray<
+  int32, WireFormatLite::TYPE_SFIXED32>(
+    const uint8* buffer,
+    int32* value) {
+  uint32 temp;
+  buffer = io::CodedInputStream::ReadLittleEndian32FromArray(buffer, &temp);
+  *value = static_cast<int32>(temp);
+  return buffer;
+}
+template <>
+inline const uint8* WireFormatLite::ReadPrimitiveFromArray<
+  int64, WireFormatLite::TYPE_SFIXED64>(
+    const uint8* buffer,
+    int64* value) {
+  uint64 temp;
+  buffer = io::CodedInputStream::ReadLittleEndian64FromArray(buffer, &temp);
+  *value = static_cast<int64>(temp);
+  return buffer;
+}
+template <>
+inline const uint8* WireFormatLite::ReadPrimitiveFromArray<
+  float, WireFormatLite::TYPE_FLOAT>(
+    const uint8* buffer,
+    float* value) {
+  uint32 temp;
+  buffer = io::CodedInputStream::ReadLittleEndian32FromArray(buffer, &temp);
+  *value = DecodeFloat(temp);
+  return buffer;
+}
+template <>
+inline const uint8* WireFormatLite::ReadPrimitiveFromArray<
+  double, WireFormatLite::TYPE_DOUBLE>(
+    const uint8* buffer,
+    double* value) {
+  uint64 temp;
+  buffer = io::CodedInputStream::ReadLittleEndian64FromArray(buffer, &temp);
+  *value = DecodeDouble(temp);
+  return buffer;
+}
+
+template <typename CType, enum WireFormatLite::FieldType DeclaredType>
+inline bool WireFormatLite::ReadRepeatedPrimitive(
+    int,  // tag_size, unused.
+    uint32 tag,
+    io::CodedInputStream* input,
+    RepeatedField<CType>* values) {
+  CType value;
+  if (!ReadPrimitive<CType, DeclaredType>(input, &value)) return false;
+  values->Add(value);
+  int elements_already_reserved = values->Capacity() - values->size();
+  while (elements_already_reserved > 0 && input->ExpectTag(tag)) {
+    if (!ReadPrimitive<CType, DeclaredType>(input, &value)) return false;
+    values->AddAlreadyReserved(value);
+    elements_already_reserved--;
+  }
+  return true;
+}
+
+template <typename CType, enum WireFormatLite::FieldType DeclaredType>
+inline bool WireFormatLite::ReadRepeatedFixedSizePrimitive(
+    int tag_size,
+    uint32 tag,
+    io::CodedInputStream* input,
+    RepeatedField<CType>* values) {
+  GOOGLE_DCHECK_EQ(UInt32Size(tag), static_cast<size_t>(tag_size));
+  CType value;
+  if (!ReadPrimitive<CType, DeclaredType>(input, &value))
+    return false;
+  values->Add(value);
+
+  // For fixed size values, repeated values can be read more quickly by
+  // reading directly from a raw array.
+  //
+  // We can get a tight loop by only reading as many elements as can be
+  // added to the RepeatedField without having to do any resizing. Additionally,
+  // we only try to read as many elements as are available from the current
+  // buffer space. Doing so avoids having to perform boundary checks when
+  // reading the value: the maximum number of elements that can be read is
+  // known outside of the loop.
+  const void* void_pointer;
+  int size;
+  input->GetDirectBufferPointerInline(&void_pointer, &size);
+  if (size > 0) {
+    const uint8* buffer = reinterpret_cast<const uint8*>(void_pointer);
+    // The number of bytes each type occupies on the wire.
+    const int per_value_size = tag_size + static_cast<int>(sizeof(value));
+
+    // parentheses around (std::min) prevents macro expansion of min(...)
+    int elements_available =
+        (std::min)(values->Capacity() - values->size(), size / per_value_size);
+    int num_read = 0;
+    while (num_read < elements_available &&
+           (buffer = io::CodedInputStream::ExpectTagFromArray(
+               buffer, tag)) != NULL) {
+      buffer = ReadPrimitiveFromArray<CType, DeclaredType>(buffer, &value);
+      values->AddAlreadyReserved(value);
+      ++num_read;
+    }
+    const int read_bytes = num_read * per_value_size;
+    if (read_bytes > 0) {
+      input->Skip(read_bytes);
+    }
+  }
+  return true;
+}
+
+// Specializations of ReadRepeatedPrimitive for the fixed size types, which use
+// the optimized code path.
+#define READ_REPEATED_FIXED_SIZE_PRIMITIVE(CPPTYPE, DECLARED_TYPE)             \
+template <>                                                                    \
+inline bool WireFormatLite::ReadRepeatedPrimitive<                             \
+  CPPTYPE, WireFormatLite::DECLARED_TYPE>(                                     \
+    int tag_size,                                                              \
+    uint32 tag,                                                                \
+    io::CodedInputStream* input,                                               \
+    RepeatedField<CPPTYPE>* values) {                                          \
+  return ReadRepeatedFixedSizePrimitive<                                       \
+    CPPTYPE, WireFormatLite::DECLARED_TYPE>(                                   \
+      tag_size, tag, input, values);                                           \
+}
+
+READ_REPEATED_FIXED_SIZE_PRIMITIVE(uint32, TYPE_FIXED32)
+READ_REPEATED_FIXED_SIZE_PRIMITIVE(uint64, TYPE_FIXED64)
+READ_REPEATED_FIXED_SIZE_PRIMITIVE(int32, TYPE_SFIXED32)
+READ_REPEATED_FIXED_SIZE_PRIMITIVE(int64, TYPE_SFIXED64)
+READ_REPEATED_FIXED_SIZE_PRIMITIVE(float, TYPE_FLOAT)
+READ_REPEATED_FIXED_SIZE_PRIMITIVE(double, TYPE_DOUBLE)
+
+#undef READ_REPEATED_FIXED_SIZE_PRIMITIVE
+
+template <typename CType, enum WireFormatLite::FieldType DeclaredType>
+bool WireFormatLite::ReadRepeatedPrimitiveNoInline(
+    int tag_size,
+    uint32 tag,
+    io::CodedInputStream* input,
+    RepeatedField<CType>* value) {
+  return ReadRepeatedPrimitive<CType, DeclaredType>(
+      tag_size, tag, input, value);
+}
+
+template <typename CType, enum WireFormatLite::FieldType DeclaredType>
+inline bool WireFormatLite::ReadPackedPrimitive(io::CodedInputStream* input,
+                                                RepeatedField<CType>* values) {
+  int length;
+  if (!input->ReadVarintSizeAsInt(&length)) return false;
+  io::CodedInputStream::Limit limit = input->PushLimit(length);
+  while (input->BytesUntilLimit() > 0) {
+    CType value;
+    if (!ReadPrimitive<CType, DeclaredType>(input, &value)) return false;
+    values->Add(value);
+  }
+  input->PopLimit(limit);
+  return true;
+}
+
+template <typename CType, enum WireFormatLite::FieldType DeclaredType>
+inline bool WireFormatLite::ReadPackedFixedSizePrimitive(
+    io::CodedInputStream* input, RepeatedField<CType>* values) {
+  int length;
+  if (!input->ReadVarintSizeAsInt(&length)) return false;
+  const int old_entries = values->size();
+  const int new_entries = length / static_cast<int>(sizeof(CType));
+  const int new_bytes = new_entries * static_cast<int>(sizeof(CType));
+  if (new_bytes != length) return false;
+  // We would *like* to pre-allocate the buffer to write into (for
+  // speed), but *must* avoid performing a very large allocation due
+  // to a malicious user-supplied "length" above.  So we have a fast
+  // path that pre-allocates when the "length" is less than a bound.
+  // We determine the bound by calling BytesUntilTotalBytesLimit() and
+  // BytesUntilLimit().  These return -1 to mean "no limit set".
+  // There are four cases:
+  // TotalBytesLimit  Limit
+  // -1               -1     Use slow path.
+  // -1               >= 0   Use fast path if length <= Limit.
+  // >= 0             -1     Use slow path.
+  // >= 0             >= 0   Use fast path if length <= min(both limits).
+  int64 bytes_limit = input->BytesUntilTotalBytesLimit();
+  if (bytes_limit == -1) {
+    bytes_limit = input->BytesUntilLimit();
+  } else {
+    // parentheses around (std::min) prevents macro expansion of min(...)
+    bytes_limit =
+        (std::min)(bytes_limit, static_cast<int64>(input->BytesUntilLimit()));
+  }
+  if (bytes_limit >= new_bytes) {
+    // Fast-path that pre-allocates *values to the final size.
+#if defined(PROTOBUF_LITTLE_ENDIAN)
+    values->Resize(old_entries + new_entries, 0);
+    // values->mutable_data() may change after Resize(), so do this after:
+    void* dest = reinterpret_cast<void*>(values->mutable_data() + old_entries);
+    if (!input->ReadRaw(dest, new_bytes)) {
+      values->Truncate(old_entries);
+      return false;
+    }
+#else
+    values->Reserve(old_entries + new_entries);
+    CType value;
+    for (int i = 0; i < new_entries; ++i) {
+      if (!ReadPrimitive<CType, DeclaredType>(input, &value)) return false;
+      values->AddAlreadyReserved(value);
+    }
+#endif
+  } else {
+    // This is the slow-path case where "length" may be too large to
+    // safely allocate.  We read as much as we can into *values
+    // without pre-allocating "length" bytes.
+    CType value;
+    for (int i = 0; i < new_entries; ++i) {
+      if (!ReadPrimitive<CType, DeclaredType>(input, &value)) return false;
+      values->Add(value);
+    }
+  }
+  return true;
+}
+
+// Specializations of ReadPackedPrimitive for the fixed size types, which use
+// an optimized code path.
+#define READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE(CPPTYPE, DECLARED_TYPE)      \
+template <>                                                                    \
+inline bool WireFormatLite::ReadPackedPrimitive<                               \
+  CPPTYPE, WireFormatLite::DECLARED_TYPE>(                                     \
+    io::CodedInputStream* input,                                               \
+    RepeatedField<CPPTYPE>* values) {                                          \
+  return ReadPackedFixedSizePrimitive<                                         \
+      CPPTYPE, WireFormatLite::DECLARED_TYPE>(input, values);                  \
+}
+
+READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE(uint32, TYPE_FIXED32)
+READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE(uint64, TYPE_FIXED64)
+READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE(int32, TYPE_SFIXED32)
+READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE(int64, TYPE_SFIXED64)
+READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE(float, TYPE_FLOAT)
+READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE(double, TYPE_DOUBLE)
+
+#undef READ_REPEATED_PACKED_FIXED_SIZE_PRIMITIVE
+
+template <typename CType, enum WireFormatLite::FieldType DeclaredType>
+bool WireFormatLite::ReadPackedPrimitiveNoInline(io::CodedInputStream* input,
+                                                 RepeatedField<CType>* values) {
+  return ReadPackedPrimitive<CType, DeclaredType>(input, values);
+}
+
+
+inline bool WireFormatLite::ReadGroup(int field_number,
+                                      io::CodedInputStream* input,
+                                      MessageLite* value) {
+  if (!input->IncrementRecursionDepth()) return false;
+  if (!value->MergePartialFromCodedStream(input)) return false;
+  input->DecrementRecursionDepth();
+  // Make sure the last thing read was an end tag for this group.
+  if (!input->LastTagWas(MakeTag(field_number, WIRETYPE_END_GROUP))) {
+    return false;
+  }
+  return true;
+}
+inline bool WireFormatLite::ReadMessage(io::CodedInputStream* input,
+                                        MessageLite* value) {
+  int length;
+  if (!input->ReadVarintSizeAsInt(&length)) return false;
+  std::pair<io::CodedInputStream::Limit, int> p =
+      input->IncrementRecursionDepthAndPushLimit(length);
+  if (p.second < 0 || !value->MergePartialFromCodedStream(input)) return false;
+  // Make sure that parsing stopped when the limit was hit, not at an endgroup
+  // tag.
+ return input->DecrementRecursionDepthAndPopLimit(p.first);
+}
+
+// We name the template parameter something long and extremely unlikely to occur
+// elsewhere because a *qualified* member access expression designed to avoid
+// virtual dispatch, C++03 [basic.lookup.classref] 3.4.5/4 requires that the
+// name of the qualifying class to be looked up both in the context of the full
+// expression (finding the template parameter) and in the context of the object
+// whose member we are accessing. This could potentially find a nested type
+// within that object. The standard goes on to require these names to refer to
+// the same entity, which this collision would violate. The lack of a safe way
+// to avoid this collision appears to be a defect in the standard, but until it
+// is corrected, we choose the name to avoid accidental collisions.
+template<typename MessageType_WorkAroundCppLookupDefect>
+inline bool WireFormatLite::ReadGroupNoVirtual(
+    int field_number, io::CodedInputStream* input,
+    MessageType_WorkAroundCppLookupDefect* value) {
+  if (!input->IncrementRecursionDepth()) return false;
+  if (!value->
+      MessageType_WorkAroundCppLookupDefect::MergePartialFromCodedStream(input))
+    return false;
+  input->UnsafeDecrementRecursionDepth();
+  // Make sure the last thing read was an end tag for this group.
+  if (!input->LastTagWas(MakeTag(field_number, WIRETYPE_END_GROUP))) {
+    return false;
+  }
+  return true;
+}
+template<typename MessageType_WorkAroundCppLookupDefect>
+inline bool WireFormatLite::ReadGroupNoVirtualNoRecursionDepth(
+    int field_number, io::CodedInputStream* input,
+    MessageType_WorkAroundCppLookupDefect* value) {
+  return value->MessageType_WorkAroundCppLookupDefect::
+             MergePartialFromCodedStream(input) &&
+         input->LastTagWas(MakeTag(field_number, WIRETYPE_END_GROUP));
+}
+template<typename MessageType_WorkAroundCppLookupDefect>
+inline bool WireFormatLite::ReadMessageNoVirtual(
+    io::CodedInputStream* input, MessageType_WorkAroundCppLookupDefect* value) {
+  int length;
+  if (!input->ReadVarintSizeAsInt(&length)) return false;
+  std::pair<io::CodedInputStream::Limit, int> p =
+      input->IncrementRecursionDepthAndPushLimit(length);
+  if (p.second < 0 || !value->
+      MessageType_WorkAroundCppLookupDefect::MergePartialFromCodedStream(input))
+    return false;
+  // Make sure that parsing stopped when the limit was hit, not at an endgroup
+  // tag.
+  return input->DecrementRecursionDepthAndPopLimit(p.first);
+}
+
+template<typename MessageType_WorkAroundCppLookupDefect>
+inline bool WireFormatLite::ReadMessageNoVirtualNoRecursionDepth(
+    io::CodedInputStream* input, MessageType_WorkAroundCppLookupDefect* value) {
+  io::CodedInputStream::Limit old_limit = input->ReadLengthAndPushLimit();
+  if (!value->
+      MessageType_WorkAroundCppLookupDefect::MergePartialFromCodedStream(input))
+    return false;
+  // Make sure that parsing stopped when the limit was hit, not at an endgroup
+  // tag.
+  return input->CheckEntireMessageConsumedAndPopLimit(old_limit);
+}
+
+// ===================================================================
+
+inline void WireFormatLite::WriteTag(int field_number, WireType type,
+                                     io::CodedOutputStream* output) {
+  output->WriteTag(MakeTag(field_number, type));
+}
+
+inline void WireFormatLite::WriteInt32NoTag(int32 value,
+                                            io::CodedOutputStream* output) {
+  output->WriteVarint32SignExtended(value);
+}
+inline void WireFormatLite::WriteInt64NoTag(int64 value,
+                                            io::CodedOutputStream* output) {
+  output->WriteVarint64(static_cast<uint64>(value));
+}
+inline void WireFormatLite::WriteUInt32NoTag(uint32 value,
+                                             io::CodedOutputStream* output) {
+  output->WriteVarint32(value);
+}
+inline void WireFormatLite::WriteUInt64NoTag(uint64 value,
+                                             io::CodedOutputStream* output) {
+  output->WriteVarint64(value);
+}
+inline void WireFormatLite::WriteSInt32NoTag(int32 value,
+                                             io::CodedOutputStream* output) {
+  output->WriteVarint32(ZigZagEncode32(value));
+}
+inline void WireFormatLite::WriteSInt64NoTag(int64 value,
+                                             io::CodedOutputStream* output) {
+  output->WriteVarint64(ZigZagEncode64(value));
+}
+inline void WireFormatLite::WriteFixed32NoTag(uint32 value,
+                                              io::CodedOutputStream* output) {
+  output->WriteLittleEndian32(value);
+}
+inline void WireFormatLite::WriteFixed64NoTag(uint64 value,
+                                              io::CodedOutputStream* output) {
+  output->WriteLittleEndian64(value);
+}
+inline void WireFormatLite::WriteSFixed32NoTag(int32 value,
+                                               io::CodedOutputStream* output) {
+  output->WriteLittleEndian32(static_cast<uint32>(value));
+}
+inline void WireFormatLite::WriteSFixed64NoTag(int64 value,
+                                               io::CodedOutputStream* output) {
+  output->WriteLittleEndian64(static_cast<uint64>(value));
+}
+inline void WireFormatLite::WriteFloatNoTag(float value,
+                                            io::CodedOutputStream* output) {
+  output->WriteLittleEndian32(EncodeFloat(value));
+}
+inline void WireFormatLite::WriteDoubleNoTag(double value,
+                                             io::CodedOutputStream* output) {
+  output->WriteLittleEndian64(EncodeDouble(value));
+}
+inline void WireFormatLite::WriteBoolNoTag(bool value,
+                                           io::CodedOutputStream* output) {
+  output->WriteVarint32(value ? 1 : 0);
+}
+inline void WireFormatLite::WriteEnumNoTag(int value,
+                                           io::CodedOutputStream* output) {
+  output->WriteVarint32SignExtended(value);
+}
+
+// See comment on ReadGroupNoVirtual to understand the need for this template
+// parameter name.
+template<typename MessageType_WorkAroundCppLookupDefect>
+inline void WireFormatLite::WriteGroupNoVirtual(
+    int field_number, const MessageType_WorkAroundCppLookupDefect& value,
+    io::CodedOutputStream* output) {
+  WriteTag(field_number, WIRETYPE_START_GROUP, output);
+  value.MessageType_WorkAroundCppLookupDefect::SerializeWithCachedSizes(output);
+  WriteTag(field_number, WIRETYPE_END_GROUP, output);
+}
+template<typename MessageType_WorkAroundCppLookupDefect>
+inline void WireFormatLite::WriteMessageNoVirtual(
+    int field_number, const MessageType_WorkAroundCppLookupDefect& value,
+    io::CodedOutputStream* output) {
+  WriteTag(field_number, WIRETYPE_LENGTH_DELIMITED, output);
+  output->WriteVarint32(
+      value.MessageType_WorkAroundCppLookupDefect::GetCachedSize());
+  value.MessageType_WorkAroundCppLookupDefect::SerializeWithCachedSizes(output);
+}
+
+// ===================================================================
+
+inline uint8* WireFormatLite::WriteTagToArray(int field_number,
+                                              WireType type,
+                                              uint8* target) {
+  return io::CodedOutputStream::WriteTagToArray(MakeTag(field_number, type),
+                                                target);
+}
+
+inline uint8* WireFormatLite::WriteInt32NoTagToArray(int32 value,
+                                                     uint8* target) {
+  return io::CodedOutputStream::WriteVarint32SignExtendedToArray(value, target);
+}
+inline uint8* WireFormatLite::WriteInt64NoTagToArray(int64 value,
+                                                     uint8* target) {
+  return io::CodedOutputStream::WriteVarint64ToArray(
+      static_cast<uint64>(value), target);
+}
+inline uint8* WireFormatLite::WriteUInt32NoTagToArray(uint32 value,
+                                                      uint8* target) {
+  return io::CodedOutputStream::WriteVarint32ToArray(value, target);
+}
+inline uint8* WireFormatLite::WriteUInt64NoTagToArray(uint64 value,
+                                                      uint8* target) {
+  return io::CodedOutputStream::WriteVarint64ToArray(value, target);
+}
+inline uint8* WireFormatLite::WriteSInt32NoTagToArray(int32 value,
+                                                      uint8* target) {
+  return io::CodedOutputStream::WriteVarint32ToArray(ZigZagEncode32(value),
+                                                     target);
+}
+inline uint8* WireFormatLite::WriteSInt64NoTagToArray(int64 value,
+                                                      uint8* target) {
+  return io::CodedOutputStream::WriteVarint64ToArray(ZigZagEncode64(value),
+                                                     target);
+}
+inline uint8* WireFormatLite::WriteFixed32NoTagToArray(uint32 value,
+                                                       uint8* target) {
+  return io::CodedOutputStream::WriteLittleEndian32ToArray(value, target);
+}
+inline uint8* WireFormatLite::WriteFixed64NoTagToArray(uint64 value,
+                                                       uint8* target) {
+  return io::CodedOutputStream::WriteLittleEndian64ToArray(value, target);
+}
+inline uint8* WireFormatLite::WriteSFixed32NoTagToArray(int32 value,
+                                                        uint8* target) {
+  return io::CodedOutputStream::WriteLittleEndian32ToArray(
+      static_cast<uint32>(value), target);
+}
+inline uint8* WireFormatLite::WriteSFixed64NoTagToArray(int64 value,
+                                                        uint8* target) {
+  return io::CodedOutputStream::WriteLittleEndian64ToArray(
+      static_cast<uint64>(value), target);
+}
+inline uint8* WireFormatLite::WriteFloatNoTagToArray(float value,
+                                                     uint8* target) {
+  return io::CodedOutputStream::WriteLittleEndian32ToArray(EncodeFloat(value),
+                                                           target);
+}
+inline uint8* WireFormatLite::WriteDoubleNoTagToArray(double value,
+                                                      uint8* target) {
+  return io::CodedOutputStream::WriteLittleEndian64ToArray(EncodeDouble(value),
+                                                           target);
+}
+inline uint8* WireFormatLite::WriteBoolNoTagToArray(bool value,
+                                                    uint8* target) {
+  return io::CodedOutputStream::WriteVarint32ToArray(value ? 1 : 0, target);
+}
+inline uint8* WireFormatLite::WriteEnumNoTagToArray(int value,
+                                                    uint8* target) {
+  return io::CodedOutputStream::WriteVarint32SignExtendedToArray(value, target);
+}
+
+template<typename T>
+inline uint8* WireFormatLite::WritePrimitiveNoTagToArray(
+      const RepeatedField<T>& value,
+      uint8* (*Writer)(T, uint8*), uint8* target) {
+  const int n = value.size();
+  GOOGLE_DCHECK_GT(n, 0);
+
+  const T* ii = value.unsafe_data();
+  int i = 0;
+  do {
+    target = Writer(ii[i], target);
+  } while (++i < n);
+
+  return target;
+}
+
+template<typename T>
+inline uint8* WireFormatLite::WriteFixedNoTagToArray(
+      const RepeatedField<T>& value,
+      uint8* (*Writer)(T, uint8*), uint8* target) {
+#if defined(PROTOBUF_LITTLE_ENDIAN)
+  (void) Writer;
+
+  const int n = value.size();
+  GOOGLE_DCHECK_GT(n, 0);
+
+  const T* ii = value.unsafe_data();
+  const int bytes = n * static_cast<int>(sizeof(ii[0]));
+  memcpy(target, ii, static_cast<size_t>(bytes));
+  return target + bytes;
+#else
+  return WritePrimitiveNoTagToArray(value, Writer, target);
+#endif
+}
+
+inline uint8* WireFormatLite::WriteInt32NoTagToArray(
+    const RepeatedField< int32>& value, uint8* target) {
+  return WritePrimitiveNoTagToArray(value, WriteInt32NoTagToArray, target);
+}
+inline uint8* WireFormatLite::WriteInt64NoTagToArray(
+    const RepeatedField< int64>& value, uint8* target) {
+  return WritePrimitiveNoTagToArray(value, WriteInt64NoTagToArray, target);
+}
+inline uint8* WireFormatLite::WriteUInt32NoTagToArray(
+    const RepeatedField<uint32>& value, uint8* target) {
+  return WritePrimitiveNoTagToArray(value, WriteUInt32NoTagToArray, target);
+}
+inline uint8* WireFormatLite::WriteUInt64NoTagToArray(
+    const RepeatedField<uint64>& value, uint8* target) {
+  return WritePrimitiveNoTagToArray(value, WriteUInt64NoTagToArray, target);
+}
+inline uint8* WireFormatLite::WriteSInt32NoTagToArray(
+    const RepeatedField< int32>& value, uint8* target) {
+  return WritePrimitiveNoTagToArray(value, WriteSInt32NoTagToArray, target);
+}
+inline uint8* WireFormatLite::WriteSInt64NoTagToArray(
+    const RepeatedField< int64>& value, uint8* target) {
+  return WritePrimitiveNoTagToArray(value, WriteSInt64NoTagToArray, target);
+}
+inline uint8* WireFormatLite::WriteFixed32NoTagToArray(
+    const RepeatedField<uint32>& value, uint8* target) {
+  return WriteFixedNoTagToArray(value, WriteFixed32NoTagToArray, target);
+}
+inline uint8* WireFormatLite::WriteFixed64NoTagToArray(
+    const RepeatedField<uint64>& value, uint8* target) {
+  return WriteFixedNoTagToArray(value, WriteFixed64NoTagToArray, target);
+}
+inline uint8* WireFormatLite::WriteSFixed32NoTagToArray(
+    const RepeatedField< int32>& value, uint8* target) {
+  return WriteFixedNoTagToArray(value, WriteSFixed32NoTagToArray, target);
+}
+inline uint8* WireFormatLite::WriteSFixed64NoTagToArray(
+    const RepeatedField< int64>& value, uint8* target) {
+  return WriteFixedNoTagToArray(value, WriteSFixed64NoTagToArray, target);
+}
+inline uint8* WireFormatLite::WriteFloatNoTagToArray(
+    const RepeatedField< float>& value, uint8* target) {
+  return WriteFixedNoTagToArray(value, WriteFloatNoTagToArray, target);
+}
+inline uint8* WireFormatLite::WriteDoubleNoTagToArray(
+    const RepeatedField<double>& value, uint8* target) {
+  return WriteFixedNoTagToArray(value, WriteDoubleNoTagToArray, target);
+}
+inline uint8* WireFormatLite::WriteBoolNoTagToArray(
+    const RepeatedField<  bool>& value, uint8* target) {
+  return WritePrimitiveNoTagToArray(value, WriteBoolNoTagToArray, target);
+}
+inline uint8* WireFormatLite::WriteEnumNoTagToArray(
+    const RepeatedField<   int>& value, uint8* target) {
+  return WritePrimitiveNoTagToArray(value, WriteEnumNoTagToArray, target);
+}
+
+inline uint8* WireFormatLite::WriteInt32ToArray(int field_number,
+                                                int32 value,
+                                                uint8* target) {
+  target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
+  return WriteInt32NoTagToArray(value, target);
+}
+inline uint8* WireFormatLite::WriteInt64ToArray(int field_number,
+                                                int64 value,
+                                                uint8* target) {
+  target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
+  return WriteInt64NoTagToArray(value, target);
+}
+inline uint8* WireFormatLite::WriteUInt32ToArray(int field_number,
+                                                 uint32 value,
+                                                 uint8* target) {
+  target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
+  return WriteUInt32NoTagToArray(value, target);
+}
+inline uint8* WireFormatLite::WriteUInt64ToArray(int field_number,
+                                                 uint64 value,
+                                                 uint8* target) {
+  target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
+  return WriteUInt64NoTagToArray(value, target);
+}
+inline uint8* WireFormatLite::WriteSInt32ToArray(int field_number,
+                                                 int32 value,
+                                                 uint8* target) {
+  target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
+  return WriteSInt32NoTagToArray(value, target);
+}
+inline uint8* WireFormatLite::WriteSInt64ToArray(int field_number,
+                                                 int64 value,
+                                                 uint8* target) {
+  target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
+  return WriteSInt64NoTagToArray(value, target);
+}
+inline uint8* WireFormatLite::WriteFixed32ToArray(int field_number,
+                                                  uint32 value,
+                                                  uint8* target) {
+  target = WriteTagToArray(field_number, WIRETYPE_FIXED32, target);
+  return WriteFixed32NoTagToArray(value, target);
+}
+inline uint8* WireFormatLite::WriteFixed64ToArray(int field_number,
+                                                  uint64 value,
+                                                  uint8* target) {
+  target = WriteTagToArray(field_number, WIRETYPE_FIXED64, target);
+  return WriteFixed64NoTagToArray(value, target);
+}
+inline uint8* WireFormatLite::WriteSFixed32ToArray(int field_number,
+                                                   int32 value,
+                                                   uint8* target) {
+  target = WriteTagToArray(field_number, WIRETYPE_FIXED32, target);
+  return WriteSFixed32NoTagToArray(value, target);
+}
+inline uint8* WireFormatLite::WriteSFixed64ToArray(int field_number,
+                                                   int64 value,
+                                                   uint8* target) {
+  target = WriteTagToArray(field_number, WIRETYPE_FIXED64, target);
+  return WriteSFixed64NoTagToArray(value, target);
+}
+inline uint8* WireFormatLite::WriteFloatToArray(int field_number,
+                                                float value,
+                                                uint8* target) {
+  target = WriteTagToArray(field_number, WIRETYPE_FIXED32, target);
+  return WriteFloatNoTagToArray(value, target);
+}
+inline uint8* WireFormatLite::WriteDoubleToArray(int field_number,
+                                                 double value,
+                                                 uint8* target) {
+  target = WriteTagToArray(field_number, WIRETYPE_FIXED64, target);
+  return WriteDoubleNoTagToArray(value, target);
+}
+inline uint8* WireFormatLite::WriteBoolToArray(int field_number,
+                                               bool value,
+                                               uint8* target) {
+  target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
+  return WriteBoolNoTagToArray(value, target);
+}
+inline uint8* WireFormatLite::WriteEnumToArray(int field_number,
+                                               int value,
+                                               uint8* target) {
+  target = WriteTagToArray(field_number, WIRETYPE_VARINT, target);
+  return WriteEnumNoTagToArray(value, target);
+}
+
+template<typename T>
+inline uint8* WireFormatLite::WritePrimitiveToArray(
+    int field_number,
+    const RepeatedField<T>& value,
+    uint8* (*Writer)(int, T, uint8*), uint8* target) {
+  const int n = value.size();
+  if (n == 0) {
+    return target;
+  }
+
+  const T* ii = value.unsafe_data();
+  int i = 0;
+  do {
+    target = Writer(field_number, ii[i], target);
+  } while (++i < n);
+
+  return target;
+}
+
+inline uint8* WireFormatLite::WriteInt32ToArray(
+    int field_number, const RepeatedField< int32>& value, uint8* target) {
+  return WritePrimitiveToArray(field_number, value, WriteInt32ToArray, target);
+}
+inline uint8* WireFormatLite::WriteInt64ToArray(
+    int field_number, const RepeatedField< int64>& value, uint8* target) {
+  return WritePrimitiveToArray(field_number, value, WriteInt64ToArray, target);
+}
+inline uint8* WireFormatLite::WriteUInt32ToArray(
+    int field_number, const RepeatedField<uint32>& value, uint8* target) {
+  return WritePrimitiveToArray(field_number, value, WriteUInt32ToArray, target);
+}
+inline uint8* WireFormatLite::WriteUInt64ToArray(
+    int field_number, const RepeatedField<uint64>& value, uint8* target) {
+  return WritePrimitiveToArray(field_number, value, WriteUInt64ToArray, target);
+}
+inline uint8* WireFormatLite::WriteSInt32ToArray(
+    int field_number, const RepeatedField< int32>& value, uint8* target) {
+  return WritePrimitiveToArray(field_number, value, WriteSInt32ToArray, target);
+}
+inline uint8* WireFormatLite::WriteSInt64ToArray(
+    int field_number, const RepeatedField< int64>& value, uint8* target) {
+  return WritePrimitiveToArray(field_number, value, WriteSInt64ToArray, target);
+}
+inline uint8* WireFormatLite::WriteFixed32ToArray(
+    int field_number, const RepeatedField<uint32>& value, uint8* target) {
+  return WritePrimitiveToArray(
+      field_number, value, WriteFixed32ToArray, target);
+}
+inline uint8* WireFormatLite::WriteFixed64ToArray(
+    int field_number, const RepeatedField<uint64>& value, uint8* target) {
+  return WritePrimitiveToArray(
+      field_number, value, WriteFixed64ToArray, target);
+}
+inline uint8* WireFormatLite::WriteSFixed32ToArray(
+    int field_number, const RepeatedField< int32>& value, uint8* target) {
+  return WritePrimitiveToArray(
+      field_number, value, WriteSFixed32ToArray, target);
+}
+inline uint8* WireFormatLite::WriteSFixed64ToArray(
+    int field_number, const RepeatedField< int64>& value, uint8* target) {
+  return WritePrimitiveToArray(
+      field_number, value, WriteSFixed64ToArray, target);
+}
+inline uint8* WireFormatLite::WriteFloatToArray(
+    int field_number, const RepeatedField< float>& value, uint8* target) {
+  return WritePrimitiveToArray(field_number, value, WriteFloatToArray, target);
+}
+inline uint8* WireFormatLite::WriteDoubleToArray(
+    int field_number, const RepeatedField<double>& value, uint8* target) {
+  return WritePrimitiveToArray(field_number, value, WriteDoubleToArray, target);
+}
+inline uint8* WireFormatLite::WriteBoolToArray(
+    int field_number, const RepeatedField<  bool>& value, uint8* target) {
+  return WritePrimitiveToArray(field_number, value, WriteBoolToArray, target);
+}
+inline uint8* WireFormatLite::WriteEnumToArray(
+    int field_number, const RepeatedField<   int>& value, uint8* target) {
+  return WritePrimitiveToArray(field_number, value, WriteEnumToArray, target);
+}
+inline uint8* WireFormatLite::WriteStringToArray(int field_number,
+                                                 const string& value,
+                                                 uint8* target) {
+  // String is for UTF-8 text only
+  // WARNING:  In wire_format.cc, both strings and bytes are handled by
+  //   WriteString() to avoid code duplication.  If the implementations become
+  //   different, you will need to update that usage.
+  target = WriteTagToArray(field_number, WIRETYPE_LENGTH_DELIMITED, target);
+  return io::CodedOutputStream::WriteStringWithSizeToArray(value, target);
+}
+inline uint8* WireFormatLite::WriteBytesToArray(int field_number,
+                                                const string& value,
+                                                uint8* target) {
+  target = WriteTagToArray(field_number, WIRETYPE_LENGTH_DELIMITED, target);
+  return io::CodedOutputStream::WriteStringWithSizeToArray(value, target);
+}
+
+
+inline uint8* WireFormatLite::InternalWriteGroupToArray(
+    int field_number, const MessageLite& value, bool deterministic,
+    uint8* target) {
+  target = WriteTagToArray(field_number, WIRETYPE_START_GROUP, target);
+  target = value.InternalSerializeWithCachedSizesToArray(deterministic, target);
+  return WriteTagToArray(field_number, WIRETYPE_END_GROUP, target);
+}
+inline uint8* WireFormatLite::InternalWriteMessageToArray(
+    int field_number, const MessageLite& value, bool deterministic,
+    uint8* target) {
+  target = WriteTagToArray(field_number, WIRETYPE_LENGTH_DELIMITED, target);
+  target = io::CodedOutputStream::WriteVarint32ToArray(
+    static_cast<uint32>(value.GetCachedSize()), target);
+  return value.InternalSerializeWithCachedSizesToArray(deterministic, target);
+}
+
+// See comment on ReadGroupNoVirtual to understand the need for this template
+// parameter name.
+template<typename MessageType_WorkAroundCppLookupDefect>
+inline uint8* WireFormatLite::InternalWriteGroupNoVirtualToArray(
+    int field_number, const MessageType_WorkAroundCppLookupDefect& value,
+    bool deterministic, uint8* target) {
+  target = WriteTagToArray(field_number, WIRETYPE_START_GROUP, target);
+  target = value.MessageType_WorkAroundCppLookupDefect::
+      InternalSerializeWithCachedSizesToArray(deterministic, target);
+  return WriteTagToArray(field_number, WIRETYPE_END_GROUP, target);
+}
+template<typename MessageType_WorkAroundCppLookupDefect>
+inline uint8* WireFormatLite::InternalWriteMessageNoVirtualToArray(
+    int field_number, const MessageType_WorkAroundCppLookupDefect& value,
+    bool deterministic, uint8* target) {
+  target = WriteTagToArray(field_number, WIRETYPE_LENGTH_DELIMITED, target);
+  target = io::CodedOutputStream::WriteVarint32ToArray(
+        static_cast<uint32>(
+            value.MessageType_WorkAroundCppLookupDefect::GetCachedSize()),
+        target);
+  return value.MessageType_WorkAroundCppLookupDefect::
+      InternalSerializeWithCachedSizesToArray(deterministic, target);
+}
+
+// ===================================================================
+
+inline size_t WireFormatLite::Int32Size(int32 value) {
+  return io::CodedOutputStream::VarintSize32SignExtended(value);
+}
+inline size_t WireFormatLite::Int64Size(int64 value) {
+  return io::CodedOutputStream::VarintSize64(static_cast<uint64>(value));
+}
+inline size_t WireFormatLite::UInt32Size(uint32 value) {
+  return io::CodedOutputStream::VarintSize32(value);
+}
+inline size_t WireFormatLite::UInt64Size(uint64 value) {
+  return io::CodedOutputStream::VarintSize64(value);
+}
+inline size_t WireFormatLite::SInt32Size(int32 value) {
+  return io::CodedOutputStream::VarintSize32(ZigZagEncode32(value));
+}
+inline size_t WireFormatLite::SInt64Size(int64 value) {
+  return io::CodedOutputStream::VarintSize64(ZigZagEncode64(value));
+}
+inline size_t WireFormatLite::EnumSize(int value) {
+  return io::CodedOutputStream::VarintSize32SignExtended(value);
+}
+
+inline size_t WireFormatLite::StringSize(const string& value) {
+  return LengthDelimitedSize(value.size());
+}
+inline size_t WireFormatLite::BytesSize(const string& value) {
+  return LengthDelimitedSize(value.size());
+}
+
+
+inline size_t WireFormatLite::GroupSize(const MessageLite& value) {
+  return value.ByteSizeLong();
+}
+inline size_t WireFormatLite::MessageSize(const MessageLite& value) {
+  return LengthDelimitedSize(value.ByteSizeLong());
+}
+
+// See comment on ReadGroupNoVirtual to understand the need for this template
+// parameter name.
+template<typename MessageType_WorkAroundCppLookupDefect>
+inline size_t WireFormatLite::GroupSizeNoVirtual(
+    const MessageType_WorkAroundCppLookupDefect& value) {
+  return value.MessageType_WorkAroundCppLookupDefect::ByteSizeLong();
+}
+template<typename MessageType_WorkAroundCppLookupDefect>
+inline size_t WireFormatLite::MessageSizeNoVirtual(
+    const MessageType_WorkAroundCppLookupDefect& value) {
+  return LengthDelimitedSize(
+      value.MessageType_WorkAroundCppLookupDefect::ByteSizeLong());
+}
+
+inline size_t WireFormatLite::LengthDelimitedSize(size_t length) {
+  // The static_cast here prevents an error in certain compiler configurations
+  // but is not technically correct--if length is too large to fit in a uint32
+  // then it will be silently truncated. We will need to fix this if we ever
+  // decide to start supporting serialized messages greater than 2 GiB in size.
+  return length + io::CodedOutputStream::VarintSize32(
+      static_cast<uint32>(length));
+}
+
+size_t WireFormatLite::Int64Size (const RepeatedField< int64>& value) {
+  size_t out = 0;
+  const int n = value.size();
+  for (int i = 0; i < n; i++) {
+    out += Int64Size(value.Get(i));
+  }
+  return out;
+}
+
+size_t WireFormatLite::UInt64Size(const RepeatedField<uint64>& value) {
+  size_t out = 0;
+  const int n = value.size();
+  for (int i = 0; i < n; i++) {
+    out += UInt64Size(value.Get(i));
+  }
+  return out;
+}
+
+size_t WireFormatLite::SInt64Size(const RepeatedField< int64>& value) {
+  size_t out = 0;
+  const int n = value.size();
+  for (int i = 0; i < n; i++) {
+    out += SInt64Size(value.Get(i));
+  }
+  return out;
+}
+
+}  // namespace internal
+}  // namespace protobuf
+
+}  // namespace google
+#endif  // GOOGLE_PROTOBUF_WIRE_FORMAT_LITE_INL_H__
diff --git a/kortex_api/include/google/protobuf/wrappers.pb.h b/kortex_api/include/google/protobuf/wrappers.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..a2f10c8bfa073a79fccebc45929e2d2ab6d8324e
--- /dev/null
+++ b/kortex_api/include/google/protobuf/wrappers.pb.h
@@ -0,0 +1,1487 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: google/protobuf/wrappers.proto
+
+#ifndef PROTOBUF_google_2fprotobuf_2fwrappers_2eproto__INCLUDED
+#define PROTOBUF_google_2fprotobuf_2fwrappers_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 3005000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 3005001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+// @@protoc_insertion_point(includes)
+
+namespace protobuf_google_2fprotobuf_2fwrappers_2eproto {
+// Internal implementation detail -- do not use these members.
+struct LIBPROTOBUF_EXPORT TableStruct {
+  static const ::google::protobuf::internal::ParseTableField entries[];
+  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
+  static const ::google::protobuf::internal::ParseTable schema[9];
+  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
+  static const ::google::protobuf::internal::SerializationTable serialization_table[];
+  static const ::google::protobuf::uint32 offsets[];
+};
+void LIBPROTOBUF_EXPORT AddDescriptors();
+void LIBPROTOBUF_EXPORT InitDefaultsDoubleValueImpl();
+void LIBPROTOBUF_EXPORT InitDefaultsDoubleValue();
+void LIBPROTOBUF_EXPORT InitDefaultsFloatValueImpl();
+void LIBPROTOBUF_EXPORT InitDefaultsFloatValue();
+void LIBPROTOBUF_EXPORT InitDefaultsInt64ValueImpl();
+void LIBPROTOBUF_EXPORT InitDefaultsInt64Value();
+void LIBPROTOBUF_EXPORT InitDefaultsUInt64ValueImpl();
+void LIBPROTOBUF_EXPORT InitDefaultsUInt64Value();
+void LIBPROTOBUF_EXPORT InitDefaultsInt32ValueImpl();
+void LIBPROTOBUF_EXPORT InitDefaultsInt32Value();
+void LIBPROTOBUF_EXPORT InitDefaultsUInt32ValueImpl();
+void LIBPROTOBUF_EXPORT InitDefaultsUInt32Value();
+void LIBPROTOBUF_EXPORT InitDefaultsBoolValueImpl();
+void LIBPROTOBUF_EXPORT InitDefaultsBoolValue();
+void LIBPROTOBUF_EXPORT InitDefaultsStringValueImpl();
+void LIBPROTOBUF_EXPORT InitDefaultsStringValue();
+void LIBPROTOBUF_EXPORT InitDefaultsBytesValueImpl();
+void LIBPROTOBUF_EXPORT InitDefaultsBytesValue();
+inline void LIBPROTOBUF_EXPORT InitDefaults() {
+  InitDefaultsDoubleValue();
+  InitDefaultsFloatValue();
+  InitDefaultsInt64Value();
+  InitDefaultsUInt64Value();
+  InitDefaultsInt32Value();
+  InitDefaultsUInt32Value();
+  InitDefaultsBoolValue();
+  InitDefaultsStringValue();
+  InitDefaultsBytesValue();
+}
+}  // namespace protobuf_google_2fprotobuf_2fwrappers_2eproto
+namespace google {
+namespace protobuf {
+class BoolValue;
+class BoolValueDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern BoolValueDefaultTypeInternal _BoolValue_default_instance_;
+class BytesValue;
+class BytesValueDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern BytesValueDefaultTypeInternal _BytesValue_default_instance_;
+class DoubleValue;
+class DoubleValueDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern DoubleValueDefaultTypeInternal _DoubleValue_default_instance_;
+class FloatValue;
+class FloatValueDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern FloatValueDefaultTypeInternal _FloatValue_default_instance_;
+class Int32Value;
+class Int32ValueDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern Int32ValueDefaultTypeInternal _Int32Value_default_instance_;
+class Int64Value;
+class Int64ValueDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern Int64ValueDefaultTypeInternal _Int64Value_default_instance_;
+class StringValue;
+class StringValueDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern StringValueDefaultTypeInternal _StringValue_default_instance_;
+class UInt32Value;
+class UInt32ValueDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern UInt32ValueDefaultTypeInternal _UInt32Value_default_instance_;
+class UInt64Value;
+class UInt64ValueDefaultTypeInternal;
+LIBPROTOBUF_EXPORT extern UInt64ValueDefaultTypeInternal _UInt64Value_default_instance_;
+}  // namespace protobuf
+}  // namespace google
+namespace google {
+namespace protobuf {
+
+// ===================================================================
+
+class LIBPROTOBUF_EXPORT DoubleValue : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.DoubleValue) */ {
+ public:
+  DoubleValue();
+  virtual ~DoubleValue();
+
+  DoubleValue(const DoubleValue& from);
+
+  inline DoubleValue& operator=(const DoubleValue& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  DoubleValue(DoubleValue&& from) noexcept
+    : DoubleValue() {
+    *this = ::std::move(from);
+  }
+
+  inline DoubleValue& operator=(DoubleValue&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
+    return GetArenaNoVirtual();
+  }
+  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
+    return MaybeArenaPtr();
+  }
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const DoubleValue& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const DoubleValue* internal_default_instance() {
+    return reinterpret_cast<const DoubleValue*>(
+               &_DoubleValue_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    0;
+
+  void UnsafeArenaSwap(DoubleValue* other);
+  void Swap(DoubleValue* other);
+  friend void swap(DoubleValue& a, DoubleValue& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline DoubleValue* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  DoubleValue* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const DoubleValue& from);
+  void MergeFrom(const DoubleValue& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(DoubleValue* other);
+  protected:
+  explicit DoubleValue(::google::protobuf::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return _internal_metadata_.arena();
+  }
+  inline void* MaybeArenaPtr() const {
+    return _internal_metadata_.raw_arena_ptr();
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // double value = 1;
+  void clear_value();
+  static const int kValueFieldNumber = 1;
+  double value() const;
+  void set_value(double value);
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.DoubleValue)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  double value_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_google_2fprotobuf_2fwrappers_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2fwrappers_2eproto::InitDefaultsDoubleValueImpl();
+};
+// -------------------------------------------------------------------
+
+class LIBPROTOBUF_EXPORT FloatValue : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.FloatValue) */ {
+ public:
+  FloatValue();
+  virtual ~FloatValue();
+
+  FloatValue(const FloatValue& from);
+
+  inline FloatValue& operator=(const FloatValue& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  FloatValue(FloatValue&& from) noexcept
+    : FloatValue() {
+    *this = ::std::move(from);
+  }
+
+  inline FloatValue& operator=(FloatValue&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
+    return GetArenaNoVirtual();
+  }
+  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
+    return MaybeArenaPtr();
+  }
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const FloatValue& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const FloatValue* internal_default_instance() {
+    return reinterpret_cast<const FloatValue*>(
+               &_FloatValue_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    1;
+
+  void UnsafeArenaSwap(FloatValue* other);
+  void Swap(FloatValue* other);
+  friend void swap(FloatValue& a, FloatValue& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline FloatValue* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  FloatValue* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const FloatValue& from);
+  void MergeFrom(const FloatValue& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(FloatValue* other);
+  protected:
+  explicit FloatValue(::google::protobuf::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return _internal_metadata_.arena();
+  }
+  inline void* MaybeArenaPtr() const {
+    return _internal_metadata_.raw_arena_ptr();
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // float value = 1;
+  void clear_value();
+  static const int kValueFieldNumber = 1;
+  float value() const;
+  void set_value(float value);
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.FloatValue)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  float value_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_google_2fprotobuf_2fwrappers_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2fwrappers_2eproto::InitDefaultsFloatValueImpl();
+};
+// -------------------------------------------------------------------
+
+class LIBPROTOBUF_EXPORT Int64Value : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Int64Value) */ {
+ public:
+  Int64Value();
+  virtual ~Int64Value();
+
+  Int64Value(const Int64Value& from);
+
+  inline Int64Value& operator=(const Int64Value& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Int64Value(Int64Value&& from) noexcept
+    : Int64Value() {
+    *this = ::std::move(from);
+  }
+
+  inline Int64Value& operator=(Int64Value&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
+    return GetArenaNoVirtual();
+  }
+  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
+    return MaybeArenaPtr();
+  }
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Int64Value& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Int64Value* internal_default_instance() {
+    return reinterpret_cast<const Int64Value*>(
+               &_Int64Value_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    2;
+
+  void UnsafeArenaSwap(Int64Value* other);
+  void Swap(Int64Value* other);
+  friend void swap(Int64Value& a, Int64Value& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Int64Value* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Int64Value* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Int64Value& from);
+  void MergeFrom(const Int64Value& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Int64Value* other);
+  protected:
+  explicit Int64Value(::google::protobuf::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return _internal_metadata_.arena();
+  }
+  inline void* MaybeArenaPtr() const {
+    return _internal_metadata_.raw_arena_ptr();
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // int64 value = 1;
+  void clear_value();
+  static const int kValueFieldNumber = 1;
+  ::google::protobuf::int64 value() const;
+  void set_value(::google::protobuf::int64 value);
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.Int64Value)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::google::protobuf::int64 value_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_google_2fprotobuf_2fwrappers_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2fwrappers_2eproto::InitDefaultsInt64ValueImpl();
+};
+// -------------------------------------------------------------------
+
+class LIBPROTOBUF_EXPORT UInt64Value : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.UInt64Value) */ {
+ public:
+  UInt64Value();
+  virtual ~UInt64Value();
+
+  UInt64Value(const UInt64Value& from);
+
+  inline UInt64Value& operator=(const UInt64Value& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  UInt64Value(UInt64Value&& from) noexcept
+    : UInt64Value() {
+    *this = ::std::move(from);
+  }
+
+  inline UInt64Value& operator=(UInt64Value&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
+    return GetArenaNoVirtual();
+  }
+  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
+    return MaybeArenaPtr();
+  }
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const UInt64Value& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const UInt64Value* internal_default_instance() {
+    return reinterpret_cast<const UInt64Value*>(
+               &_UInt64Value_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    3;
+
+  void UnsafeArenaSwap(UInt64Value* other);
+  void Swap(UInt64Value* other);
+  friend void swap(UInt64Value& a, UInt64Value& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline UInt64Value* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  UInt64Value* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const UInt64Value& from);
+  void MergeFrom(const UInt64Value& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(UInt64Value* other);
+  protected:
+  explicit UInt64Value(::google::protobuf::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return _internal_metadata_.arena();
+  }
+  inline void* MaybeArenaPtr() const {
+    return _internal_metadata_.raw_arena_ptr();
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // uint64 value = 1;
+  void clear_value();
+  static const int kValueFieldNumber = 1;
+  ::google::protobuf::uint64 value() const;
+  void set_value(::google::protobuf::uint64 value);
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.UInt64Value)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::google::protobuf::uint64 value_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_google_2fprotobuf_2fwrappers_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2fwrappers_2eproto::InitDefaultsUInt64ValueImpl();
+};
+// -------------------------------------------------------------------
+
+class LIBPROTOBUF_EXPORT Int32Value : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.Int32Value) */ {
+ public:
+  Int32Value();
+  virtual ~Int32Value();
+
+  Int32Value(const Int32Value& from);
+
+  inline Int32Value& operator=(const Int32Value& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Int32Value(Int32Value&& from) noexcept
+    : Int32Value() {
+    *this = ::std::move(from);
+  }
+
+  inline Int32Value& operator=(Int32Value&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
+    return GetArenaNoVirtual();
+  }
+  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
+    return MaybeArenaPtr();
+  }
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Int32Value& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Int32Value* internal_default_instance() {
+    return reinterpret_cast<const Int32Value*>(
+               &_Int32Value_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    4;
+
+  void UnsafeArenaSwap(Int32Value* other);
+  void Swap(Int32Value* other);
+  friend void swap(Int32Value& a, Int32Value& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Int32Value* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Int32Value* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Int32Value& from);
+  void MergeFrom(const Int32Value& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Int32Value* other);
+  protected:
+  explicit Int32Value(::google::protobuf::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return _internal_metadata_.arena();
+  }
+  inline void* MaybeArenaPtr() const {
+    return _internal_metadata_.raw_arena_ptr();
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // int32 value = 1;
+  void clear_value();
+  static const int kValueFieldNumber = 1;
+  ::google::protobuf::int32 value() const;
+  void set_value(::google::protobuf::int32 value);
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.Int32Value)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::google::protobuf::int32 value_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_google_2fprotobuf_2fwrappers_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2fwrappers_2eproto::InitDefaultsInt32ValueImpl();
+};
+// -------------------------------------------------------------------
+
+class LIBPROTOBUF_EXPORT UInt32Value : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.UInt32Value) */ {
+ public:
+  UInt32Value();
+  virtual ~UInt32Value();
+
+  UInt32Value(const UInt32Value& from);
+
+  inline UInt32Value& operator=(const UInt32Value& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  UInt32Value(UInt32Value&& from) noexcept
+    : UInt32Value() {
+    *this = ::std::move(from);
+  }
+
+  inline UInt32Value& operator=(UInt32Value&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
+    return GetArenaNoVirtual();
+  }
+  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
+    return MaybeArenaPtr();
+  }
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const UInt32Value& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const UInt32Value* internal_default_instance() {
+    return reinterpret_cast<const UInt32Value*>(
+               &_UInt32Value_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    5;
+
+  void UnsafeArenaSwap(UInt32Value* other);
+  void Swap(UInt32Value* other);
+  friend void swap(UInt32Value& a, UInt32Value& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline UInt32Value* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  UInt32Value* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const UInt32Value& from);
+  void MergeFrom(const UInt32Value& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(UInt32Value* other);
+  protected:
+  explicit UInt32Value(::google::protobuf::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return _internal_metadata_.arena();
+  }
+  inline void* MaybeArenaPtr() const {
+    return _internal_metadata_.raw_arena_ptr();
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // uint32 value = 1;
+  void clear_value();
+  static const int kValueFieldNumber = 1;
+  ::google::protobuf::uint32 value() const;
+  void set_value(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.UInt32Value)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::google::protobuf::uint32 value_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_google_2fprotobuf_2fwrappers_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2fwrappers_2eproto::InitDefaultsUInt32ValueImpl();
+};
+// -------------------------------------------------------------------
+
+class LIBPROTOBUF_EXPORT BoolValue : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.BoolValue) */ {
+ public:
+  BoolValue();
+  virtual ~BoolValue();
+
+  BoolValue(const BoolValue& from);
+
+  inline BoolValue& operator=(const BoolValue& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  BoolValue(BoolValue&& from) noexcept
+    : BoolValue() {
+    *this = ::std::move(from);
+  }
+
+  inline BoolValue& operator=(BoolValue&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
+    return GetArenaNoVirtual();
+  }
+  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
+    return MaybeArenaPtr();
+  }
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const BoolValue& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const BoolValue* internal_default_instance() {
+    return reinterpret_cast<const BoolValue*>(
+               &_BoolValue_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    6;
+
+  void UnsafeArenaSwap(BoolValue* other);
+  void Swap(BoolValue* other);
+  friend void swap(BoolValue& a, BoolValue& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline BoolValue* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  BoolValue* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const BoolValue& from);
+  void MergeFrom(const BoolValue& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(BoolValue* other);
+  protected:
+  explicit BoolValue(::google::protobuf::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return _internal_metadata_.arena();
+  }
+  inline void* MaybeArenaPtr() const {
+    return _internal_metadata_.raw_arena_ptr();
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // bool value = 1;
+  void clear_value();
+  static const int kValueFieldNumber = 1;
+  bool value() const;
+  void set_value(bool value);
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.BoolValue)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  bool value_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_google_2fprotobuf_2fwrappers_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2fwrappers_2eproto::InitDefaultsBoolValueImpl();
+};
+// -------------------------------------------------------------------
+
+class LIBPROTOBUF_EXPORT StringValue : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.StringValue) */ {
+ public:
+  StringValue();
+  virtual ~StringValue();
+
+  StringValue(const StringValue& from);
+
+  inline StringValue& operator=(const StringValue& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  StringValue(StringValue&& from) noexcept
+    : StringValue() {
+    *this = ::std::move(from);
+  }
+
+  inline StringValue& operator=(StringValue&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
+    return GetArenaNoVirtual();
+  }
+  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
+    return MaybeArenaPtr();
+  }
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const StringValue& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const StringValue* internal_default_instance() {
+    return reinterpret_cast<const StringValue*>(
+               &_StringValue_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    7;
+
+  void UnsafeArenaSwap(StringValue* other);
+  void Swap(StringValue* other);
+  friend void swap(StringValue& a, StringValue& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline StringValue* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  StringValue* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const StringValue& from);
+  void MergeFrom(const StringValue& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(StringValue* other);
+  protected:
+  explicit StringValue(::google::protobuf::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return _internal_metadata_.arena();
+  }
+  inline void* MaybeArenaPtr() const {
+    return _internal_metadata_.raw_arena_ptr();
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // string value = 1;
+  void clear_value();
+  static const int kValueFieldNumber = 1;
+  const ::std::string& value() const;
+  void set_value(const ::std::string& value);
+  #if LANG_CXX11
+  void set_value(::std::string&& value);
+  #endif
+  void set_value(const char* value);
+  void set_value(const char* value, size_t size);
+  ::std::string* mutable_value();
+  ::std::string* release_value();
+  void set_allocated_value(::std::string* value);
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  ::std::string* unsafe_arena_release_value();
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  void unsafe_arena_set_allocated_value(
+      ::std::string* value);
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.StringValue)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::google::protobuf::internal::ArenaStringPtr value_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_google_2fprotobuf_2fwrappers_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2fwrappers_2eproto::InitDefaultsStringValueImpl();
+};
+// -------------------------------------------------------------------
+
+class LIBPROTOBUF_EXPORT BytesValue : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:google.protobuf.BytesValue) */ {
+ public:
+  BytesValue();
+  virtual ~BytesValue();
+
+  BytesValue(const BytesValue& from);
+
+  inline BytesValue& operator=(const BytesValue& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  BytesValue(BytesValue&& from) noexcept
+    : BytesValue() {
+    *this = ::std::move(from);
+  }
+
+  inline BytesValue& operator=(BytesValue&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  inline ::google::protobuf::Arena* GetArena() const PROTOBUF_FINAL {
+    return GetArenaNoVirtual();
+  }
+  inline void* GetMaybeArenaPointer() const PROTOBUF_FINAL {
+    return MaybeArenaPtr();
+  }
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const BytesValue& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const BytesValue* internal_default_instance() {
+    return reinterpret_cast<const BytesValue*>(
+               &_BytesValue_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    8;
+
+  void UnsafeArenaSwap(BytesValue* other);
+  void Swap(BytesValue* other);
+  friend void swap(BytesValue& a, BytesValue& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline BytesValue* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  BytesValue* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const BytesValue& from);
+  void MergeFrom(const BytesValue& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(BytesValue* other);
+  protected:
+  explicit BytesValue(::google::protobuf::Arena* arena);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::google::protobuf::Arena* arena);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return _internal_metadata_.arena();
+  }
+  inline void* MaybeArenaPtr() const {
+    return _internal_metadata_.raw_arena_ptr();
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // bytes value = 1;
+  void clear_value();
+  static const int kValueFieldNumber = 1;
+  const ::std::string& value() const;
+  void set_value(const ::std::string& value);
+  #if LANG_CXX11
+  void set_value(::std::string&& value);
+  #endif
+  void set_value(const char* value);
+  void set_value(const void* value, size_t size);
+  ::std::string* mutable_value();
+  ::std::string* release_value();
+  void set_allocated_value(::std::string* value);
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  ::std::string* unsafe_arena_release_value();
+  PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
+  "    string fields are deprecated and will be removed in a"
+  "    future release.")
+  void unsafe_arena_set_allocated_value(
+      ::std::string* value);
+
+  // @@protoc_insertion_point(class_scope:google.protobuf.BytesValue)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  template <typename T> friend class ::google::protobuf::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::google::protobuf::internal::ArenaStringPtr value_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_google_2fprotobuf_2fwrappers_2eproto::TableStruct;
+  friend void ::protobuf_google_2fprotobuf_2fwrappers_2eproto::InitDefaultsBytesValueImpl();
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// DoubleValue
+
+// double value = 1;
+inline void DoubleValue::clear_value() {
+  value_ = 0;
+}
+inline double DoubleValue::value() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.DoubleValue.value)
+  return value_;
+}
+inline void DoubleValue::set_value(double value) {
+  
+  value_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.DoubleValue.value)
+}
+
+// -------------------------------------------------------------------
+
+// FloatValue
+
+// float value = 1;
+inline void FloatValue::clear_value() {
+  value_ = 0;
+}
+inline float FloatValue::value() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.FloatValue.value)
+  return value_;
+}
+inline void FloatValue::set_value(float value) {
+  
+  value_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.FloatValue.value)
+}
+
+// -------------------------------------------------------------------
+
+// Int64Value
+
+// int64 value = 1;
+inline void Int64Value::clear_value() {
+  value_ = GOOGLE_LONGLONG(0);
+}
+inline ::google::protobuf::int64 Int64Value::value() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Int64Value.value)
+  return value_;
+}
+inline void Int64Value::set_value(::google::protobuf::int64 value) {
+  
+  value_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.Int64Value.value)
+}
+
+// -------------------------------------------------------------------
+
+// UInt64Value
+
+// uint64 value = 1;
+inline void UInt64Value::clear_value() {
+  value_ = GOOGLE_ULONGLONG(0);
+}
+inline ::google::protobuf::uint64 UInt64Value::value() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.UInt64Value.value)
+  return value_;
+}
+inline void UInt64Value::set_value(::google::protobuf::uint64 value) {
+  
+  value_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.UInt64Value.value)
+}
+
+// -------------------------------------------------------------------
+
+// Int32Value
+
+// int32 value = 1;
+inline void Int32Value::clear_value() {
+  value_ = 0;
+}
+inline ::google::protobuf::int32 Int32Value::value() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.Int32Value.value)
+  return value_;
+}
+inline void Int32Value::set_value(::google::protobuf::int32 value) {
+  
+  value_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.Int32Value.value)
+}
+
+// -------------------------------------------------------------------
+
+// UInt32Value
+
+// uint32 value = 1;
+inline void UInt32Value::clear_value() {
+  value_ = 0u;
+}
+inline ::google::protobuf::uint32 UInt32Value::value() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.UInt32Value.value)
+  return value_;
+}
+inline void UInt32Value::set_value(::google::protobuf::uint32 value) {
+  
+  value_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.UInt32Value.value)
+}
+
+// -------------------------------------------------------------------
+
+// BoolValue
+
+// bool value = 1;
+inline void BoolValue::clear_value() {
+  value_ = false;
+}
+inline bool BoolValue::value() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.BoolValue.value)
+  return value_;
+}
+inline void BoolValue::set_value(bool value) {
+  
+  value_ = value;
+  // @@protoc_insertion_point(field_set:google.protobuf.BoolValue.value)
+}
+
+// -------------------------------------------------------------------
+
+// StringValue
+
+// string value = 1;
+inline void StringValue::clear_value() {
+  value_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline const ::std::string& StringValue::value() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.StringValue.value)
+  return value_.Get();
+}
+inline void StringValue::set_value(const ::std::string& value) {
+  
+  value_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set:google.protobuf.StringValue.value)
+}
+#if LANG_CXX11
+inline void StringValue::set_value(::std::string&& value) {
+  
+  value_.Set(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.StringValue.value)
+}
+#endif
+inline void StringValue::set_value(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  value_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
+              GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_char:google.protobuf.StringValue.value)
+}
+inline void StringValue::set_value(const char* value,
+    size_t size) {
+  
+  value_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
+      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.StringValue.value)
+}
+inline ::std::string* StringValue::mutable_value() {
+  
+  // @@protoc_insertion_point(field_mutable:google.protobuf.StringValue.value)
+  return value_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline ::std::string* StringValue::release_value() {
+  // @@protoc_insertion_point(field_release:google.protobuf.StringValue.value)
+  
+  return value_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline void StringValue::set_allocated_value(::std::string* value) {
+  if (value != NULL) {
+    
+  } else {
+    
+  }
+  value_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value,
+      GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.StringValue.value)
+}
+inline ::std::string* StringValue::unsafe_arena_release_value() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.StringValue.value)
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  
+  return value_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      GetArenaNoVirtual());
+}
+inline void StringValue::unsafe_arena_set_allocated_value(
+    ::std::string* value) {
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  if (value != NULL) {
+    
+  } else {
+    
+  }
+  value_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      value, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.StringValue.value)
+}
+
+// -------------------------------------------------------------------
+
+// BytesValue
+
+// bytes value = 1;
+inline void BytesValue::clear_value() {
+  value_.ClearToEmpty(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline const ::std::string& BytesValue::value() const {
+  // @@protoc_insertion_point(field_get:google.protobuf.BytesValue.value)
+  return value_.Get();
+}
+inline void BytesValue::set_value(const ::std::string& value) {
+  
+  value_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set:google.protobuf.BytesValue.value)
+}
+#if LANG_CXX11
+inline void BytesValue::set_value(::std::string&& value) {
+  
+  value_.Set(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_rvalue:google.protobuf.BytesValue.value)
+}
+#endif
+inline void BytesValue::set_value(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  value_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
+              GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_char:google.protobuf.BytesValue.value)
+}
+inline void BytesValue::set_value(const void* value,
+    size_t size) {
+  
+  value_.Set(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(
+      reinterpret_cast<const char*>(value), size), GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_pointer:google.protobuf.BytesValue.value)
+}
+inline ::std::string* BytesValue::mutable_value() {
+  
+  // @@protoc_insertion_point(field_mutable:google.protobuf.BytesValue.value)
+  return value_.Mutable(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline ::std::string* BytesValue::release_value() {
+  // @@protoc_insertion_point(field_release:google.protobuf.BytesValue.value)
+  
+  return value_.Release(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), GetArenaNoVirtual());
+}
+inline void BytesValue::set_allocated_value(::std::string* value) {
+  if (value != NULL) {
+    
+  } else {
+    
+  }
+  value_.SetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value,
+      GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_set_allocated:google.protobuf.BytesValue.value)
+}
+inline ::std::string* BytesValue::unsafe_arena_release_value() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:google.protobuf.BytesValue.value)
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  
+  return value_.UnsafeArenaRelease(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      GetArenaNoVirtual());
+}
+inline void BytesValue::unsafe_arena_set_allocated_value(
+    ::std::string* value) {
+  GOOGLE_DCHECK(GetArenaNoVirtual() != NULL);
+  if (value != NULL) {
+    
+  } else {
+    
+  }
+  value_.UnsafeArenaSetAllocated(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      value, GetArenaNoVirtual());
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:google.protobuf.BytesValue.value)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace protobuf
+}  // namespace google
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_google_2fprotobuf_2fwrappers_2eproto__INCLUDED
diff --git a/kortex_api/include/messages/ActuatorConfig.pb.h b/kortex_api/include/messages/ActuatorConfig.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..b401cd9c480ce5be8b4bc18268a0de88712190c6
--- /dev/null
+++ b/kortex_api/include/messages/ActuatorConfig.pb.h
@@ -0,0 +1,3315 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: ActuatorConfig.proto
+
+#ifndef PROTOBUF_ActuatorConfig_2eproto__INCLUDED
+#define PROTOBUF_ActuatorConfig_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 3005000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 3005001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "Common.pb.h"  // IWYU pragma: export
+// @@protoc_insertion_point(includes)
+
+namespace protobuf_ActuatorConfig_2eproto {
+// Internal implementation detail -- do not use these members.
+struct TableStruct {
+  static const ::google::protobuf::internal::ParseTableField entries[];
+  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
+  static const ::google::protobuf::internal::ParseTable schema[18];
+  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
+  static const ::google::protobuf::internal::SerializationTable serialization_table[];
+  static const ::google::protobuf::uint32 offsets[];
+};
+void AddDescriptors();
+void InitDefaultsAxisPositionImpl();
+void InitDefaultsAxisPosition();
+void InitDefaultsAxisOffsetsImpl();
+void InitDefaultsAxisOffsets();
+void InitDefaultsTorqueCalibrationImpl();
+void InitDefaultsTorqueCalibration();
+void InitDefaultsTorqueOffsetImpl();
+void InitDefaultsTorqueOffset();
+void InitDefaultsControlModeInformationImpl();
+void InitDefaultsControlModeInformation();
+void InitDefaultsControlLoopImpl();
+void InitDefaultsControlLoop();
+void InitDefaultsLoopSelectionImpl();
+void InitDefaultsLoopSelection();
+void InitDefaultsVectorDriveParametersImpl();
+void InitDefaultsVectorDriveParameters();
+void InitDefaultsEncoderDerivativeParametersImpl();
+void InitDefaultsEncoderDerivativeParameters();
+void InitDefaultsControlLoopParametersImpl();
+void InitDefaultsControlLoopParameters();
+void InitDefaultsFrequencyResponseImpl();
+void InitDefaultsFrequencyResponse();
+void InitDefaultsStepResponseImpl();
+void InitDefaultsStepResponse();
+void InitDefaultsRampResponseImpl();
+void InitDefaultsRampResponse();
+void InitDefaultsCustomDataSelectionImpl();
+void InitDefaultsCustomDataSelection();
+void InitDefaultsCommandModeInformationImpl();
+void InitDefaultsCommandModeInformation();
+void InitDefaultsServoingImpl();
+void InitDefaultsServoing();
+void InitDefaultsPositionCommandImpl();
+void InitDefaultsPositionCommand();
+void InitDefaultsCoggingFeedforwardModeInformationImpl();
+void InitDefaultsCoggingFeedforwardModeInformation();
+inline void InitDefaults() {
+  InitDefaultsAxisPosition();
+  InitDefaultsAxisOffsets();
+  InitDefaultsTorqueCalibration();
+  InitDefaultsTorqueOffset();
+  InitDefaultsControlModeInformation();
+  InitDefaultsControlLoop();
+  InitDefaultsLoopSelection();
+  InitDefaultsVectorDriveParameters();
+  InitDefaultsEncoderDerivativeParameters();
+  InitDefaultsControlLoopParameters();
+  InitDefaultsFrequencyResponse();
+  InitDefaultsStepResponse();
+  InitDefaultsRampResponse();
+  InitDefaultsCustomDataSelection();
+  InitDefaultsCommandModeInformation();
+  InitDefaultsServoing();
+  InitDefaultsPositionCommand();
+  InitDefaultsCoggingFeedforwardModeInformation();
+}
+}  // namespace protobuf_ActuatorConfig_2eproto
+namespace Kinova {
+namespace Api {
+namespace ActuatorConfig {
+class AxisOffsets;
+class AxisOffsetsDefaultTypeInternal;
+extern AxisOffsetsDefaultTypeInternal _AxisOffsets_default_instance_;
+class AxisPosition;
+class AxisPositionDefaultTypeInternal;
+extern AxisPositionDefaultTypeInternal _AxisPosition_default_instance_;
+class CoggingFeedforwardModeInformation;
+class CoggingFeedforwardModeInformationDefaultTypeInternal;
+extern CoggingFeedforwardModeInformationDefaultTypeInternal _CoggingFeedforwardModeInformation_default_instance_;
+class CommandModeInformation;
+class CommandModeInformationDefaultTypeInternal;
+extern CommandModeInformationDefaultTypeInternal _CommandModeInformation_default_instance_;
+class ControlLoop;
+class ControlLoopDefaultTypeInternal;
+extern ControlLoopDefaultTypeInternal _ControlLoop_default_instance_;
+class ControlLoopParameters;
+class ControlLoopParametersDefaultTypeInternal;
+extern ControlLoopParametersDefaultTypeInternal _ControlLoopParameters_default_instance_;
+class ControlModeInformation;
+class ControlModeInformationDefaultTypeInternal;
+extern ControlModeInformationDefaultTypeInternal _ControlModeInformation_default_instance_;
+class CustomDataSelection;
+class CustomDataSelectionDefaultTypeInternal;
+extern CustomDataSelectionDefaultTypeInternal _CustomDataSelection_default_instance_;
+class EncoderDerivativeParameters;
+class EncoderDerivativeParametersDefaultTypeInternal;
+extern EncoderDerivativeParametersDefaultTypeInternal _EncoderDerivativeParameters_default_instance_;
+class FrequencyResponse;
+class FrequencyResponseDefaultTypeInternal;
+extern FrequencyResponseDefaultTypeInternal _FrequencyResponse_default_instance_;
+class LoopSelection;
+class LoopSelectionDefaultTypeInternal;
+extern LoopSelectionDefaultTypeInternal _LoopSelection_default_instance_;
+class PositionCommand;
+class PositionCommandDefaultTypeInternal;
+extern PositionCommandDefaultTypeInternal _PositionCommand_default_instance_;
+class RampResponse;
+class RampResponseDefaultTypeInternal;
+extern RampResponseDefaultTypeInternal _RampResponse_default_instance_;
+class Servoing;
+class ServoingDefaultTypeInternal;
+extern ServoingDefaultTypeInternal _Servoing_default_instance_;
+class StepResponse;
+class StepResponseDefaultTypeInternal;
+extern StepResponseDefaultTypeInternal _StepResponse_default_instance_;
+class TorqueCalibration;
+class TorqueCalibrationDefaultTypeInternal;
+extern TorqueCalibrationDefaultTypeInternal _TorqueCalibration_default_instance_;
+class TorqueOffset;
+class TorqueOffsetDefaultTypeInternal;
+extern TorqueOffsetDefaultTypeInternal _TorqueOffset_default_instance_;
+class VectorDriveParameters;
+class VectorDriveParametersDefaultTypeInternal;
+extern VectorDriveParametersDefaultTypeInternal _VectorDriveParameters_default_instance_;
+}  // namespace ActuatorConfig
+}  // namespace Api
+}  // namespace Kinova
+namespace Kinova {
+namespace Api {
+namespace ActuatorConfig {
+
+enum ServiceVersion {
+  RESERVED_0 = 0,
+  CURRENT_VERSION = 1,
+  ServiceVersion_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  ServiceVersion_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool ServiceVersion_IsValid(int value);
+const ServiceVersion ServiceVersion_MIN = RESERVED_0;
+const ServiceVersion ServiceVersion_MAX = CURRENT_VERSION;
+const int ServiceVersion_ARRAYSIZE = ServiceVersion_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* ServiceVersion_descriptor();
+inline const ::std::string& ServiceVersion_Name(ServiceVersion value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    ServiceVersion_descriptor(), value);
+}
+inline bool ServiceVersion_Parse(
+    const ::std::string& name, ServiceVersion* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<ServiceVersion>(
+    ServiceVersion_descriptor(), name, value);
+}
+enum SafetyLimitType {
+  MAXIMAL_LIMIT = 0,
+  MINIMAL_LIMIT = 1,
+  SafetyLimitType_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  SafetyLimitType_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool SafetyLimitType_IsValid(int value);
+const SafetyLimitType SafetyLimitType_MIN = MAXIMAL_LIMIT;
+const SafetyLimitType SafetyLimitType_MAX = MINIMAL_LIMIT;
+const int SafetyLimitType_ARRAYSIZE = SafetyLimitType_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* SafetyLimitType_descriptor();
+inline const ::std::string& SafetyLimitType_Name(SafetyLimitType value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    SafetyLimitType_descriptor(), value);
+}
+inline bool SafetyLimitType_Parse(
+    const ::std::string& name, SafetyLimitType* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<SafetyLimitType>(
+    SafetyLimitType_descriptor(), name, value);
+}
+enum ControlMode {
+  NONE = 0,
+  POSITION = 1,
+  VELOCITY = 2,
+  TORQUE = 3,
+  CURRENT = 4,
+  CUSTOM = 5,
+  TORQUE_HIGH_VELOCITY = 6,
+  ControlMode_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  ControlMode_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool ControlMode_IsValid(int value);
+const ControlMode ControlMode_MIN = NONE;
+const ControlMode ControlMode_MAX = TORQUE_HIGH_VELOCITY;
+const int ControlMode_ARRAYSIZE = ControlMode_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* ControlMode_descriptor();
+inline const ::std::string& ControlMode_Name(ControlMode value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    ControlMode_descriptor(), value);
+}
+inline bool ControlMode_Parse(
+    const ::std::string& name, ControlMode* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<ControlMode>(
+    ControlMode_descriptor(), name, value);
+}
+enum CommandMode {
+  CYCLIC = 0,
+  ASYNC_CYCLIC_FLAGS = 1,
+  ASYNC = 2,
+  CYCLIC_JITTERCOMPENSATED_POSITION = 3,
+  CYCLIC_JITTERCOMPENSATED_VELOCITY = 4,
+  CYCLIC_JITTERCOMPENSATED_ACCELERATION = 5,
+  CommandMode_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  CommandMode_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool CommandMode_IsValid(int value);
+const CommandMode CommandMode_MIN = CYCLIC;
+const CommandMode CommandMode_MAX = CYCLIC_JITTERCOMPENSATED_ACCELERATION;
+const int CommandMode_ARRAYSIZE = CommandMode_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* CommandMode_descriptor();
+inline const ::std::string& CommandMode_Name(CommandMode value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    CommandMode_descriptor(), value);
+}
+inline bool CommandMode_Parse(
+    const ::std::string& name, CommandMode* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<CommandMode>(
+    CommandMode_descriptor(), name, value);
+}
+enum ControlLoopSelection {
+  RESERVED = 0,
+  JOINT_POSITION = 1,
+  MOTOR_POSITION = 2,
+  JOINT_VELOCITY = 4,
+  MOTOR_VELOCITY = 8,
+  JOINT_TORQUE = 16,
+  MOTOR_CURRENT = 32,
+  JOINT_TORQUE_HIGH_VELOCITY = 64,
+  ControlLoopSelection_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  ControlLoopSelection_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool ControlLoopSelection_IsValid(int value);
+const ControlLoopSelection ControlLoopSelection_MIN = RESERVED;
+const ControlLoopSelection ControlLoopSelection_MAX = JOINT_TORQUE_HIGH_VELOCITY;
+const int ControlLoopSelection_ARRAYSIZE = ControlLoopSelection_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* ControlLoopSelection_descriptor();
+inline const ::std::string& ControlLoopSelection_Name(ControlLoopSelection value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    ControlLoopSelection_descriptor(), value);
+}
+inline bool ControlLoopSelection_Parse(
+    const ::std::string& name, ControlLoopSelection* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<ControlLoopSelection>(
+    ControlLoopSelection_descriptor(), name, value);
+}
+enum CoggingFeedforwardMode {
+  FEEDFORWARD_OFF = 0,
+  FEEDFORWARD_ADAPTIVE = 1,
+  FEEDFORWARD_CALIBRATED = 2,
+  CoggingFeedforwardMode_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  CoggingFeedforwardMode_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool CoggingFeedforwardMode_IsValid(int value);
+const CoggingFeedforwardMode CoggingFeedforwardMode_MIN = FEEDFORWARD_OFF;
+const CoggingFeedforwardMode CoggingFeedforwardMode_MAX = FEEDFORWARD_CALIBRATED;
+const int CoggingFeedforwardMode_ARRAYSIZE = CoggingFeedforwardMode_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* CoggingFeedforwardMode_descriptor();
+inline const ::std::string& CoggingFeedforwardMode_Name(CoggingFeedforwardMode value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    CoggingFeedforwardMode_descriptor(), value);
+}
+inline bool CoggingFeedforwardMode_Parse(
+    const ::std::string& name, CoggingFeedforwardMode* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<CoggingFeedforwardMode>(
+    CoggingFeedforwardMode_descriptor(), name, value);
+}
+enum SafetyIdentifierBankA {
+  UNSPECIFIED_ACTUATOR_SAFETY_IDENTIFIER_BANK_A = 0,
+  FOLLOWING_ERROR = 1,
+  MAXIMUM_VELOCITY = 2,
+  JOINT_LIMIT_HIGH = 4,
+  JOINT_LIMIT_LOW = 8,
+  STRAIN_GAUGE_MISMATCH = 16,
+  MAXIMUM_TORQUE = 32,
+  UNRELIABLE_ABSOLUTE_POSITION = 64,
+  MAGNETIC_POSITION = 128,
+  HALL_POSITION = 256,
+  HALL_SEQUENCE = 512,
+  INPUT_ENCODER_HALL_MISMATCH = 1024,
+  INPUT_ENCODER_INDEX_MISMATCH = 2048,
+  INPUT_ENCODER_MAGNETIC_MISMATCH = 4096,
+  MAXIMUM_MOTOR_CURRENT = 8192,
+  MOTOR_CURRENT_MISMATCH = 16384,
+  MAXIMUM_VOLTAGE = 32768,
+  MINIMUM_VOLTAGE = 65536,
+  MAXIMUM_MOTOR_TEMPERATURE = 131072,
+  MAXIMUM_CORE_TEMPERATURE = 262144,
+  NON_VOLATILE_MEMORY_CORRUPTED = 524288,
+  MOTOR_DRIVER_FAULT = 1048576,
+  EMERGENCY_LINE_ASSERTED = 2097152,
+  COMMUNICATION_TICK_LOST = 4194304,
+  WATCHDOG_TRIGGERED = 8388608,
+  UNRELIABLE_CAPACITIVE_SENSOR = 16777216,
+  UNEXPECTED_GEAR_RATIO = 33554432,
+  HALL_MAGNETIC_MISMATCH = 67108864,
+  SafetyIdentifierBankA_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  SafetyIdentifierBankA_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool SafetyIdentifierBankA_IsValid(int value);
+const SafetyIdentifierBankA SafetyIdentifierBankA_MIN = UNSPECIFIED_ACTUATOR_SAFETY_IDENTIFIER_BANK_A;
+const SafetyIdentifierBankA SafetyIdentifierBankA_MAX = HALL_MAGNETIC_MISMATCH;
+const int SafetyIdentifierBankA_ARRAYSIZE = SafetyIdentifierBankA_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* SafetyIdentifierBankA_descriptor();
+inline const ::std::string& SafetyIdentifierBankA_Name(SafetyIdentifierBankA value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    SafetyIdentifierBankA_descriptor(), value);
+}
+inline bool SafetyIdentifierBankA_Parse(
+    const ::std::string& name, SafetyIdentifierBankA* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<SafetyIdentifierBankA>(
+    SafetyIdentifierBankA_descriptor(), name, value);
+}
+enum CustomDataIndex {
+  NO_CUSTOM_DATA_SELECTED = 0,
+  UINT32_TEST_RAMP = 1,
+  UINT32_MOTOR_ENCODER_RAW = 2,
+  UINT32_JOINT_ENCODER_RAW = 3,
+  FLOAT_TEMPERATURE_PHASE_0 = 4,
+  FLOAT_TEMPERATURE_PHASE_1 = 5,
+  FLOAT_TEMPERATURE_PHASE_2 = 6,
+  INT32_TORQUE_SENSOR_RAW_0 = 7,
+  INT32_TORQUE_SENSOR_RAW_1 = 8,
+  INT32_TORQUE_SENSOR_RAW_2 = 9,
+  INT32_TORQUE_SENSOR_RAW_3 = 10,
+  FLOAT_TORQUE_SENSOR_0 = 11,
+  FLOAT_TORQUE_SENSOR_1 = 12,
+  FLOAT_TORQUE_SENSOR_2 = 13,
+  FLOAT_TORQUE_SENSOR_3 = 14,
+  UINT32_MOTOR_ENCODER_RAW_LATCH_ON_INDEX_RISING = 15,
+  UINT32_JOINT_ENCODER_RAW_LATCH_ON_INDEX_RISING = 16,
+  UINT32_ABSOLUTE_POSITION_SENSOR_RAW = 17,
+  FLOAT_ABSOLUTE_POSITION_SENSOR = 18,
+  FLOAT_CONTROL_POSITION_JOINT_REQUESTED = 19,
+  UINT32_JIG_FLAGS = 20,
+  UINT32_TICK_MOTOR_CONTROL = 21,
+  UINT32_TICK_JOINT_CONTROL = 22,
+  UINT32_INDEX_TICK_MOTOR_CONTROL = 23,
+  UINT32_INDEX_TICK_JOINT_CONTROL = 24,
+  FLOAT_ACCELERATION_X = 25,
+  FLOAT_ACCELERATION_Y = 26,
+  FLOAT_ACCELERATION_Z = 27,
+  FLOAT_ANGULAR_RATE_X = 28,
+  FLOAT_ANGULAR_RATE_Y = 29,
+  FLOAT_ANGULAR_RATE_Z = 30,
+  FLOAT_POSITION_MOTOR_CMD = 31,
+  FLOAT_VELOCITY_MOTOR_CMD = 32,
+  FLOAT_POSITION_MOTOR = 33,
+  FLOAT_VELOCITY_MOTOR = 34,
+  UINT32_COMMUNICATIONS_JITTER = 35,
+  FLOAT_TORQUE_AVERAGE = 36,
+  FLOAT_CURRENT_MOTOR = 37,
+  FLOAT_VOLTAGE_DIGITAL = 38,
+  FLOAT_TEMPERATURE_MOTOR_CELSIUS = 39,
+  FLOAT_TEMPERATURE_CORE_CELSIUS = 40,
+  UINT32_FAULT_A = 41,
+  UINT32_FAULT_B = 42,
+  UINT32_WARNING_A = 43,
+  UINT32_WARNING_B = 44,
+  FLOAT_POSITION_FROM_HALLS = 45,
+  FLOAT_PHASE_CURRENT_0 = 46,
+  FLOAT_PHASE_CURRENT_1 = 47,
+  FLOAT_PHASE_CURRENT_2 = 48,
+  FLOAT_PHASE_PWM_0 = 49,
+  FLOAT_PHASE_PWM_1 = 50,
+  FLOAT_PHASE_PWM_2 = 51,
+  FLOAT_MOTOR_ELECTRICAL_ANGLE = 52,
+  FLOAT_CURRENT_MOTOR_CMD = 53,
+  FLOAT_TORQUE_JOINT_CMD = 54,
+  FLOAT_POSITION_UNWRAPPED = 55,
+  UINT32_HALL_SENSOR_0 = 56,
+  UINT32_HALL_SENSOR_1 = 57,
+  UINT32_HALL_SENSOR_2 = 58,
+  INT32_HALL_SENSOR_SCALED_0 = 59,
+  INT32_HALL_SENSOR_SCALED_1 = 60,
+  INT32_HALL_SENSOR_SCALED_2 = 61,
+  FLOAT_COGGING_COEFFICIENT_A_0 = 62,
+  FLOAT_COGGING_COEFFICIENT_A_1 = 63,
+  FLOAT_COGGING_COEFFICIENT_A_2 = 64,
+  FLOAT_COGGING_COEFFICIENT_A_3 = 65,
+  FLOAT_COGGING_COEFFICIENT_A_4 = 66,
+  FLOAT_COGGING_COEFFICIENT_A_5 = 67,
+  FLOAT_COGGING_COEFFICIENT_A_6 = 68,
+  FLOAT_COGGING_COEFFICIENT_A_7 = 69,
+  FLOAT_COGGING_COEFFICIENT_A_8 = 70,
+  FLOAT_COGGING_COEFFICIENT_A_9 = 71,
+  FLOAT_COGGING_COEFFICIENT_A_10 = 72,
+  FLOAT_COGGING_COEFFICIENT_A_11 = 73,
+  FLOAT_COGGING_COEFFICIENT_A_12 = 74,
+  FLOAT_COGGING_COEFFICIENT_A_13 = 75,
+  FLOAT_COGGING_COEFFICIENT_A_14 = 76,
+  FLOAT_COGGING_COEFFICIENT_A_15 = 77,
+  FLOAT_COGGING_COEFFICIENT_B_0 = 78,
+  FLOAT_COGGING_COEFFICIENT_B_1 = 79,
+  FLOAT_COGGING_COEFFICIENT_B_2 = 80,
+  FLOAT_COGGING_COEFFICIENT_B_3 = 81,
+  FLOAT_COGGING_COEFFICIENT_B_4 = 82,
+  FLOAT_COGGING_COEFFICIENT_B_5 = 83,
+  FLOAT_COGGING_COEFFICIENT_B_6 = 84,
+  FLOAT_COGGING_COEFFICIENT_B_7 = 85,
+  FLOAT_COGGING_COEFFICIENT_B_8 = 86,
+  FLOAT_COGGING_COEFFICIENT_B_9 = 87,
+  FLOAT_COGGING_COEFFICIENT_B_10 = 88,
+  FLOAT_COGGING_COEFFICIENT_B_11 = 89,
+  FLOAT_COGGING_COEFFICIENT_B_12 = 90,
+  FLOAT_COGGING_COEFFICIENT_B_13 = 91,
+  FLOAT_COGGING_COEFFICIENT_B_14 = 92,
+  FLOAT_COGGING_COEFFICIENT_B_15 = 93,
+  FLOAT_CURRENT_COGGING_FEEDFORWARD = 94,
+  CustomDataIndex_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  CustomDataIndex_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool CustomDataIndex_IsValid(int value);
+const CustomDataIndex CustomDataIndex_MIN = NO_CUSTOM_DATA_SELECTED;
+const CustomDataIndex CustomDataIndex_MAX = FLOAT_CURRENT_COGGING_FEEDFORWARD;
+const int CustomDataIndex_ARRAYSIZE = CustomDataIndex_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* CustomDataIndex_descriptor();
+inline const ::std::string& CustomDataIndex_Name(CustomDataIndex value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    CustomDataIndex_descriptor(), value);
+}
+inline bool CustomDataIndex_Parse(
+    const ::std::string& name, CustomDataIndex* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<CustomDataIndex>(
+    CustomDataIndex_descriptor(), name, value);
+}
+// ===================================================================
+
+class AxisPosition : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.ActuatorConfig.AxisPosition) */ {
+ public:
+  AxisPosition();
+  virtual ~AxisPosition();
+
+  AxisPosition(const AxisPosition& from);
+
+  inline AxisPosition& operator=(const AxisPosition& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  AxisPosition(AxisPosition&& from) noexcept
+    : AxisPosition() {
+    *this = ::std::move(from);
+  }
+
+  inline AxisPosition& operator=(AxisPosition&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const AxisPosition& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const AxisPosition* internal_default_instance() {
+    return reinterpret_cast<const AxisPosition*>(
+               &_AxisPosition_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    0;
+
+  void Swap(AxisPosition* other);
+  friend void swap(AxisPosition& a, AxisPosition& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline AxisPosition* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  AxisPosition* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const AxisPosition& from);
+  void MergeFrom(const AxisPosition& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(AxisPosition* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // float position = 1;
+  void clear_position();
+  static const int kPositionFieldNumber = 1;
+  float position() const;
+  void set_position(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.ActuatorConfig.AxisPosition)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  float position_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_ActuatorConfig_2eproto::TableStruct;
+  friend void ::protobuf_ActuatorConfig_2eproto::InitDefaultsAxisPositionImpl();
+};
+// -------------------------------------------------------------------
+
+class AxisOffsets : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.ActuatorConfig.AxisOffsets) */ {
+ public:
+  AxisOffsets();
+  virtual ~AxisOffsets();
+
+  AxisOffsets(const AxisOffsets& from);
+
+  inline AxisOffsets& operator=(const AxisOffsets& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  AxisOffsets(AxisOffsets&& from) noexcept
+    : AxisOffsets() {
+    *this = ::std::move(from);
+  }
+
+  inline AxisOffsets& operator=(AxisOffsets&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const AxisOffsets& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const AxisOffsets* internal_default_instance() {
+    return reinterpret_cast<const AxisOffsets*>(
+               &_AxisOffsets_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    1;
+
+  void Swap(AxisOffsets* other);
+  friend void swap(AxisOffsets& a, AxisOffsets& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline AxisOffsets* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  AxisOffsets* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const AxisOffsets& from);
+  void MergeFrom(const AxisOffsets& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(AxisOffsets* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // float absolute_offset = 1;
+  void clear_absolute_offset();
+  static const int kAbsoluteOffsetFieldNumber = 1;
+  float absolute_offset() const;
+  void set_absolute_offset(float value);
+
+  // float relative_offset = 2;
+  void clear_relative_offset();
+  static const int kRelativeOffsetFieldNumber = 2;
+  float relative_offset() const;
+  void set_relative_offset(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.ActuatorConfig.AxisOffsets)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  float absolute_offset_;
+  float relative_offset_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_ActuatorConfig_2eproto::TableStruct;
+  friend void ::protobuf_ActuatorConfig_2eproto::InitDefaultsAxisOffsetsImpl();
+};
+// -------------------------------------------------------------------
+
+class TorqueCalibration : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.ActuatorConfig.TorqueCalibration) */ {
+ public:
+  TorqueCalibration();
+  virtual ~TorqueCalibration();
+
+  TorqueCalibration(const TorqueCalibration& from);
+
+  inline TorqueCalibration& operator=(const TorqueCalibration& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  TorqueCalibration(TorqueCalibration&& from) noexcept
+    : TorqueCalibration() {
+    *this = ::std::move(from);
+  }
+
+  inline TorqueCalibration& operator=(TorqueCalibration&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const TorqueCalibration& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const TorqueCalibration* internal_default_instance() {
+    return reinterpret_cast<const TorqueCalibration*>(
+               &_TorqueCalibration_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    2;
+
+  void Swap(TorqueCalibration* other);
+  friend void swap(TorqueCalibration& a, TorqueCalibration& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline TorqueCalibration* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  TorqueCalibration* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const TorqueCalibration& from);
+  void MergeFrom(const TorqueCalibration& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(TorqueCalibration* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated float gain = 3;
+  int gain_size() const;
+  void clear_gain();
+  static const int kGainFieldNumber = 3;
+  float gain(int index) const;
+  void set_gain(int index, float value);
+  void add_gain(float value);
+  const ::google::protobuf::RepeatedField< float >&
+      gain() const;
+  ::google::protobuf::RepeatedField< float >*
+      mutable_gain();
+
+  // repeated float offset = 4;
+  int offset_size() const;
+  void clear_offset();
+  static const int kOffsetFieldNumber = 4;
+  float offset(int index) const;
+  void set_offset(int index, float value);
+  void add_offset(float value);
+  const ::google::protobuf::RepeatedField< float >&
+      offset() const;
+  ::google::protobuf::RepeatedField< float >*
+      mutable_offset();
+
+  // float global_gain = 1;
+  void clear_global_gain();
+  static const int kGlobalGainFieldNumber = 1;
+  float global_gain() const;
+  void set_global_gain(float value);
+
+  // float global_offset = 2;
+  void clear_global_offset();
+  static const int kGlobalOffsetFieldNumber = 2;
+  float global_offset() const;
+  void set_global_offset(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.ActuatorConfig.TorqueCalibration)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedField< float > gain_;
+  mutable int _gain_cached_byte_size_;
+  ::google::protobuf::RepeatedField< float > offset_;
+  mutable int _offset_cached_byte_size_;
+  float global_gain_;
+  float global_offset_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_ActuatorConfig_2eproto::TableStruct;
+  friend void ::protobuf_ActuatorConfig_2eproto::InitDefaultsTorqueCalibrationImpl();
+};
+// -------------------------------------------------------------------
+
+class TorqueOffset : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.ActuatorConfig.TorqueOffset) */ {
+ public:
+  TorqueOffset();
+  virtual ~TorqueOffset();
+
+  TorqueOffset(const TorqueOffset& from);
+
+  inline TorqueOffset& operator=(const TorqueOffset& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  TorqueOffset(TorqueOffset&& from) noexcept
+    : TorqueOffset() {
+    *this = ::std::move(from);
+  }
+
+  inline TorqueOffset& operator=(TorqueOffset&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const TorqueOffset& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const TorqueOffset* internal_default_instance() {
+    return reinterpret_cast<const TorqueOffset*>(
+               &_TorqueOffset_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    3;
+
+  void Swap(TorqueOffset* other);
+  friend void swap(TorqueOffset& a, TorqueOffset& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline TorqueOffset* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  TorqueOffset* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const TorqueOffset& from);
+  void MergeFrom(const TorqueOffset& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(TorqueOffset* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // float torque_offset = 1;
+  void clear_torque_offset();
+  static const int kTorqueOffsetFieldNumber = 1;
+  float torque_offset() const;
+  void set_torque_offset(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.ActuatorConfig.TorqueOffset)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  float torque_offset_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_ActuatorConfig_2eproto::TableStruct;
+  friend void ::protobuf_ActuatorConfig_2eproto::InitDefaultsTorqueOffsetImpl();
+};
+// -------------------------------------------------------------------
+
+class ControlModeInformation : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.ActuatorConfig.ControlModeInformation) */ {
+ public:
+  ControlModeInformation();
+  virtual ~ControlModeInformation();
+
+  ControlModeInformation(const ControlModeInformation& from);
+
+  inline ControlModeInformation& operator=(const ControlModeInformation& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ControlModeInformation(ControlModeInformation&& from) noexcept
+    : ControlModeInformation() {
+    *this = ::std::move(from);
+  }
+
+  inline ControlModeInformation& operator=(ControlModeInformation&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ControlModeInformation& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ControlModeInformation* internal_default_instance() {
+    return reinterpret_cast<const ControlModeInformation*>(
+               &_ControlModeInformation_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    4;
+
+  void Swap(ControlModeInformation* other);
+  friend void swap(ControlModeInformation& a, ControlModeInformation& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ControlModeInformation* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ControlModeInformation* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ControlModeInformation& from);
+  void MergeFrom(const ControlModeInformation& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ControlModeInformation* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.ActuatorConfig.ControlMode control_mode = 1;
+  void clear_control_mode();
+  static const int kControlModeFieldNumber = 1;
+  ::Kinova::Api::ActuatorConfig::ControlMode control_mode() const;
+  void set_control_mode(::Kinova::Api::ActuatorConfig::ControlMode value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.ActuatorConfig.ControlModeInformation)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  int control_mode_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_ActuatorConfig_2eproto::TableStruct;
+  friend void ::protobuf_ActuatorConfig_2eproto::InitDefaultsControlModeInformationImpl();
+};
+// -------------------------------------------------------------------
+
+class ControlLoop : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.ActuatorConfig.ControlLoop) */ {
+ public:
+  ControlLoop();
+  virtual ~ControlLoop();
+
+  ControlLoop(const ControlLoop& from);
+
+  inline ControlLoop& operator=(const ControlLoop& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ControlLoop(ControlLoop&& from) noexcept
+    : ControlLoop() {
+    *this = ::std::move(from);
+  }
+
+  inline ControlLoop& operator=(ControlLoop&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ControlLoop& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ControlLoop* internal_default_instance() {
+    return reinterpret_cast<const ControlLoop*>(
+               &_ControlLoop_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    5;
+
+  void Swap(ControlLoop* other);
+  friend void swap(ControlLoop& a, ControlLoop& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ControlLoop* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ControlLoop* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ControlLoop& from);
+  void MergeFrom(const ControlLoop& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ControlLoop* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // fixed32 control_loop = 1;
+  void clear_control_loop();
+  static const int kControlLoopFieldNumber = 1;
+  ::google::protobuf::uint32 control_loop() const;
+  void set_control_loop(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.ActuatorConfig.ControlLoop)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 control_loop_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_ActuatorConfig_2eproto::TableStruct;
+  friend void ::protobuf_ActuatorConfig_2eproto::InitDefaultsControlLoopImpl();
+};
+// -------------------------------------------------------------------
+
+class LoopSelection : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.ActuatorConfig.LoopSelection) */ {
+ public:
+  LoopSelection();
+  virtual ~LoopSelection();
+
+  LoopSelection(const LoopSelection& from);
+
+  inline LoopSelection& operator=(const LoopSelection& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  LoopSelection(LoopSelection&& from) noexcept
+    : LoopSelection() {
+    *this = ::std::move(from);
+  }
+
+  inline LoopSelection& operator=(LoopSelection&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const LoopSelection& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const LoopSelection* internal_default_instance() {
+    return reinterpret_cast<const LoopSelection*>(
+               &_LoopSelection_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    6;
+
+  void Swap(LoopSelection* other);
+  friend void swap(LoopSelection& a, LoopSelection& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline LoopSelection* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  LoopSelection* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const LoopSelection& from);
+  void MergeFrom(const LoopSelection& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(LoopSelection* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.ActuatorConfig.ControlLoopSelection loop_selection = 1;
+  void clear_loop_selection();
+  static const int kLoopSelectionFieldNumber = 1;
+  ::Kinova::Api::ActuatorConfig::ControlLoopSelection loop_selection() const;
+  void set_loop_selection(::Kinova::Api::ActuatorConfig::ControlLoopSelection value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.ActuatorConfig.LoopSelection)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  int loop_selection_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_ActuatorConfig_2eproto::TableStruct;
+  friend void ::protobuf_ActuatorConfig_2eproto::InitDefaultsLoopSelectionImpl();
+};
+// -------------------------------------------------------------------
+
+class VectorDriveParameters : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.ActuatorConfig.VectorDriveParameters) */ {
+ public:
+  VectorDriveParameters();
+  virtual ~VectorDriveParameters();
+
+  VectorDriveParameters(const VectorDriveParameters& from);
+
+  inline VectorDriveParameters& operator=(const VectorDriveParameters& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  VectorDriveParameters(VectorDriveParameters&& from) noexcept
+    : VectorDriveParameters() {
+    *this = ::std::move(from);
+  }
+
+  inline VectorDriveParameters& operator=(VectorDriveParameters&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const VectorDriveParameters& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const VectorDriveParameters* internal_default_instance() {
+    return reinterpret_cast<const VectorDriveParameters*>(
+               &_VectorDriveParameters_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    7;
+
+  void Swap(VectorDriveParameters* other);
+  friend void swap(VectorDriveParameters& a, VectorDriveParameters& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline VectorDriveParameters* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  VectorDriveParameters* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const VectorDriveParameters& from);
+  void MergeFrom(const VectorDriveParameters& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(VectorDriveParameters* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // float kpq = 1;
+  void clear_kpq();
+  static const int kKpqFieldNumber = 1;
+  float kpq() const;
+  void set_kpq(float value);
+
+  // float kiq = 2;
+  void clear_kiq();
+  static const int kKiqFieldNumber = 2;
+  float kiq() const;
+  void set_kiq(float value);
+
+  // float kpd = 3;
+  void clear_kpd();
+  static const int kKpdFieldNumber = 3;
+  float kpd() const;
+  void set_kpd(float value);
+
+  // float kid = 4;
+  void clear_kid();
+  static const int kKidFieldNumber = 4;
+  float kid() const;
+  void set_kid(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.ActuatorConfig.VectorDriveParameters)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  float kpq_;
+  float kiq_;
+  float kpd_;
+  float kid_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_ActuatorConfig_2eproto::TableStruct;
+  friend void ::protobuf_ActuatorConfig_2eproto::InitDefaultsVectorDriveParametersImpl();
+};
+// -------------------------------------------------------------------
+
+class EncoderDerivativeParameters : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.ActuatorConfig.EncoderDerivativeParameters) */ {
+ public:
+  EncoderDerivativeParameters();
+  virtual ~EncoderDerivativeParameters();
+
+  EncoderDerivativeParameters(const EncoderDerivativeParameters& from);
+
+  inline EncoderDerivativeParameters& operator=(const EncoderDerivativeParameters& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  EncoderDerivativeParameters(EncoderDerivativeParameters&& from) noexcept
+    : EncoderDerivativeParameters() {
+    *this = ::std::move(from);
+  }
+
+  inline EncoderDerivativeParameters& operator=(EncoderDerivativeParameters&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const EncoderDerivativeParameters& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const EncoderDerivativeParameters* internal_default_instance() {
+    return reinterpret_cast<const EncoderDerivativeParameters*>(
+               &_EncoderDerivativeParameters_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    8;
+
+  void Swap(EncoderDerivativeParameters* other);
+  friend void swap(EncoderDerivativeParameters& a, EncoderDerivativeParameters& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline EncoderDerivativeParameters* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  EncoderDerivativeParameters* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const EncoderDerivativeParameters& from);
+  void MergeFrom(const EncoderDerivativeParameters& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(EncoderDerivativeParameters* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // uint32 max_window_width = 1;
+  void clear_max_window_width();
+  static const int kMaxWindowWidthFieldNumber = 1;
+  ::google::protobuf::uint32 max_window_width() const;
+  void set_max_window_width(::google::protobuf::uint32 value);
+
+  // float min_angle = 2;
+  void clear_min_angle();
+  static const int kMinAngleFieldNumber = 2;
+  float min_angle() const;
+  void set_min_angle(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.ActuatorConfig.EncoderDerivativeParameters)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 max_window_width_;
+  float min_angle_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_ActuatorConfig_2eproto::TableStruct;
+  friend void ::protobuf_ActuatorConfig_2eproto::InitDefaultsEncoderDerivativeParametersImpl();
+};
+// -------------------------------------------------------------------
+
+class ControlLoopParameters : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.ActuatorConfig.ControlLoopParameters) */ {
+ public:
+  ControlLoopParameters();
+  virtual ~ControlLoopParameters();
+
+  ControlLoopParameters(const ControlLoopParameters& from);
+
+  inline ControlLoopParameters& operator=(const ControlLoopParameters& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ControlLoopParameters(ControlLoopParameters&& from) noexcept
+    : ControlLoopParameters() {
+    *this = ::std::move(from);
+  }
+
+  inline ControlLoopParameters& operator=(ControlLoopParameters&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ControlLoopParameters& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ControlLoopParameters* internal_default_instance() {
+    return reinterpret_cast<const ControlLoopParameters*>(
+               &_ControlLoopParameters_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    9;
+
+  void Swap(ControlLoopParameters* other);
+  friend void swap(ControlLoopParameters& a, ControlLoopParameters& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ControlLoopParameters* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ControlLoopParameters* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ControlLoopParameters& from);
+  void MergeFrom(const ControlLoopParameters& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ControlLoopParameters* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated float kAz = 4;
+  int kaz_size() const;
+  void clear_kaz();
+  static const int kKAzFieldNumber = 4;
+  float kaz(int index) const;
+  void set_kaz(int index, float value);
+  void add_kaz(float value);
+  const ::google::protobuf::RepeatedField< float >&
+      kaz() const;
+  ::google::protobuf::RepeatedField< float >*
+      mutable_kaz();
+
+  // repeated float kBz = 5;
+  int kbz_size() const;
+  void clear_kbz();
+  static const int kKBzFieldNumber = 5;
+  float kbz(int index) const;
+  void set_kbz(int index, float value);
+  void add_kbz(float value);
+  const ::google::protobuf::RepeatedField< float >&
+      kbz() const;
+  ::google::protobuf::RepeatedField< float >*
+      mutable_kbz();
+
+  // .Kinova.Api.ActuatorConfig.ControlLoopSelection loop_selection = 1;
+  void clear_loop_selection();
+  static const int kLoopSelectionFieldNumber = 1;
+  ::Kinova::Api::ActuatorConfig::ControlLoopSelection loop_selection() const;
+  void set_loop_selection(::Kinova::Api::ActuatorConfig::ControlLoopSelection value);
+
+  // float error_saturation = 2;
+  void clear_error_saturation();
+  static const int kErrorSaturationFieldNumber = 2;
+  float error_saturation() const;
+  void set_error_saturation(float value);
+
+  // float output_saturation = 3;
+  void clear_output_saturation();
+  static const int kOutputSaturationFieldNumber = 3;
+  float output_saturation() const;
+  void set_output_saturation(float value);
+
+  // float error_dead_band = 6;
+  void clear_error_dead_band();
+  static const int kErrorDeadBandFieldNumber = 6;
+  float error_dead_band() const;
+  void set_error_dead_band(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.ActuatorConfig.ControlLoopParameters)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedField< float > kaz_;
+  mutable int _kaz_cached_byte_size_;
+  ::google::protobuf::RepeatedField< float > kbz_;
+  mutable int _kbz_cached_byte_size_;
+  int loop_selection_;
+  float error_saturation_;
+  float output_saturation_;
+  float error_dead_band_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_ActuatorConfig_2eproto::TableStruct;
+  friend void ::protobuf_ActuatorConfig_2eproto::InitDefaultsControlLoopParametersImpl();
+};
+// -------------------------------------------------------------------
+
+class FrequencyResponse : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.ActuatorConfig.FrequencyResponse) */ {
+ public:
+  FrequencyResponse();
+  virtual ~FrequencyResponse();
+
+  FrequencyResponse(const FrequencyResponse& from);
+
+  inline FrequencyResponse& operator=(const FrequencyResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  FrequencyResponse(FrequencyResponse&& from) noexcept
+    : FrequencyResponse() {
+    *this = ::std::move(from);
+  }
+
+  inline FrequencyResponse& operator=(FrequencyResponse&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const FrequencyResponse& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const FrequencyResponse* internal_default_instance() {
+    return reinterpret_cast<const FrequencyResponse*>(
+               &_FrequencyResponse_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    10;
+
+  void Swap(FrequencyResponse* other);
+  friend void swap(FrequencyResponse& a, FrequencyResponse& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline FrequencyResponse* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  FrequencyResponse* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const FrequencyResponse& from);
+  void MergeFrom(const FrequencyResponse& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(FrequencyResponse* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.ActuatorConfig.ControlLoopSelection loop_selection = 1;
+  void clear_loop_selection();
+  static const int kLoopSelectionFieldNumber = 1;
+  ::Kinova::Api::ActuatorConfig::ControlLoopSelection loop_selection() const;
+  void set_loop_selection(::Kinova::Api::ActuatorConfig::ControlLoopSelection value);
+
+  // float min_frequency = 2;
+  void clear_min_frequency();
+  static const int kMinFrequencyFieldNumber = 2;
+  float min_frequency() const;
+  void set_min_frequency(float value);
+
+  // float max_frequency = 3;
+  void clear_max_frequency();
+  static const int kMaxFrequencyFieldNumber = 3;
+  float max_frequency() const;
+  void set_max_frequency(float value);
+
+  // float amplitude = 4;
+  void clear_amplitude();
+  static const int kAmplitudeFieldNumber = 4;
+  float amplitude() const;
+  void set_amplitude(float value);
+
+  // float duration = 5;
+  void clear_duration();
+  static const int kDurationFieldNumber = 5;
+  float duration() const;
+  void set_duration(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.ActuatorConfig.FrequencyResponse)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  int loop_selection_;
+  float min_frequency_;
+  float max_frequency_;
+  float amplitude_;
+  float duration_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_ActuatorConfig_2eproto::TableStruct;
+  friend void ::protobuf_ActuatorConfig_2eproto::InitDefaultsFrequencyResponseImpl();
+};
+// -------------------------------------------------------------------
+
+class StepResponse : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.ActuatorConfig.StepResponse) */ {
+ public:
+  StepResponse();
+  virtual ~StepResponse();
+
+  StepResponse(const StepResponse& from);
+
+  inline StepResponse& operator=(const StepResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  StepResponse(StepResponse&& from) noexcept
+    : StepResponse() {
+    *this = ::std::move(from);
+  }
+
+  inline StepResponse& operator=(StepResponse&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const StepResponse& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const StepResponse* internal_default_instance() {
+    return reinterpret_cast<const StepResponse*>(
+               &_StepResponse_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    11;
+
+  void Swap(StepResponse* other);
+  friend void swap(StepResponse& a, StepResponse& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline StepResponse* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  StepResponse* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const StepResponse& from);
+  void MergeFrom(const StepResponse& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(StepResponse* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.ActuatorConfig.ControlLoopSelection loop_selection = 1;
+  void clear_loop_selection();
+  static const int kLoopSelectionFieldNumber = 1;
+  ::Kinova::Api::ActuatorConfig::ControlLoopSelection loop_selection() const;
+  void set_loop_selection(::Kinova::Api::ActuatorConfig::ControlLoopSelection value);
+
+  // float amplitude = 2;
+  void clear_amplitude();
+  static const int kAmplitudeFieldNumber = 2;
+  float amplitude() const;
+  void set_amplitude(float value);
+
+  // float step_delay = 3;
+  void clear_step_delay();
+  static const int kStepDelayFieldNumber = 3;
+  float step_delay() const;
+  void set_step_delay(float value);
+
+  // float duration = 4;
+  void clear_duration();
+  static const int kDurationFieldNumber = 4;
+  float duration() const;
+  void set_duration(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.ActuatorConfig.StepResponse)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  int loop_selection_;
+  float amplitude_;
+  float step_delay_;
+  float duration_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_ActuatorConfig_2eproto::TableStruct;
+  friend void ::protobuf_ActuatorConfig_2eproto::InitDefaultsStepResponseImpl();
+};
+// -------------------------------------------------------------------
+
+class RampResponse : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.ActuatorConfig.RampResponse) */ {
+ public:
+  RampResponse();
+  virtual ~RampResponse();
+
+  RampResponse(const RampResponse& from);
+
+  inline RampResponse& operator=(const RampResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  RampResponse(RampResponse&& from) noexcept
+    : RampResponse() {
+    *this = ::std::move(from);
+  }
+
+  inline RampResponse& operator=(RampResponse&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const RampResponse& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const RampResponse* internal_default_instance() {
+    return reinterpret_cast<const RampResponse*>(
+               &_RampResponse_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    12;
+
+  void Swap(RampResponse* other);
+  friend void swap(RampResponse& a, RampResponse& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline RampResponse* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  RampResponse* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const RampResponse& from);
+  void MergeFrom(const RampResponse& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(RampResponse* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.ActuatorConfig.ControlLoopSelection loop_selection = 1;
+  void clear_loop_selection();
+  static const int kLoopSelectionFieldNumber = 1;
+  ::Kinova::Api::ActuatorConfig::ControlLoopSelection loop_selection() const;
+  void set_loop_selection(::Kinova::Api::ActuatorConfig::ControlLoopSelection value);
+
+  // float slope = 2;
+  void clear_slope();
+  static const int kSlopeFieldNumber = 2;
+  float slope() const;
+  void set_slope(float value);
+
+  // float ramp_delay = 3;
+  void clear_ramp_delay();
+  static const int kRampDelayFieldNumber = 3;
+  float ramp_delay() const;
+  void set_ramp_delay(float value);
+
+  // float duration = 4;
+  void clear_duration();
+  static const int kDurationFieldNumber = 4;
+  float duration() const;
+  void set_duration(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.ActuatorConfig.RampResponse)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  int loop_selection_;
+  float slope_;
+  float ramp_delay_;
+  float duration_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_ActuatorConfig_2eproto::TableStruct;
+  friend void ::protobuf_ActuatorConfig_2eproto::InitDefaultsRampResponseImpl();
+};
+// -------------------------------------------------------------------
+
+class CustomDataSelection : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.ActuatorConfig.CustomDataSelection) */ {
+ public:
+  CustomDataSelection();
+  virtual ~CustomDataSelection();
+
+  CustomDataSelection(const CustomDataSelection& from);
+
+  inline CustomDataSelection& operator=(const CustomDataSelection& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  CustomDataSelection(CustomDataSelection&& from) noexcept
+    : CustomDataSelection() {
+    *this = ::std::move(from);
+  }
+
+  inline CustomDataSelection& operator=(CustomDataSelection&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const CustomDataSelection& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const CustomDataSelection* internal_default_instance() {
+    return reinterpret_cast<const CustomDataSelection*>(
+               &_CustomDataSelection_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    13;
+
+  void Swap(CustomDataSelection* other);
+  friend void swap(CustomDataSelection& a, CustomDataSelection& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline CustomDataSelection* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  CustomDataSelection* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const CustomDataSelection& from);
+  void MergeFrom(const CustomDataSelection& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(CustomDataSelection* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .Kinova.Api.ActuatorConfig.CustomDataIndex channel = 1;
+  int channel_size() const;
+  void clear_channel();
+  static const int kChannelFieldNumber = 1;
+  ::Kinova::Api::ActuatorConfig::CustomDataIndex channel(int index) const;
+  void set_channel(int index, ::Kinova::Api::ActuatorConfig::CustomDataIndex value);
+  void add_channel(::Kinova::Api::ActuatorConfig::CustomDataIndex value);
+  const ::google::protobuf::RepeatedField<int>& channel() const;
+  ::google::protobuf::RepeatedField<int>* mutable_channel();
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.ActuatorConfig.CustomDataSelection)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedField<int> channel_;
+  mutable int _channel_cached_byte_size_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_ActuatorConfig_2eproto::TableStruct;
+  friend void ::protobuf_ActuatorConfig_2eproto::InitDefaultsCustomDataSelectionImpl();
+};
+// -------------------------------------------------------------------
+
+class CommandModeInformation : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.ActuatorConfig.CommandModeInformation) */ {
+ public:
+  CommandModeInformation();
+  virtual ~CommandModeInformation();
+
+  CommandModeInformation(const CommandModeInformation& from);
+
+  inline CommandModeInformation& operator=(const CommandModeInformation& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  CommandModeInformation(CommandModeInformation&& from) noexcept
+    : CommandModeInformation() {
+    *this = ::std::move(from);
+  }
+
+  inline CommandModeInformation& operator=(CommandModeInformation&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const CommandModeInformation& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const CommandModeInformation* internal_default_instance() {
+    return reinterpret_cast<const CommandModeInformation*>(
+               &_CommandModeInformation_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    14;
+
+  void Swap(CommandModeInformation* other);
+  friend void swap(CommandModeInformation& a, CommandModeInformation& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline CommandModeInformation* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  CommandModeInformation* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const CommandModeInformation& from);
+  void MergeFrom(const CommandModeInformation& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(CommandModeInformation* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.ActuatorConfig.CommandMode command_mode = 1;
+  void clear_command_mode();
+  static const int kCommandModeFieldNumber = 1;
+  ::Kinova::Api::ActuatorConfig::CommandMode command_mode() const;
+  void set_command_mode(::Kinova::Api::ActuatorConfig::CommandMode value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.ActuatorConfig.CommandModeInformation)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  int command_mode_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_ActuatorConfig_2eproto::TableStruct;
+  friend void ::protobuf_ActuatorConfig_2eproto::InitDefaultsCommandModeInformationImpl();
+};
+// -------------------------------------------------------------------
+
+class Servoing : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.ActuatorConfig.Servoing) */ {
+ public:
+  Servoing();
+  virtual ~Servoing();
+
+  Servoing(const Servoing& from);
+
+  inline Servoing& operator=(const Servoing& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Servoing(Servoing&& from) noexcept
+    : Servoing() {
+    *this = ::std::move(from);
+  }
+
+  inline Servoing& operator=(Servoing&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Servoing& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Servoing* internal_default_instance() {
+    return reinterpret_cast<const Servoing*>(
+               &_Servoing_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    15;
+
+  void Swap(Servoing* other);
+  friend void swap(Servoing& a, Servoing& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Servoing* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Servoing* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Servoing& from);
+  void MergeFrom(const Servoing& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Servoing* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // bool enabled = 1;
+  void clear_enabled();
+  static const int kEnabledFieldNumber = 1;
+  bool enabled() const;
+  void set_enabled(bool value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.ActuatorConfig.Servoing)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  bool enabled_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_ActuatorConfig_2eproto::TableStruct;
+  friend void ::protobuf_ActuatorConfig_2eproto::InitDefaultsServoingImpl();
+};
+// -------------------------------------------------------------------
+
+class PositionCommand : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.ActuatorConfig.PositionCommand) */ {
+ public:
+  PositionCommand();
+  virtual ~PositionCommand();
+
+  PositionCommand(const PositionCommand& from);
+
+  inline PositionCommand& operator=(const PositionCommand& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  PositionCommand(PositionCommand&& from) noexcept
+    : PositionCommand() {
+    *this = ::std::move(from);
+  }
+
+  inline PositionCommand& operator=(PositionCommand&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const PositionCommand& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const PositionCommand* internal_default_instance() {
+    return reinterpret_cast<const PositionCommand*>(
+               &_PositionCommand_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    16;
+
+  void Swap(PositionCommand* other);
+  friend void swap(PositionCommand& a, PositionCommand& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline PositionCommand* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  PositionCommand* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const PositionCommand& from);
+  void MergeFrom(const PositionCommand& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(PositionCommand* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // float position = 1;
+  void clear_position();
+  static const int kPositionFieldNumber = 1;
+  float position() const;
+  void set_position(float value);
+
+  // float velocity = 2;
+  void clear_velocity();
+  static const int kVelocityFieldNumber = 2;
+  float velocity() const;
+  void set_velocity(float value);
+
+  // float acceleration = 3;
+  void clear_acceleration();
+  static const int kAccelerationFieldNumber = 3;
+  float acceleration() const;
+  void set_acceleration(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.ActuatorConfig.PositionCommand)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  float position_;
+  float velocity_;
+  float acceleration_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_ActuatorConfig_2eproto::TableStruct;
+  friend void ::protobuf_ActuatorConfig_2eproto::InitDefaultsPositionCommandImpl();
+};
+// -------------------------------------------------------------------
+
+class CoggingFeedforwardModeInformation : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.ActuatorConfig.CoggingFeedforwardModeInformation) */ {
+ public:
+  CoggingFeedforwardModeInformation();
+  virtual ~CoggingFeedforwardModeInformation();
+
+  CoggingFeedforwardModeInformation(const CoggingFeedforwardModeInformation& from);
+
+  inline CoggingFeedforwardModeInformation& operator=(const CoggingFeedforwardModeInformation& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  CoggingFeedforwardModeInformation(CoggingFeedforwardModeInformation&& from) noexcept
+    : CoggingFeedforwardModeInformation() {
+    *this = ::std::move(from);
+  }
+
+  inline CoggingFeedforwardModeInformation& operator=(CoggingFeedforwardModeInformation&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const CoggingFeedforwardModeInformation& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const CoggingFeedforwardModeInformation* internal_default_instance() {
+    return reinterpret_cast<const CoggingFeedforwardModeInformation*>(
+               &_CoggingFeedforwardModeInformation_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    17;
+
+  void Swap(CoggingFeedforwardModeInformation* other);
+  friend void swap(CoggingFeedforwardModeInformation& a, CoggingFeedforwardModeInformation& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline CoggingFeedforwardModeInformation* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  CoggingFeedforwardModeInformation* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const CoggingFeedforwardModeInformation& from);
+  void MergeFrom(const CoggingFeedforwardModeInformation& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(CoggingFeedforwardModeInformation* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.ActuatorConfig.CoggingFeedforwardMode cogging_feedforward_mode = 1;
+  void clear_cogging_feedforward_mode();
+  static const int kCoggingFeedforwardModeFieldNumber = 1;
+  ::Kinova::Api::ActuatorConfig::CoggingFeedforwardMode cogging_feedforward_mode() const;
+  void set_cogging_feedforward_mode(::Kinova::Api::ActuatorConfig::CoggingFeedforwardMode value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.ActuatorConfig.CoggingFeedforwardModeInformation)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  int cogging_feedforward_mode_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_ActuatorConfig_2eproto::TableStruct;
+  friend void ::protobuf_ActuatorConfig_2eproto::InitDefaultsCoggingFeedforwardModeInformationImpl();
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// AxisPosition
+
+// float position = 1;
+inline void AxisPosition::clear_position() {
+  position_ = 0;
+}
+inline float AxisPosition::position() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorConfig.AxisPosition.position)
+  return position_;
+}
+inline void AxisPosition::set_position(float value) {
+  
+  position_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorConfig.AxisPosition.position)
+}
+
+// -------------------------------------------------------------------
+
+// AxisOffsets
+
+// float absolute_offset = 1;
+inline void AxisOffsets::clear_absolute_offset() {
+  absolute_offset_ = 0;
+}
+inline float AxisOffsets::absolute_offset() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorConfig.AxisOffsets.absolute_offset)
+  return absolute_offset_;
+}
+inline void AxisOffsets::set_absolute_offset(float value) {
+  
+  absolute_offset_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorConfig.AxisOffsets.absolute_offset)
+}
+
+// float relative_offset = 2;
+inline void AxisOffsets::clear_relative_offset() {
+  relative_offset_ = 0;
+}
+inline float AxisOffsets::relative_offset() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorConfig.AxisOffsets.relative_offset)
+  return relative_offset_;
+}
+inline void AxisOffsets::set_relative_offset(float value) {
+  
+  relative_offset_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorConfig.AxisOffsets.relative_offset)
+}
+
+// -------------------------------------------------------------------
+
+// TorqueCalibration
+
+// float global_gain = 1;
+inline void TorqueCalibration::clear_global_gain() {
+  global_gain_ = 0;
+}
+inline float TorqueCalibration::global_gain() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorConfig.TorqueCalibration.global_gain)
+  return global_gain_;
+}
+inline void TorqueCalibration::set_global_gain(float value) {
+  
+  global_gain_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorConfig.TorqueCalibration.global_gain)
+}
+
+// float global_offset = 2;
+inline void TorqueCalibration::clear_global_offset() {
+  global_offset_ = 0;
+}
+inline float TorqueCalibration::global_offset() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorConfig.TorqueCalibration.global_offset)
+  return global_offset_;
+}
+inline void TorqueCalibration::set_global_offset(float value) {
+  
+  global_offset_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorConfig.TorqueCalibration.global_offset)
+}
+
+// repeated float gain = 3;
+inline int TorqueCalibration::gain_size() const {
+  return gain_.size();
+}
+inline void TorqueCalibration::clear_gain() {
+  gain_.Clear();
+}
+inline float TorqueCalibration::gain(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorConfig.TorqueCalibration.gain)
+  return gain_.Get(index);
+}
+inline void TorqueCalibration::set_gain(int index, float value) {
+  gain_.Set(index, value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorConfig.TorqueCalibration.gain)
+}
+inline void TorqueCalibration::add_gain(float value) {
+  gain_.Add(value);
+  // @@protoc_insertion_point(field_add:Kinova.Api.ActuatorConfig.TorqueCalibration.gain)
+}
+inline const ::google::protobuf::RepeatedField< float >&
+TorqueCalibration::gain() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.ActuatorConfig.TorqueCalibration.gain)
+  return gain_;
+}
+inline ::google::protobuf::RepeatedField< float >*
+TorqueCalibration::mutable_gain() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.ActuatorConfig.TorqueCalibration.gain)
+  return &gain_;
+}
+
+// repeated float offset = 4;
+inline int TorqueCalibration::offset_size() const {
+  return offset_.size();
+}
+inline void TorqueCalibration::clear_offset() {
+  offset_.Clear();
+}
+inline float TorqueCalibration::offset(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorConfig.TorqueCalibration.offset)
+  return offset_.Get(index);
+}
+inline void TorqueCalibration::set_offset(int index, float value) {
+  offset_.Set(index, value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorConfig.TorqueCalibration.offset)
+}
+inline void TorqueCalibration::add_offset(float value) {
+  offset_.Add(value);
+  // @@protoc_insertion_point(field_add:Kinova.Api.ActuatorConfig.TorqueCalibration.offset)
+}
+inline const ::google::protobuf::RepeatedField< float >&
+TorqueCalibration::offset() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.ActuatorConfig.TorqueCalibration.offset)
+  return offset_;
+}
+inline ::google::protobuf::RepeatedField< float >*
+TorqueCalibration::mutable_offset() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.ActuatorConfig.TorqueCalibration.offset)
+  return &offset_;
+}
+
+// -------------------------------------------------------------------
+
+// TorqueOffset
+
+// float torque_offset = 1;
+inline void TorqueOffset::clear_torque_offset() {
+  torque_offset_ = 0;
+}
+inline float TorqueOffset::torque_offset() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorConfig.TorqueOffset.torque_offset)
+  return torque_offset_;
+}
+inline void TorqueOffset::set_torque_offset(float value) {
+  
+  torque_offset_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorConfig.TorqueOffset.torque_offset)
+}
+
+// -------------------------------------------------------------------
+
+// ControlModeInformation
+
+// .Kinova.Api.ActuatorConfig.ControlMode control_mode = 1;
+inline void ControlModeInformation::clear_control_mode() {
+  control_mode_ = 0;
+}
+inline ::Kinova::Api::ActuatorConfig::ControlMode ControlModeInformation::control_mode() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorConfig.ControlModeInformation.control_mode)
+  return static_cast< ::Kinova::Api::ActuatorConfig::ControlMode >(control_mode_);
+}
+inline void ControlModeInformation::set_control_mode(::Kinova::Api::ActuatorConfig::ControlMode value) {
+  
+  control_mode_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorConfig.ControlModeInformation.control_mode)
+}
+
+// -------------------------------------------------------------------
+
+// ControlLoop
+
+// fixed32 control_loop = 1;
+inline void ControlLoop::clear_control_loop() {
+  control_loop_ = 0u;
+}
+inline ::google::protobuf::uint32 ControlLoop::control_loop() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorConfig.ControlLoop.control_loop)
+  return control_loop_;
+}
+inline void ControlLoop::set_control_loop(::google::protobuf::uint32 value) {
+  
+  control_loop_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorConfig.ControlLoop.control_loop)
+}
+
+// -------------------------------------------------------------------
+
+// LoopSelection
+
+// .Kinova.Api.ActuatorConfig.ControlLoopSelection loop_selection = 1;
+inline void LoopSelection::clear_loop_selection() {
+  loop_selection_ = 0;
+}
+inline ::Kinova::Api::ActuatorConfig::ControlLoopSelection LoopSelection::loop_selection() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorConfig.LoopSelection.loop_selection)
+  return static_cast< ::Kinova::Api::ActuatorConfig::ControlLoopSelection >(loop_selection_);
+}
+inline void LoopSelection::set_loop_selection(::Kinova::Api::ActuatorConfig::ControlLoopSelection value) {
+  
+  loop_selection_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorConfig.LoopSelection.loop_selection)
+}
+
+// -------------------------------------------------------------------
+
+// VectorDriveParameters
+
+// float kpq = 1;
+inline void VectorDriveParameters::clear_kpq() {
+  kpq_ = 0;
+}
+inline float VectorDriveParameters::kpq() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorConfig.VectorDriveParameters.kpq)
+  return kpq_;
+}
+inline void VectorDriveParameters::set_kpq(float value) {
+  
+  kpq_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorConfig.VectorDriveParameters.kpq)
+}
+
+// float kiq = 2;
+inline void VectorDriveParameters::clear_kiq() {
+  kiq_ = 0;
+}
+inline float VectorDriveParameters::kiq() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorConfig.VectorDriveParameters.kiq)
+  return kiq_;
+}
+inline void VectorDriveParameters::set_kiq(float value) {
+  
+  kiq_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorConfig.VectorDriveParameters.kiq)
+}
+
+// float kpd = 3;
+inline void VectorDriveParameters::clear_kpd() {
+  kpd_ = 0;
+}
+inline float VectorDriveParameters::kpd() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorConfig.VectorDriveParameters.kpd)
+  return kpd_;
+}
+inline void VectorDriveParameters::set_kpd(float value) {
+  
+  kpd_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorConfig.VectorDriveParameters.kpd)
+}
+
+// float kid = 4;
+inline void VectorDriveParameters::clear_kid() {
+  kid_ = 0;
+}
+inline float VectorDriveParameters::kid() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorConfig.VectorDriveParameters.kid)
+  return kid_;
+}
+inline void VectorDriveParameters::set_kid(float value) {
+  
+  kid_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorConfig.VectorDriveParameters.kid)
+}
+
+// -------------------------------------------------------------------
+
+// EncoderDerivativeParameters
+
+// uint32 max_window_width = 1;
+inline void EncoderDerivativeParameters::clear_max_window_width() {
+  max_window_width_ = 0u;
+}
+inline ::google::protobuf::uint32 EncoderDerivativeParameters::max_window_width() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorConfig.EncoderDerivativeParameters.max_window_width)
+  return max_window_width_;
+}
+inline void EncoderDerivativeParameters::set_max_window_width(::google::protobuf::uint32 value) {
+  
+  max_window_width_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorConfig.EncoderDerivativeParameters.max_window_width)
+}
+
+// float min_angle = 2;
+inline void EncoderDerivativeParameters::clear_min_angle() {
+  min_angle_ = 0;
+}
+inline float EncoderDerivativeParameters::min_angle() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorConfig.EncoderDerivativeParameters.min_angle)
+  return min_angle_;
+}
+inline void EncoderDerivativeParameters::set_min_angle(float value) {
+  
+  min_angle_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorConfig.EncoderDerivativeParameters.min_angle)
+}
+
+// -------------------------------------------------------------------
+
+// ControlLoopParameters
+
+// .Kinova.Api.ActuatorConfig.ControlLoopSelection loop_selection = 1;
+inline void ControlLoopParameters::clear_loop_selection() {
+  loop_selection_ = 0;
+}
+inline ::Kinova::Api::ActuatorConfig::ControlLoopSelection ControlLoopParameters::loop_selection() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorConfig.ControlLoopParameters.loop_selection)
+  return static_cast< ::Kinova::Api::ActuatorConfig::ControlLoopSelection >(loop_selection_);
+}
+inline void ControlLoopParameters::set_loop_selection(::Kinova::Api::ActuatorConfig::ControlLoopSelection value) {
+  
+  loop_selection_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorConfig.ControlLoopParameters.loop_selection)
+}
+
+// float error_saturation = 2;
+inline void ControlLoopParameters::clear_error_saturation() {
+  error_saturation_ = 0;
+}
+inline float ControlLoopParameters::error_saturation() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorConfig.ControlLoopParameters.error_saturation)
+  return error_saturation_;
+}
+inline void ControlLoopParameters::set_error_saturation(float value) {
+  
+  error_saturation_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorConfig.ControlLoopParameters.error_saturation)
+}
+
+// float output_saturation = 3;
+inline void ControlLoopParameters::clear_output_saturation() {
+  output_saturation_ = 0;
+}
+inline float ControlLoopParameters::output_saturation() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorConfig.ControlLoopParameters.output_saturation)
+  return output_saturation_;
+}
+inline void ControlLoopParameters::set_output_saturation(float value) {
+  
+  output_saturation_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorConfig.ControlLoopParameters.output_saturation)
+}
+
+// repeated float kAz = 4;
+inline int ControlLoopParameters::kaz_size() const {
+  return kaz_.size();
+}
+inline void ControlLoopParameters::clear_kaz() {
+  kaz_.Clear();
+}
+inline float ControlLoopParameters::kaz(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorConfig.ControlLoopParameters.kAz)
+  return kaz_.Get(index);
+}
+inline void ControlLoopParameters::set_kaz(int index, float value) {
+  kaz_.Set(index, value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorConfig.ControlLoopParameters.kAz)
+}
+inline void ControlLoopParameters::add_kaz(float value) {
+  kaz_.Add(value);
+  // @@protoc_insertion_point(field_add:Kinova.Api.ActuatorConfig.ControlLoopParameters.kAz)
+}
+inline const ::google::protobuf::RepeatedField< float >&
+ControlLoopParameters::kaz() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.ActuatorConfig.ControlLoopParameters.kAz)
+  return kaz_;
+}
+inline ::google::protobuf::RepeatedField< float >*
+ControlLoopParameters::mutable_kaz() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.ActuatorConfig.ControlLoopParameters.kAz)
+  return &kaz_;
+}
+
+// repeated float kBz = 5;
+inline int ControlLoopParameters::kbz_size() const {
+  return kbz_.size();
+}
+inline void ControlLoopParameters::clear_kbz() {
+  kbz_.Clear();
+}
+inline float ControlLoopParameters::kbz(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorConfig.ControlLoopParameters.kBz)
+  return kbz_.Get(index);
+}
+inline void ControlLoopParameters::set_kbz(int index, float value) {
+  kbz_.Set(index, value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorConfig.ControlLoopParameters.kBz)
+}
+inline void ControlLoopParameters::add_kbz(float value) {
+  kbz_.Add(value);
+  // @@protoc_insertion_point(field_add:Kinova.Api.ActuatorConfig.ControlLoopParameters.kBz)
+}
+inline const ::google::protobuf::RepeatedField< float >&
+ControlLoopParameters::kbz() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.ActuatorConfig.ControlLoopParameters.kBz)
+  return kbz_;
+}
+inline ::google::protobuf::RepeatedField< float >*
+ControlLoopParameters::mutable_kbz() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.ActuatorConfig.ControlLoopParameters.kBz)
+  return &kbz_;
+}
+
+// float error_dead_band = 6;
+inline void ControlLoopParameters::clear_error_dead_band() {
+  error_dead_band_ = 0;
+}
+inline float ControlLoopParameters::error_dead_band() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorConfig.ControlLoopParameters.error_dead_band)
+  return error_dead_band_;
+}
+inline void ControlLoopParameters::set_error_dead_band(float value) {
+  
+  error_dead_band_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorConfig.ControlLoopParameters.error_dead_band)
+}
+
+// -------------------------------------------------------------------
+
+// FrequencyResponse
+
+// .Kinova.Api.ActuatorConfig.ControlLoopSelection loop_selection = 1;
+inline void FrequencyResponse::clear_loop_selection() {
+  loop_selection_ = 0;
+}
+inline ::Kinova::Api::ActuatorConfig::ControlLoopSelection FrequencyResponse::loop_selection() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorConfig.FrequencyResponse.loop_selection)
+  return static_cast< ::Kinova::Api::ActuatorConfig::ControlLoopSelection >(loop_selection_);
+}
+inline void FrequencyResponse::set_loop_selection(::Kinova::Api::ActuatorConfig::ControlLoopSelection value) {
+  
+  loop_selection_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorConfig.FrequencyResponse.loop_selection)
+}
+
+// float min_frequency = 2;
+inline void FrequencyResponse::clear_min_frequency() {
+  min_frequency_ = 0;
+}
+inline float FrequencyResponse::min_frequency() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorConfig.FrequencyResponse.min_frequency)
+  return min_frequency_;
+}
+inline void FrequencyResponse::set_min_frequency(float value) {
+  
+  min_frequency_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorConfig.FrequencyResponse.min_frequency)
+}
+
+// float max_frequency = 3;
+inline void FrequencyResponse::clear_max_frequency() {
+  max_frequency_ = 0;
+}
+inline float FrequencyResponse::max_frequency() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorConfig.FrequencyResponse.max_frequency)
+  return max_frequency_;
+}
+inline void FrequencyResponse::set_max_frequency(float value) {
+  
+  max_frequency_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorConfig.FrequencyResponse.max_frequency)
+}
+
+// float amplitude = 4;
+inline void FrequencyResponse::clear_amplitude() {
+  amplitude_ = 0;
+}
+inline float FrequencyResponse::amplitude() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorConfig.FrequencyResponse.amplitude)
+  return amplitude_;
+}
+inline void FrequencyResponse::set_amplitude(float value) {
+  
+  amplitude_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorConfig.FrequencyResponse.amplitude)
+}
+
+// float duration = 5;
+inline void FrequencyResponse::clear_duration() {
+  duration_ = 0;
+}
+inline float FrequencyResponse::duration() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorConfig.FrequencyResponse.duration)
+  return duration_;
+}
+inline void FrequencyResponse::set_duration(float value) {
+  
+  duration_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorConfig.FrequencyResponse.duration)
+}
+
+// -------------------------------------------------------------------
+
+// StepResponse
+
+// .Kinova.Api.ActuatorConfig.ControlLoopSelection loop_selection = 1;
+inline void StepResponse::clear_loop_selection() {
+  loop_selection_ = 0;
+}
+inline ::Kinova::Api::ActuatorConfig::ControlLoopSelection StepResponse::loop_selection() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorConfig.StepResponse.loop_selection)
+  return static_cast< ::Kinova::Api::ActuatorConfig::ControlLoopSelection >(loop_selection_);
+}
+inline void StepResponse::set_loop_selection(::Kinova::Api::ActuatorConfig::ControlLoopSelection value) {
+  
+  loop_selection_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorConfig.StepResponse.loop_selection)
+}
+
+// float amplitude = 2;
+inline void StepResponse::clear_amplitude() {
+  amplitude_ = 0;
+}
+inline float StepResponse::amplitude() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorConfig.StepResponse.amplitude)
+  return amplitude_;
+}
+inline void StepResponse::set_amplitude(float value) {
+  
+  amplitude_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorConfig.StepResponse.amplitude)
+}
+
+// float step_delay = 3;
+inline void StepResponse::clear_step_delay() {
+  step_delay_ = 0;
+}
+inline float StepResponse::step_delay() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorConfig.StepResponse.step_delay)
+  return step_delay_;
+}
+inline void StepResponse::set_step_delay(float value) {
+  
+  step_delay_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorConfig.StepResponse.step_delay)
+}
+
+// float duration = 4;
+inline void StepResponse::clear_duration() {
+  duration_ = 0;
+}
+inline float StepResponse::duration() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorConfig.StepResponse.duration)
+  return duration_;
+}
+inline void StepResponse::set_duration(float value) {
+  
+  duration_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorConfig.StepResponse.duration)
+}
+
+// -------------------------------------------------------------------
+
+// RampResponse
+
+// .Kinova.Api.ActuatorConfig.ControlLoopSelection loop_selection = 1;
+inline void RampResponse::clear_loop_selection() {
+  loop_selection_ = 0;
+}
+inline ::Kinova::Api::ActuatorConfig::ControlLoopSelection RampResponse::loop_selection() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorConfig.RampResponse.loop_selection)
+  return static_cast< ::Kinova::Api::ActuatorConfig::ControlLoopSelection >(loop_selection_);
+}
+inline void RampResponse::set_loop_selection(::Kinova::Api::ActuatorConfig::ControlLoopSelection value) {
+  
+  loop_selection_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorConfig.RampResponse.loop_selection)
+}
+
+// float slope = 2;
+inline void RampResponse::clear_slope() {
+  slope_ = 0;
+}
+inline float RampResponse::slope() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorConfig.RampResponse.slope)
+  return slope_;
+}
+inline void RampResponse::set_slope(float value) {
+  
+  slope_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorConfig.RampResponse.slope)
+}
+
+// float ramp_delay = 3;
+inline void RampResponse::clear_ramp_delay() {
+  ramp_delay_ = 0;
+}
+inline float RampResponse::ramp_delay() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorConfig.RampResponse.ramp_delay)
+  return ramp_delay_;
+}
+inline void RampResponse::set_ramp_delay(float value) {
+  
+  ramp_delay_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorConfig.RampResponse.ramp_delay)
+}
+
+// float duration = 4;
+inline void RampResponse::clear_duration() {
+  duration_ = 0;
+}
+inline float RampResponse::duration() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorConfig.RampResponse.duration)
+  return duration_;
+}
+inline void RampResponse::set_duration(float value) {
+  
+  duration_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorConfig.RampResponse.duration)
+}
+
+// -------------------------------------------------------------------
+
+// CustomDataSelection
+
+// repeated .Kinova.Api.ActuatorConfig.CustomDataIndex channel = 1;
+inline int CustomDataSelection::channel_size() const {
+  return channel_.size();
+}
+inline void CustomDataSelection::clear_channel() {
+  channel_.Clear();
+}
+inline ::Kinova::Api::ActuatorConfig::CustomDataIndex CustomDataSelection::channel(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorConfig.CustomDataSelection.channel)
+  return static_cast< ::Kinova::Api::ActuatorConfig::CustomDataIndex >(channel_.Get(index));
+}
+inline void CustomDataSelection::set_channel(int index, ::Kinova::Api::ActuatorConfig::CustomDataIndex value) {
+  channel_.Set(index, value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorConfig.CustomDataSelection.channel)
+}
+inline void CustomDataSelection::add_channel(::Kinova::Api::ActuatorConfig::CustomDataIndex value) {
+  channel_.Add(value);
+  // @@protoc_insertion_point(field_add:Kinova.Api.ActuatorConfig.CustomDataSelection.channel)
+}
+inline const ::google::protobuf::RepeatedField<int>&
+CustomDataSelection::channel() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.ActuatorConfig.CustomDataSelection.channel)
+  return channel_;
+}
+inline ::google::protobuf::RepeatedField<int>*
+CustomDataSelection::mutable_channel() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.ActuatorConfig.CustomDataSelection.channel)
+  return &channel_;
+}
+
+// -------------------------------------------------------------------
+
+// CommandModeInformation
+
+// .Kinova.Api.ActuatorConfig.CommandMode command_mode = 1;
+inline void CommandModeInformation::clear_command_mode() {
+  command_mode_ = 0;
+}
+inline ::Kinova::Api::ActuatorConfig::CommandMode CommandModeInformation::command_mode() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorConfig.CommandModeInformation.command_mode)
+  return static_cast< ::Kinova::Api::ActuatorConfig::CommandMode >(command_mode_);
+}
+inline void CommandModeInformation::set_command_mode(::Kinova::Api::ActuatorConfig::CommandMode value) {
+  
+  command_mode_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorConfig.CommandModeInformation.command_mode)
+}
+
+// -------------------------------------------------------------------
+
+// Servoing
+
+// bool enabled = 1;
+inline void Servoing::clear_enabled() {
+  enabled_ = false;
+}
+inline bool Servoing::enabled() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorConfig.Servoing.enabled)
+  return enabled_;
+}
+inline void Servoing::set_enabled(bool value) {
+  
+  enabled_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorConfig.Servoing.enabled)
+}
+
+// -------------------------------------------------------------------
+
+// PositionCommand
+
+// float position = 1;
+inline void PositionCommand::clear_position() {
+  position_ = 0;
+}
+inline float PositionCommand::position() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorConfig.PositionCommand.position)
+  return position_;
+}
+inline void PositionCommand::set_position(float value) {
+  
+  position_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorConfig.PositionCommand.position)
+}
+
+// float velocity = 2;
+inline void PositionCommand::clear_velocity() {
+  velocity_ = 0;
+}
+inline float PositionCommand::velocity() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorConfig.PositionCommand.velocity)
+  return velocity_;
+}
+inline void PositionCommand::set_velocity(float value) {
+  
+  velocity_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorConfig.PositionCommand.velocity)
+}
+
+// float acceleration = 3;
+inline void PositionCommand::clear_acceleration() {
+  acceleration_ = 0;
+}
+inline float PositionCommand::acceleration() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorConfig.PositionCommand.acceleration)
+  return acceleration_;
+}
+inline void PositionCommand::set_acceleration(float value) {
+  
+  acceleration_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorConfig.PositionCommand.acceleration)
+}
+
+// -------------------------------------------------------------------
+
+// CoggingFeedforwardModeInformation
+
+// .Kinova.Api.ActuatorConfig.CoggingFeedforwardMode cogging_feedforward_mode = 1;
+inline void CoggingFeedforwardModeInformation::clear_cogging_feedforward_mode() {
+  cogging_feedforward_mode_ = 0;
+}
+inline ::Kinova::Api::ActuatorConfig::CoggingFeedforwardMode CoggingFeedforwardModeInformation::cogging_feedforward_mode() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorConfig.CoggingFeedforwardModeInformation.cogging_feedforward_mode)
+  return static_cast< ::Kinova::Api::ActuatorConfig::CoggingFeedforwardMode >(cogging_feedforward_mode_);
+}
+inline void CoggingFeedforwardModeInformation::set_cogging_feedforward_mode(::Kinova::Api::ActuatorConfig::CoggingFeedforwardMode value) {
+  
+  cogging_feedforward_mode_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorConfig.CoggingFeedforwardModeInformation.cogging_feedforward_mode)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace ActuatorConfig
+}  // namespace Api
+}  // namespace Kinova
+
+namespace google {
+namespace protobuf {
+
+template <> struct is_proto_enum< ::Kinova::Api::ActuatorConfig::ServiceVersion> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::ActuatorConfig::ServiceVersion>() {
+  return ::Kinova::Api::ActuatorConfig::ServiceVersion_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::ActuatorConfig::SafetyLimitType> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::ActuatorConfig::SafetyLimitType>() {
+  return ::Kinova::Api::ActuatorConfig::SafetyLimitType_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::ActuatorConfig::ControlMode> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::ActuatorConfig::ControlMode>() {
+  return ::Kinova::Api::ActuatorConfig::ControlMode_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::ActuatorConfig::CommandMode> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::ActuatorConfig::CommandMode>() {
+  return ::Kinova::Api::ActuatorConfig::CommandMode_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::ActuatorConfig::ControlLoopSelection> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::ActuatorConfig::ControlLoopSelection>() {
+  return ::Kinova::Api::ActuatorConfig::ControlLoopSelection_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::ActuatorConfig::CoggingFeedforwardMode> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::ActuatorConfig::CoggingFeedforwardMode>() {
+  return ::Kinova::Api::ActuatorConfig::CoggingFeedforwardMode_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::ActuatorConfig::SafetyIdentifierBankA> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::ActuatorConfig::SafetyIdentifierBankA>() {
+  return ::Kinova::Api::ActuatorConfig::SafetyIdentifierBankA_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::ActuatorConfig::CustomDataIndex> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::ActuatorConfig::CustomDataIndex>() {
+  return ::Kinova::Api::ActuatorConfig::CustomDataIndex_descriptor();
+}
+
+}  // namespace protobuf
+}  // namespace google
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_ActuatorConfig_2eproto__INCLUDED
diff --git a/kortex_api/include/messages/ActuatorCyclic.pb.h b/kortex_api/include/messages/ActuatorCyclic.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..a204e1d7bc4da6fd71ba806264b4cc823f9ffbb4
--- /dev/null
+++ b/kortex_api/include/messages/ActuatorCyclic.pb.h
@@ -0,0 +1,1525 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: ActuatorCyclic.proto
+
+#ifndef PROTOBUF_ActuatorCyclic_2eproto__INCLUDED
+#define PROTOBUF_ActuatorCyclic_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 3005000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 3005001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "Common.pb.h"  // IWYU pragma: export
+// @@protoc_insertion_point(includes)
+
+namespace protobuf_ActuatorCyclic_2eproto {
+// Internal implementation detail -- do not use these members.
+struct TableStruct {
+  static const ::google::protobuf::internal::ParseTableField entries[];
+  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
+  static const ::google::protobuf::internal::ParseTable schema[4];
+  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
+  static const ::google::protobuf::internal::SerializationTable serialization_table[];
+  static const ::google::protobuf::uint32 offsets[];
+};
+void AddDescriptors();
+void InitDefaultsMessageIdImpl();
+void InitDefaultsMessageId();
+void InitDefaultsCommandImpl();
+void InitDefaultsCommand();
+void InitDefaultsFeedbackImpl();
+void InitDefaultsFeedback();
+void InitDefaultsCustomDataImpl();
+void InitDefaultsCustomData();
+inline void InitDefaults() {
+  InitDefaultsMessageId();
+  InitDefaultsCommand();
+  InitDefaultsFeedback();
+  InitDefaultsCustomData();
+}
+}  // namespace protobuf_ActuatorCyclic_2eproto
+namespace Kinova {
+namespace Api {
+namespace ActuatorCyclic {
+class Command;
+class CommandDefaultTypeInternal;
+extern CommandDefaultTypeInternal _Command_default_instance_;
+class CustomData;
+class CustomDataDefaultTypeInternal;
+extern CustomDataDefaultTypeInternal _CustomData_default_instance_;
+class Feedback;
+class FeedbackDefaultTypeInternal;
+extern FeedbackDefaultTypeInternal _Feedback_default_instance_;
+class MessageId;
+class MessageIdDefaultTypeInternal;
+extern MessageIdDefaultTypeInternal _MessageId_default_instance_;
+}  // namespace ActuatorCyclic
+}  // namespace Api
+}  // namespace Kinova
+namespace Kinova {
+namespace Api {
+namespace ActuatorCyclic {
+
+enum ServiceVersion {
+  RESERVED_0 = 0,
+  CURRENT_VERSION = 1,
+  ServiceVersion_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  ServiceVersion_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool ServiceVersion_IsValid(int value);
+const ServiceVersion ServiceVersion_MIN = RESERVED_0;
+const ServiceVersion ServiceVersion_MAX = CURRENT_VERSION;
+const int ServiceVersion_ARRAYSIZE = ServiceVersion_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* ServiceVersion_descriptor();
+inline const ::std::string& ServiceVersion_Name(ServiceVersion value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    ServiceVersion_descriptor(), value);
+}
+inline bool ServiceVersion_Parse(
+    const ::std::string& name, ServiceVersion* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<ServiceVersion>(
+    ServiceVersion_descriptor(), name, value);
+}
+enum CommandFlags {
+  NO_COMMAND = 0,
+  SERVO_ENABLE = 1,
+  BRAKE_DISABLE = 2,
+  CLEAR_MAJOR_FAULT = 4,
+  CLEAR_MINOR_FAULT = 8,
+  PROTECTIVE_STOP = 16,
+  FORCE_BRAKE_RELEASE = 32,
+  IGNORE = 64,
+  LOW_GAINS = 128,
+  LED_0 = 256,
+  LED_1 = 512,
+  CommandFlags_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  CommandFlags_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool CommandFlags_IsValid(int value);
+const CommandFlags CommandFlags_MIN = NO_COMMAND;
+const CommandFlags CommandFlags_MAX = LED_1;
+const int CommandFlags_ARRAYSIZE = CommandFlags_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* CommandFlags_descriptor();
+inline const ::std::string& CommandFlags_Name(CommandFlags value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    CommandFlags_descriptor(), value);
+}
+inline bool CommandFlags_Parse(
+    const ::std::string& name, CommandFlags* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<CommandFlags>(
+    CommandFlags_descriptor(), name, value);
+}
+enum StatusFlags {
+  UNKNOWN_STATUS = 0,
+  STABILIZED = 16,
+  MOTOR_INDEXED = 32,
+  MOTOR_INDEXING = 64,
+  JOINT_INDEXED = 128,
+  JOINT_INDEXING = 256,
+  HIGH_PRECISION = 512,
+  BRAKING = 1024,
+  SERVOING = 2048,
+  MAJOR_FAULT = 4096,
+  MINOR_FAULT = 8192,
+  CALIBRATED_TORQUE = 16384,
+  CALIBRATED_MAG_SENSOR = 32768,
+  CALIBRATED_ZERO = 65536,
+  GPIO_0 = 131072,
+  GPIO_1 = 262144,
+  CS_QUASI_STATIC_CONTACT = 524288,
+  CS_TRANSIENT_CONTACT = 1048576,
+  VFD_HALL_SYNC = 2097152,
+  VFD_INDEXED = 4194304,
+  DRIVE_BOARD_READY = 8388608,
+  CALIBRATED_CURRENT = 16777216,
+  CALIBRATED_MOTOR = 33554432,
+  SW0_ACTIVE = 67108864,
+  SW1_ACTIVE = 134217728,
+  StatusFlags_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  StatusFlags_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool StatusFlags_IsValid(int value);
+const StatusFlags StatusFlags_MIN = UNKNOWN_STATUS;
+const StatusFlags StatusFlags_MAX = SW1_ACTIVE;
+const int StatusFlags_ARRAYSIZE = StatusFlags_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* StatusFlags_descriptor();
+inline const ::std::string& StatusFlags_Name(StatusFlags value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    StatusFlags_descriptor(), value);
+}
+inline bool StatusFlags_Parse(
+    const ::std::string& name, StatusFlags* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<StatusFlags>(
+    StatusFlags_descriptor(), name, value);
+}
+// ===================================================================
+
+class MessageId : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.ActuatorCyclic.MessageId) */ {
+ public:
+  MessageId();
+  virtual ~MessageId();
+
+  MessageId(const MessageId& from);
+
+  inline MessageId& operator=(const MessageId& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  MessageId(MessageId&& from) noexcept
+    : MessageId() {
+    *this = ::std::move(from);
+  }
+
+  inline MessageId& operator=(MessageId&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const MessageId& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const MessageId* internal_default_instance() {
+    return reinterpret_cast<const MessageId*>(
+               &_MessageId_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    0;
+
+  void Swap(MessageId* other);
+  friend void swap(MessageId& a, MessageId& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline MessageId* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  MessageId* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const MessageId& from);
+  void MergeFrom(const MessageId& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(MessageId* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // fixed32 identifier = 1;
+  void clear_identifier();
+  static const int kIdentifierFieldNumber = 1;
+  ::google::protobuf::uint32 identifier() const;
+  void set_identifier(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.ActuatorCyclic.MessageId)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 identifier_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_ActuatorCyclic_2eproto::TableStruct;
+  friend void ::protobuf_ActuatorCyclic_2eproto::InitDefaultsMessageIdImpl();
+};
+// -------------------------------------------------------------------
+
+class Command : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.ActuatorCyclic.Command) */ {
+ public:
+  Command();
+  virtual ~Command();
+
+  Command(const Command& from);
+
+  inline Command& operator=(const Command& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Command(Command&& from) noexcept
+    : Command() {
+    *this = ::std::move(from);
+  }
+
+  inline Command& operator=(Command&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Command& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Command* internal_default_instance() {
+    return reinterpret_cast<const Command*>(
+               &_Command_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    1;
+
+  void Swap(Command* other);
+  friend void swap(Command& a, Command& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Command* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Command* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Command& from);
+  void MergeFrom(const Command& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Command* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.ActuatorCyclic.MessageId command_id = 1;
+  bool has_command_id() const;
+  void clear_command_id();
+  static const int kCommandIdFieldNumber = 1;
+  const ::Kinova::Api::ActuatorCyclic::MessageId& command_id() const;
+  ::Kinova::Api::ActuatorCyclic::MessageId* release_command_id();
+  ::Kinova::Api::ActuatorCyclic::MessageId* mutable_command_id();
+  void set_allocated_command_id(::Kinova::Api::ActuatorCyclic::MessageId* command_id);
+
+  // fixed32 flags = 2;
+  void clear_flags();
+  static const int kFlagsFieldNumber = 2;
+  ::google::protobuf::uint32 flags() const;
+  void set_flags(::google::protobuf::uint32 value);
+
+  // float position = 3;
+  void clear_position();
+  static const int kPositionFieldNumber = 3;
+  float position() const;
+  void set_position(float value);
+
+  // float velocity = 4;
+  void clear_velocity();
+  static const int kVelocityFieldNumber = 4;
+  float velocity() const;
+  void set_velocity(float value);
+
+  // float torque_joint = 5;
+  void clear_torque_joint();
+  static const int kTorqueJointFieldNumber = 5;
+  float torque_joint() const;
+  void set_torque_joint(float value);
+
+  // float current_motor = 6;
+  void clear_current_motor();
+  static const int kCurrentMotorFieldNumber = 6;
+  float current_motor() const;
+  void set_current_motor(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.ActuatorCyclic.Command)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::ActuatorCyclic::MessageId* command_id_;
+  ::google::protobuf::uint32 flags_;
+  float position_;
+  float velocity_;
+  float torque_joint_;
+  float current_motor_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_ActuatorCyclic_2eproto::TableStruct;
+  friend void ::protobuf_ActuatorCyclic_2eproto::InitDefaultsCommandImpl();
+};
+// -------------------------------------------------------------------
+
+class Feedback : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.ActuatorCyclic.Feedback) */ {
+ public:
+  Feedback();
+  virtual ~Feedback();
+
+  Feedback(const Feedback& from);
+
+  inline Feedback& operator=(const Feedback& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Feedback(Feedback&& from) noexcept
+    : Feedback() {
+    *this = ::std::move(from);
+  }
+
+  inline Feedback& operator=(Feedback&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Feedback& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Feedback* internal_default_instance() {
+    return reinterpret_cast<const Feedback*>(
+               &_Feedback_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    2;
+
+  void Swap(Feedback* other);
+  friend void swap(Feedback& a, Feedback& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Feedback* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Feedback* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Feedback& from);
+  void MergeFrom(const Feedback& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Feedback* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.ActuatorCyclic.MessageId feedback_id = 1;
+  bool has_feedback_id() const;
+  void clear_feedback_id();
+  static const int kFeedbackIdFieldNumber = 1;
+  const ::Kinova::Api::ActuatorCyclic::MessageId& feedback_id() const;
+  ::Kinova::Api::ActuatorCyclic::MessageId* release_feedback_id();
+  ::Kinova::Api::ActuatorCyclic::MessageId* mutable_feedback_id();
+  void set_allocated_feedback_id(::Kinova::Api::ActuatorCyclic::MessageId* feedback_id);
+
+  // fixed32 status_flags = 2;
+  void clear_status_flags();
+  static const int kStatusFlagsFieldNumber = 2;
+  ::google::protobuf::uint32 status_flags() const;
+  void set_status_flags(::google::protobuf::uint32 value);
+
+  // fixed32 jitter_comm = 3;
+  void clear_jitter_comm();
+  static const int kJitterCommFieldNumber = 3;
+  ::google::protobuf::uint32 jitter_comm() const;
+  void set_jitter_comm(::google::protobuf::uint32 value);
+
+  // float position = 4;
+  void clear_position();
+  static const int kPositionFieldNumber = 4;
+  float position() const;
+  void set_position(float value);
+
+  // float velocity = 5;
+  void clear_velocity();
+  static const int kVelocityFieldNumber = 5;
+  float velocity() const;
+  void set_velocity(float value);
+
+  // float torque = 6;
+  void clear_torque();
+  static const int kTorqueFieldNumber = 6;
+  float torque() const;
+  void set_torque(float value);
+
+  // float current_motor = 7;
+  void clear_current_motor();
+  static const int kCurrentMotorFieldNumber = 7;
+  float current_motor() const;
+  void set_current_motor(float value);
+
+  // float voltage = 8;
+  void clear_voltage();
+  static const int kVoltageFieldNumber = 8;
+  float voltage() const;
+  void set_voltage(float value);
+
+  // float temperature_motor = 9;
+  void clear_temperature_motor();
+  static const int kTemperatureMotorFieldNumber = 9;
+  float temperature_motor() const;
+  void set_temperature_motor(float value);
+
+  // float temperature_core = 10;
+  void clear_temperature_core();
+  static const int kTemperatureCoreFieldNumber = 10;
+  float temperature_core() const;
+  void set_temperature_core(float value);
+
+  // fixed32 fault_bank_a = 11;
+  void clear_fault_bank_a();
+  static const int kFaultBankAFieldNumber = 11;
+  ::google::protobuf::uint32 fault_bank_a() const;
+  void set_fault_bank_a(::google::protobuf::uint32 value);
+
+  // fixed32 fault_bank_b = 12;
+  void clear_fault_bank_b();
+  static const int kFaultBankBFieldNumber = 12;
+  ::google::protobuf::uint32 fault_bank_b() const;
+  void set_fault_bank_b(::google::protobuf::uint32 value);
+
+  // fixed32 warning_bank_a = 13;
+  void clear_warning_bank_a();
+  static const int kWarningBankAFieldNumber = 13;
+  ::google::protobuf::uint32 warning_bank_a() const;
+  void set_warning_bank_a(::google::protobuf::uint32 value);
+
+  // fixed32 warning_bank_b = 14;
+  void clear_warning_bank_b();
+  static const int kWarningBankBFieldNumber = 14;
+  ::google::protobuf::uint32 warning_bank_b() const;
+  void set_warning_bank_b(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.ActuatorCyclic.Feedback)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::ActuatorCyclic::MessageId* feedback_id_;
+  ::google::protobuf::uint32 status_flags_;
+  ::google::protobuf::uint32 jitter_comm_;
+  float position_;
+  float velocity_;
+  float torque_;
+  float current_motor_;
+  float voltage_;
+  float temperature_motor_;
+  float temperature_core_;
+  ::google::protobuf::uint32 fault_bank_a_;
+  ::google::protobuf::uint32 fault_bank_b_;
+  ::google::protobuf::uint32 warning_bank_a_;
+  ::google::protobuf::uint32 warning_bank_b_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_ActuatorCyclic_2eproto::TableStruct;
+  friend void ::protobuf_ActuatorCyclic_2eproto::InitDefaultsFeedbackImpl();
+};
+// -------------------------------------------------------------------
+
+class CustomData : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.ActuatorCyclic.CustomData) */ {
+ public:
+  CustomData();
+  virtual ~CustomData();
+
+  CustomData(const CustomData& from);
+
+  inline CustomData& operator=(const CustomData& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  CustomData(CustomData&& from) noexcept
+    : CustomData() {
+    *this = ::std::move(from);
+  }
+
+  inline CustomData& operator=(CustomData&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const CustomData& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const CustomData* internal_default_instance() {
+    return reinterpret_cast<const CustomData*>(
+               &_CustomData_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    3;
+
+  void Swap(CustomData* other);
+  friend void swap(CustomData& a, CustomData& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline CustomData* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  CustomData* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const CustomData& from);
+  void MergeFrom(const CustomData& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(CustomData* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.ActuatorCyclic.MessageId custom_data_id = 1;
+  bool has_custom_data_id() const;
+  void clear_custom_data_id();
+  static const int kCustomDataIdFieldNumber = 1;
+  const ::Kinova::Api::ActuatorCyclic::MessageId& custom_data_id() const;
+  ::Kinova::Api::ActuatorCyclic::MessageId* release_custom_data_id();
+  ::Kinova::Api::ActuatorCyclic::MessageId* mutable_custom_data_id();
+  void set_allocated_custom_data_id(::Kinova::Api::ActuatorCyclic::MessageId* custom_data_id);
+
+  // fixed32 custom_data_0 = 2;
+  void clear_custom_data_0();
+  static const int kCustomData0FieldNumber = 2;
+  ::google::protobuf::uint32 custom_data_0() const;
+  void set_custom_data_0(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_1 = 3;
+  void clear_custom_data_1();
+  static const int kCustomData1FieldNumber = 3;
+  ::google::protobuf::uint32 custom_data_1() const;
+  void set_custom_data_1(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_2 = 4;
+  void clear_custom_data_2();
+  static const int kCustomData2FieldNumber = 4;
+  ::google::protobuf::uint32 custom_data_2() const;
+  void set_custom_data_2(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_3 = 5;
+  void clear_custom_data_3();
+  static const int kCustomData3FieldNumber = 5;
+  ::google::protobuf::uint32 custom_data_3() const;
+  void set_custom_data_3(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_4 = 6;
+  void clear_custom_data_4();
+  static const int kCustomData4FieldNumber = 6;
+  ::google::protobuf::uint32 custom_data_4() const;
+  void set_custom_data_4(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_5 = 7;
+  void clear_custom_data_5();
+  static const int kCustomData5FieldNumber = 7;
+  ::google::protobuf::uint32 custom_data_5() const;
+  void set_custom_data_5(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_6 = 8;
+  void clear_custom_data_6();
+  static const int kCustomData6FieldNumber = 8;
+  ::google::protobuf::uint32 custom_data_6() const;
+  void set_custom_data_6(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_7 = 9;
+  void clear_custom_data_7();
+  static const int kCustomData7FieldNumber = 9;
+  ::google::protobuf::uint32 custom_data_7() const;
+  void set_custom_data_7(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_8 = 10;
+  void clear_custom_data_8();
+  static const int kCustomData8FieldNumber = 10;
+  ::google::protobuf::uint32 custom_data_8() const;
+  void set_custom_data_8(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_9 = 11;
+  void clear_custom_data_9();
+  static const int kCustomData9FieldNumber = 11;
+  ::google::protobuf::uint32 custom_data_9() const;
+  void set_custom_data_9(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_10 = 12;
+  void clear_custom_data_10();
+  static const int kCustomData10FieldNumber = 12;
+  ::google::protobuf::uint32 custom_data_10() const;
+  void set_custom_data_10(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_11 = 13;
+  void clear_custom_data_11();
+  static const int kCustomData11FieldNumber = 13;
+  ::google::protobuf::uint32 custom_data_11() const;
+  void set_custom_data_11(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_12 = 14;
+  void clear_custom_data_12();
+  static const int kCustomData12FieldNumber = 14;
+  ::google::protobuf::uint32 custom_data_12() const;
+  void set_custom_data_12(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_13 = 15;
+  void clear_custom_data_13();
+  static const int kCustomData13FieldNumber = 15;
+  ::google::protobuf::uint32 custom_data_13() const;
+  void set_custom_data_13(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_14 = 16;
+  void clear_custom_data_14();
+  static const int kCustomData14FieldNumber = 16;
+  ::google::protobuf::uint32 custom_data_14() const;
+  void set_custom_data_14(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_15 = 17;
+  void clear_custom_data_15();
+  static const int kCustomData15FieldNumber = 17;
+  ::google::protobuf::uint32 custom_data_15() const;
+  void set_custom_data_15(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.ActuatorCyclic.CustomData)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::ActuatorCyclic::MessageId* custom_data_id_;
+  ::google::protobuf::uint32 custom_data_0_;
+  ::google::protobuf::uint32 custom_data_1_;
+  ::google::protobuf::uint32 custom_data_2_;
+  ::google::protobuf::uint32 custom_data_3_;
+  ::google::protobuf::uint32 custom_data_4_;
+  ::google::protobuf::uint32 custom_data_5_;
+  ::google::protobuf::uint32 custom_data_6_;
+  ::google::protobuf::uint32 custom_data_7_;
+  ::google::protobuf::uint32 custom_data_8_;
+  ::google::protobuf::uint32 custom_data_9_;
+  ::google::protobuf::uint32 custom_data_10_;
+  ::google::protobuf::uint32 custom_data_11_;
+  ::google::protobuf::uint32 custom_data_12_;
+  ::google::protobuf::uint32 custom_data_13_;
+  ::google::protobuf::uint32 custom_data_14_;
+  ::google::protobuf::uint32 custom_data_15_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_ActuatorCyclic_2eproto::TableStruct;
+  friend void ::protobuf_ActuatorCyclic_2eproto::InitDefaultsCustomDataImpl();
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// MessageId
+
+// fixed32 identifier = 1;
+inline void MessageId::clear_identifier() {
+  identifier_ = 0u;
+}
+inline ::google::protobuf::uint32 MessageId::identifier() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorCyclic.MessageId.identifier)
+  return identifier_;
+}
+inline void MessageId::set_identifier(::google::protobuf::uint32 value) {
+  
+  identifier_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorCyclic.MessageId.identifier)
+}
+
+// -------------------------------------------------------------------
+
+// Command
+
+// .Kinova.Api.ActuatorCyclic.MessageId command_id = 1;
+inline bool Command::has_command_id() const {
+  return this != internal_default_instance() && command_id_ != NULL;
+}
+inline void Command::clear_command_id() {
+  if (GetArenaNoVirtual() == NULL && command_id_ != NULL) {
+    delete command_id_;
+  }
+  command_id_ = NULL;
+}
+inline const ::Kinova::Api::ActuatorCyclic::MessageId& Command::command_id() const {
+  const ::Kinova::Api::ActuatorCyclic::MessageId* p = command_id_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorCyclic.Command.command_id)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::ActuatorCyclic::MessageId*>(
+      &::Kinova::Api::ActuatorCyclic::_MessageId_default_instance_);
+}
+inline ::Kinova::Api::ActuatorCyclic::MessageId* Command::release_command_id() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.ActuatorCyclic.Command.command_id)
+  
+  ::Kinova::Api::ActuatorCyclic::MessageId* temp = command_id_;
+  command_id_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::ActuatorCyclic::MessageId* Command::mutable_command_id() {
+  
+  if (command_id_ == NULL) {
+    command_id_ = new ::Kinova::Api::ActuatorCyclic::MessageId;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.ActuatorCyclic.Command.command_id)
+  return command_id_;
+}
+inline void Command::set_allocated_command_id(::Kinova::Api::ActuatorCyclic::MessageId* command_id) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete command_id_;
+  }
+  if (command_id) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      command_id = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, command_id, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  command_id_ = command_id;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.ActuatorCyclic.Command.command_id)
+}
+
+// fixed32 flags = 2;
+inline void Command::clear_flags() {
+  flags_ = 0u;
+}
+inline ::google::protobuf::uint32 Command::flags() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorCyclic.Command.flags)
+  return flags_;
+}
+inline void Command::set_flags(::google::protobuf::uint32 value) {
+  
+  flags_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorCyclic.Command.flags)
+}
+
+// float position = 3;
+inline void Command::clear_position() {
+  position_ = 0;
+}
+inline float Command::position() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorCyclic.Command.position)
+  return position_;
+}
+inline void Command::set_position(float value) {
+  
+  position_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorCyclic.Command.position)
+}
+
+// float velocity = 4;
+inline void Command::clear_velocity() {
+  velocity_ = 0;
+}
+inline float Command::velocity() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorCyclic.Command.velocity)
+  return velocity_;
+}
+inline void Command::set_velocity(float value) {
+  
+  velocity_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorCyclic.Command.velocity)
+}
+
+// float torque_joint = 5;
+inline void Command::clear_torque_joint() {
+  torque_joint_ = 0;
+}
+inline float Command::torque_joint() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorCyclic.Command.torque_joint)
+  return torque_joint_;
+}
+inline void Command::set_torque_joint(float value) {
+  
+  torque_joint_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorCyclic.Command.torque_joint)
+}
+
+// float current_motor = 6;
+inline void Command::clear_current_motor() {
+  current_motor_ = 0;
+}
+inline float Command::current_motor() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorCyclic.Command.current_motor)
+  return current_motor_;
+}
+inline void Command::set_current_motor(float value) {
+  
+  current_motor_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorCyclic.Command.current_motor)
+}
+
+// -------------------------------------------------------------------
+
+// Feedback
+
+// .Kinova.Api.ActuatorCyclic.MessageId feedback_id = 1;
+inline bool Feedback::has_feedback_id() const {
+  return this != internal_default_instance() && feedback_id_ != NULL;
+}
+inline void Feedback::clear_feedback_id() {
+  if (GetArenaNoVirtual() == NULL && feedback_id_ != NULL) {
+    delete feedback_id_;
+  }
+  feedback_id_ = NULL;
+}
+inline const ::Kinova::Api::ActuatorCyclic::MessageId& Feedback::feedback_id() const {
+  const ::Kinova::Api::ActuatorCyclic::MessageId* p = feedback_id_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorCyclic.Feedback.feedback_id)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::ActuatorCyclic::MessageId*>(
+      &::Kinova::Api::ActuatorCyclic::_MessageId_default_instance_);
+}
+inline ::Kinova::Api::ActuatorCyclic::MessageId* Feedback::release_feedback_id() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.ActuatorCyclic.Feedback.feedback_id)
+  
+  ::Kinova::Api::ActuatorCyclic::MessageId* temp = feedback_id_;
+  feedback_id_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::ActuatorCyclic::MessageId* Feedback::mutable_feedback_id() {
+  
+  if (feedback_id_ == NULL) {
+    feedback_id_ = new ::Kinova::Api::ActuatorCyclic::MessageId;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.ActuatorCyclic.Feedback.feedback_id)
+  return feedback_id_;
+}
+inline void Feedback::set_allocated_feedback_id(::Kinova::Api::ActuatorCyclic::MessageId* feedback_id) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete feedback_id_;
+  }
+  if (feedback_id) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      feedback_id = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, feedback_id, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  feedback_id_ = feedback_id;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.ActuatorCyclic.Feedback.feedback_id)
+}
+
+// fixed32 status_flags = 2;
+inline void Feedback::clear_status_flags() {
+  status_flags_ = 0u;
+}
+inline ::google::protobuf::uint32 Feedback::status_flags() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorCyclic.Feedback.status_flags)
+  return status_flags_;
+}
+inline void Feedback::set_status_flags(::google::protobuf::uint32 value) {
+  
+  status_flags_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorCyclic.Feedback.status_flags)
+}
+
+// fixed32 jitter_comm = 3;
+inline void Feedback::clear_jitter_comm() {
+  jitter_comm_ = 0u;
+}
+inline ::google::protobuf::uint32 Feedback::jitter_comm() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorCyclic.Feedback.jitter_comm)
+  return jitter_comm_;
+}
+inline void Feedback::set_jitter_comm(::google::protobuf::uint32 value) {
+  
+  jitter_comm_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorCyclic.Feedback.jitter_comm)
+}
+
+// float position = 4;
+inline void Feedback::clear_position() {
+  position_ = 0;
+}
+inline float Feedback::position() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorCyclic.Feedback.position)
+  return position_;
+}
+inline void Feedback::set_position(float value) {
+  
+  position_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorCyclic.Feedback.position)
+}
+
+// float velocity = 5;
+inline void Feedback::clear_velocity() {
+  velocity_ = 0;
+}
+inline float Feedback::velocity() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorCyclic.Feedback.velocity)
+  return velocity_;
+}
+inline void Feedback::set_velocity(float value) {
+  
+  velocity_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorCyclic.Feedback.velocity)
+}
+
+// float torque = 6;
+inline void Feedback::clear_torque() {
+  torque_ = 0;
+}
+inline float Feedback::torque() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorCyclic.Feedback.torque)
+  return torque_;
+}
+inline void Feedback::set_torque(float value) {
+  
+  torque_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorCyclic.Feedback.torque)
+}
+
+// float current_motor = 7;
+inline void Feedback::clear_current_motor() {
+  current_motor_ = 0;
+}
+inline float Feedback::current_motor() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorCyclic.Feedback.current_motor)
+  return current_motor_;
+}
+inline void Feedback::set_current_motor(float value) {
+  
+  current_motor_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorCyclic.Feedback.current_motor)
+}
+
+// float voltage = 8;
+inline void Feedback::clear_voltage() {
+  voltage_ = 0;
+}
+inline float Feedback::voltage() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorCyclic.Feedback.voltage)
+  return voltage_;
+}
+inline void Feedback::set_voltage(float value) {
+  
+  voltage_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorCyclic.Feedback.voltage)
+}
+
+// float temperature_motor = 9;
+inline void Feedback::clear_temperature_motor() {
+  temperature_motor_ = 0;
+}
+inline float Feedback::temperature_motor() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorCyclic.Feedback.temperature_motor)
+  return temperature_motor_;
+}
+inline void Feedback::set_temperature_motor(float value) {
+  
+  temperature_motor_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorCyclic.Feedback.temperature_motor)
+}
+
+// float temperature_core = 10;
+inline void Feedback::clear_temperature_core() {
+  temperature_core_ = 0;
+}
+inline float Feedback::temperature_core() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorCyclic.Feedback.temperature_core)
+  return temperature_core_;
+}
+inline void Feedback::set_temperature_core(float value) {
+  
+  temperature_core_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorCyclic.Feedback.temperature_core)
+}
+
+// fixed32 fault_bank_a = 11;
+inline void Feedback::clear_fault_bank_a() {
+  fault_bank_a_ = 0u;
+}
+inline ::google::protobuf::uint32 Feedback::fault_bank_a() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorCyclic.Feedback.fault_bank_a)
+  return fault_bank_a_;
+}
+inline void Feedback::set_fault_bank_a(::google::protobuf::uint32 value) {
+  
+  fault_bank_a_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorCyclic.Feedback.fault_bank_a)
+}
+
+// fixed32 fault_bank_b = 12;
+inline void Feedback::clear_fault_bank_b() {
+  fault_bank_b_ = 0u;
+}
+inline ::google::protobuf::uint32 Feedback::fault_bank_b() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorCyclic.Feedback.fault_bank_b)
+  return fault_bank_b_;
+}
+inline void Feedback::set_fault_bank_b(::google::protobuf::uint32 value) {
+  
+  fault_bank_b_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorCyclic.Feedback.fault_bank_b)
+}
+
+// fixed32 warning_bank_a = 13;
+inline void Feedback::clear_warning_bank_a() {
+  warning_bank_a_ = 0u;
+}
+inline ::google::protobuf::uint32 Feedback::warning_bank_a() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorCyclic.Feedback.warning_bank_a)
+  return warning_bank_a_;
+}
+inline void Feedback::set_warning_bank_a(::google::protobuf::uint32 value) {
+  
+  warning_bank_a_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorCyclic.Feedback.warning_bank_a)
+}
+
+// fixed32 warning_bank_b = 14;
+inline void Feedback::clear_warning_bank_b() {
+  warning_bank_b_ = 0u;
+}
+inline ::google::protobuf::uint32 Feedback::warning_bank_b() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorCyclic.Feedback.warning_bank_b)
+  return warning_bank_b_;
+}
+inline void Feedback::set_warning_bank_b(::google::protobuf::uint32 value) {
+  
+  warning_bank_b_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorCyclic.Feedback.warning_bank_b)
+}
+
+// -------------------------------------------------------------------
+
+// CustomData
+
+// .Kinova.Api.ActuatorCyclic.MessageId custom_data_id = 1;
+inline bool CustomData::has_custom_data_id() const {
+  return this != internal_default_instance() && custom_data_id_ != NULL;
+}
+inline void CustomData::clear_custom_data_id() {
+  if (GetArenaNoVirtual() == NULL && custom_data_id_ != NULL) {
+    delete custom_data_id_;
+  }
+  custom_data_id_ = NULL;
+}
+inline const ::Kinova::Api::ActuatorCyclic::MessageId& CustomData::custom_data_id() const {
+  const ::Kinova::Api::ActuatorCyclic::MessageId* p = custom_data_id_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorCyclic.CustomData.custom_data_id)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::ActuatorCyclic::MessageId*>(
+      &::Kinova::Api::ActuatorCyclic::_MessageId_default_instance_);
+}
+inline ::Kinova::Api::ActuatorCyclic::MessageId* CustomData::release_custom_data_id() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.ActuatorCyclic.CustomData.custom_data_id)
+  
+  ::Kinova::Api::ActuatorCyclic::MessageId* temp = custom_data_id_;
+  custom_data_id_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::ActuatorCyclic::MessageId* CustomData::mutable_custom_data_id() {
+  
+  if (custom_data_id_ == NULL) {
+    custom_data_id_ = new ::Kinova::Api::ActuatorCyclic::MessageId;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.ActuatorCyclic.CustomData.custom_data_id)
+  return custom_data_id_;
+}
+inline void CustomData::set_allocated_custom_data_id(::Kinova::Api::ActuatorCyclic::MessageId* custom_data_id) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete custom_data_id_;
+  }
+  if (custom_data_id) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      custom_data_id = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, custom_data_id, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  custom_data_id_ = custom_data_id;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.ActuatorCyclic.CustomData.custom_data_id)
+}
+
+// fixed32 custom_data_0 = 2;
+inline void CustomData::clear_custom_data_0() {
+  custom_data_0_ = 0u;
+}
+inline ::google::protobuf::uint32 CustomData::custom_data_0() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorCyclic.CustomData.custom_data_0)
+  return custom_data_0_;
+}
+inline void CustomData::set_custom_data_0(::google::protobuf::uint32 value) {
+  
+  custom_data_0_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorCyclic.CustomData.custom_data_0)
+}
+
+// fixed32 custom_data_1 = 3;
+inline void CustomData::clear_custom_data_1() {
+  custom_data_1_ = 0u;
+}
+inline ::google::protobuf::uint32 CustomData::custom_data_1() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorCyclic.CustomData.custom_data_1)
+  return custom_data_1_;
+}
+inline void CustomData::set_custom_data_1(::google::protobuf::uint32 value) {
+  
+  custom_data_1_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorCyclic.CustomData.custom_data_1)
+}
+
+// fixed32 custom_data_2 = 4;
+inline void CustomData::clear_custom_data_2() {
+  custom_data_2_ = 0u;
+}
+inline ::google::protobuf::uint32 CustomData::custom_data_2() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorCyclic.CustomData.custom_data_2)
+  return custom_data_2_;
+}
+inline void CustomData::set_custom_data_2(::google::protobuf::uint32 value) {
+  
+  custom_data_2_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorCyclic.CustomData.custom_data_2)
+}
+
+// fixed32 custom_data_3 = 5;
+inline void CustomData::clear_custom_data_3() {
+  custom_data_3_ = 0u;
+}
+inline ::google::protobuf::uint32 CustomData::custom_data_3() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorCyclic.CustomData.custom_data_3)
+  return custom_data_3_;
+}
+inline void CustomData::set_custom_data_3(::google::protobuf::uint32 value) {
+  
+  custom_data_3_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorCyclic.CustomData.custom_data_3)
+}
+
+// fixed32 custom_data_4 = 6;
+inline void CustomData::clear_custom_data_4() {
+  custom_data_4_ = 0u;
+}
+inline ::google::protobuf::uint32 CustomData::custom_data_4() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorCyclic.CustomData.custom_data_4)
+  return custom_data_4_;
+}
+inline void CustomData::set_custom_data_4(::google::protobuf::uint32 value) {
+  
+  custom_data_4_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorCyclic.CustomData.custom_data_4)
+}
+
+// fixed32 custom_data_5 = 7;
+inline void CustomData::clear_custom_data_5() {
+  custom_data_5_ = 0u;
+}
+inline ::google::protobuf::uint32 CustomData::custom_data_5() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorCyclic.CustomData.custom_data_5)
+  return custom_data_5_;
+}
+inline void CustomData::set_custom_data_5(::google::protobuf::uint32 value) {
+  
+  custom_data_5_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorCyclic.CustomData.custom_data_5)
+}
+
+// fixed32 custom_data_6 = 8;
+inline void CustomData::clear_custom_data_6() {
+  custom_data_6_ = 0u;
+}
+inline ::google::protobuf::uint32 CustomData::custom_data_6() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorCyclic.CustomData.custom_data_6)
+  return custom_data_6_;
+}
+inline void CustomData::set_custom_data_6(::google::protobuf::uint32 value) {
+  
+  custom_data_6_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorCyclic.CustomData.custom_data_6)
+}
+
+// fixed32 custom_data_7 = 9;
+inline void CustomData::clear_custom_data_7() {
+  custom_data_7_ = 0u;
+}
+inline ::google::protobuf::uint32 CustomData::custom_data_7() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorCyclic.CustomData.custom_data_7)
+  return custom_data_7_;
+}
+inline void CustomData::set_custom_data_7(::google::protobuf::uint32 value) {
+  
+  custom_data_7_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorCyclic.CustomData.custom_data_7)
+}
+
+// fixed32 custom_data_8 = 10;
+inline void CustomData::clear_custom_data_8() {
+  custom_data_8_ = 0u;
+}
+inline ::google::protobuf::uint32 CustomData::custom_data_8() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorCyclic.CustomData.custom_data_8)
+  return custom_data_8_;
+}
+inline void CustomData::set_custom_data_8(::google::protobuf::uint32 value) {
+  
+  custom_data_8_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorCyclic.CustomData.custom_data_8)
+}
+
+// fixed32 custom_data_9 = 11;
+inline void CustomData::clear_custom_data_9() {
+  custom_data_9_ = 0u;
+}
+inline ::google::protobuf::uint32 CustomData::custom_data_9() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorCyclic.CustomData.custom_data_9)
+  return custom_data_9_;
+}
+inline void CustomData::set_custom_data_9(::google::protobuf::uint32 value) {
+  
+  custom_data_9_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorCyclic.CustomData.custom_data_9)
+}
+
+// fixed32 custom_data_10 = 12;
+inline void CustomData::clear_custom_data_10() {
+  custom_data_10_ = 0u;
+}
+inline ::google::protobuf::uint32 CustomData::custom_data_10() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorCyclic.CustomData.custom_data_10)
+  return custom_data_10_;
+}
+inline void CustomData::set_custom_data_10(::google::protobuf::uint32 value) {
+  
+  custom_data_10_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorCyclic.CustomData.custom_data_10)
+}
+
+// fixed32 custom_data_11 = 13;
+inline void CustomData::clear_custom_data_11() {
+  custom_data_11_ = 0u;
+}
+inline ::google::protobuf::uint32 CustomData::custom_data_11() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorCyclic.CustomData.custom_data_11)
+  return custom_data_11_;
+}
+inline void CustomData::set_custom_data_11(::google::protobuf::uint32 value) {
+  
+  custom_data_11_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorCyclic.CustomData.custom_data_11)
+}
+
+// fixed32 custom_data_12 = 14;
+inline void CustomData::clear_custom_data_12() {
+  custom_data_12_ = 0u;
+}
+inline ::google::protobuf::uint32 CustomData::custom_data_12() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorCyclic.CustomData.custom_data_12)
+  return custom_data_12_;
+}
+inline void CustomData::set_custom_data_12(::google::protobuf::uint32 value) {
+  
+  custom_data_12_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorCyclic.CustomData.custom_data_12)
+}
+
+// fixed32 custom_data_13 = 15;
+inline void CustomData::clear_custom_data_13() {
+  custom_data_13_ = 0u;
+}
+inline ::google::protobuf::uint32 CustomData::custom_data_13() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorCyclic.CustomData.custom_data_13)
+  return custom_data_13_;
+}
+inline void CustomData::set_custom_data_13(::google::protobuf::uint32 value) {
+  
+  custom_data_13_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorCyclic.CustomData.custom_data_13)
+}
+
+// fixed32 custom_data_14 = 16;
+inline void CustomData::clear_custom_data_14() {
+  custom_data_14_ = 0u;
+}
+inline ::google::protobuf::uint32 CustomData::custom_data_14() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorCyclic.CustomData.custom_data_14)
+  return custom_data_14_;
+}
+inline void CustomData::set_custom_data_14(::google::protobuf::uint32 value) {
+  
+  custom_data_14_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorCyclic.CustomData.custom_data_14)
+}
+
+// fixed32 custom_data_15 = 17;
+inline void CustomData::clear_custom_data_15() {
+  custom_data_15_ = 0u;
+}
+inline ::google::protobuf::uint32 CustomData::custom_data_15() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ActuatorCyclic.CustomData.custom_data_15)
+  return custom_data_15_;
+}
+inline void CustomData::set_custom_data_15(::google::protobuf::uint32 value) {
+  
+  custom_data_15_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ActuatorCyclic.CustomData.custom_data_15)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace ActuatorCyclic
+}  // namespace Api
+}  // namespace Kinova
+
+namespace google {
+namespace protobuf {
+
+template <> struct is_proto_enum< ::Kinova::Api::ActuatorCyclic::ServiceVersion> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::ActuatorCyclic::ServiceVersion>() {
+  return ::Kinova::Api::ActuatorCyclic::ServiceVersion_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::ActuatorCyclic::CommandFlags> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::ActuatorCyclic::CommandFlags>() {
+  return ::Kinova::Api::ActuatorCyclic::CommandFlags_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::ActuatorCyclic::StatusFlags> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::ActuatorCyclic::StatusFlags>() {
+  return ::Kinova::Api::ActuatorCyclic::StatusFlags_descriptor();
+}
+
+}  // namespace protobuf
+}  // namespace google
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_ActuatorCyclic_2eproto__INCLUDED
diff --git a/kortex_api/include/messages/Base.pb.h b/kortex_api/include/messages/Base.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..6a6affd1f4bd9666e3173ab2fe4db8206f74006f
--- /dev/null
+++ b/kortex_api/include/messages/Base.pb.h
@@ -0,0 +1,35607 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: Base.proto
+
+#ifndef PROTOBUF_Base_2eproto__INCLUDED
+#define PROTOBUF_Base_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 3005000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 3005001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "Common.pb.h"  // IWYU pragma: export
+#include "Errors.pb.h"  // IWYU pragma: export
+#include "ProductConfiguration.pb.h"  // IWYU pragma: export
+// @@protoc_insertion_point(includes)
+
+namespace protobuf_Base_2eproto {
+// Internal implementation detail -- do not use these members.
+struct TableStruct {
+  static const ::google::protobuf::internal::ParseTableField entries[];
+  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
+  static const ::google::protobuf::internal::ParseTable schema[159];
+  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
+  static const ::google::protobuf::internal::SerializationTable serialization_table[];
+  static const ::google::protobuf::uint32 offsets[];
+};
+void AddDescriptors();
+void InitDefaultsGpioConfigurationListImpl();
+void InitDefaultsGpioConfigurationList();
+void InitDefaultsGpioConfigurationImpl();
+void InitDefaultsGpioConfiguration();
+void InitDefaultsGpioPinConfigurationImpl();
+void InitDefaultsGpioPinConfiguration();
+void InitDefaultsFullUserProfileImpl();
+void InitDefaultsFullUserProfile();
+void InitDefaultsUserProfileImpl();
+void InitDefaultsUserProfile();
+void InitDefaultsUserProfileListImpl();
+void InitDefaultsUserProfileList();
+void InitDefaultsUserListImpl();
+void InitDefaultsUserList();
+void InitDefaultsPasswordChangeImpl();
+void InitDefaultsPasswordChange();
+void InitDefaultsSequenceHandleImpl();
+void InitDefaultsSequenceHandle();
+void InitDefaultsAdvancedSequenceHandleImpl();
+void InitDefaultsAdvancedSequenceHandle();
+void InitDefaultsSequenceTaskHandleImpl();
+void InitDefaultsSequenceTaskHandle();
+void InitDefaultsSequenceTaskImpl();
+void InitDefaultsSequenceTask();
+void InitDefaultsSequenceTasksImpl();
+void InitDefaultsSequenceTasks();
+void InitDefaultsSequenceTasksConfigurationImpl();
+void InitDefaultsSequenceTasksConfiguration();
+void InitDefaultsSequenceTaskConfigurationImpl();
+void InitDefaultsSequenceTaskConfiguration();
+void InitDefaultsSequenceTasksRangeImpl();
+void InitDefaultsSequenceTasksRange();
+void InitDefaultsSequenceTasksPairImpl();
+void InitDefaultsSequenceTasksPair();
+void InitDefaultsSequenceImpl();
+void InitDefaultsSequence();
+void InitDefaultsSequenceListImpl();
+void InitDefaultsSequenceList();
+void InitDefaultsActionHandleImpl();
+void InitDefaultsActionHandle();
+void InitDefaultsRequestedActionTypeImpl();
+void InitDefaultsRequestedActionType();
+void InitDefaultsActionImpl();
+void InitDefaultsAction();
+void InitDefaultsSnapshotImpl();
+void InitDefaultsSnapshot();
+void InitDefaultsSwitchControlMappingImpl();
+void InitDefaultsSwitchControlMapping();
+void InitDefaultsChangeTwistImpl();
+void InitDefaultsChangeTwist();
+void InitDefaultsChangeJointSpeedsImpl();
+void InitDefaultsChangeJointSpeeds();
+void InitDefaultsChangeWrenchImpl();
+void InitDefaultsChangeWrench();
+void InitDefaultsEmergencyStopImpl();
+void InitDefaultsEmergencyStop();
+void InitDefaultsFaultsImpl();
+void InitDefaultsFaults();
+void InitDefaultsDelayImpl();
+void InitDefaultsDelay();
+void InitDefaultsStopImpl();
+void InitDefaultsStop();
+void InitDefaultsActionListImpl();
+void InitDefaultsActionList();
+void InitDefaultsTimeoutImpl();
+void InitDefaultsTimeout();
+void InitDefaultsSsidImpl();
+void InitDefaultsSsid();
+void InitDefaultsCommunicationInterfaceConfigurationImpl();
+void InitDefaultsCommunicationInterfaceConfiguration();
+void InitDefaultsNetworkHandleImpl();
+void InitDefaultsNetworkHandle();
+void InitDefaultsIPv4ConfigurationImpl();
+void InitDefaultsIPv4Configuration();
+void InitDefaultsIPv4InformationImpl();
+void InitDefaultsIPv4Information();
+void InitDefaultsFullIPv4ConfigurationImpl();
+void InitDefaultsFullIPv4Configuration();
+void InitDefaultsWifiEnableStateImpl();
+void InitDefaultsWifiEnableState();
+void InitDefaultsBluetoothEnableStateImpl();
+void InitDefaultsBluetoothEnableState();
+void InitDefaultsRFConfigurationImpl();
+void InitDefaultsRFConfiguration();
+void InitDefaultsWifiInformationImpl();
+void InitDefaultsWifiInformation();
+void InitDefaultsWifiInformationListImpl();
+void InitDefaultsWifiInformationList();
+void InitDefaultsWifiConfigurationImpl();
+void InitDefaultsWifiConfiguration();
+void InitDefaultsWifiConfigurationListImpl();
+void InitDefaultsWifiConfigurationList();
+void InitDefaultsProtectionZoneHandleImpl();
+void InitDefaultsProtectionZoneHandle();
+void InitDefaultsRotationMatrixRowImpl();
+void InitDefaultsRotationMatrixRow();
+void InitDefaultsRotationMatrixImpl();
+void InitDefaultsRotationMatrix();
+void InitDefaultsPointImpl();
+void InitDefaultsPoint();
+void InitDefaultsZoneShapeImpl();
+void InitDefaultsZoneShape();
+void InitDefaultsProtectionZoneImpl();
+void InitDefaultsProtectionZone();
+void InitDefaultsProtectionZoneListImpl();
+void InitDefaultsProtectionZoneList();
+void InitDefaultsCartesianLimitationImpl();
+void InitDefaultsCartesianLimitation();
+void InitDefaultsTwistLimitationImpl();
+void InitDefaultsTwistLimitation();
+void InitDefaultsWrenchLimitationImpl();
+void InitDefaultsWrenchLimitation();
+void InitDefaultsCartesianLimitationListImpl();
+void InitDefaultsCartesianLimitationList();
+void InitDefaultsJointLimitationImpl();
+void InitDefaultsJointLimitation();
+void InitDefaultsJointsLimitationsListImpl();
+void InitDefaultsJointsLimitationsList();
+void InitDefaultsConfigurationChangeNotificationImpl();
+void InitDefaultsConfigurationChangeNotification();
+void InitDefaultsMappingInfoNotificationImpl();
+void InitDefaultsMappingInfoNotification();
+void InitDefaultsServoingModeInformationImpl();
+void InitDefaultsServoingModeInformation();
+void InitDefaultsOperatingModeInformationImpl();
+void InitDefaultsOperatingModeInformation();
+void InitDefaultsOperatingModeNotificationImpl();
+void InitDefaultsOperatingModeNotification();
+void InitDefaultsServoingModeNotificationImpl();
+void InitDefaultsServoingModeNotification();
+void InitDefaultsSequenceInfoNotificationImpl();
+void InitDefaultsSequenceInfoNotification();
+void InitDefaultsSequenceInformationImpl();
+void InitDefaultsSequenceInformation();
+void InitDefaultsProtectionZoneNotificationImpl();
+void InitDefaultsProtectionZoneNotification();
+void InitDefaultsProtectionZoneInformationImpl();
+void InitDefaultsProtectionZoneInformation();
+void InitDefaultsUserNotificationImpl();
+void InitDefaultsUserNotification();
+void InitDefaultsControllerHandleImpl();
+void InitDefaultsControllerHandle();
+void InitDefaultsControllerElementHandleImpl();
+void InitDefaultsControllerElementHandle();
+void InitDefaultsControllerNotificationImpl();
+void InitDefaultsControllerNotification();
+void InitDefaultsControllerListImpl();
+void InitDefaultsControllerList();
+void InitDefaultsControllerStateImpl();
+void InitDefaultsControllerState();
+void InitDefaultsControllerElementStateImpl();
+void InitDefaultsControllerElementState();
+void InitDefaultsActionNotificationImpl();
+void InitDefaultsActionNotification();
+void InitDefaultsTrajectoryInfoImpl();
+void InitDefaultsTrajectoryInfo();
+void InitDefaultsRobotEventNotificationImpl();
+void InitDefaultsRobotEventNotification();
+void InitDefaultsFactoryNotificationImpl();
+void InitDefaultsFactoryNotification();
+void InitDefaultsNetworkNotificationImpl();
+void InitDefaultsNetworkNotification();
+void InitDefaultsConfigurationChangeNotificationListImpl();
+void InitDefaultsConfigurationChangeNotificationList();
+void InitDefaultsMappingInfoNotificationListImpl();
+void InitDefaultsMappingInfoNotificationList();
+void InitDefaultsOperatingModeNotificationListImpl();
+void InitDefaultsOperatingModeNotificationList();
+void InitDefaultsServoingModeNotificationListImpl();
+void InitDefaultsServoingModeNotificationList();
+void InitDefaultsSequenceInfoNotificationListImpl();
+void InitDefaultsSequenceInfoNotificationList();
+void InitDefaultsProtectionZoneNotificationListImpl();
+void InitDefaultsProtectionZoneNotificationList();
+void InitDefaultsUserNotificationListImpl();
+void InitDefaultsUserNotificationList();
+void InitDefaultsSafetyNotificationListImpl();
+void InitDefaultsSafetyNotificationList();
+void InitDefaultsControllerNotificationListImpl();
+void InitDefaultsControllerNotificationList();
+void InitDefaultsActionNotificationListImpl();
+void InitDefaultsActionNotificationList();
+void InitDefaultsRobotEventNotificationListImpl();
+void InitDefaultsRobotEventNotificationList();
+void InitDefaultsNetworkNotificationListImpl();
+void InitDefaultsNetworkNotificationList();
+void InitDefaultsMappingHandleImpl();
+void InitDefaultsMappingHandle();
+void InitDefaultsControllerEventImpl();
+void InitDefaultsControllerEvent();
+void InitDefaultsGpioEventImpl();
+void InitDefaultsGpioEvent();
+void InitDefaultsMapEventImpl();
+void InitDefaultsMapEvent();
+void InitDefaultsMapElementImpl();
+void InitDefaultsMapElement();
+void InitDefaultsActivateMapHandleImpl();
+void InitDefaultsActivateMapHandle();
+void InitDefaultsMapImpl();
+void InitDefaultsMap();
+void InitDefaultsMapHandleImpl();
+void InitDefaultsMapHandle();
+void InitDefaultsMapListImpl();
+void InitDefaultsMapList();
+void InitDefaultsMapGroupHandleImpl();
+void InitDefaultsMapGroupHandle();
+void InitDefaultsMapGroupImpl();
+void InitDefaultsMapGroup();
+void InitDefaultsMapGroupListImpl();
+void InitDefaultsMapGroupList();
+void InitDefaultsMappingImpl();
+void InitDefaultsMapping();
+void InitDefaultsMappingListImpl();
+void InitDefaultsMappingList();
+void InitDefaultsTransformationMatrixImpl();
+void InitDefaultsTransformationMatrix();
+void InitDefaultsTransformationRowImpl();
+void InitDefaultsTransformationRow();
+void InitDefaultsPoseImpl();
+void InitDefaultsPose();
+void InitDefaultsPositionImpl();
+void InitDefaultsPosition();
+void InitDefaultsOrientationImpl();
+void InitDefaultsOrientation();
+void InitDefaultsCartesianSpeedImpl();
+void InitDefaultsCartesianSpeed();
+void InitDefaultsCartesianTrajectoryConstraintImpl();
+void InitDefaultsCartesianTrajectoryConstraint();
+void InitDefaultsJointTrajectoryConstraintImpl();
+void InitDefaultsJointTrajectoryConstraint();
+void InitDefaultsWrenchImpl();
+void InitDefaultsWrench();
+void InitDefaultsTwistImpl();
+void InitDefaultsTwist();
+void InitDefaultsAdmittanceImpl();
+void InitDefaultsAdmittance();
+void InitDefaultsConstrainedPoseImpl();
+void InitDefaultsConstrainedPose();
+void InitDefaultsConstrainedPositionImpl();
+void InitDefaultsConstrainedPosition();
+void InitDefaultsConstrainedOrientationImpl();
+void InitDefaultsConstrainedOrientation();
+void InitDefaultsWrenchCommandImpl();
+void InitDefaultsWrenchCommand();
+void InitDefaultsTwistCommandImpl();
+void InitDefaultsTwistCommand();
+void InitDefaultsConstrainedJointAnglesImpl();
+void InitDefaultsConstrainedJointAngles();
+void InitDefaultsConstrainedJointAngleImpl();
+void InitDefaultsConstrainedJointAngle();
+void InitDefaultsJointAnglesImpl();
+void InitDefaultsJointAngles();
+void InitDefaultsJointAngleImpl();
+void InitDefaultsJointAngle();
+void InitDefaultsJointSpeedsImpl();
+void InitDefaultsJointSpeeds();
+void InitDefaultsJointSpeedImpl();
+void InitDefaultsJointSpeed();
+void InitDefaultsGripperCommandImpl();
+void InitDefaultsGripperCommand();
+void InitDefaultsGripperRequestImpl();
+void InitDefaultsGripperRequest();
+void InitDefaultsGripperImpl();
+void InitDefaultsGripper();
+void InitDefaultsFingerImpl();
+void InitDefaultsFinger();
+void InitDefaultsGpioCommandImpl();
+void InitDefaultsGpioCommand();
+void InitDefaultsControllerConfigurationModeImpl();
+void InitDefaultsControllerConfigurationMode();
+void InitDefaultsControllerConfigurationImpl();
+void InitDefaultsControllerConfiguration();
+void InitDefaultsControllerConfigurationListImpl();
+void InitDefaultsControllerConfigurationList();
+void InitDefaultsActuatorInformationImpl();
+void InitDefaultsActuatorInformation();
+void InitDefaultsArmStateInformationImpl();
+void InitDefaultsArmStateInformation();
+void InitDefaultsArmStateNotificationImpl();
+void InitDefaultsArmStateNotification();
+void InitDefaultsCapSenseConfigImpl();
+void InitDefaultsCapSenseConfig();
+void InitDefaultsBridgeListImpl();
+void InitDefaultsBridgeList();
+void InitDefaultsBridgeResultImpl();
+void InitDefaultsBridgeResult();
+void InitDefaultsBridgeIdentifierImpl();
+void InitDefaultsBridgeIdentifier();
+void InitDefaultsBridgeConfigImpl();
+void InitDefaultsBridgeConfig();
+void InitDefaultsBridgePortConfigImpl();
+void InitDefaultsBridgePortConfig();
+void InitDefaultsPreComputedJointTrajectoryImpl();
+void InitDefaultsPreComputedJointTrajectory();
+void InitDefaultsPreComputedJointTrajectoryElementImpl();
+void InitDefaultsPreComputedJointTrajectoryElement();
+void InitDefaultsTrajectoryErrorElementImpl();
+void InitDefaultsTrajectoryErrorElement();
+void InitDefaultsTrajectoryErrorReportImpl();
+void InitDefaultsTrajectoryErrorReport();
+void InitDefaultsWaypointValidationReportImpl();
+void InitDefaultsWaypointValidationReport();
+void InitDefaultsWaypointImpl();
+void InitDefaultsWaypoint();
+void InitDefaultsAngularWaypointImpl();
+void InitDefaultsAngularWaypoint();
+void InitDefaultsCartesianWaypointImpl();
+void InitDefaultsCartesianWaypoint();
+void InitDefaultsWaypointListImpl();
+void InitDefaultsWaypointList();
+void InitDefaultsKinematicTrajectoryConstraintsImpl();
+void InitDefaultsKinematicTrajectoryConstraints();
+void InitDefaultsFirmwareBundleVersionsImpl();
+void InitDefaultsFirmwareBundleVersions();
+void InitDefaultsFirmwareComponentVersionImpl();
+void InitDefaultsFirmwareComponentVersion();
+void InitDefaultsIKDataImpl();
+void InitDefaultsIKData();
+inline void InitDefaults() {
+  InitDefaultsGpioConfigurationList();
+  InitDefaultsGpioConfiguration();
+  InitDefaultsGpioPinConfiguration();
+  InitDefaultsFullUserProfile();
+  InitDefaultsUserProfile();
+  InitDefaultsUserProfileList();
+  InitDefaultsUserList();
+  InitDefaultsPasswordChange();
+  InitDefaultsSequenceHandle();
+  InitDefaultsAdvancedSequenceHandle();
+  InitDefaultsSequenceTaskHandle();
+  InitDefaultsSequenceTask();
+  InitDefaultsSequenceTasks();
+  InitDefaultsSequenceTasksConfiguration();
+  InitDefaultsSequenceTaskConfiguration();
+  InitDefaultsSequenceTasksRange();
+  InitDefaultsSequenceTasksPair();
+  InitDefaultsSequence();
+  InitDefaultsSequenceList();
+  InitDefaultsActionHandle();
+  InitDefaultsRequestedActionType();
+  InitDefaultsAction();
+  InitDefaultsSnapshot();
+  InitDefaultsSwitchControlMapping();
+  InitDefaultsChangeTwist();
+  InitDefaultsChangeJointSpeeds();
+  InitDefaultsChangeWrench();
+  InitDefaultsEmergencyStop();
+  InitDefaultsFaults();
+  InitDefaultsDelay();
+  InitDefaultsStop();
+  InitDefaultsActionList();
+  InitDefaultsTimeout();
+  InitDefaultsSsid();
+  InitDefaultsCommunicationInterfaceConfiguration();
+  InitDefaultsNetworkHandle();
+  InitDefaultsIPv4Configuration();
+  InitDefaultsIPv4Information();
+  InitDefaultsFullIPv4Configuration();
+  InitDefaultsWifiEnableState();
+  InitDefaultsBluetoothEnableState();
+  InitDefaultsRFConfiguration();
+  InitDefaultsWifiInformation();
+  InitDefaultsWifiInformationList();
+  InitDefaultsWifiConfiguration();
+  InitDefaultsWifiConfigurationList();
+  InitDefaultsProtectionZoneHandle();
+  InitDefaultsRotationMatrixRow();
+  InitDefaultsRotationMatrix();
+  InitDefaultsPoint();
+  InitDefaultsZoneShape();
+  InitDefaultsProtectionZone();
+  InitDefaultsProtectionZoneList();
+  InitDefaultsCartesianLimitation();
+  InitDefaultsTwistLimitation();
+  InitDefaultsWrenchLimitation();
+  InitDefaultsCartesianLimitationList();
+  InitDefaultsJointLimitation();
+  InitDefaultsJointsLimitationsList();
+  InitDefaultsConfigurationChangeNotification();
+  InitDefaultsMappingInfoNotification();
+  InitDefaultsServoingModeInformation();
+  InitDefaultsOperatingModeInformation();
+  InitDefaultsOperatingModeNotification();
+  InitDefaultsServoingModeNotification();
+  InitDefaultsSequenceInfoNotification();
+  InitDefaultsSequenceInformation();
+  InitDefaultsProtectionZoneNotification();
+  InitDefaultsProtectionZoneInformation();
+  InitDefaultsUserNotification();
+  InitDefaultsControllerHandle();
+  InitDefaultsControllerElementHandle();
+  InitDefaultsControllerNotification();
+  InitDefaultsControllerList();
+  InitDefaultsControllerState();
+  InitDefaultsControllerElementState();
+  InitDefaultsActionNotification();
+  InitDefaultsTrajectoryInfo();
+  InitDefaultsRobotEventNotification();
+  InitDefaultsFactoryNotification();
+  InitDefaultsNetworkNotification();
+  InitDefaultsConfigurationChangeNotificationList();
+  InitDefaultsMappingInfoNotificationList();
+  InitDefaultsOperatingModeNotificationList();
+  InitDefaultsServoingModeNotificationList();
+  InitDefaultsSequenceInfoNotificationList();
+  InitDefaultsProtectionZoneNotificationList();
+  InitDefaultsUserNotificationList();
+  InitDefaultsSafetyNotificationList();
+  InitDefaultsControllerNotificationList();
+  InitDefaultsActionNotificationList();
+  InitDefaultsRobotEventNotificationList();
+  InitDefaultsNetworkNotificationList();
+  InitDefaultsMappingHandle();
+  InitDefaultsControllerEvent();
+  InitDefaultsGpioEvent();
+  InitDefaultsMapEvent();
+  InitDefaultsMapElement();
+  InitDefaultsActivateMapHandle();
+  InitDefaultsMap();
+  InitDefaultsMapHandle();
+  InitDefaultsMapList();
+  InitDefaultsMapGroupHandle();
+  InitDefaultsMapGroup();
+  InitDefaultsMapGroupList();
+  InitDefaultsMapping();
+  InitDefaultsMappingList();
+  InitDefaultsTransformationMatrix();
+  InitDefaultsTransformationRow();
+  InitDefaultsPose();
+  InitDefaultsPosition();
+  InitDefaultsOrientation();
+  InitDefaultsCartesianSpeed();
+  InitDefaultsCartesianTrajectoryConstraint();
+  InitDefaultsJointTrajectoryConstraint();
+  InitDefaultsWrench();
+  InitDefaultsTwist();
+  InitDefaultsAdmittance();
+  InitDefaultsConstrainedPose();
+  InitDefaultsConstrainedPosition();
+  InitDefaultsConstrainedOrientation();
+  InitDefaultsWrenchCommand();
+  InitDefaultsTwistCommand();
+  InitDefaultsConstrainedJointAngles();
+  InitDefaultsConstrainedJointAngle();
+  InitDefaultsJointAngles();
+  InitDefaultsJointAngle();
+  InitDefaultsJointSpeeds();
+  InitDefaultsJointSpeed();
+  InitDefaultsGripperCommand();
+  InitDefaultsGripperRequest();
+  InitDefaultsGripper();
+  InitDefaultsFinger();
+  InitDefaultsGpioCommand();
+  InitDefaultsControllerConfigurationMode();
+  InitDefaultsControllerConfiguration();
+  InitDefaultsControllerConfigurationList();
+  InitDefaultsActuatorInformation();
+  InitDefaultsArmStateInformation();
+  InitDefaultsArmStateNotification();
+  InitDefaultsCapSenseConfig();
+  InitDefaultsBridgeList();
+  InitDefaultsBridgeResult();
+  InitDefaultsBridgeIdentifier();
+  InitDefaultsBridgeConfig();
+  InitDefaultsBridgePortConfig();
+  InitDefaultsPreComputedJointTrajectory();
+  InitDefaultsPreComputedJointTrajectoryElement();
+  InitDefaultsTrajectoryErrorElement();
+  InitDefaultsTrajectoryErrorReport();
+  InitDefaultsWaypointValidationReport();
+  InitDefaultsWaypoint();
+  InitDefaultsAngularWaypoint();
+  InitDefaultsCartesianWaypoint();
+  InitDefaultsWaypointList();
+  InitDefaultsKinematicTrajectoryConstraints();
+  InitDefaultsFirmwareBundleVersions();
+  InitDefaultsFirmwareComponentVersion();
+  InitDefaultsIKData();
+}
+}  // namespace protobuf_Base_2eproto
+namespace Kinova {
+namespace Api {
+namespace Base {
+class Action;
+class ActionDefaultTypeInternal;
+extern ActionDefaultTypeInternal _Action_default_instance_;
+class ActionHandle;
+class ActionHandleDefaultTypeInternal;
+extern ActionHandleDefaultTypeInternal _ActionHandle_default_instance_;
+class ActionList;
+class ActionListDefaultTypeInternal;
+extern ActionListDefaultTypeInternal _ActionList_default_instance_;
+class ActionNotification;
+class ActionNotificationDefaultTypeInternal;
+extern ActionNotificationDefaultTypeInternal _ActionNotification_default_instance_;
+class ActionNotificationList;
+class ActionNotificationListDefaultTypeInternal;
+extern ActionNotificationListDefaultTypeInternal _ActionNotificationList_default_instance_;
+class ActivateMapHandle;
+class ActivateMapHandleDefaultTypeInternal;
+extern ActivateMapHandleDefaultTypeInternal _ActivateMapHandle_default_instance_;
+class ActuatorInformation;
+class ActuatorInformationDefaultTypeInternal;
+extern ActuatorInformationDefaultTypeInternal _ActuatorInformation_default_instance_;
+class Admittance;
+class AdmittanceDefaultTypeInternal;
+extern AdmittanceDefaultTypeInternal _Admittance_default_instance_;
+class AdvancedSequenceHandle;
+class AdvancedSequenceHandleDefaultTypeInternal;
+extern AdvancedSequenceHandleDefaultTypeInternal _AdvancedSequenceHandle_default_instance_;
+class AngularWaypoint;
+class AngularWaypointDefaultTypeInternal;
+extern AngularWaypointDefaultTypeInternal _AngularWaypoint_default_instance_;
+class ArmStateInformation;
+class ArmStateInformationDefaultTypeInternal;
+extern ArmStateInformationDefaultTypeInternal _ArmStateInformation_default_instance_;
+class ArmStateNotification;
+class ArmStateNotificationDefaultTypeInternal;
+extern ArmStateNotificationDefaultTypeInternal _ArmStateNotification_default_instance_;
+class BluetoothEnableState;
+class BluetoothEnableStateDefaultTypeInternal;
+extern BluetoothEnableStateDefaultTypeInternal _BluetoothEnableState_default_instance_;
+class BridgeConfig;
+class BridgeConfigDefaultTypeInternal;
+extern BridgeConfigDefaultTypeInternal _BridgeConfig_default_instance_;
+class BridgeIdentifier;
+class BridgeIdentifierDefaultTypeInternal;
+extern BridgeIdentifierDefaultTypeInternal _BridgeIdentifier_default_instance_;
+class BridgeList;
+class BridgeListDefaultTypeInternal;
+extern BridgeListDefaultTypeInternal _BridgeList_default_instance_;
+class BridgePortConfig;
+class BridgePortConfigDefaultTypeInternal;
+extern BridgePortConfigDefaultTypeInternal _BridgePortConfig_default_instance_;
+class BridgeResult;
+class BridgeResultDefaultTypeInternal;
+extern BridgeResultDefaultTypeInternal _BridgeResult_default_instance_;
+class CapSenseConfig;
+class CapSenseConfigDefaultTypeInternal;
+extern CapSenseConfigDefaultTypeInternal _CapSenseConfig_default_instance_;
+class CartesianLimitation;
+class CartesianLimitationDefaultTypeInternal;
+extern CartesianLimitationDefaultTypeInternal _CartesianLimitation_default_instance_;
+class CartesianLimitationList;
+class CartesianLimitationListDefaultTypeInternal;
+extern CartesianLimitationListDefaultTypeInternal _CartesianLimitationList_default_instance_;
+class CartesianSpeed;
+class CartesianSpeedDefaultTypeInternal;
+extern CartesianSpeedDefaultTypeInternal _CartesianSpeed_default_instance_;
+class CartesianTrajectoryConstraint;
+class CartesianTrajectoryConstraintDefaultTypeInternal;
+extern CartesianTrajectoryConstraintDefaultTypeInternal _CartesianTrajectoryConstraint_default_instance_;
+class CartesianWaypoint;
+class CartesianWaypointDefaultTypeInternal;
+extern CartesianWaypointDefaultTypeInternal _CartesianWaypoint_default_instance_;
+class ChangeJointSpeeds;
+class ChangeJointSpeedsDefaultTypeInternal;
+extern ChangeJointSpeedsDefaultTypeInternal _ChangeJointSpeeds_default_instance_;
+class ChangeTwist;
+class ChangeTwistDefaultTypeInternal;
+extern ChangeTwistDefaultTypeInternal _ChangeTwist_default_instance_;
+class ChangeWrench;
+class ChangeWrenchDefaultTypeInternal;
+extern ChangeWrenchDefaultTypeInternal _ChangeWrench_default_instance_;
+class CommunicationInterfaceConfiguration;
+class CommunicationInterfaceConfigurationDefaultTypeInternal;
+extern CommunicationInterfaceConfigurationDefaultTypeInternal _CommunicationInterfaceConfiguration_default_instance_;
+class ConfigurationChangeNotification;
+class ConfigurationChangeNotificationDefaultTypeInternal;
+extern ConfigurationChangeNotificationDefaultTypeInternal _ConfigurationChangeNotification_default_instance_;
+class ConfigurationChangeNotificationList;
+class ConfigurationChangeNotificationListDefaultTypeInternal;
+extern ConfigurationChangeNotificationListDefaultTypeInternal _ConfigurationChangeNotificationList_default_instance_;
+class ConstrainedJointAngle;
+class ConstrainedJointAngleDefaultTypeInternal;
+extern ConstrainedJointAngleDefaultTypeInternal _ConstrainedJointAngle_default_instance_;
+class ConstrainedJointAngles;
+class ConstrainedJointAnglesDefaultTypeInternal;
+extern ConstrainedJointAnglesDefaultTypeInternal _ConstrainedJointAngles_default_instance_;
+class ConstrainedOrientation;
+class ConstrainedOrientationDefaultTypeInternal;
+extern ConstrainedOrientationDefaultTypeInternal _ConstrainedOrientation_default_instance_;
+class ConstrainedPose;
+class ConstrainedPoseDefaultTypeInternal;
+extern ConstrainedPoseDefaultTypeInternal _ConstrainedPose_default_instance_;
+class ConstrainedPosition;
+class ConstrainedPositionDefaultTypeInternal;
+extern ConstrainedPositionDefaultTypeInternal _ConstrainedPosition_default_instance_;
+class ControllerConfiguration;
+class ControllerConfigurationDefaultTypeInternal;
+extern ControllerConfigurationDefaultTypeInternal _ControllerConfiguration_default_instance_;
+class ControllerConfigurationList;
+class ControllerConfigurationListDefaultTypeInternal;
+extern ControllerConfigurationListDefaultTypeInternal _ControllerConfigurationList_default_instance_;
+class ControllerConfigurationMode;
+class ControllerConfigurationModeDefaultTypeInternal;
+extern ControllerConfigurationModeDefaultTypeInternal _ControllerConfigurationMode_default_instance_;
+class ControllerElementHandle;
+class ControllerElementHandleDefaultTypeInternal;
+extern ControllerElementHandleDefaultTypeInternal _ControllerElementHandle_default_instance_;
+class ControllerElementState;
+class ControllerElementStateDefaultTypeInternal;
+extern ControllerElementStateDefaultTypeInternal _ControllerElementState_default_instance_;
+class ControllerEvent;
+class ControllerEventDefaultTypeInternal;
+extern ControllerEventDefaultTypeInternal _ControllerEvent_default_instance_;
+class ControllerHandle;
+class ControllerHandleDefaultTypeInternal;
+extern ControllerHandleDefaultTypeInternal _ControllerHandle_default_instance_;
+class ControllerList;
+class ControllerListDefaultTypeInternal;
+extern ControllerListDefaultTypeInternal _ControllerList_default_instance_;
+class ControllerNotification;
+class ControllerNotificationDefaultTypeInternal;
+extern ControllerNotificationDefaultTypeInternal _ControllerNotification_default_instance_;
+class ControllerNotificationList;
+class ControllerNotificationListDefaultTypeInternal;
+extern ControllerNotificationListDefaultTypeInternal _ControllerNotificationList_default_instance_;
+class ControllerState;
+class ControllerStateDefaultTypeInternal;
+extern ControllerStateDefaultTypeInternal _ControllerState_default_instance_;
+class Delay;
+class DelayDefaultTypeInternal;
+extern DelayDefaultTypeInternal _Delay_default_instance_;
+class EmergencyStop;
+class EmergencyStopDefaultTypeInternal;
+extern EmergencyStopDefaultTypeInternal _EmergencyStop_default_instance_;
+class FactoryNotification;
+class FactoryNotificationDefaultTypeInternal;
+extern FactoryNotificationDefaultTypeInternal _FactoryNotification_default_instance_;
+class Faults;
+class FaultsDefaultTypeInternal;
+extern FaultsDefaultTypeInternal _Faults_default_instance_;
+class Finger;
+class FingerDefaultTypeInternal;
+extern FingerDefaultTypeInternal _Finger_default_instance_;
+class FirmwareBundleVersions;
+class FirmwareBundleVersionsDefaultTypeInternal;
+extern FirmwareBundleVersionsDefaultTypeInternal _FirmwareBundleVersions_default_instance_;
+class FirmwareComponentVersion;
+class FirmwareComponentVersionDefaultTypeInternal;
+extern FirmwareComponentVersionDefaultTypeInternal _FirmwareComponentVersion_default_instance_;
+class FullIPv4Configuration;
+class FullIPv4ConfigurationDefaultTypeInternal;
+extern FullIPv4ConfigurationDefaultTypeInternal _FullIPv4Configuration_default_instance_;
+class FullUserProfile;
+class FullUserProfileDefaultTypeInternal;
+extern FullUserProfileDefaultTypeInternal _FullUserProfile_default_instance_;
+class GpioCommand;
+class GpioCommandDefaultTypeInternal;
+extern GpioCommandDefaultTypeInternal _GpioCommand_default_instance_;
+class GpioConfiguration;
+class GpioConfigurationDefaultTypeInternal;
+extern GpioConfigurationDefaultTypeInternal _GpioConfiguration_default_instance_;
+class GpioConfigurationList;
+class GpioConfigurationListDefaultTypeInternal;
+extern GpioConfigurationListDefaultTypeInternal _GpioConfigurationList_default_instance_;
+class GpioEvent;
+class GpioEventDefaultTypeInternal;
+extern GpioEventDefaultTypeInternal _GpioEvent_default_instance_;
+class GpioPinConfiguration;
+class GpioPinConfigurationDefaultTypeInternal;
+extern GpioPinConfigurationDefaultTypeInternal _GpioPinConfiguration_default_instance_;
+class Gripper;
+class GripperDefaultTypeInternal;
+extern GripperDefaultTypeInternal _Gripper_default_instance_;
+class GripperCommand;
+class GripperCommandDefaultTypeInternal;
+extern GripperCommandDefaultTypeInternal _GripperCommand_default_instance_;
+class GripperRequest;
+class GripperRequestDefaultTypeInternal;
+extern GripperRequestDefaultTypeInternal _GripperRequest_default_instance_;
+class IKData;
+class IKDataDefaultTypeInternal;
+extern IKDataDefaultTypeInternal _IKData_default_instance_;
+class IPv4Configuration;
+class IPv4ConfigurationDefaultTypeInternal;
+extern IPv4ConfigurationDefaultTypeInternal _IPv4Configuration_default_instance_;
+class IPv4Information;
+class IPv4InformationDefaultTypeInternal;
+extern IPv4InformationDefaultTypeInternal _IPv4Information_default_instance_;
+class JointAngle;
+class JointAngleDefaultTypeInternal;
+extern JointAngleDefaultTypeInternal _JointAngle_default_instance_;
+class JointAngles;
+class JointAnglesDefaultTypeInternal;
+extern JointAnglesDefaultTypeInternal _JointAngles_default_instance_;
+class JointLimitation;
+class JointLimitationDefaultTypeInternal;
+extern JointLimitationDefaultTypeInternal _JointLimitation_default_instance_;
+class JointSpeed;
+class JointSpeedDefaultTypeInternal;
+extern JointSpeedDefaultTypeInternal _JointSpeed_default_instance_;
+class JointSpeeds;
+class JointSpeedsDefaultTypeInternal;
+extern JointSpeedsDefaultTypeInternal _JointSpeeds_default_instance_;
+class JointTrajectoryConstraint;
+class JointTrajectoryConstraintDefaultTypeInternal;
+extern JointTrajectoryConstraintDefaultTypeInternal _JointTrajectoryConstraint_default_instance_;
+class JointsLimitationsList;
+class JointsLimitationsListDefaultTypeInternal;
+extern JointsLimitationsListDefaultTypeInternal _JointsLimitationsList_default_instance_;
+class KinematicTrajectoryConstraints;
+class KinematicTrajectoryConstraintsDefaultTypeInternal;
+extern KinematicTrajectoryConstraintsDefaultTypeInternal _KinematicTrajectoryConstraints_default_instance_;
+class Map;
+class MapDefaultTypeInternal;
+extern MapDefaultTypeInternal _Map_default_instance_;
+class MapElement;
+class MapElementDefaultTypeInternal;
+extern MapElementDefaultTypeInternal _MapElement_default_instance_;
+class MapEvent;
+class MapEventDefaultTypeInternal;
+extern MapEventDefaultTypeInternal _MapEvent_default_instance_;
+class MapGroup;
+class MapGroupDefaultTypeInternal;
+extern MapGroupDefaultTypeInternal _MapGroup_default_instance_;
+class MapGroupHandle;
+class MapGroupHandleDefaultTypeInternal;
+extern MapGroupHandleDefaultTypeInternal _MapGroupHandle_default_instance_;
+class MapGroupList;
+class MapGroupListDefaultTypeInternal;
+extern MapGroupListDefaultTypeInternal _MapGroupList_default_instance_;
+class MapHandle;
+class MapHandleDefaultTypeInternal;
+extern MapHandleDefaultTypeInternal _MapHandle_default_instance_;
+class MapList;
+class MapListDefaultTypeInternal;
+extern MapListDefaultTypeInternal _MapList_default_instance_;
+class Mapping;
+class MappingDefaultTypeInternal;
+extern MappingDefaultTypeInternal _Mapping_default_instance_;
+class MappingHandle;
+class MappingHandleDefaultTypeInternal;
+extern MappingHandleDefaultTypeInternal _MappingHandle_default_instance_;
+class MappingInfoNotification;
+class MappingInfoNotificationDefaultTypeInternal;
+extern MappingInfoNotificationDefaultTypeInternal _MappingInfoNotification_default_instance_;
+class MappingInfoNotificationList;
+class MappingInfoNotificationListDefaultTypeInternal;
+extern MappingInfoNotificationListDefaultTypeInternal _MappingInfoNotificationList_default_instance_;
+class MappingList;
+class MappingListDefaultTypeInternal;
+extern MappingListDefaultTypeInternal _MappingList_default_instance_;
+class NetworkHandle;
+class NetworkHandleDefaultTypeInternal;
+extern NetworkHandleDefaultTypeInternal _NetworkHandle_default_instance_;
+class NetworkNotification;
+class NetworkNotificationDefaultTypeInternal;
+extern NetworkNotificationDefaultTypeInternal _NetworkNotification_default_instance_;
+class NetworkNotificationList;
+class NetworkNotificationListDefaultTypeInternal;
+extern NetworkNotificationListDefaultTypeInternal _NetworkNotificationList_default_instance_;
+class OperatingModeInformation;
+class OperatingModeInformationDefaultTypeInternal;
+extern OperatingModeInformationDefaultTypeInternal _OperatingModeInformation_default_instance_;
+class OperatingModeNotification;
+class OperatingModeNotificationDefaultTypeInternal;
+extern OperatingModeNotificationDefaultTypeInternal _OperatingModeNotification_default_instance_;
+class OperatingModeNotificationList;
+class OperatingModeNotificationListDefaultTypeInternal;
+extern OperatingModeNotificationListDefaultTypeInternal _OperatingModeNotificationList_default_instance_;
+class Orientation;
+class OrientationDefaultTypeInternal;
+extern OrientationDefaultTypeInternal _Orientation_default_instance_;
+class PasswordChange;
+class PasswordChangeDefaultTypeInternal;
+extern PasswordChangeDefaultTypeInternal _PasswordChange_default_instance_;
+class Point;
+class PointDefaultTypeInternal;
+extern PointDefaultTypeInternal _Point_default_instance_;
+class Pose;
+class PoseDefaultTypeInternal;
+extern PoseDefaultTypeInternal _Pose_default_instance_;
+class Position;
+class PositionDefaultTypeInternal;
+extern PositionDefaultTypeInternal _Position_default_instance_;
+class PreComputedJointTrajectory;
+class PreComputedJointTrajectoryDefaultTypeInternal;
+extern PreComputedJointTrajectoryDefaultTypeInternal _PreComputedJointTrajectory_default_instance_;
+class PreComputedJointTrajectoryElement;
+class PreComputedJointTrajectoryElementDefaultTypeInternal;
+extern PreComputedJointTrajectoryElementDefaultTypeInternal _PreComputedJointTrajectoryElement_default_instance_;
+class ProtectionZone;
+class ProtectionZoneDefaultTypeInternal;
+extern ProtectionZoneDefaultTypeInternal _ProtectionZone_default_instance_;
+class ProtectionZoneHandle;
+class ProtectionZoneHandleDefaultTypeInternal;
+extern ProtectionZoneHandleDefaultTypeInternal _ProtectionZoneHandle_default_instance_;
+class ProtectionZoneInformation;
+class ProtectionZoneInformationDefaultTypeInternal;
+extern ProtectionZoneInformationDefaultTypeInternal _ProtectionZoneInformation_default_instance_;
+class ProtectionZoneList;
+class ProtectionZoneListDefaultTypeInternal;
+extern ProtectionZoneListDefaultTypeInternal _ProtectionZoneList_default_instance_;
+class ProtectionZoneNotification;
+class ProtectionZoneNotificationDefaultTypeInternal;
+extern ProtectionZoneNotificationDefaultTypeInternal _ProtectionZoneNotification_default_instance_;
+class ProtectionZoneNotificationList;
+class ProtectionZoneNotificationListDefaultTypeInternal;
+extern ProtectionZoneNotificationListDefaultTypeInternal _ProtectionZoneNotificationList_default_instance_;
+class RFConfiguration;
+class RFConfigurationDefaultTypeInternal;
+extern RFConfigurationDefaultTypeInternal _RFConfiguration_default_instance_;
+class RequestedActionType;
+class RequestedActionTypeDefaultTypeInternal;
+extern RequestedActionTypeDefaultTypeInternal _RequestedActionType_default_instance_;
+class RobotEventNotification;
+class RobotEventNotificationDefaultTypeInternal;
+extern RobotEventNotificationDefaultTypeInternal _RobotEventNotification_default_instance_;
+class RobotEventNotificationList;
+class RobotEventNotificationListDefaultTypeInternal;
+extern RobotEventNotificationListDefaultTypeInternal _RobotEventNotificationList_default_instance_;
+class RotationMatrix;
+class RotationMatrixDefaultTypeInternal;
+extern RotationMatrixDefaultTypeInternal _RotationMatrix_default_instance_;
+class RotationMatrixRow;
+class RotationMatrixRowDefaultTypeInternal;
+extern RotationMatrixRowDefaultTypeInternal _RotationMatrixRow_default_instance_;
+class SafetyNotificationList;
+class SafetyNotificationListDefaultTypeInternal;
+extern SafetyNotificationListDefaultTypeInternal _SafetyNotificationList_default_instance_;
+class Sequence;
+class SequenceDefaultTypeInternal;
+extern SequenceDefaultTypeInternal _Sequence_default_instance_;
+class SequenceHandle;
+class SequenceHandleDefaultTypeInternal;
+extern SequenceHandleDefaultTypeInternal _SequenceHandle_default_instance_;
+class SequenceInfoNotification;
+class SequenceInfoNotificationDefaultTypeInternal;
+extern SequenceInfoNotificationDefaultTypeInternal _SequenceInfoNotification_default_instance_;
+class SequenceInfoNotificationList;
+class SequenceInfoNotificationListDefaultTypeInternal;
+extern SequenceInfoNotificationListDefaultTypeInternal _SequenceInfoNotificationList_default_instance_;
+class SequenceInformation;
+class SequenceInformationDefaultTypeInternal;
+extern SequenceInformationDefaultTypeInternal _SequenceInformation_default_instance_;
+class SequenceList;
+class SequenceListDefaultTypeInternal;
+extern SequenceListDefaultTypeInternal _SequenceList_default_instance_;
+class SequenceTask;
+class SequenceTaskDefaultTypeInternal;
+extern SequenceTaskDefaultTypeInternal _SequenceTask_default_instance_;
+class SequenceTaskConfiguration;
+class SequenceTaskConfigurationDefaultTypeInternal;
+extern SequenceTaskConfigurationDefaultTypeInternal _SequenceTaskConfiguration_default_instance_;
+class SequenceTaskHandle;
+class SequenceTaskHandleDefaultTypeInternal;
+extern SequenceTaskHandleDefaultTypeInternal _SequenceTaskHandle_default_instance_;
+class SequenceTasks;
+class SequenceTasksDefaultTypeInternal;
+extern SequenceTasksDefaultTypeInternal _SequenceTasks_default_instance_;
+class SequenceTasksConfiguration;
+class SequenceTasksConfigurationDefaultTypeInternal;
+extern SequenceTasksConfigurationDefaultTypeInternal _SequenceTasksConfiguration_default_instance_;
+class SequenceTasksPair;
+class SequenceTasksPairDefaultTypeInternal;
+extern SequenceTasksPairDefaultTypeInternal _SequenceTasksPair_default_instance_;
+class SequenceTasksRange;
+class SequenceTasksRangeDefaultTypeInternal;
+extern SequenceTasksRangeDefaultTypeInternal _SequenceTasksRange_default_instance_;
+class ServoingModeInformation;
+class ServoingModeInformationDefaultTypeInternal;
+extern ServoingModeInformationDefaultTypeInternal _ServoingModeInformation_default_instance_;
+class ServoingModeNotification;
+class ServoingModeNotificationDefaultTypeInternal;
+extern ServoingModeNotificationDefaultTypeInternal _ServoingModeNotification_default_instance_;
+class ServoingModeNotificationList;
+class ServoingModeNotificationListDefaultTypeInternal;
+extern ServoingModeNotificationListDefaultTypeInternal _ServoingModeNotificationList_default_instance_;
+class Snapshot;
+class SnapshotDefaultTypeInternal;
+extern SnapshotDefaultTypeInternal _Snapshot_default_instance_;
+class Ssid;
+class SsidDefaultTypeInternal;
+extern SsidDefaultTypeInternal _Ssid_default_instance_;
+class Stop;
+class StopDefaultTypeInternal;
+extern StopDefaultTypeInternal _Stop_default_instance_;
+class SwitchControlMapping;
+class SwitchControlMappingDefaultTypeInternal;
+extern SwitchControlMappingDefaultTypeInternal _SwitchControlMapping_default_instance_;
+class Timeout;
+class TimeoutDefaultTypeInternal;
+extern TimeoutDefaultTypeInternal _Timeout_default_instance_;
+class TrajectoryErrorElement;
+class TrajectoryErrorElementDefaultTypeInternal;
+extern TrajectoryErrorElementDefaultTypeInternal _TrajectoryErrorElement_default_instance_;
+class TrajectoryErrorReport;
+class TrajectoryErrorReportDefaultTypeInternal;
+extern TrajectoryErrorReportDefaultTypeInternal _TrajectoryErrorReport_default_instance_;
+class TrajectoryInfo;
+class TrajectoryInfoDefaultTypeInternal;
+extern TrajectoryInfoDefaultTypeInternal _TrajectoryInfo_default_instance_;
+class TransformationMatrix;
+class TransformationMatrixDefaultTypeInternal;
+extern TransformationMatrixDefaultTypeInternal _TransformationMatrix_default_instance_;
+class TransformationRow;
+class TransformationRowDefaultTypeInternal;
+extern TransformationRowDefaultTypeInternal _TransformationRow_default_instance_;
+class Twist;
+class TwistDefaultTypeInternal;
+extern TwistDefaultTypeInternal _Twist_default_instance_;
+class TwistCommand;
+class TwistCommandDefaultTypeInternal;
+extern TwistCommandDefaultTypeInternal _TwistCommand_default_instance_;
+class TwistLimitation;
+class TwistLimitationDefaultTypeInternal;
+extern TwistLimitationDefaultTypeInternal _TwistLimitation_default_instance_;
+class UserList;
+class UserListDefaultTypeInternal;
+extern UserListDefaultTypeInternal _UserList_default_instance_;
+class UserNotification;
+class UserNotificationDefaultTypeInternal;
+extern UserNotificationDefaultTypeInternal _UserNotification_default_instance_;
+class UserNotificationList;
+class UserNotificationListDefaultTypeInternal;
+extern UserNotificationListDefaultTypeInternal _UserNotificationList_default_instance_;
+class UserProfile;
+class UserProfileDefaultTypeInternal;
+extern UserProfileDefaultTypeInternal _UserProfile_default_instance_;
+class UserProfileList;
+class UserProfileListDefaultTypeInternal;
+extern UserProfileListDefaultTypeInternal _UserProfileList_default_instance_;
+class Waypoint;
+class WaypointDefaultTypeInternal;
+extern WaypointDefaultTypeInternal _Waypoint_default_instance_;
+class WaypointList;
+class WaypointListDefaultTypeInternal;
+extern WaypointListDefaultTypeInternal _WaypointList_default_instance_;
+class WaypointValidationReport;
+class WaypointValidationReportDefaultTypeInternal;
+extern WaypointValidationReportDefaultTypeInternal _WaypointValidationReport_default_instance_;
+class WifiConfiguration;
+class WifiConfigurationDefaultTypeInternal;
+extern WifiConfigurationDefaultTypeInternal _WifiConfiguration_default_instance_;
+class WifiConfigurationList;
+class WifiConfigurationListDefaultTypeInternal;
+extern WifiConfigurationListDefaultTypeInternal _WifiConfigurationList_default_instance_;
+class WifiEnableState;
+class WifiEnableStateDefaultTypeInternal;
+extern WifiEnableStateDefaultTypeInternal _WifiEnableState_default_instance_;
+class WifiInformation;
+class WifiInformationDefaultTypeInternal;
+extern WifiInformationDefaultTypeInternal _WifiInformation_default_instance_;
+class WifiInformationList;
+class WifiInformationListDefaultTypeInternal;
+extern WifiInformationListDefaultTypeInternal _WifiInformationList_default_instance_;
+class Wrench;
+class WrenchDefaultTypeInternal;
+extern WrenchDefaultTypeInternal _Wrench_default_instance_;
+class WrenchCommand;
+class WrenchCommandDefaultTypeInternal;
+extern WrenchCommandDefaultTypeInternal _WrenchCommand_default_instance_;
+class WrenchLimitation;
+class WrenchLimitationDefaultTypeInternal;
+extern WrenchLimitationDefaultTypeInternal _WrenchLimitation_default_instance_;
+class ZoneShape;
+class ZoneShapeDefaultTypeInternal;
+extern ZoneShapeDefaultTypeInternal _ZoneShape_default_instance_;
+}  // namespace Base
+}  // namespace Api
+}  // namespace Kinova
+namespace Kinova {
+namespace Api {
+namespace Base {
+
+enum GpioPinPropertyFlags {
+  GPIOPROPERTY_UNKNOWN = 0,
+  GPIOPROPERTY_INPUT = 1,
+  GPIOPROPERTY_OUTPUT = 2,
+  GPIOPROPERTY_ANALOG = 4,
+  GpioPinPropertyFlags_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  GpioPinPropertyFlags_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool GpioPinPropertyFlags_IsValid(int value);
+const GpioPinPropertyFlags GpioPinPropertyFlags_MIN = GPIOPROPERTY_UNKNOWN;
+const GpioPinPropertyFlags GpioPinPropertyFlags_MAX = GPIOPROPERTY_ANALOG;
+const int GpioPinPropertyFlags_ARRAYSIZE = GpioPinPropertyFlags_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* GpioPinPropertyFlags_descriptor();
+inline const ::std::string& GpioPinPropertyFlags_Name(GpioPinPropertyFlags value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    GpioPinPropertyFlags_descriptor(), value);
+}
+inline bool GpioPinPropertyFlags_Parse(
+    const ::std::string& name, GpioPinPropertyFlags* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<GpioPinPropertyFlags>(
+    GpioPinPropertyFlags_descriptor(), name, value);
+}
+enum ServiceVersion {
+  RESERVED_0 = 0,
+  CURRENT_VERSION = 1,
+  ServiceVersion_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  ServiceVersion_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool ServiceVersion_IsValid(int value);
+const ServiceVersion ServiceVersion_MIN = RESERVED_0;
+const ServiceVersion ServiceVersion_MAX = CURRENT_VERSION;
+const int ServiceVersion_ARRAYSIZE = ServiceVersion_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* ServiceVersion_descriptor();
+inline const ::std::string& ServiceVersion_Name(ServiceVersion value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    ServiceVersion_descriptor(), value);
+}
+inline bool ServiceVersion_Parse(
+    const ::std::string& name, ServiceVersion* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<ServiceVersion>(
+    ServiceVersion_descriptor(), name, value);
+}
+enum ActionType {
+  UNSPECIFIED_ACTION = 0,
+  SEND_TWIST_COMMAND = 1,
+  SEND_WRENCH_COMMAND = 2,
+  SEND_JOINT_SPEEDS = 4,
+  REACH_POSE = 6,
+  REACH_JOINT_ANGLES = 7,
+  TOGGLE_ADMITTANCE_MODE = 13,
+  SNAPSHOT = 14,
+  SWITCH_CONTROL_MAPPING = 16,
+  NAVIGATE_JOINTS = 17,
+  NAVIGATE_MAPPINGS = 18,
+  CHANGE_TWIST = 22,
+  CHANGE_JOINT_SPEEDS = 23,
+  CHANGE_WRENCH = 25,
+  APPLY_EMERGENCY_STOP = 28,
+  CLEAR_FAULTS = 29,
+  TIME_DELAY = 31,
+  EXECUTE_ACTION = 32,
+  SEND_GRIPPER_COMMAND = 33,
+  SEND_GPIO_COMMAND = 34,
+  STOP_ACTION = 35,
+  PLAY_PRE_COMPUTED_TRAJECTORY = 39,
+  EXECUTE_SEQUENCE = 40,
+  EXECUTE_WAYPOINT_LIST = 41,
+  ActionType_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  ActionType_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool ActionType_IsValid(int value);
+const ActionType ActionType_MIN = UNSPECIFIED_ACTION;
+const ActionType ActionType_MAX = EXECUTE_WAYPOINT_LIST;
+const int ActionType_ARRAYSIZE = ActionType_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* ActionType_descriptor();
+inline const ::std::string& ActionType_Name(ActionType value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    ActionType_descriptor(), value);
+}
+inline bool ActionType_Parse(
+    const ::std::string& name, ActionType* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<ActionType>(
+    ActionType_descriptor(), name, value);
+}
+enum SnapshotType {
+  UNSPECIFIED_SNAPSHOT = 0,
+  CARTESIAN_POSITION_SNAPSHOT = 1,
+  JOINT_POSITION_SNAPSHOT = 2,
+  GRIPPER_SNAPSHOT = 3,
+  COMBINED_SNAPSHOT = 4,
+  SnapshotType_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  SnapshotType_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool SnapshotType_IsValid(int value);
+const SnapshotType SnapshotType_MIN = UNSPECIFIED_SNAPSHOT;
+const SnapshotType SnapshotType_MAX = COMBINED_SNAPSHOT;
+const int SnapshotType_ARRAYSIZE = SnapshotType_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* SnapshotType_descriptor();
+inline const ::std::string& SnapshotType_Name(SnapshotType value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    SnapshotType_descriptor(), value);
+}
+inline bool SnapshotType_Parse(
+    const ::std::string& name, SnapshotType* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<SnapshotType>(
+    SnapshotType_descriptor(), name, value);
+}
+enum NetworkType {
+  UNSPECIFIED_NETWORK_TYPE = 0,
+  WIFI = 1,
+  WIRED_ETHERNET = 2,
+  WIRED_MICROUSB = 3,
+  NetworkType_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  NetworkType_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool NetworkType_IsValid(int value);
+const NetworkType NetworkType_MIN = UNSPECIFIED_NETWORK_TYPE;
+const NetworkType NetworkType_MAX = WIRED_MICROUSB;
+const int NetworkType_ARRAYSIZE = NetworkType_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* NetworkType_descriptor();
+inline const ::std::string& NetworkType_Name(NetworkType value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    NetworkType_descriptor(), value);
+}
+inline bool NetworkType_Parse(
+    const ::std::string& name, NetworkType* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<NetworkType>(
+    NetworkType_descriptor(), name, value);
+}
+enum WifiSecurityType {
+  UNSPECIFIED_AUTHENTICATION = 0,
+  WEP = 1,
+  WPA2_PERSONAL = 2,
+  WPA_PERSONAL = 4,
+  NO_AUTHENTICATION = 8,
+  WifiSecurityType_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  WifiSecurityType_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool WifiSecurityType_IsValid(int value);
+const WifiSecurityType WifiSecurityType_MIN = UNSPECIFIED_AUTHENTICATION;
+const WifiSecurityType WifiSecurityType_MAX = NO_AUTHENTICATION;
+const int WifiSecurityType_ARRAYSIZE = WifiSecurityType_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* WifiSecurityType_descriptor();
+inline const ::std::string& WifiSecurityType_Name(WifiSecurityType value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    WifiSecurityType_descriptor(), value);
+}
+inline bool WifiSecurityType_Parse(
+    const ::std::string& name, WifiSecurityType* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<WifiSecurityType>(
+    WifiSecurityType_descriptor(), name, value);
+}
+enum WifiEncryptionType {
+  UNSPECIFIED_ENCRYPTION = 0,
+  AES_ENCRYPTION = 1,
+  TKIP_ENCRYPTION = 2,
+  WEP_ENCRYPTION = 4,
+  WifiEncryptionType_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  WifiEncryptionType_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool WifiEncryptionType_IsValid(int value);
+const WifiEncryptionType WifiEncryptionType_MIN = UNSPECIFIED_ENCRYPTION;
+const WifiEncryptionType WifiEncryptionType_MAX = WEP_ENCRYPTION;
+const int WifiEncryptionType_ARRAYSIZE = WifiEncryptionType_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* WifiEncryptionType_descriptor();
+inline const ::std::string& WifiEncryptionType_Name(WifiEncryptionType value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    WifiEncryptionType_descriptor(), value);
+}
+inline bool WifiEncryptionType_Parse(
+    const ::std::string& name, WifiEncryptionType* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<WifiEncryptionType>(
+    WifiEncryptionType_descriptor(), name, value);
+}
+enum SignalQuality {
+  UNSPECIFIED_SIGNAL_QUALITY = 0,
+  POOR = 1,
+  FAIR = 2,
+  GOOD = 3,
+  EXCELLENT = 4,
+  NONE = 5,
+  SignalQuality_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  SignalQuality_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool SignalQuality_IsValid(int value);
+const SignalQuality SignalQuality_MIN = UNSPECIFIED_SIGNAL_QUALITY;
+const SignalQuality SignalQuality_MAX = NONE;
+const int SignalQuality_ARRAYSIZE = SignalQuality_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* SignalQuality_descriptor();
+inline const ::std::string& SignalQuality_Name(SignalQuality value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    SignalQuality_descriptor(), value);
+}
+inline bool SignalQuality_Parse(
+    const ::std::string& name, SignalQuality* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<SignalQuality>(
+    SignalQuality_descriptor(), name, value);
+}
+enum ShapeType {
+  UNSPECIFIED_SHAPE = 0,
+  CYLINDER = 1,
+  SPHERE = 2,
+  RECTANGULAR_PRISM = 3,
+  ShapeType_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  ShapeType_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool ShapeType_IsValid(int value);
+const ShapeType ShapeType_MIN = UNSPECIFIED_SHAPE;
+const ShapeType ShapeType_MAX = RECTANGULAR_PRISM;
+const int ShapeType_ARRAYSIZE = ShapeType_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* ShapeType_descriptor();
+inline const ::std::string& ShapeType_Name(ShapeType value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    ShapeType_descriptor(), value);
+}
+inline bool ShapeType_Parse(
+    const ::std::string& name, ShapeType* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<ShapeType>(
+    ShapeType_descriptor(), name, value);
+}
+enum LimitationType {
+  UNSPECIFIED_LIMITATION = 0,
+  FORCE_LIMITATION = 1,
+  ACCELERATION_LIMITATION = 2,
+  VELOCITY_LIMITATION = 3,
+  TORQUE_LIMITATION = 4,
+  LimitationType_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  LimitationType_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool LimitationType_IsValid(int value);
+const LimitationType LimitationType_MIN = UNSPECIFIED_LIMITATION;
+const LimitationType LimitationType_MAX = TORQUE_LIMITATION;
+const int LimitationType_ARRAYSIZE = LimitationType_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* LimitationType_descriptor();
+inline const ::std::string& LimitationType_Name(LimitationType value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    LimitationType_descriptor(), value);
+}
+inline bool LimitationType_Parse(
+    const ::std::string& name, LimitationType* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<LimitationType>(
+    LimitationType_descriptor(), name, value);
+}
+enum ConfigurationNotificationEvent {
+  UNSPECIFIED_CONFIGURATION_EVENT = 0,
+  CONFIGURATION_UPDATED = 1,
+  CONFIGURATION_DELETED = 2,
+  CONFIGURATION_DELETED_ALL = 3,
+  CONFIGURATION_CREATED = 4,
+  ConfigurationNotificationEvent_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  ConfigurationNotificationEvent_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool ConfigurationNotificationEvent_IsValid(int value);
+const ConfigurationNotificationEvent ConfigurationNotificationEvent_MIN = UNSPECIFIED_CONFIGURATION_EVENT;
+const ConfigurationNotificationEvent ConfigurationNotificationEvent_MAX = CONFIGURATION_CREATED;
+const int ConfigurationNotificationEvent_ARRAYSIZE = ConfigurationNotificationEvent_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* ConfigurationNotificationEvent_descriptor();
+inline const ::std::string& ConfigurationNotificationEvent_Name(ConfigurationNotificationEvent value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    ConfigurationNotificationEvent_descriptor(), value);
+}
+inline bool ConfigurationNotificationEvent_Parse(
+    const ::std::string& name, ConfigurationNotificationEvent* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<ConfigurationNotificationEvent>(
+    ConfigurationNotificationEvent_descriptor(), name, value);
+}
+enum OperatingMode {
+  UNSPECIFIED_OPERATING_MODE = 0,
+  MAINTENANCE_MODE = 1,
+  UPDATE_MODE = 2,
+  UPDATE_COMPLETED_MODE = 3,
+  UPDATE_FAILED_MODE = 4,
+  SHUTTING_DOWN_MODE = 5,
+  RUN_MODE = 6,
+  UPDATING_DEVICE_MODE = 7,
+  OperatingMode_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  OperatingMode_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool OperatingMode_IsValid(int value);
+const OperatingMode OperatingMode_MIN = UNSPECIFIED_OPERATING_MODE;
+const OperatingMode OperatingMode_MAX = UPDATING_DEVICE_MODE;
+const int OperatingMode_ARRAYSIZE = OperatingMode_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* OperatingMode_descriptor();
+inline const ::std::string& OperatingMode_Name(OperatingMode value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    OperatingMode_descriptor(), value);
+}
+inline bool OperatingMode_Parse(
+    const ::std::string& name, OperatingMode* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<OperatingMode>(
+    OperatingMode_descriptor(), name, value);
+}
+enum ServoingMode {
+  UNSPECIFIED_SERVOING_MODE = 0,
+  SINGLE_LEVEL_SERVOING = 2,
+  LOW_LEVEL_SERVOING = 3,
+  BYPASS_SERVOING = 4,
+  ServoingMode_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  ServoingMode_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool ServoingMode_IsValid(int value);
+const ServoingMode ServoingMode_MIN = UNSPECIFIED_SERVOING_MODE;
+const ServoingMode ServoingMode_MAX = BYPASS_SERVOING;
+const int ServoingMode_ARRAYSIZE = ServoingMode_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* ServoingMode_descriptor();
+inline const ::std::string& ServoingMode_Name(ServoingMode value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    ServoingMode_descriptor(), value);
+}
+inline bool ServoingMode_Parse(
+    const ::std::string& name, ServoingMode* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<ServoingMode>(
+    ServoingMode_descriptor(), name, value);
+}
+enum EventIdSequenceInfoNotification {
+  UNSPECIFIED_SEQUENCE_EVENT = 0,
+  SEQUENCE_COMPLETED = 1,
+  SEQUENCE_ABORTED = 2,
+  SEQUENCE_PAUSED = 3,
+  SEQUENCE_TASK_STARTED = 4,
+  SEQUENCE_TASK_COMPLETED = 5,
+  SEQUENCE_STARTED = 6,
+  EventIdSequenceInfoNotification_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  EventIdSequenceInfoNotification_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool EventIdSequenceInfoNotification_IsValid(int value);
+const EventIdSequenceInfoNotification EventIdSequenceInfoNotification_MIN = UNSPECIFIED_SEQUENCE_EVENT;
+const EventIdSequenceInfoNotification EventIdSequenceInfoNotification_MAX = SEQUENCE_STARTED;
+const int EventIdSequenceInfoNotification_ARRAYSIZE = EventIdSequenceInfoNotification_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* EventIdSequenceInfoNotification_descriptor();
+inline const ::std::string& EventIdSequenceInfoNotification_Name(EventIdSequenceInfoNotification value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    EventIdSequenceInfoNotification_descriptor(), value);
+}
+inline bool EventIdSequenceInfoNotification_Parse(
+    const ::std::string& name, EventIdSequenceInfoNotification* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<EventIdSequenceInfoNotification>(
+    EventIdSequenceInfoNotification_descriptor(), name, value);
+}
+enum ProtectionZoneEvent {
+  UNSPECIFIED_PROTECTION_ZONE_EVENT = 0,
+  REACHED = 1,
+  ENTERED = 2,
+  EXITED = 3,
+  ProtectionZoneEvent_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  ProtectionZoneEvent_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool ProtectionZoneEvent_IsValid(int value);
+const ProtectionZoneEvent ProtectionZoneEvent_MIN = UNSPECIFIED_PROTECTION_ZONE_EVENT;
+const ProtectionZoneEvent ProtectionZoneEvent_MAX = EXITED;
+const int ProtectionZoneEvent_ARRAYSIZE = ProtectionZoneEvent_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* ProtectionZoneEvent_descriptor();
+inline const ::std::string& ProtectionZoneEvent_Name(ProtectionZoneEvent value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    ProtectionZoneEvent_descriptor(), value);
+}
+inline bool ProtectionZoneEvent_Parse(
+    const ::std::string& name, ProtectionZoneEvent* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<ProtectionZoneEvent>(
+    ProtectionZoneEvent_descriptor(), name, value);
+}
+enum UserEvent {
+  UNSPECIFIED_USER_EVENT = 0,
+  LOGGED_OUT = 1,
+  LOGGED_IN = 2,
+  UserEvent_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  UserEvent_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool UserEvent_IsValid(int value);
+const UserEvent UserEvent_MIN = UNSPECIFIED_USER_EVENT;
+const UserEvent UserEvent_MAX = LOGGED_IN;
+const int UserEvent_ARRAYSIZE = UserEvent_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* UserEvent_descriptor();
+inline const ::std::string& UserEvent_Name(UserEvent value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    UserEvent_descriptor(), value);
+}
+inline bool UserEvent_Parse(
+    const ::std::string& name, UserEvent* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<UserEvent>(
+    UserEvent_descriptor(), name, value);
+}
+enum ControllerType {
+  UNSPECIFIED_CONTROLLER_TYPE = 0,
+  XBOX_CONTROLLER = 1,
+  WRIST_CONTROLLER = 2,
+  BASIC_JOYSTICK_CONTROLLER = 3,
+  BASE_GPIO_CONTROLLER = 4,
+  GPIO_JOYSTICK = 5,
+  ControllerType_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  ControllerType_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool ControllerType_IsValid(int value);
+const ControllerType ControllerType_MIN = UNSPECIFIED_CONTROLLER_TYPE;
+const ControllerType ControllerType_MAX = GPIO_JOYSTICK;
+const int ControllerType_ARRAYSIZE = ControllerType_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* ControllerType_descriptor();
+inline const ::std::string& ControllerType_Name(ControllerType value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    ControllerType_descriptor(), value);
+}
+inline bool ControllerType_Parse(
+    const ::std::string& name, ControllerType* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<ControllerType>(
+    ControllerType_descriptor(), name, value);
+}
+enum ControllerEventType {
+  UNSPECIFIED_CONTROLLER_EVENT = 0,
+  CONTROLLER_DISCONNECTED = 1,
+  CONTROLLER_CONNECTED = 2,
+  ControllerEventType_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  ControllerEventType_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool ControllerEventType_IsValid(int value);
+const ControllerEventType ControllerEventType_MIN = UNSPECIFIED_CONTROLLER_EVENT;
+const ControllerEventType ControllerEventType_MAX = CONTROLLER_CONNECTED;
+const int ControllerEventType_ARRAYSIZE = ControllerEventType_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* ControllerEventType_descriptor();
+inline const ::std::string& ControllerEventType_Name(ControllerEventType value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    ControllerEventType_descriptor(), value);
+}
+inline bool ControllerEventType_Parse(
+    const ::std::string& name, ControllerEventType* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<ControllerEventType>(
+    ControllerEventType_descriptor(), name, value);
+}
+enum ControllerElementEventType {
+  UNSPECIFIED_CONTROLLER_ELEMENT_EVENT = 0,
+  AXIS_MOVED = 1,
+  BUTTON_DOWN = 2,
+  BUTTON_UP = 3,
+  BUTTON_CLICK = 4,
+  ControllerElementEventType_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  ControllerElementEventType_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool ControllerElementEventType_IsValid(int value);
+const ControllerElementEventType ControllerElementEventType_MIN = UNSPECIFIED_CONTROLLER_ELEMENT_EVENT;
+const ControllerElementEventType ControllerElementEventType_MAX = BUTTON_CLICK;
+const int ControllerElementEventType_ARRAYSIZE = ControllerElementEventType_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* ControllerElementEventType_descriptor();
+inline const ::std::string& ControllerElementEventType_Name(ControllerElementEventType value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    ControllerElementEventType_descriptor(), value);
+}
+inline bool ControllerElementEventType_Parse(
+    const ::std::string& name, ControllerElementEventType* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<ControllerElementEventType>(
+    ControllerElementEventType_descriptor(), name, value);
+}
+enum ActionEvent {
+  UNSPECIFIED_ACTION_EVENT = 0,
+  ACTION_END = 1,
+  ACTION_ABORT = 2,
+  ACTION_PAUSE = 3,
+  ACTION_START = 4,
+  ACTION_PREPROCESS_START = 5,
+  ACTION_PREPROCESS_ABORT = 6,
+  ACTION_PREPROCESS_END = 7,
+  ACTION_POSTPROCESS_START = 8,
+  ACTION_POSTPROCESS_ABORT = 9,
+  ACTION_POSTPROCESS_END = 10,
+  ACTION_FEEDBACK = 11,
+  ActionEvent_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  ActionEvent_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool ActionEvent_IsValid(int value);
+const ActionEvent ActionEvent_MIN = UNSPECIFIED_ACTION_EVENT;
+const ActionEvent ActionEvent_MAX = ACTION_FEEDBACK;
+const int ActionEvent_ARRAYSIZE = ActionEvent_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* ActionEvent_descriptor();
+inline const ::std::string& ActionEvent_Name(ActionEvent value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    ActionEvent_descriptor(), value);
+}
+inline bool ActionEvent_Parse(
+    const ::std::string& name, ActionEvent* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<ActionEvent>(
+    ActionEvent_descriptor(), name, value);
+}
+enum RobotEvent {
+  UNSPECIFIED_ROBOT_EVENT = 0,
+  ARM_CONNECTED = 1,
+  ARM_DISCONNECTED = 2,
+  TOOL_CONNECTED = 5,
+  TOOL_DISCONNECTED = 6,
+  RobotEvent_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  RobotEvent_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool RobotEvent_IsValid(int value);
+const RobotEvent RobotEvent_MIN = UNSPECIFIED_ROBOT_EVENT;
+const RobotEvent RobotEvent_MAX = TOOL_DISCONNECTED;
+const int RobotEvent_ARRAYSIZE = RobotEvent_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* RobotEvent_descriptor();
+inline const ::std::string& RobotEvent_Name(RobotEvent value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    RobotEvent_descriptor(), value);
+}
+inline bool RobotEvent_Parse(
+    const ::std::string& name, RobotEvent* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<RobotEvent>(
+    RobotEvent_descriptor(), name, value);
+}
+enum FactoryEvent {
+  UNSPECIFIED_FACTORY_EVENT = 0,
+  FACTORY_DEFAULT_RESTORED = 1,
+  NETWORK_FACTORY_DEFAULT_RESTORED = 2,
+  FactoryEvent_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  FactoryEvent_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool FactoryEvent_IsValid(int value);
+const FactoryEvent FactoryEvent_MIN = UNSPECIFIED_FACTORY_EVENT;
+const FactoryEvent FactoryEvent_MAX = NETWORK_FACTORY_DEFAULT_RESTORED;
+const int FactoryEvent_ARRAYSIZE = FactoryEvent_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* FactoryEvent_descriptor();
+inline const ::std::string& FactoryEvent_Name(FactoryEvent value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    FactoryEvent_descriptor(), value);
+}
+inline bool FactoryEvent_Parse(
+    const ::std::string& name, FactoryEvent* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<FactoryEvent>(
+    FactoryEvent_descriptor(), name, value);
+}
+enum NetworkEvent {
+  UNSPECIFIED_NETWORK_EVENT = 0,
+  WIFI_CONNECTED = 1,
+  WIFI_DISCONNECTED = 2,
+  WIFI_SCAN_STARTED = 3,
+  WIFI_SCAN_RESULTS = 4,
+  WIFI_SCAN_FAILED = 5,
+  WIFI_NOT_FOUND = 6,
+  WIFI_ASSOC_REJECTED = 7,
+  WIFI_AUTH_WRONG_KEY = 8,
+  WIFI_AUTH_CONN_FAILED = 9,
+  WIFI_AUTH_FAILED = 10,
+  WIFI_ENABLED = 11,
+  WIFI_DISABLED = 12,
+  BLUETOOTH_ENABLED = 13,
+  BLUETOOTH_DISABLED = 14,
+  NetworkEvent_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  NetworkEvent_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool NetworkEvent_IsValid(int value);
+const NetworkEvent NetworkEvent_MIN = UNSPECIFIED_NETWORK_EVENT;
+const NetworkEvent NetworkEvent_MAX = BLUETOOTH_DISABLED;
+const int NetworkEvent_ARRAYSIZE = NetworkEvent_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* NetworkEvent_descriptor();
+inline const ::std::string& NetworkEvent_Name(NetworkEvent value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    NetworkEvent_descriptor(), value);
+}
+inline bool NetworkEvent_Parse(
+    const ::std::string& name, NetworkEvent* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<NetworkEvent>(
+    NetworkEvent_descriptor(), name, value);
+}
+enum ControllerInputType {
+  UNSPECIFIED_CONTROLLER_INPUT_TYPE = 0,
+  ANALOG = 1,
+  DIGITAL = 2,
+  ControllerInputType_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  ControllerInputType_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool ControllerInputType_IsValid(int value);
+const ControllerInputType ControllerInputType_MIN = UNSPECIFIED_CONTROLLER_INPUT_TYPE;
+const ControllerInputType ControllerInputType_MAX = DIGITAL;
+const int ControllerInputType_ARRAYSIZE = ControllerInputType_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* ControllerInputType_descriptor();
+inline const ::std::string& ControllerInputType_Name(ControllerInputType value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    ControllerInputType_descriptor(), value);
+}
+inline bool ControllerInputType_Parse(
+    const ::std::string& name, ControllerInputType* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<ControllerInputType>(
+    ControllerInputType_descriptor(), name, value);
+}
+enum ControllerBehavior {
+  UNSPECIFIED_CONTROLLER_BEHAVIOR = 0,
+  CONTROLLER_BUTTON_DOWN = 1,
+  CONTROLLER_BUTTON_UP = 2,
+  CONTROLLER_AXIS_POSITIVE = 3,
+  CONTROLLER_AXIS_NEGATIVE = 4,
+  CONTROLLER_BUTTON_CLICK = 5,
+  ControllerBehavior_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  ControllerBehavior_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool ControllerBehavior_IsValid(int value);
+const ControllerBehavior ControllerBehavior_MIN = UNSPECIFIED_CONTROLLER_BEHAVIOR;
+const ControllerBehavior ControllerBehavior_MAX = CONTROLLER_BUTTON_CLICK;
+const int ControllerBehavior_ARRAYSIZE = ControllerBehavior_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* ControllerBehavior_descriptor();
+inline const ::std::string& ControllerBehavior_Name(ControllerBehavior value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    ControllerBehavior_descriptor(), value);
+}
+inline bool ControllerBehavior_Parse(
+    const ::std::string& name, ControllerBehavior* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<ControllerBehavior>(
+    ControllerBehavior_descriptor(), name, value);
+}
+enum SafetyIdentifier {
+  UNSPECIFIED_BASE_SAFETY_IDENTIFIER = 0,
+  FIRMWARE_UPDATE_FAILURE = 1,
+  EXTERNAL_COMMUNICATION_ERROR = 2,
+  MAXIMUM_AMBIENT_TEMPERATURE = 4,
+  MAXIMUM_CORE_TEMPERATURE = 8,
+  JOINT_FAULT = 16,
+  CYCLIC_DATA_JITTER = 32,
+  REACHED_MAXIMUM_EVENT_LOGS = 64,
+  NO_KINEMATICS_SUPPORT = 128,
+  NETWORK_ERROR = 512,
+  UNABLE_TO_REACH_POSE = 1024,
+  JOINT_DETECTION_ERROR = 2048,
+  NETWORK_INITIALIZATION_ERROR = 4096,
+  MAXIMUM_CURRENT = 8192,
+  MAXIMUM_VOLTAGE = 16384,
+  MINIMUM_VOLTAGE = 32768,
+  MAXIMUM_END_EFFECTOR_TRANSLATION_VELOCITY = 65536,
+  MAXIMUM_END_EFFECTOR_ORIENTATION_VELOCITY = 131072,
+  MAXIMUM_END_EFFECTOR_TRANSLATION_ACCELERATION = 262144,
+  MAXIMUM_END_EFFECTOR_ORIENTATION_ACCELERATION = 524288,
+  MAXIMUM_END_EFFECTOR_TRANSLATION_FORCE = 1048576,
+  MAXIMUM_END_EFFECTOR_ORIENTATION_FORCE = 2097152,
+  MAXIMUM_END_EFFECTOR_PAYLOAD = 4194304,
+  EMERGENCY_STOP_ACTIVATED = 8388608,
+  EMERGENCY_LINE_ACTIVATED = 16777216,
+  INRUSH_CURRENT_LIMITER_FAULT = 33554432,
+  NVRAM_CORRUPTED = 67108864,
+  INCOMPATIBLE_FIRMWARE_VERSION = 134217728,
+  POWERON_SELF_TEST_FAILURE = 268435456,
+  DISCRETE_INPUT_STUCK_ACTIVE = 536870912,
+  ARM_INTO_ILLEGAL_POSITION = 1073741824,
+  SafetyIdentifier_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  SafetyIdentifier_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool SafetyIdentifier_IsValid(int value);
+const SafetyIdentifier SafetyIdentifier_MIN = UNSPECIFIED_BASE_SAFETY_IDENTIFIER;
+const SafetyIdentifier SafetyIdentifier_MAX = ARM_INTO_ILLEGAL_POSITION;
+const int SafetyIdentifier_ARRAYSIZE = SafetyIdentifier_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* SafetyIdentifier_descriptor();
+inline const ::std::string& SafetyIdentifier_Name(SafetyIdentifier value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    SafetyIdentifier_descriptor(), value);
+}
+inline bool SafetyIdentifier_Parse(
+    const ::std::string& name, SafetyIdentifier* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<SafetyIdentifier>(
+    SafetyIdentifier_descriptor(), name, value);
+}
+enum JointTrajectoryConstraintType {
+  UNSPECIFIED_JOINT_CONSTRAINT = 0,
+  JOINT_CONSTRAINT_DURATION = 1,
+  JOINT_CONSTRAINT_SPEED = 2,
+  JointTrajectoryConstraintType_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  JointTrajectoryConstraintType_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool JointTrajectoryConstraintType_IsValid(int value);
+const JointTrajectoryConstraintType JointTrajectoryConstraintType_MIN = UNSPECIFIED_JOINT_CONSTRAINT;
+const JointTrajectoryConstraintType JointTrajectoryConstraintType_MAX = JOINT_CONSTRAINT_SPEED;
+const int JointTrajectoryConstraintType_ARRAYSIZE = JointTrajectoryConstraintType_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* JointTrajectoryConstraintType_descriptor();
+inline const ::std::string& JointTrajectoryConstraintType_Name(JointTrajectoryConstraintType value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    JointTrajectoryConstraintType_descriptor(), value);
+}
+inline bool JointTrajectoryConstraintType_Parse(
+    const ::std::string& name, JointTrajectoryConstraintType* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<JointTrajectoryConstraintType>(
+    JointTrajectoryConstraintType_descriptor(), name, value);
+}
+enum WrenchMode {
+  UNSPECIFIED_WRENCH_MODE = 0,
+  WRENCH_RESTRICTED = 1,
+  WRENCH_NORMAL = 2,
+  WrenchMode_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  WrenchMode_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool WrenchMode_IsValid(int value);
+const WrenchMode WrenchMode_MIN = UNSPECIFIED_WRENCH_MODE;
+const WrenchMode WrenchMode_MAX = WRENCH_NORMAL;
+const int WrenchMode_ARRAYSIZE = WrenchMode_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* WrenchMode_descriptor();
+inline const ::std::string& WrenchMode_Name(WrenchMode value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    WrenchMode_descriptor(), value);
+}
+inline bool WrenchMode_Parse(
+    const ::std::string& name, WrenchMode* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<WrenchMode>(
+    WrenchMode_descriptor(), name, value);
+}
+enum AdmittanceMode {
+  UNSPECIFIED_ADMITTANCE_MODE = 0,
+  CARTESIAN = 1,
+  JOINT = 2,
+  NULL_SPACE = 3,
+  DISABLED = 4,
+  AdmittanceMode_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  AdmittanceMode_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool AdmittanceMode_IsValid(int value);
+const AdmittanceMode AdmittanceMode_MIN = UNSPECIFIED_ADMITTANCE_MODE;
+const AdmittanceMode AdmittanceMode_MAX = DISABLED;
+const int AdmittanceMode_ARRAYSIZE = AdmittanceMode_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* AdmittanceMode_descriptor();
+inline const ::std::string& AdmittanceMode_Name(AdmittanceMode value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    AdmittanceMode_descriptor(), value);
+}
+inline bool AdmittanceMode_Parse(
+    const ::std::string& name, AdmittanceMode* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<AdmittanceMode>(
+    AdmittanceMode_descriptor(), name, value);
+}
+enum GripperMode {
+  UNSPECIFIED_GRIPPER_MODE = 0,
+  GRIPPER_SPEED = 2,
+  GRIPPER_POSITION = 3,
+  GripperMode_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  GripperMode_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool GripperMode_IsValid(int value);
+const GripperMode GripperMode_MIN = UNSPECIFIED_GRIPPER_MODE;
+const GripperMode GripperMode_MAX = GRIPPER_POSITION;
+const int GripperMode_ARRAYSIZE = GripperMode_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* GripperMode_descriptor();
+inline const ::std::string& GripperMode_Name(GripperMode value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    GripperMode_descriptor(), value);
+}
+inline bool GripperMode_Parse(
+    const ::std::string& name, GripperMode* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<GripperMode>(
+    GripperMode_descriptor(), name, value);
+}
+enum GpioAction {
+  UNSPECIFIED_GPIO_ACTION = 0,
+  GPIOACTION_SET = 1,
+  GPIOACTION_CLEAR = 2,
+  GPIOACTION_PULSE_HIGH = 3,
+  GPIOACTION_PULSE_LOW = 4,
+  GpioAction_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  GpioAction_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool GpioAction_IsValid(int value);
+const GpioAction GpioAction_MIN = UNSPECIFIED_GPIO_ACTION;
+const GpioAction GpioAction_MAX = GPIOACTION_PULSE_LOW;
+const int GpioAction_ARRAYSIZE = GpioAction_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* GpioAction_descriptor();
+inline const ::std::string& GpioAction_Name(GpioAction value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    GpioAction_descriptor(), value);
+}
+inline bool GpioAction_Parse(
+    const ::std::string& name, GpioAction* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<GpioAction>(
+    GpioAction_descriptor(), name, value);
+}
+enum NavigationDirection {
+  UNSPECIFIED_NAVIGATION_DIRECTION = 0,
+  NEXT = 1,
+  PREVIOUS = 4,
+  NavigationDirection_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  NavigationDirection_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool NavigationDirection_IsValid(int value);
+const NavigationDirection NavigationDirection_MIN = UNSPECIFIED_NAVIGATION_DIRECTION;
+const NavigationDirection NavigationDirection_MAX = PREVIOUS;
+const int NavigationDirection_ARRAYSIZE = NavigationDirection_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* NavigationDirection_descriptor();
+inline const ::std::string& NavigationDirection_Name(NavigationDirection value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    NavigationDirection_descriptor(), value);
+}
+inline bool NavigationDirection_Parse(
+    const ::std::string& name, NavigationDirection* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<NavigationDirection>(
+    NavigationDirection_descriptor(), name, value);
+}
+enum JointNavigationDirection {
+  UNSPECIFIED_JOINT_NAVIGATION_DIRECTION = 0,
+  JOINT_NEXT = 1,
+  JOINT_PREVIOUS = 2,
+  JointNavigationDirection_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  JointNavigationDirection_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool JointNavigationDirection_IsValid(int value);
+const JointNavigationDirection JointNavigationDirection_MIN = UNSPECIFIED_JOINT_NAVIGATION_DIRECTION;
+const JointNavigationDirection JointNavigationDirection_MAX = JOINT_PREVIOUS;
+const int JointNavigationDirection_ARRAYSIZE = JointNavigationDirection_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* JointNavigationDirection_descriptor();
+inline const ::std::string& JointNavigationDirection_Name(JointNavigationDirection value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    JointNavigationDirection_descriptor(), value);
+}
+inline bool JointNavigationDirection_Parse(
+    const ::std::string& name, JointNavigationDirection* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<JointNavigationDirection>(
+    JointNavigationDirection_descriptor(), name, value);
+}
+enum GpioBehavior {
+  UNSPECIFIED_GPIO_BEHAVIOR = 0,
+  GPIO_FALLING = 1,
+  GPIO_RISING = 2,
+  GPIO_PULSE_LOW = 3,
+  GPIO_PULSE_HIGH = 4,
+  GPIO_ANALOG_CHANGE = 5,
+  GpioBehavior_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  GpioBehavior_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool GpioBehavior_IsValid(int value);
+const GpioBehavior GpioBehavior_MIN = UNSPECIFIED_GPIO_BEHAVIOR;
+const GpioBehavior GpioBehavior_MAX = GPIO_ANALOG_CHANGE;
+const int GpioBehavior_ARRAYSIZE = GpioBehavior_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* GpioBehavior_descriptor();
+inline const ::std::string& GpioBehavior_Name(GpioBehavior value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    GpioBehavior_descriptor(), value);
+}
+inline bool GpioBehavior_Parse(
+    const ::std::string& name, GpioBehavior* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<GpioBehavior>(
+    GpioBehavior_descriptor(), name, value);
+}
+enum Gen3GpioPinId {
+  UNSPECIFIED_PIN = 0,
+  GPIO_PIN_B = 1,
+  GPIO_PIN_C = 2,
+  GPIO_PIN_D = 3,
+  GPIO_PIN_E = 4,
+  GPIO_PIN_G = 5,
+  GPIO_PIN_H = 6,
+  GPIO_PIN_I = 7,
+  GPIO_PIN_K = 8,
+  GPIO_PIN_N = 9,
+  GPIO_PIN_O = 10,
+  GPIO_PIN_S = 11,
+  GPIO_PIN_T = 12,
+  Gen3GpioPinId_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  Gen3GpioPinId_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool Gen3GpioPinId_IsValid(int value);
+const Gen3GpioPinId Gen3GpioPinId_MIN = UNSPECIFIED_PIN;
+const Gen3GpioPinId Gen3GpioPinId_MAX = GPIO_PIN_T;
+const int Gen3GpioPinId_ARRAYSIZE = Gen3GpioPinId_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* Gen3GpioPinId_descriptor();
+inline const ::std::string& Gen3GpioPinId_Name(Gen3GpioPinId value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    Gen3GpioPinId_descriptor(), value);
+}
+inline bool Gen3GpioPinId_Parse(
+    const ::std::string& name, Gen3GpioPinId* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<Gen3GpioPinId>(
+    Gen3GpioPinId_descriptor(), name, value);
+}
+enum Xbox360DigitalInputIdentifier {
+  UNSPECIFIED_XBOX360_DIGITAL = 0,
+  XBOX360_PAD_UP = 1,
+  XBOX360_PAD_DOWN = 2,
+  XBOX360_PAD_LEFT = 3,
+  XBOX360_PAD_RIGHT = 4,
+  XBOX360_FILE_BUTTON_START = 5,
+  XBOX360_DOCUMENT_BUTTON_BACK = 6,
+  XBOX360_LEFT_THUMB_BUTTON = 7,
+  XBOX360_RIGHT_THUMB_BUTTON = 8,
+  XBOX360_LEFT_SHOULDER = 9,
+  XBOX360_RIGHT_SHOULDER = 10,
+  XBOX360_BUTTON_A = 13,
+  XBOX360_BUTTON_B = 14,
+  XBOX360_BUTTON_X = 15,
+  XBOX360_BUTTON_Y = 16,
+  Xbox360DigitalInputIdentifier_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  Xbox360DigitalInputIdentifier_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool Xbox360DigitalInputIdentifier_IsValid(int value);
+const Xbox360DigitalInputIdentifier Xbox360DigitalInputIdentifier_MIN = UNSPECIFIED_XBOX360_DIGITAL;
+const Xbox360DigitalInputIdentifier Xbox360DigitalInputIdentifier_MAX = XBOX360_BUTTON_Y;
+const int Xbox360DigitalInputIdentifier_ARRAYSIZE = Xbox360DigitalInputIdentifier_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* Xbox360DigitalInputIdentifier_descriptor();
+inline const ::std::string& Xbox360DigitalInputIdentifier_Name(Xbox360DigitalInputIdentifier value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    Xbox360DigitalInputIdentifier_descriptor(), value);
+}
+inline bool Xbox360DigitalInputIdentifier_Parse(
+    const ::std::string& name, Xbox360DigitalInputIdentifier* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<Xbox360DigitalInputIdentifier>(
+    Xbox360DigitalInputIdentifier_descriptor(), name, value);
+}
+enum Xbox360AnalogInputIdentifier {
+  UNSPECIFIED_XBOX360_ANALOG = 0,
+  XBOX360_THUMB_LEFT_X = 1,
+  XBOX360_THUMB_LEFT_Y = 2,
+  XBOX360_THUMB_RIGHT_X = 3,
+  XBOX360_THUMB_RIGHT_Y = 4,
+  XBOX360_TRIGGER_LEFT = 5,
+  XBOX360_TRIGGER_RIGHT = 6,
+  Xbox360AnalogInputIdentifier_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  Xbox360AnalogInputIdentifier_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool Xbox360AnalogInputIdentifier_IsValid(int value);
+const Xbox360AnalogInputIdentifier Xbox360AnalogInputIdentifier_MIN = UNSPECIFIED_XBOX360_ANALOG;
+const Xbox360AnalogInputIdentifier Xbox360AnalogInputIdentifier_MAX = XBOX360_TRIGGER_RIGHT;
+const int Xbox360AnalogInputIdentifier_ARRAYSIZE = Xbox360AnalogInputIdentifier_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* Xbox360AnalogInputIdentifier_descriptor();
+inline const ::std::string& Xbox360AnalogInputIdentifier_Name(Xbox360AnalogInputIdentifier value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    Xbox360AnalogInputIdentifier_descriptor(), value);
+}
+inline bool Xbox360AnalogInputIdentifier_Parse(
+    const ::std::string& name, Xbox360AnalogInputIdentifier* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<Xbox360AnalogInputIdentifier>(
+    Xbox360AnalogInputIdentifier_descriptor(), name, value);
+}
+enum WristDigitalInputIdentifier {
+  UNSPECIFIED_WRIST_DIGITAL = 0,
+  WRIST_BUTTON_1 = 1,
+  WRIST_BUTTON_2 = 2,
+  WRIST_BUTTON_BOTH = 3,
+  WristDigitalInputIdentifier_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  WristDigitalInputIdentifier_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool WristDigitalInputIdentifier_IsValid(int value);
+const WristDigitalInputIdentifier WristDigitalInputIdentifier_MIN = UNSPECIFIED_WRIST_DIGITAL;
+const WristDigitalInputIdentifier WristDigitalInputIdentifier_MAX = WRIST_BUTTON_BOTH;
+const int WristDigitalInputIdentifier_ARRAYSIZE = WristDigitalInputIdentifier_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* WristDigitalInputIdentifier_descriptor();
+inline const ::std::string& WristDigitalInputIdentifier_Name(WristDigitalInputIdentifier value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    WristDigitalInputIdentifier_descriptor(), value);
+}
+inline bool WristDigitalInputIdentifier_Parse(
+    const ::std::string& name, WristDigitalInputIdentifier* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<WristDigitalInputIdentifier>(
+    WristDigitalInputIdentifier_descriptor(), name, value);
+}
+enum CapSenseMode {
+  RESERVED = 0,
+  INACTIVE = 1,
+  ACTIVE_AUTO_THRESHOLD = 2,
+  ACTIVE_NOISE_ATT = 4,
+  ACTIVE_NORMAL = 5,
+  CONFIGURATION = 6,
+  CapSenseMode_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  CapSenseMode_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool CapSenseMode_IsValid(int value);
+const CapSenseMode CapSenseMode_MIN = RESERVED;
+const CapSenseMode CapSenseMode_MAX = CONFIGURATION;
+const int CapSenseMode_ARRAYSIZE = CapSenseMode_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* CapSenseMode_descriptor();
+inline const ::std::string& CapSenseMode_Name(CapSenseMode value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    CapSenseMode_descriptor(), value);
+}
+inline bool CapSenseMode_Parse(
+    const ::std::string& name, CapSenseMode* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<CapSenseMode>(
+    CapSenseMode_descriptor(), name, value);
+}
+enum BridgeStatus {
+  BRIDGE_STATUS_OK = 0,
+  BRIDGE_STATUS_OUTP_UNAVAILABLE = 1,
+  BRIDGE_STATUS_UNKNOWN_DEVID = 2,
+  BRIDGE_STATUS_UNKNOWN_BRIDGE_TYPE = 3,
+  BRIDGE_STATUS_NOT_FOUND = 4,
+  BRIDGE_STATUS_NOT_INITIALIZED = 5,
+  BRIDGE_STATUS_UNKNOWN = 6,
+  BridgeStatus_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  BridgeStatus_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool BridgeStatus_IsValid(int value);
+const BridgeStatus BridgeStatus_MIN = BRIDGE_STATUS_OK;
+const BridgeStatus BridgeStatus_MAX = BRIDGE_STATUS_UNKNOWN;
+const int BridgeStatus_ARRAYSIZE = BridgeStatus_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* BridgeStatus_descriptor();
+inline const ::std::string& BridgeStatus_Name(BridgeStatus value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    BridgeStatus_descriptor(), value);
+}
+inline bool BridgeStatus_Parse(
+    const ::std::string& name, BridgeStatus* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<BridgeStatus>(
+    BridgeStatus_descriptor(), name, value);
+}
+enum BridgeType {
+  BRIDGE_TYPE_UNSPECIFIED = 0,
+  BRIDGE_TYPE_UART = 1,
+  BRIDGE_TYPE_TELNET = 2,
+  BridgeType_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  BridgeType_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool BridgeType_IsValid(int value);
+const BridgeType BridgeType_MIN = BRIDGE_TYPE_UNSPECIFIED;
+const BridgeType BridgeType_MAX = BRIDGE_TYPE_TELNET;
+const int BridgeType_ARRAYSIZE = BridgeType_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* BridgeType_descriptor();
+inline const ::std::string& BridgeType_Name(BridgeType value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    BridgeType_descriptor(), value);
+}
+inline bool BridgeType_Parse(
+    const ::std::string& name, BridgeType* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<BridgeType>(
+    BridgeType_descriptor(), name, value);
+}
+enum TrajectoryContinuityMode {
+  TRAJECTORY_CONTINUITY_MODE_UNSPECIFIED = 0,
+  TRAJECTORY_CONTINUITY_MODE_POSITION = 1,
+  TRAJECTORY_CONTINUITY_MODE_SPEED = 2,
+  TRAJECTORY_CONTINUITY_MODE_ACCELERATION = 3,
+  TrajectoryContinuityMode_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  TrajectoryContinuityMode_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool TrajectoryContinuityMode_IsValid(int value);
+const TrajectoryContinuityMode TrajectoryContinuityMode_MIN = TRAJECTORY_CONTINUITY_MODE_UNSPECIFIED;
+const TrajectoryContinuityMode TrajectoryContinuityMode_MAX = TRAJECTORY_CONTINUITY_MODE_ACCELERATION;
+const int TrajectoryContinuityMode_ARRAYSIZE = TrajectoryContinuityMode_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* TrajectoryContinuityMode_descriptor();
+inline const ::std::string& TrajectoryContinuityMode_Name(TrajectoryContinuityMode value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    TrajectoryContinuityMode_descriptor(), value);
+}
+inline bool TrajectoryContinuityMode_Parse(
+    const ::std::string& name, TrajectoryContinuityMode* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<TrajectoryContinuityMode>(
+    TrajectoryContinuityMode_descriptor(), name, value);
+}
+enum TrajectoryErrorType {
+  TRAJECTORY_ERROR_TYPE_UNSPECIFIED = 0,
+  TRAJECTORY_ERROR_TYPE_OUTSIDE_WORKSPACE = 1,
+  TRAJECTORY_ERROR_TYPE_ACTUATOR_COUNT_MISMATCH = 2,
+  TRAJECTORY_ERROR_TYPE_INVALID_DURATION = 3,
+  TRAJECTORY_ERROR_TYPE_JOINT_NO_MOTION = 4,
+  TRAJECTORY_ERROR_TYPE_ZERO_DISTANCE PROTOBUF_DEPRECATED = 4,
+  TRAJECTORY_ERROR_TYPE_INVALID_JOINT_SPEED = 5,
+  TRAJECTORY_ERROR_TYPE_INVALID_SPEED PROTOBUF_DEPRECATED = 5,
+  TRAJECTORY_ERROR_TYPE_LARGE_SPEED PROTOBUF_DEPRECATED = 6,
+  TRAJECTORY_ERROR_TYPE_INVALID_JOINT_ACCELERATION = 7,
+  TRAJECTORY_ERROR_TYPE_INVALID_ACCELERATION PROTOBUF_DEPRECATED = 7,
+  TRAJECTORY_ERROR_TYPE_INVALID_TIME_STEP = 8,
+  TRAJECTORY_ERROR_TYPE_INVALID_TRAJECTORY_SIZE = 9,
+  TRAJECTORY_ERROR_TYPE_LARGE_SIZE PROTOBUF_DEPRECATED = 9,
+  TRAJECTORY_ERROR_TYPE_WRONG_MODE PROTOBUF_DEPRECATED = 10,
+  TRAJECTORY_ERROR_TYPE_INVALID_JOINT_POSITION = 11,
+  TRAJECTORY_ERROR_TYPE_JOINT_POSITION_LIMIT PROTOBUF_DEPRECATED = 11,
+  TRAJECTORY_ERROR_TYPE_FILE_ERROR PROTOBUF_DEPRECATED = 12,
+  TRAJECTORY_ERROR_TYPE_NO_FILE_IN_MEMORY PROTOBUF_DEPRECATED = 13,
+  TRAJECTORY_ERROR_TYPE_INDEX_OUT_OF_TRAJ PROTOBUF_DEPRECATED = 14,
+  TRAJECTORY_ERROR_TYPE_TRAJECTORY_ALREADY_RUNNING = 15,
+  TRAJECTORY_ERROR_TYPE_ALREADY_RUNNING PROTOBUF_DEPRECATED = 15,
+  TRAJECTORY_ERROR_TYPE_WRONG_STARTING_POINT PROTOBUF_DEPRECATED = 16,
+  TRAJECTORY_ERROR_TYPE_CARTESIAN_CANNOT_START PROTOBUF_DEPRECATED = 17,
+  TRAJECTORY_ERROR_TYPE_WRONG_STARTING_SPEED PROTOBUF_DEPRECATED = 18,
+  TRAJECTORY_ERROR_TYPE_INVALID_POSITION PROTOBUF_DEPRECATED = 19,
+  TRAJECTORY_ERROR_TYPE_INVALID_CARTESIAN_POSITION = 20,
+  TRAJECTORY_ERROR_TYPE_INVALID_CARTESIAN_ORIENTATION = 21,
+  TRAJECTORY_ERROR_TYPE_INVALID_CARTESIAN_LINEAR_VELOCITY = 22,
+  TRAJECTORY_ERROR_TYPE_INVALID_CARTESIAN_ANGULAR_VELOCITY = 23,
+  TRAJECTORY_ERROR_TYPE_INVALID_JOINT_TORQUE = 24,
+  TRAJECTORY_ERROR_TYPE_MULTIPLE_WAYPOINT_TYPE_LIST = 25,
+  TRAJECTORY_ERROR_TYPE_INITIAL_WAYPOINT_NO_STOP = 26,
+  TRAJECTORY_ERROR_TYPE_FINAL_WAYPOINT_NO_STOP = 27,
+  TRAJECTORY_ERROR_TYPE_INVALID_BLENDING_RADIUS = 28,
+  TRAJECTORY_ERROR_TYPE_INVALID_REFERENCE_FRAME = 29,
+  TRAJECTORY_ERROR_TYPE_NUMERICAL_ERROR_IMPOSSIBLE_TRAJECTORY = 30,
+  TrajectoryErrorType_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  TrajectoryErrorType_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool TrajectoryErrorType_IsValid(int value);
+const TrajectoryErrorType TrajectoryErrorType_MIN = TRAJECTORY_ERROR_TYPE_UNSPECIFIED;
+const TrajectoryErrorType TrajectoryErrorType_MAX = TRAJECTORY_ERROR_TYPE_NUMERICAL_ERROR_IMPOSSIBLE_TRAJECTORY;
+const int TrajectoryErrorType_ARRAYSIZE = TrajectoryErrorType_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* TrajectoryErrorType_descriptor();
+inline const ::std::string& TrajectoryErrorType_Name(TrajectoryErrorType value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    TrajectoryErrorType_descriptor(), value);
+}
+inline bool TrajectoryErrorType_Parse(
+    const ::std::string& name, TrajectoryErrorType* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<TrajectoryErrorType>(
+    TrajectoryErrorType_descriptor(), name, value);
+}
+enum TrajectoryInfoType {
+  UNSPECIFIED_TRAJECTORY_INFORMATION = 0,
+  JOINT_ACCELERATION_LIMIT_REACHED = 1,
+  JOINT_SPEED_LIMIT_REACHED = 2,
+  JOINT_POSITION_LIMIT_REACHED = 3,
+  JOINT_TORQUE_LIMIT_REACHED = 4,
+  SINGULARITY_REGION = 5,
+  INVERSE_KINEMATIC_FAILED = 6,
+  CARTESIAN_ACCELERATION_LIMIT_REACHED = 7,
+  CARTESIAN_SPEED_LIMIT_REACHED = 8,
+  CARTESIAN_POSITION_LIMIT_REACHED = 9,
+  CARTESIAN_WRENCH_LIMIT_REACHED = 10,
+  ENTERING_PROTECTION_ZONE = 11,
+  WAYPOINT_REACHED = 12,
+  TRAJECTORY_OK = 13,
+  TrajectoryInfoType_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  TrajectoryInfoType_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool TrajectoryInfoType_IsValid(int value);
+const TrajectoryInfoType TrajectoryInfoType_MIN = UNSPECIFIED_TRAJECTORY_INFORMATION;
+const TrajectoryInfoType TrajectoryInfoType_MAX = TRAJECTORY_OK;
+const int TrajectoryInfoType_ARRAYSIZE = TrajectoryInfoType_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* TrajectoryInfoType_descriptor();
+inline const ::std::string& TrajectoryInfoType_Name(TrajectoryInfoType value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    TrajectoryInfoType_descriptor(), value);
+}
+inline bool TrajectoryInfoType_Parse(
+    const ::std::string& name, TrajectoryInfoType* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<TrajectoryInfoType>(
+    TrajectoryInfoType_descriptor(), name, value);
+}
+// ===================================================================
+
+class GpioConfigurationList : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.GpioConfigurationList) */ {
+ public:
+  GpioConfigurationList();
+  virtual ~GpioConfigurationList();
+
+  GpioConfigurationList(const GpioConfigurationList& from);
+
+  inline GpioConfigurationList& operator=(const GpioConfigurationList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  GpioConfigurationList(GpioConfigurationList&& from) noexcept
+    : GpioConfigurationList() {
+    *this = ::std::move(from);
+  }
+
+  inline GpioConfigurationList& operator=(GpioConfigurationList&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const GpioConfigurationList& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const GpioConfigurationList* internal_default_instance() {
+    return reinterpret_cast<const GpioConfigurationList*>(
+               &_GpioConfigurationList_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    0;
+
+  void Swap(GpioConfigurationList* other);
+  friend void swap(GpioConfigurationList& a, GpioConfigurationList& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline GpioConfigurationList* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  GpioConfigurationList* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const GpioConfigurationList& from);
+  void MergeFrom(const GpioConfigurationList& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(GpioConfigurationList* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .Kinova.Api.Base.GpioConfiguration port_configurations = 1;
+  int port_configurations_size() const;
+  void clear_port_configurations();
+  static const int kPortConfigurationsFieldNumber = 1;
+  const ::Kinova::Api::Base::GpioConfiguration& port_configurations(int index) const;
+  ::Kinova::Api::Base::GpioConfiguration* mutable_port_configurations(int index);
+  ::Kinova::Api::Base::GpioConfiguration* add_port_configurations();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::GpioConfiguration >*
+      mutable_port_configurations();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::GpioConfiguration >&
+      port_configurations() const;
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.GpioConfigurationList)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::GpioConfiguration > port_configurations_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsGpioConfigurationListImpl();
+};
+// -------------------------------------------------------------------
+
+class GpioConfiguration : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.GpioConfiguration) */ {
+ public:
+  GpioConfiguration();
+  virtual ~GpioConfiguration();
+
+  GpioConfiguration(const GpioConfiguration& from);
+
+  inline GpioConfiguration& operator=(const GpioConfiguration& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  GpioConfiguration(GpioConfiguration&& from) noexcept
+    : GpioConfiguration() {
+    *this = ::std::move(from);
+  }
+
+  inline GpioConfiguration& operator=(GpioConfiguration&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const GpioConfiguration& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const GpioConfiguration* internal_default_instance() {
+    return reinterpret_cast<const GpioConfiguration*>(
+               &_GpioConfiguration_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    1;
+
+  void Swap(GpioConfiguration* other);
+  friend void swap(GpioConfiguration& a, GpioConfiguration& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline GpioConfiguration* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  GpioConfiguration* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const GpioConfiguration& from);
+  void MergeFrom(const GpioConfiguration& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(GpioConfiguration* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .Kinova.Api.Base.GpioPinConfiguration pin_configurations = 2;
+  int pin_configurations_size() const;
+  void clear_pin_configurations();
+  static const int kPinConfigurationsFieldNumber = 2;
+  const ::Kinova::Api::Base::GpioPinConfiguration& pin_configurations(int index) const;
+  ::Kinova::Api::Base::GpioPinConfiguration* mutable_pin_configurations(int index);
+  ::Kinova::Api::Base::GpioPinConfiguration* add_pin_configurations();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::GpioPinConfiguration >*
+      mutable_pin_configurations();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::GpioPinConfiguration >&
+      pin_configurations() const;
+
+  // uint32 port_number = 1;
+  void clear_port_number();
+  static const int kPortNumberFieldNumber = 1;
+  ::google::protobuf::uint32 port_number() const;
+  void set_port_number(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.GpioConfiguration)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::GpioPinConfiguration > pin_configurations_;
+  ::google::protobuf::uint32 port_number_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsGpioConfigurationImpl();
+};
+// -------------------------------------------------------------------
+
+class GpioPinConfiguration : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.GpioPinConfiguration) */ {
+ public:
+  GpioPinConfiguration();
+  virtual ~GpioPinConfiguration();
+
+  GpioPinConfiguration(const GpioPinConfiguration& from);
+
+  inline GpioPinConfiguration& operator=(const GpioPinConfiguration& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  GpioPinConfiguration(GpioPinConfiguration&& from) noexcept
+    : GpioPinConfiguration() {
+    *this = ::std::move(from);
+  }
+
+  inline GpioPinConfiguration& operator=(GpioPinConfiguration&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const GpioPinConfiguration& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const GpioPinConfiguration* internal_default_instance() {
+    return reinterpret_cast<const GpioPinConfiguration*>(
+               &_GpioPinConfiguration_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    2;
+
+  void Swap(GpioPinConfiguration* other);
+  friend void swap(GpioPinConfiguration& a, GpioPinConfiguration& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline GpioPinConfiguration* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  GpioPinConfiguration* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const GpioPinConfiguration& from);
+  void MergeFrom(const GpioPinConfiguration& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(GpioPinConfiguration* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // uint32 pin_id = 1;
+  void clear_pin_id();
+  static const int kPinIdFieldNumber = 1;
+  ::google::protobuf::uint32 pin_id() const;
+  void set_pin_id(::google::protobuf::uint32 value);
+
+  // .Kinova.Api.Base.GpioPinPropertyFlags pin_property = 2;
+  void clear_pin_property();
+  static const int kPinPropertyFieldNumber = 2;
+  ::Kinova::Api::Base::GpioPinPropertyFlags pin_property() const;
+  void set_pin_property(::Kinova::Api::Base::GpioPinPropertyFlags value);
+
+  // bool output_enable = 3;
+  void clear_output_enable();
+  static const int kOutputEnableFieldNumber = 3;
+  bool output_enable() const;
+  void set_output_enable(bool value);
+
+  // bool default_output_value = 4;
+  void clear_default_output_value();
+  static const int kDefaultOutputValueFieldNumber = 4;
+  bool default_output_value() const;
+  void set_default_output_value(bool value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.GpioPinConfiguration)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 pin_id_;
+  int pin_property_;
+  bool output_enable_;
+  bool default_output_value_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsGpioPinConfigurationImpl();
+};
+// -------------------------------------------------------------------
+
+class FullUserProfile : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.FullUserProfile) */ {
+ public:
+  FullUserProfile();
+  virtual ~FullUserProfile();
+
+  FullUserProfile(const FullUserProfile& from);
+
+  inline FullUserProfile& operator=(const FullUserProfile& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  FullUserProfile(FullUserProfile&& from) noexcept
+    : FullUserProfile() {
+    *this = ::std::move(from);
+  }
+
+  inline FullUserProfile& operator=(FullUserProfile&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const FullUserProfile& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const FullUserProfile* internal_default_instance() {
+    return reinterpret_cast<const FullUserProfile*>(
+               &_FullUserProfile_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    3;
+
+  void Swap(FullUserProfile* other);
+  friend void swap(FullUserProfile& a, FullUserProfile& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline FullUserProfile* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  FullUserProfile* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const FullUserProfile& from);
+  void MergeFrom(const FullUserProfile& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(FullUserProfile* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // string password = 2;
+  void clear_password();
+  static const int kPasswordFieldNumber = 2;
+  const ::std::string& password() const;
+  void set_password(const ::std::string& value);
+  #if LANG_CXX11
+  void set_password(::std::string&& value);
+  #endif
+  void set_password(const char* value);
+  void set_password(const char* value, size_t size);
+  ::std::string* mutable_password();
+  ::std::string* release_password();
+  void set_allocated_password(::std::string* password);
+
+  // .Kinova.Api.Base.UserProfile user_profile = 1;
+  bool has_user_profile() const;
+  void clear_user_profile();
+  static const int kUserProfileFieldNumber = 1;
+  const ::Kinova::Api::Base::UserProfile& user_profile() const;
+  ::Kinova::Api::Base::UserProfile* release_user_profile();
+  ::Kinova::Api::Base::UserProfile* mutable_user_profile();
+  void set_allocated_user_profile(::Kinova::Api::Base::UserProfile* user_profile);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.FullUserProfile)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::internal::ArenaStringPtr password_;
+  ::Kinova::Api::Base::UserProfile* user_profile_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsFullUserProfileImpl();
+};
+// -------------------------------------------------------------------
+
+class UserProfile : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.UserProfile) */ {
+ public:
+  UserProfile();
+  virtual ~UserProfile();
+
+  UserProfile(const UserProfile& from);
+
+  inline UserProfile& operator=(const UserProfile& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  UserProfile(UserProfile&& from) noexcept
+    : UserProfile() {
+    *this = ::std::move(from);
+  }
+
+  inline UserProfile& operator=(UserProfile&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const UserProfile& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const UserProfile* internal_default_instance() {
+    return reinterpret_cast<const UserProfile*>(
+               &_UserProfile_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    4;
+
+  void Swap(UserProfile* other);
+  friend void swap(UserProfile& a, UserProfile& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline UserProfile* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  UserProfile* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const UserProfile& from);
+  void MergeFrom(const UserProfile& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(UserProfile* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // string username = 2;
+  void clear_username();
+  static const int kUsernameFieldNumber = 2;
+  const ::std::string& username() const;
+  void set_username(const ::std::string& value);
+  #if LANG_CXX11
+  void set_username(::std::string&& value);
+  #endif
+  void set_username(const char* value);
+  void set_username(const char* value, size_t size);
+  ::std::string* mutable_username();
+  ::std::string* release_username();
+  void set_allocated_username(::std::string* username);
+
+  // string firstname = 3;
+  void clear_firstname();
+  static const int kFirstnameFieldNumber = 3;
+  const ::std::string& firstname() const;
+  void set_firstname(const ::std::string& value);
+  #if LANG_CXX11
+  void set_firstname(::std::string&& value);
+  #endif
+  void set_firstname(const char* value);
+  void set_firstname(const char* value, size_t size);
+  ::std::string* mutable_firstname();
+  ::std::string* release_firstname();
+  void set_allocated_firstname(::std::string* firstname);
+
+  // string lastname = 4;
+  void clear_lastname();
+  static const int kLastnameFieldNumber = 4;
+  const ::std::string& lastname() const;
+  void set_lastname(const ::std::string& value);
+  #if LANG_CXX11
+  void set_lastname(::std::string&& value);
+  #endif
+  void set_lastname(const char* value);
+  void set_lastname(const char* value, size_t size);
+  ::std::string* mutable_lastname();
+  ::std::string* release_lastname();
+  void set_allocated_lastname(::std::string* lastname);
+
+  // string application_data = 5;
+  void clear_application_data();
+  static const int kApplicationDataFieldNumber = 5;
+  const ::std::string& application_data() const;
+  void set_application_data(const ::std::string& value);
+  #if LANG_CXX11
+  void set_application_data(::std::string&& value);
+  #endif
+  void set_application_data(const char* value);
+  void set_application_data(const char* value, size_t size);
+  ::std::string* mutable_application_data();
+  ::std::string* release_application_data();
+  void set_allocated_application_data(::std::string* application_data);
+
+  // .Kinova.Api.Common.UserProfileHandle handle = 1;
+  bool has_handle() const;
+  void clear_handle();
+  static const int kHandleFieldNumber = 1;
+  const ::Kinova::Api::Common::UserProfileHandle& handle() const;
+  ::Kinova::Api::Common::UserProfileHandle* release_handle();
+  ::Kinova::Api::Common::UserProfileHandle* mutable_handle();
+  void set_allocated_handle(::Kinova::Api::Common::UserProfileHandle* handle);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.UserProfile)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::internal::ArenaStringPtr username_;
+  ::google::protobuf::internal::ArenaStringPtr firstname_;
+  ::google::protobuf::internal::ArenaStringPtr lastname_;
+  ::google::protobuf::internal::ArenaStringPtr application_data_;
+  ::Kinova::Api::Common::UserProfileHandle* handle_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsUserProfileImpl();
+};
+// -------------------------------------------------------------------
+
+class UserProfileList : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.UserProfileList) */ {
+ public:
+  UserProfileList();
+  virtual ~UserProfileList();
+
+  UserProfileList(const UserProfileList& from);
+
+  inline UserProfileList& operator=(const UserProfileList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  UserProfileList(UserProfileList&& from) noexcept
+    : UserProfileList() {
+    *this = ::std::move(from);
+  }
+
+  inline UserProfileList& operator=(UserProfileList&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const UserProfileList& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const UserProfileList* internal_default_instance() {
+    return reinterpret_cast<const UserProfileList*>(
+               &_UserProfileList_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    5;
+
+  void Swap(UserProfileList* other);
+  friend void swap(UserProfileList& a, UserProfileList& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline UserProfileList* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  UserProfileList* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const UserProfileList& from);
+  void MergeFrom(const UserProfileList& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(UserProfileList* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .Kinova.Api.Base.UserProfile user_profiles = 1;
+  int user_profiles_size() const;
+  void clear_user_profiles();
+  static const int kUserProfilesFieldNumber = 1;
+  const ::Kinova::Api::Base::UserProfile& user_profiles(int index) const;
+  ::Kinova::Api::Base::UserProfile* mutable_user_profiles(int index);
+  ::Kinova::Api::Base::UserProfile* add_user_profiles();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::UserProfile >*
+      mutable_user_profiles();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::UserProfile >&
+      user_profiles() const;
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.UserProfileList)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::UserProfile > user_profiles_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsUserProfileListImpl();
+};
+// -------------------------------------------------------------------
+
+class UserList : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.UserList) */ {
+ public:
+  UserList();
+  virtual ~UserList();
+
+  UserList(const UserList& from);
+
+  inline UserList& operator=(const UserList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  UserList(UserList&& from) noexcept
+    : UserList() {
+    *this = ::std::move(from);
+  }
+
+  inline UserList& operator=(UserList&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const UserList& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const UserList* internal_default_instance() {
+    return reinterpret_cast<const UserList*>(
+               &_UserList_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    6;
+
+  void Swap(UserList* other);
+  friend void swap(UserList& a, UserList& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline UserList* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  UserList* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const UserList& from);
+  void MergeFrom(const UserList& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(UserList* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .Kinova.Api.Common.UserProfileHandle user_handles = 1;
+  int user_handles_size() const;
+  void clear_user_handles();
+  static const int kUserHandlesFieldNumber = 1;
+  const ::Kinova::Api::Common::UserProfileHandle& user_handles(int index) const;
+  ::Kinova::Api::Common::UserProfileHandle* mutable_user_handles(int index);
+  ::Kinova::Api::Common::UserProfileHandle* add_user_handles();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Common::UserProfileHandle >*
+      mutable_user_handles();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Common::UserProfileHandle >&
+      user_handles() const;
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.UserList)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Common::UserProfileHandle > user_handles_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsUserListImpl();
+};
+// -------------------------------------------------------------------
+
+class PasswordChange : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.PasswordChange) */ {
+ public:
+  PasswordChange();
+  virtual ~PasswordChange();
+
+  PasswordChange(const PasswordChange& from);
+
+  inline PasswordChange& operator=(const PasswordChange& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  PasswordChange(PasswordChange&& from) noexcept
+    : PasswordChange() {
+    *this = ::std::move(from);
+  }
+
+  inline PasswordChange& operator=(PasswordChange&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const PasswordChange& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const PasswordChange* internal_default_instance() {
+    return reinterpret_cast<const PasswordChange*>(
+               &_PasswordChange_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    7;
+
+  void Swap(PasswordChange* other);
+  friend void swap(PasswordChange& a, PasswordChange& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline PasswordChange* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  PasswordChange* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const PasswordChange& from);
+  void MergeFrom(const PasswordChange& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(PasswordChange* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // string old_password = 2;
+  void clear_old_password();
+  static const int kOldPasswordFieldNumber = 2;
+  const ::std::string& old_password() const;
+  void set_old_password(const ::std::string& value);
+  #if LANG_CXX11
+  void set_old_password(::std::string&& value);
+  #endif
+  void set_old_password(const char* value);
+  void set_old_password(const char* value, size_t size);
+  ::std::string* mutable_old_password();
+  ::std::string* release_old_password();
+  void set_allocated_old_password(::std::string* old_password);
+
+  // string new_password = 3;
+  void clear_new_password();
+  static const int kNewPasswordFieldNumber = 3;
+  const ::std::string& new_password() const;
+  void set_new_password(const ::std::string& value);
+  #if LANG_CXX11
+  void set_new_password(::std::string&& value);
+  #endif
+  void set_new_password(const char* value);
+  void set_new_password(const char* value, size_t size);
+  ::std::string* mutable_new_password();
+  ::std::string* release_new_password();
+  void set_allocated_new_password(::std::string* new_password);
+
+  // .Kinova.Api.Common.UserProfileHandle handle = 1;
+  bool has_handle() const;
+  void clear_handle();
+  static const int kHandleFieldNumber = 1;
+  const ::Kinova::Api::Common::UserProfileHandle& handle() const;
+  ::Kinova::Api::Common::UserProfileHandle* release_handle();
+  ::Kinova::Api::Common::UserProfileHandle* mutable_handle();
+  void set_allocated_handle(::Kinova::Api::Common::UserProfileHandle* handle);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.PasswordChange)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::internal::ArenaStringPtr old_password_;
+  ::google::protobuf::internal::ArenaStringPtr new_password_;
+  ::Kinova::Api::Common::UserProfileHandle* handle_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsPasswordChangeImpl();
+};
+// -------------------------------------------------------------------
+
+class SequenceHandle : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.SequenceHandle) */ {
+ public:
+  SequenceHandle();
+  virtual ~SequenceHandle();
+
+  SequenceHandle(const SequenceHandle& from);
+
+  inline SequenceHandle& operator=(const SequenceHandle& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  SequenceHandle(SequenceHandle&& from) noexcept
+    : SequenceHandle() {
+    *this = ::std::move(from);
+  }
+
+  inline SequenceHandle& operator=(SequenceHandle&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SequenceHandle& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const SequenceHandle* internal_default_instance() {
+    return reinterpret_cast<const SequenceHandle*>(
+               &_SequenceHandle_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    8;
+
+  void Swap(SequenceHandle* other);
+  friend void swap(SequenceHandle& a, SequenceHandle& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SequenceHandle* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  SequenceHandle* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const SequenceHandle& from);
+  void MergeFrom(const SequenceHandle& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(SequenceHandle* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // uint32 identifier = 1;
+  void clear_identifier();
+  static const int kIdentifierFieldNumber = 1;
+  ::google::protobuf::uint32 identifier() const;
+  void set_identifier(::google::protobuf::uint32 value);
+
+  // fixed32 permission = 2;
+  void clear_permission();
+  static const int kPermissionFieldNumber = 2;
+  ::google::protobuf::uint32 permission() const;
+  void set_permission(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.SequenceHandle)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 identifier_;
+  ::google::protobuf::uint32 permission_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsSequenceHandleImpl();
+};
+// -------------------------------------------------------------------
+
+class AdvancedSequenceHandle : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.AdvancedSequenceHandle) */ {
+ public:
+  AdvancedSequenceHandle();
+  virtual ~AdvancedSequenceHandle();
+
+  AdvancedSequenceHandle(const AdvancedSequenceHandle& from);
+
+  inline AdvancedSequenceHandle& operator=(const AdvancedSequenceHandle& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  AdvancedSequenceHandle(AdvancedSequenceHandle&& from) noexcept
+    : AdvancedSequenceHandle() {
+    *this = ::std::move(from);
+  }
+
+  inline AdvancedSequenceHandle& operator=(AdvancedSequenceHandle&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const AdvancedSequenceHandle& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const AdvancedSequenceHandle* internal_default_instance() {
+    return reinterpret_cast<const AdvancedSequenceHandle*>(
+               &_AdvancedSequenceHandle_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    9;
+
+  void Swap(AdvancedSequenceHandle* other);
+  friend void swap(AdvancedSequenceHandle& a, AdvancedSequenceHandle& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline AdvancedSequenceHandle* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  AdvancedSequenceHandle* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const AdvancedSequenceHandle& from);
+  void MergeFrom(const AdvancedSequenceHandle& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(AdvancedSequenceHandle* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Base.SequenceHandle handle = 1;
+  bool has_handle() const;
+  void clear_handle();
+  static const int kHandleFieldNumber = 1;
+  const ::Kinova::Api::Base::SequenceHandle& handle() const;
+  ::Kinova::Api::Base::SequenceHandle* release_handle();
+  ::Kinova::Api::Base::SequenceHandle* mutable_handle();
+  void set_allocated_handle(::Kinova::Api::Base::SequenceHandle* handle);
+
+  // bool in_loop = 2;
+  void clear_in_loop();
+  static const int kInLoopFieldNumber = 2;
+  bool in_loop() const;
+  void set_in_loop(bool value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.AdvancedSequenceHandle)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::Base::SequenceHandle* handle_;
+  bool in_loop_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsAdvancedSequenceHandleImpl();
+};
+// -------------------------------------------------------------------
+
+class SequenceTaskHandle : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.SequenceTaskHandle) */ {
+ public:
+  SequenceTaskHandle();
+  virtual ~SequenceTaskHandle();
+
+  SequenceTaskHandle(const SequenceTaskHandle& from);
+
+  inline SequenceTaskHandle& operator=(const SequenceTaskHandle& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  SequenceTaskHandle(SequenceTaskHandle&& from) noexcept
+    : SequenceTaskHandle() {
+    *this = ::std::move(from);
+  }
+
+  inline SequenceTaskHandle& operator=(SequenceTaskHandle&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SequenceTaskHandle& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const SequenceTaskHandle* internal_default_instance() {
+    return reinterpret_cast<const SequenceTaskHandle*>(
+               &_SequenceTaskHandle_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    10;
+
+  void Swap(SequenceTaskHandle* other);
+  friend void swap(SequenceTaskHandle& a, SequenceTaskHandle& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SequenceTaskHandle* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  SequenceTaskHandle* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const SequenceTaskHandle& from);
+  void MergeFrom(const SequenceTaskHandle& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(SequenceTaskHandle* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Base.SequenceHandle sequence_handle = 1;
+  bool has_sequence_handle() const;
+  void clear_sequence_handle();
+  static const int kSequenceHandleFieldNumber = 1;
+  const ::Kinova::Api::Base::SequenceHandle& sequence_handle() const;
+  ::Kinova::Api::Base::SequenceHandle* release_sequence_handle();
+  ::Kinova::Api::Base::SequenceHandle* mutable_sequence_handle();
+  void set_allocated_sequence_handle(::Kinova::Api::Base::SequenceHandle* sequence_handle);
+
+  // uint32 task_index = 2;
+  void clear_task_index();
+  static const int kTaskIndexFieldNumber = 2;
+  ::google::protobuf::uint32 task_index() const;
+  void set_task_index(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.SequenceTaskHandle)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::Base::SequenceHandle* sequence_handle_;
+  ::google::protobuf::uint32 task_index_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsSequenceTaskHandleImpl();
+};
+// -------------------------------------------------------------------
+
+class SequenceTask : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.SequenceTask) */ {
+ public:
+  SequenceTask();
+  virtual ~SequenceTask();
+
+  SequenceTask(const SequenceTask& from);
+
+  inline SequenceTask& operator=(const SequenceTask& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  SequenceTask(SequenceTask&& from) noexcept
+    : SequenceTask() {
+    *this = ::std::move(from);
+  }
+
+  inline SequenceTask& operator=(SequenceTask&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SequenceTask& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const SequenceTask* internal_default_instance() {
+    return reinterpret_cast<const SequenceTask*>(
+               &_SequenceTask_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    11;
+
+  void Swap(SequenceTask* other);
+  friend void swap(SequenceTask& a, SequenceTask& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SequenceTask* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  SequenceTask* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const SequenceTask& from);
+  void MergeFrom(const SequenceTask& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(SequenceTask* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // string application_data = 3;
+  void clear_application_data();
+  static const int kApplicationDataFieldNumber = 3;
+  const ::std::string& application_data() const;
+  void set_application_data(const ::std::string& value);
+  #if LANG_CXX11
+  void set_application_data(::std::string&& value);
+  #endif
+  void set_application_data(const char* value);
+  void set_application_data(const char* value, size_t size);
+  ::std::string* mutable_application_data();
+  ::std::string* release_application_data();
+  void set_allocated_application_data(::std::string* application_data);
+
+  // .Kinova.Api.Base.Action action = 2;
+  bool has_action() const;
+  void clear_action();
+  static const int kActionFieldNumber = 2;
+  const ::Kinova::Api::Base::Action& action() const;
+  ::Kinova::Api::Base::Action* release_action();
+  ::Kinova::Api::Base::Action* mutable_action();
+  void set_allocated_action(::Kinova::Api::Base::Action* action);
+
+  // uint32 group_identifier = 1;
+  void clear_group_identifier();
+  static const int kGroupIdentifierFieldNumber = 1;
+  ::google::protobuf::uint32 group_identifier() const;
+  void set_group_identifier(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.SequenceTask)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::internal::ArenaStringPtr application_data_;
+  ::Kinova::Api::Base::Action* action_;
+  ::google::protobuf::uint32 group_identifier_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsSequenceTaskImpl();
+};
+// -------------------------------------------------------------------
+
+class SequenceTasks : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.SequenceTasks) */ {
+ public:
+  SequenceTasks();
+  virtual ~SequenceTasks();
+
+  SequenceTasks(const SequenceTasks& from);
+
+  inline SequenceTasks& operator=(const SequenceTasks& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  SequenceTasks(SequenceTasks&& from) noexcept
+    : SequenceTasks() {
+    *this = ::std::move(from);
+  }
+
+  inline SequenceTasks& operator=(SequenceTasks&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SequenceTasks& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const SequenceTasks* internal_default_instance() {
+    return reinterpret_cast<const SequenceTasks*>(
+               &_SequenceTasks_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    12;
+
+  void Swap(SequenceTasks* other);
+  friend void swap(SequenceTasks& a, SequenceTasks& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SequenceTasks* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  SequenceTasks* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const SequenceTasks& from);
+  void MergeFrom(const SequenceTasks& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(SequenceTasks* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .Kinova.Api.Base.SequenceTask sequence_tasks = 1;
+  int sequence_tasks_size() const;
+  void clear_sequence_tasks();
+  static const int kSequenceTasksFieldNumber = 1;
+  const ::Kinova::Api::Base::SequenceTask& sequence_tasks(int index) const;
+  ::Kinova::Api::Base::SequenceTask* mutable_sequence_tasks(int index);
+  ::Kinova::Api::Base::SequenceTask* add_sequence_tasks();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::SequenceTask >*
+      mutable_sequence_tasks();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::SequenceTask >&
+      sequence_tasks() const;
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.SequenceTasks)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::SequenceTask > sequence_tasks_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsSequenceTasksImpl();
+};
+// -------------------------------------------------------------------
+
+class SequenceTasksConfiguration : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.SequenceTasksConfiguration) */ {
+ public:
+  SequenceTasksConfiguration();
+  virtual ~SequenceTasksConfiguration();
+
+  SequenceTasksConfiguration(const SequenceTasksConfiguration& from);
+
+  inline SequenceTasksConfiguration& operator=(const SequenceTasksConfiguration& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  SequenceTasksConfiguration(SequenceTasksConfiguration&& from) noexcept
+    : SequenceTasksConfiguration() {
+    *this = ::std::move(from);
+  }
+
+  inline SequenceTasksConfiguration& operator=(SequenceTasksConfiguration&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SequenceTasksConfiguration& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const SequenceTasksConfiguration* internal_default_instance() {
+    return reinterpret_cast<const SequenceTasksConfiguration*>(
+               &_SequenceTasksConfiguration_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    13;
+
+  void Swap(SequenceTasksConfiguration* other);
+  friend void swap(SequenceTasksConfiguration& a, SequenceTasksConfiguration& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SequenceTasksConfiguration* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  SequenceTasksConfiguration* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const SequenceTasksConfiguration& from);
+  void MergeFrom(const SequenceTasksConfiguration& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(SequenceTasksConfiguration* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .Kinova.Api.Base.SequenceTask sequence_tasks = 2;
+  int sequence_tasks_size() const;
+  void clear_sequence_tasks();
+  static const int kSequenceTasksFieldNumber = 2;
+  const ::Kinova::Api::Base::SequenceTask& sequence_tasks(int index) const;
+  ::Kinova::Api::Base::SequenceTask* mutable_sequence_tasks(int index);
+  ::Kinova::Api::Base::SequenceTask* add_sequence_tasks();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::SequenceTask >*
+      mutable_sequence_tasks();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::SequenceTask >&
+      sequence_tasks() const;
+
+  // .Kinova.Api.Base.SequenceTaskHandle sequence_task_handle = 1;
+  bool has_sequence_task_handle() const;
+  void clear_sequence_task_handle();
+  static const int kSequenceTaskHandleFieldNumber = 1;
+  const ::Kinova::Api::Base::SequenceTaskHandle& sequence_task_handle() const;
+  ::Kinova::Api::Base::SequenceTaskHandle* release_sequence_task_handle();
+  ::Kinova::Api::Base::SequenceTaskHandle* mutable_sequence_task_handle();
+  void set_allocated_sequence_task_handle(::Kinova::Api::Base::SequenceTaskHandle* sequence_task_handle);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.SequenceTasksConfiguration)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::SequenceTask > sequence_tasks_;
+  ::Kinova::Api::Base::SequenceTaskHandle* sequence_task_handle_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsSequenceTasksConfigurationImpl();
+};
+// -------------------------------------------------------------------
+
+class SequenceTaskConfiguration : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.SequenceTaskConfiguration) */ {
+ public:
+  SequenceTaskConfiguration();
+  virtual ~SequenceTaskConfiguration();
+
+  SequenceTaskConfiguration(const SequenceTaskConfiguration& from);
+
+  inline SequenceTaskConfiguration& operator=(const SequenceTaskConfiguration& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  SequenceTaskConfiguration(SequenceTaskConfiguration&& from) noexcept
+    : SequenceTaskConfiguration() {
+    *this = ::std::move(from);
+  }
+
+  inline SequenceTaskConfiguration& operator=(SequenceTaskConfiguration&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SequenceTaskConfiguration& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const SequenceTaskConfiguration* internal_default_instance() {
+    return reinterpret_cast<const SequenceTaskConfiguration*>(
+               &_SequenceTaskConfiguration_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    14;
+
+  void Swap(SequenceTaskConfiguration* other);
+  friend void swap(SequenceTaskConfiguration& a, SequenceTaskConfiguration& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SequenceTaskConfiguration* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  SequenceTaskConfiguration* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const SequenceTaskConfiguration& from);
+  void MergeFrom(const SequenceTaskConfiguration& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(SequenceTaskConfiguration* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Base.SequenceTaskHandle sequence_task_handle = 1;
+  bool has_sequence_task_handle() const;
+  void clear_sequence_task_handle();
+  static const int kSequenceTaskHandleFieldNumber = 1;
+  const ::Kinova::Api::Base::SequenceTaskHandle& sequence_task_handle() const;
+  ::Kinova::Api::Base::SequenceTaskHandle* release_sequence_task_handle();
+  ::Kinova::Api::Base::SequenceTaskHandle* mutable_sequence_task_handle();
+  void set_allocated_sequence_task_handle(::Kinova::Api::Base::SequenceTaskHandle* sequence_task_handle);
+
+  // .Kinova.Api.Base.SequenceTask sequence_task = 2;
+  bool has_sequence_task() const;
+  void clear_sequence_task();
+  static const int kSequenceTaskFieldNumber = 2;
+  const ::Kinova::Api::Base::SequenceTask& sequence_task() const;
+  ::Kinova::Api::Base::SequenceTask* release_sequence_task();
+  ::Kinova::Api::Base::SequenceTask* mutable_sequence_task();
+  void set_allocated_sequence_task(::Kinova::Api::Base::SequenceTask* sequence_task);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.SequenceTaskConfiguration)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::Base::SequenceTaskHandle* sequence_task_handle_;
+  ::Kinova::Api::Base::SequenceTask* sequence_task_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsSequenceTaskConfigurationImpl();
+};
+// -------------------------------------------------------------------
+
+class SequenceTasksRange : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.SequenceTasksRange) */ {
+ public:
+  SequenceTasksRange();
+  virtual ~SequenceTasksRange();
+
+  SequenceTasksRange(const SequenceTasksRange& from);
+
+  inline SequenceTasksRange& operator=(const SequenceTasksRange& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  SequenceTasksRange(SequenceTasksRange&& from) noexcept
+    : SequenceTasksRange() {
+    *this = ::std::move(from);
+  }
+
+  inline SequenceTasksRange& operator=(SequenceTasksRange&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SequenceTasksRange& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const SequenceTasksRange* internal_default_instance() {
+    return reinterpret_cast<const SequenceTasksRange*>(
+               &_SequenceTasksRange_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    15;
+
+  void Swap(SequenceTasksRange* other);
+  friend void swap(SequenceTasksRange& a, SequenceTasksRange& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SequenceTasksRange* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  SequenceTasksRange* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const SequenceTasksRange& from);
+  void MergeFrom(const SequenceTasksRange& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(SequenceTasksRange* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // uint32 first_task_index = 1;
+  void clear_first_task_index();
+  static const int kFirstTaskIndexFieldNumber = 1;
+  ::google::protobuf::uint32 first_task_index() const;
+  void set_first_task_index(::google::protobuf::uint32 value);
+
+  // uint32 second_task_index = 2;
+  void clear_second_task_index();
+  static const int kSecondTaskIndexFieldNumber = 2;
+  ::google::protobuf::uint32 second_task_index() const;
+  void set_second_task_index(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.SequenceTasksRange)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 first_task_index_;
+  ::google::protobuf::uint32 second_task_index_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsSequenceTasksRangeImpl();
+};
+// -------------------------------------------------------------------
+
+class SequenceTasksPair : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.SequenceTasksPair) */ {
+ public:
+  SequenceTasksPair();
+  virtual ~SequenceTasksPair();
+
+  SequenceTasksPair(const SequenceTasksPair& from);
+
+  inline SequenceTasksPair& operator=(const SequenceTasksPair& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  SequenceTasksPair(SequenceTasksPair&& from) noexcept
+    : SequenceTasksPair() {
+    *this = ::std::move(from);
+  }
+
+  inline SequenceTasksPair& operator=(SequenceTasksPair&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SequenceTasksPair& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const SequenceTasksPair* internal_default_instance() {
+    return reinterpret_cast<const SequenceTasksPair*>(
+               &_SequenceTasksPair_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    16;
+
+  void Swap(SequenceTasksPair* other);
+  friend void swap(SequenceTasksPair& a, SequenceTasksPair& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SequenceTasksPair* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  SequenceTasksPair* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const SequenceTasksPair& from);
+  void MergeFrom(const SequenceTasksPair& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(SequenceTasksPair* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Base.SequenceHandle sequence_handle = 1;
+  bool has_sequence_handle() const;
+  void clear_sequence_handle();
+  static const int kSequenceHandleFieldNumber = 1;
+  const ::Kinova::Api::Base::SequenceHandle& sequence_handle() const;
+  ::Kinova::Api::Base::SequenceHandle* release_sequence_handle();
+  ::Kinova::Api::Base::SequenceHandle* mutable_sequence_handle();
+  void set_allocated_sequence_handle(::Kinova::Api::Base::SequenceHandle* sequence_handle);
+
+  // uint32 first_task_index = 2;
+  void clear_first_task_index();
+  static const int kFirstTaskIndexFieldNumber = 2;
+  ::google::protobuf::uint32 first_task_index() const;
+  void set_first_task_index(::google::protobuf::uint32 value);
+
+  // uint32 second_task_index = 3;
+  void clear_second_task_index();
+  static const int kSecondTaskIndexFieldNumber = 3;
+  ::google::protobuf::uint32 second_task_index() const;
+  void set_second_task_index(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.SequenceTasksPair)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::Base::SequenceHandle* sequence_handle_;
+  ::google::protobuf::uint32 first_task_index_;
+  ::google::protobuf::uint32 second_task_index_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsSequenceTasksPairImpl();
+};
+// -------------------------------------------------------------------
+
+class Sequence : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.Sequence) */ {
+ public:
+  Sequence();
+  virtual ~Sequence();
+
+  Sequence(const Sequence& from);
+
+  inline Sequence& operator=(const Sequence& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Sequence(Sequence&& from) noexcept
+    : Sequence() {
+    *this = ::std::move(from);
+  }
+
+  inline Sequence& operator=(Sequence&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Sequence& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Sequence* internal_default_instance() {
+    return reinterpret_cast<const Sequence*>(
+               &_Sequence_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    17;
+
+  void Swap(Sequence* other);
+  friend void swap(Sequence& a, Sequence& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Sequence* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Sequence* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Sequence& from);
+  void MergeFrom(const Sequence& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Sequence* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .Kinova.Api.Base.SequenceTask tasks = 4;
+  int tasks_size() const;
+  void clear_tasks();
+  static const int kTasksFieldNumber = 4;
+  const ::Kinova::Api::Base::SequenceTask& tasks(int index) const;
+  ::Kinova::Api::Base::SequenceTask* mutable_tasks(int index);
+  ::Kinova::Api::Base::SequenceTask* add_tasks();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::SequenceTask >*
+      mutable_tasks();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::SequenceTask >&
+      tasks() const;
+
+  // string name = 2;
+  void clear_name();
+  static const int kNameFieldNumber = 2;
+  const ::std::string& name() const;
+  void set_name(const ::std::string& value);
+  #if LANG_CXX11
+  void set_name(::std::string&& value);
+  #endif
+  void set_name(const char* value);
+  void set_name(const char* value, size_t size);
+  ::std::string* mutable_name();
+  ::std::string* release_name();
+  void set_allocated_name(::std::string* name);
+
+  // string application_data = 3;
+  void clear_application_data();
+  static const int kApplicationDataFieldNumber = 3;
+  const ::std::string& application_data() const;
+  void set_application_data(const ::std::string& value);
+  #if LANG_CXX11
+  void set_application_data(::std::string&& value);
+  #endif
+  void set_application_data(const char* value);
+  void set_application_data(const char* value, size_t size);
+  ::std::string* mutable_application_data();
+  ::std::string* release_application_data();
+  void set_allocated_application_data(::std::string* application_data);
+
+  // .Kinova.Api.Base.SequenceHandle handle = 1;
+  bool has_handle() const;
+  void clear_handle();
+  static const int kHandleFieldNumber = 1;
+  const ::Kinova::Api::Base::SequenceHandle& handle() const;
+  ::Kinova::Api::Base::SequenceHandle* release_handle();
+  ::Kinova::Api::Base::SequenceHandle* mutable_handle();
+  void set_allocated_handle(::Kinova::Api::Base::SequenceHandle* handle);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.Sequence)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::SequenceTask > tasks_;
+  ::google::protobuf::internal::ArenaStringPtr name_;
+  ::google::protobuf::internal::ArenaStringPtr application_data_;
+  ::Kinova::Api::Base::SequenceHandle* handle_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsSequenceImpl();
+};
+// -------------------------------------------------------------------
+
+class SequenceList : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.SequenceList) */ {
+ public:
+  SequenceList();
+  virtual ~SequenceList();
+
+  SequenceList(const SequenceList& from);
+
+  inline SequenceList& operator=(const SequenceList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  SequenceList(SequenceList&& from) noexcept
+    : SequenceList() {
+    *this = ::std::move(from);
+  }
+
+  inline SequenceList& operator=(SequenceList&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SequenceList& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const SequenceList* internal_default_instance() {
+    return reinterpret_cast<const SequenceList*>(
+               &_SequenceList_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    18;
+
+  void Swap(SequenceList* other);
+  friend void swap(SequenceList& a, SequenceList& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SequenceList* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  SequenceList* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const SequenceList& from);
+  void MergeFrom(const SequenceList& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(SequenceList* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .Kinova.Api.Base.Sequence sequence_list = 1;
+  int sequence_list_size() const;
+  void clear_sequence_list();
+  static const int kSequenceListFieldNumber = 1;
+  const ::Kinova::Api::Base::Sequence& sequence_list(int index) const;
+  ::Kinova::Api::Base::Sequence* mutable_sequence_list(int index);
+  ::Kinova::Api::Base::Sequence* add_sequence_list();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::Sequence >*
+      mutable_sequence_list();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::Sequence >&
+      sequence_list() const;
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.SequenceList)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::Sequence > sequence_list_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsSequenceListImpl();
+};
+// -------------------------------------------------------------------
+
+class ActionHandle : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.ActionHandle) */ {
+ public:
+  ActionHandle();
+  virtual ~ActionHandle();
+
+  ActionHandle(const ActionHandle& from);
+
+  inline ActionHandle& operator=(const ActionHandle& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ActionHandle(ActionHandle&& from) noexcept
+    : ActionHandle() {
+    *this = ::std::move(from);
+  }
+
+  inline ActionHandle& operator=(ActionHandle&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ActionHandle& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ActionHandle* internal_default_instance() {
+    return reinterpret_cast<const ActionHandle*>(
+               &_ActionHandle_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    19;
+
+  void Swap(ActionHandle* other);
+  friend void swap(ActionHandle& a, ActionHandle& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ActionHandle* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ActionHandle* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ActionHandle& from);
+  void MergeFrom(const ActionHandle& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ActionHandle* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // uint32 identifier = 1;
+  void clear_identifier();
+  static const int kIdentifierFieldNumber = 1;
+  ::google::protobuf::uint32 identifier() const;
+  void set_identifier(::google::protobuf::uint32 value);
+
+  // .Kinova.Api.Base.ActionType action_type = 2;
+  void clear_action_type();
+  static const int kActionTypeFieldNumber = 2;
+  ::Kinova::Api::Base::ActionType action_type() const;
+  void set_action_type(::Kinova::Api::Base::ActionType value);
+
+  // fixed32 permission = 3;
+  void clear_permission();
+  static const int kPermissionFieldNumber = 3;
+  ::google::protobuf::uint32 permission() const;
+  void set_permission(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.ActionHandle)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 identifier_;
+  int action_type_;
+  ::google::protobuf::uint32 permission_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsActionHandleImpl();
+};
+// -------------------------------------------------------------------
+
+class RequestedActionType : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.RequestedActionType) */ {
+ public:
+  RequestedActionType();
+  virtual ~RequestedActionType();
+
+  RequestedActionType(const RequestedActionType& from);
+
+  inline RequestedActionType& operator=(const RequestedActionType& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  RequestedActionType(RequestedActionType&& from) noexcept
+    : RequestedActionType() {
+    *this = ::std::move(from);
+  }
+
+  inline RequestedActionType& operator=(RequestedActionType&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const RequestedActionType& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const RequestedActionType* internal_default_instance() {
+    return reinterpret_cast<const RequestedActionType*>(
+               &_RequestedActionType_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    20;
+
+  void Swap(RequestedActionType* other);
+  friend void swap(RequestedActionType& a, RequestedActionType& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline RequestedActionType* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  RequestedActionType* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const RequestedActionType& from);
+  void MergeFrom(const RequestedActionType& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(RequestedActionType* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Base.ActionType action_type = 1;
+  void clear_action_type();
+  static const int kActionTypeFieldNumber = 1;
+  ::Kinova::Api::Base::ActionType action_type() const;
+  void set_action_type(::Kinova::Api::Base::ActionType value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.RequestedActionType)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  int action_type_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsRequestedActionTypeImpl();
+};
+// -------------------------------------------------------------------
+
+class Action : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.Action) */ {
+ public:
+  Action();
+  virtual ~Action();
+
+  Action(const Action& from);
+
+  inline Action& operator=(const Action& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Action(Action&& from) noexcept
+    : Action() {
+    *this = ::std::move(from);
+  }
+
+  inline Action& operator=(Action&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Action& default_instance();
+
+  enum ActionParametersCase {
+    kSendTwistCommand = 4,
+    kSendWrenchCommand = 5,
+    kSendJointSpeeds = 7,
+    kReachPose = 9,
+    kReachJointAngles = 10,
+    kToggleAdmittanceMode = 16,
+    kSnapshot = 17,
+    kSwitchControlMapping = 19,
+    kNavigateJoints = 20,
+    kNavigateMappings = 21,
+    kChangeTwist = 25,
+    kChangeJointSpeeds = 26,
+    kChangeWrench = 28,
+    kApplyEmergencyStop = 31,
+    kClearFaults = 32,
+    kDelay = 34,
+    kExecuteAction = 35,
+    kSendGripperCommand = 36,
+    kSendGpioCommand = 37,
+    kStopAction = 38,
+    kPlayPreComputedTrajectory = 39,
+    kExecuteSequence = 40,
+    kExecuteWaypointList = 41,
+    ACTION_PARAMETERS_NOT_SET = 0,
+  };
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Action* internal_default_instance() {
+    return reinterpret_cast<const Action*>(
+               &_Action_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    21;
+
+  void Swap(Action* other);
+  friend void swap(Action& a, Action& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Action* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Action* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Action& from);
+  void MergeFrom(const Action& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Action* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // string name = 2;
+  void clear_name();
+  static const int kNameFieldNumber = 2;
+  const ::std::string& name() const;
+  void set_name(const ::std::string& value);
+  #if LANG_CXX11
+  void set_name(::std::string&& value);
+  #endif
+  void set_name(const char* value);
+  void set_name(const char* value, size_t size);
+  ::std::string* mutable_name();
+  ::std::string* release_name();
+  void set_allocated_name(::std::string* name);
+
+  // string application_data = 3;
+  void clear_application_data();
+  static const int kApplicationDataFieldNumber = 3;
+  const ::std::string& application_data() const;
+  void set_application_data(const ::std::string& value);
+  #if LANG_CXX11
+  void set_application_data(::std::string&& value);
+  #endif
+  void set_application_data(const char* value);
+  void set_application_data(const char* value, size_t size);
+  ::std::string* mutable_application_data();
+  ::std::string* release_application_data();
+  void set_allocated_application_data(::std::string* application_data);
+
+  // .Kinova.Api.Base.ActionHandle handle = 1;
+  bool has_handle() const;
+  void clear_handle();
+  static const int kHandleFieldNumber = 1;
+  const ::Kinova::Api::Base::ActionHandle& handle() const;
+  ::Kinova::Api::Base::ActionHandle* release_handle();
+  ::Kinova::Api::Base::ActionHandle* mutable_handle();
+  void set_allocated_handle(::Kinova::Api::Base::ActionHandle* handle);
+
+  // .Kinova.Api.Base.TwistCommand send_twist_command = 4;
+  bool has_send_twist_command() const;
+  void clear_send_twist_command();
+  static const int kSendTwistCommandFieldNumber = 4;
+  const ::Kinova::Api::Base::TwistCommand& send_twist_command() const;
+  ::Kinova::Api::Base::TwistCommand* release_send_twist_command();
+  ::Kinova::Api::Base::TwistCommand* mutable_send_twist_command();
+  void set_allocated_send_twist_command(::Kinova::Api::Base::TwistCommand* send_twist_command);
+
+  // .Kinova.Api.Base.WrenchCommand send_wrench_command = 5;
+  bool has_send_wrench_command() const;
+  void clear_send_wrench_command();
+  static const int kSendWrenchCommandFieldNumber = 5;
+  const ::Kinova::Api::Base::WrenchCommand& send_wrench_command() const;
+  ::Kinova::Api::Base::WrenchCommand* release_send_wrench_command();
+  ::Kinova::Api::Base::WrenchCommand* mutable_send_wrench_command();
+  void set_allocated_send_wrench_command(::Kinova::Api::Base::WrenchCommand* send_wrench_command);
+
+  // .Kinova.Api.Base.JointSpeeds send_joint_speeds = 7;
+  bool has_send_joint_speeds() const;
+  void clear_send_joint_speeds();
+  static const int kSendJointSpeedsFieldNumber = 7;
+  const ::Kinova::Api::Base::JointSpeeds& send_joint_speeds() const;
+  ::Kinova::Api::Base::JointSpeeds* release_send_joint_speeds();
+  ::Kinova::Api::Base::JointSpeeds* mutable_send_joint_speeds();
+  void set_allocated_send_joint_speeds(::Kinova::Api::Base::JointSpeeds* send_joint_speeds);
+
+  // .Kinova.Api.Base.ConstrainedPose reach_pose = 9;
+  bool has_reach_pose() const;
+  void clear_reach_pose();
+  static const int kReachPoseFieldNumber = 9;
+  const ::Kinova::Api::Base::ConstrainedPose& reach_pose() const;
+  ::Kinova::Api::Base::ConstrainedPose* release_reach_pose();
+  ::Kinova::Api::Base::ConstrainedPose* mutable_reach_pose();
+  void set_allocated_reach_pose(::Kinova::Api::Base::ConstrainedPose* reach_pose);
+
+  // .Kinova.Api.Base.ConstrainedJointAngles reach_joint_angles = 10;
+  bool has_reach_joint_angles() const;
+  void clear_reach_joint_angles();
+  static const int kReachJointAnglesFieldNumber = 10;
+  const ::Kinova::Api::Base::ConstrainedJointAngles& reach_joint_angles() const;
+  ::Kinova::Api::Base::ConstrainedJointAngles* release_reach_joint_angles();
+  ::Kinova::Api::Base::ConstrainedJointAngles* mutable_reach_joint_angles();
+  void set_allocated_reach_joint_angles(::Kinova::Api::Base::ConstrainedJointAngles* reach_joint_angles);
+
+  // .Kinova.Api.Base.AdmittanceMode toggle_admittance_mode = 16;
+  private:
+  bool has_toggle_admittance_mode() const;
+  public:
+  void clear_toggle_admittance_mode();
+  static const int kToggleAdmittanceModeFieldNumber = 16;
+  ::Kinova::Api::Base::AdmittanceMode toggle_admittance_mode() const;
+  void set_toggle_admittance_mode(::Kinova::Api::Base::AdmittanceMode value);
+
+  // .Kinova.Api.Base.Snapshot snapshot = 17;
+  bool has_snapshot() const;
+  void clear_snapshot();
+  static const int kSnapshotFieldNumber = 17;
+  const ::Kinova::Api::Base::Snapshot& snapshot() const;
+  ::Kinova::Api::Base::Snapshot* release_snapshot();
+  ::Kinova::Api::Base::Snapshot* mutable_snapshot();
+  void set_allocated_snapshot(::Kinova::Api::Base::Snapshot* snapshot);
+
+  // .Kinova.Api.Base.SwitchControlMapping switch_control_mapping = 19;
+  bool has_switch_control_mapping() const;
+  void clear_switch_control_mapping();
+  static const int kSwitchControlMappingFieldNumber = 19;
+  const ::Kinova::Api::Base::SwitchControlMapping& switch_control_mapping() const;
+  ::Kinova::Api::Base::SwitchControlMapping* release_switch_control_mapping();
+  ::Kinova::Api::Base::SwitchControlMapping* mutable_switch_control_mapping();
+  void set_allocated_switch_control_mapping(::Kinova::Api::Base::SwitchControlMapping* switch_control_mapping);
+
+  // .Kinova.Api.Base.JointNavigationDirection navigate_joints = 20;
+  private:
+  bool has_navigate_joints() const;
+  public:
+  void clear_navigate_joints();
+  static const int kNavigateJointsFieldNumber = 20;
+  ::Kinova::Api::Base::JointNavigationDirection navigate_joints() const;
+  void set_navigate_joints(::Kinova::Api::Base::JointNavigationDirection value);
+
+  // .Kinova.Api.Base.NavigationDirection navigate_mappings = 21;
+  private:
+  bool has_navigate_mappings() const;
+  public:
+  void clear_navigate_mappings();
+  static const int kNavigateMappingsFieldNumber = 21;
+  ::Kinova::Api::Base::NavigationDirection navigate_mappings() const;
+  void set_navigate_mappings(::Kinova::Api::Base::NavigationDirection value);
+
+  // .Kinova.Api.Base.ChangeTwist change_twist = 25;
+  bool has_change_twist() const;
+  void clear_change_twist();
+  static const int kChangeTwistFieldNumber = 25;
+  const ::Kinova::Api::Base::ChangeTwist& change_twist() const;
+  ::Kinova::Api::Base::ChangeTwist* release_change_twist();
+  ::Kinova::Api::Base::ChangeTwist* mutable_change_twist();
+  void set_allocated_change_twist(::Kinova::Api::Base::ChangeTwist* change_twist);
+
+  // .Kinova.Api.Base.ChangeJointSpeeds change_joint_speeds = 26;
+  bool has_change_joint_speeds() const;
+  void clear_change_joint_speeds();
+  static const int kChangeJointSpeedsFieldNumber = 26;
+  const ::Kinova::Api::Base::ChangeJointSpeeds& change_joint_speeds() const;
+  ::Kinova::Api::Base::ChangeJointSpeeds* release_change_joint_speeds();
+  ::Kinova::Api::Base::ChangeJointSpeeds* mutable_change_joint_speeds();
+  void set_allocated_change_joint_speeds(::Kinova::Api::Base::ChangeJointSpeeds* change_joint_speeds);
+
+  // .Kinova.Api.Base.ChangeWrench change_wrench = 28;
+  bool has_change_wrench() const;
+  void clear_change_wrench();
+  static const int kChangeWrenchFieldNumber = 28;
+  const ::Kinova::Api::Base::ChangeWrench& change_wrench() const;
+  ::Kinova::Api::Base::ChangeWrench* release_change_wrench();
+  ::Kinova::Api::Base::ChangeWrench* mutable_change_wrench();
+  void set_allocated_change_wrench(::Kinova::Api::Base::ChangeWrench* change_wrench);
+
+  // .Kinova.Api.Base.EmergencyStop apply_emergency_stop = 31;
+  bool has_apply_emergency_stop() const;
+  void clear_apply_emergency_stop();
+  static const int kApplyEmergencyStopFieldNumber = 31;
+  const ::Kinova::Api::Base::EmergencyStop& apply_emergency_stop() const;
+  ::Kinova::Api::Base::EmergencyStop* release_apply_emergency_stop();
+  ::Kinova::Api::Base::EmergencyStop* mutable_apply_emergency_stop();
+  void set_allocated_apply_emergency_stop(::Kinova::Api::Base::EmergencyStop* apply_emergency_stop);
+
+  // .Kinova.Api.Base.Faults clear_faults = 32;
+  bool has_clear_faults() const;
+  void clear_clear_faults();
+  static const int kClearFaultsFieldNumber = 32;
+  const ::Kinova::Api::Base::Faults& clear_faults() const;
+  ::Kinova::Api::Base::Faults* release_clear_faults();
+  ::Kinova::Api::Base::Faults* mutable_clear_faults();
+  void set_allocated_clear_faults(::Kinova::Api::Base::Faults* clear_faults);
+
+  // .Kinova.Api.Base.Delay delay = 34;
+  bool has_delay() const;
+  void clear_delay();
+  static const int kDelayFieldNumber = 34;
+  const ::Kinova::Api::Base::Delay& delay() const;
+  ::Kinova::Api::Base::Delay* release_delay();
+  ::Kinova::Api::Base::Delay* mutable_delay();
+  void set_allocated_delay(::Kinova::Api::Base::Delay* delay);
+
+  // .Kinova.Api.Base.ActionHandle execute_action = 35;
+  bool has_execute_action() const;
+  void clear_execute_action();
+  static const int kExecuteActionFieldNumber = 35;
+  const ::Kinova::Api::Base::ActionHandle& execute_action() const;
+  ::Kinova::Api::Base::ActionHandle* release_execute_action();
+  ::Kinova::Api::Base::ActionHandle* mutable_execute_action();
+  void set_allocated_execute_action(::Kinova::Api::Base::ActionHandle* execute_action);
+
+  // .Kinova.Api.Base.GripperCommand send_gripper_command = 36;
+  bool has_send_gripper_command() const;
+  void clear_send_gripper_command();
+  static const int kSendGripperCommandFieldNumber = 36;
+  const ::Kinova::Api::Base::GripperCommand& send_gripper_command() const;
+  ::Kinova::Api::Base::GripperCommand* release_send_gripper_command();
+  ::Kinova::Api::Base::GripperCommand* mutable_send_gripper_command();
+  void set_allocated_send_gripper_command(::Kinova::Api::Base::GripperCommand* send_gripper_command);
+
+  // .Kinova.Api.Base.GpioCommand send_gpio_command = 37;
+  bool has_send_gpio_command() const;
+  void clear_send_gpio_command();
+  static const int kSendGpioCommandFieldNumber = 37;
+  const ::Kinova::Api::Base::GpioCommand& send_gpio_command() const;
+  ::Kinova::Api::Base::GpioCommand* release_send_gpio_command();
+  ::Kinova::Api::Base::GpioCommand* mutable_send_gpio_command();
+  void set_allocated_send_gpio_command(::Kinova::Api::Base::GpioCommand* send_gpio_command);
+
+  // .Kinova.Api.Base.Stop stop_action = 38;
+  bool has_stop_action() const;
+  void clear_stop_action();
+  static const int kStopActionFieldNumber = 38;
+  const ::Kinova::Api::Base::Stop& stop_action() const;
+  ::Kinova::Api::Base::Stop* release_stop_action();
+  ::Kinova::Api::Base::Stop* mutable_stop_action();
+  void set_allocated_stop_action(::Kinova::Api::Base::Stop* stop_action);
+
+  // .Kinova.Api.Base.PreComputedJointTrajectory play_pre_computed_trajectory = 39;
+  bool has_play_pre_computed_trajectory() const;
+  void clear_play_pre_computed_trajectory();
+  static const int kPlayPreComputedTrajectoryFieldNumber = 39;
+  const ::Kinova::Api::Base::PreComputedJointTrajectory& play_pre_computed_trajectory() const;
+  ::Kinova::Api::Base::PreComputedJointTrajectory* release_play_pre_computed_trajectory();
+  ::Kinova::Api::Base::PreComputedJointTrajectory* mutable_play_pre_computed_trajectory();
+  void set_allocated_play_pre_computed_trajectory(::Kinova::Api::Base::PreComputedJointTrajectory* play_pre_computed_trajectory);
+
+  // .Kinova.Api.Base.SequenceHandle execute_sequence = 40;
+  bool has_execute_sequence() const;
+  void clear_execute_sequence();
+  static const int kExecuteSequenceFieldNumber = 40;
+  const ::Kinova::Api::Base::SequenceHandle& execute_sequence() const;
+  ::Kinova::Api::Base::SequenceHandle* release_execute_sequence();
+  ::Kinova::Api::Base::SequenceHandle* mutable_execute_sequence();
+  void set_allocated_execute_sequence(::Kinova::Api::Base::SequenceHandle* execute_sequence);
+
+  // .Kinova.Api.Base.WaypointList execute_waypoint_list = 41;
+  bool has_execute_waypoint_list() const;
+  void clear_execute_waypoint_list();
+  static const int kExecuteWaypointListFieldNumber = 41;
+  const ::Kinova::Api::Base::WaypointList& execute_waypoint_list() const;
+  ::Kinova::Api::Base::WaypointList* release_execute_waypoint_list();
+  ::Kinova::Api::Base::WaypointList* mutable_execute_waypoint_list();
+  void set_allocated_execute_waypoint_list(::Kinova::Api::Base::WaypointList* execute_waypoint_list);
+
+  ActionParametersCase action_parameters_case() const;
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.Action)
+ private:
+  void set_has_send_twist_command();
+  void set_has_send_wrench_command();
+  void set_has_send_joint_speeds();
+  void set_has_reach_pose();
+  void set_has_reach_joint_angles();
+  void set_has_toggle_admittance_mode();
+  void set_has_snapshot();
+  void set_has_switch_control_mapping();
+  void set_has_navigate_joints();
+  void set_has_navigate_mappings();
+  void set_has_change_twist();
+  void set_has_change_joint_speeds();
+  void set_has_change_wrench();
+  void set_has_apply_emergency_stop();
+  void set_has_clear_faults();
+  void set_has_delay();
+  void set_has_execute_action();
+  void set_has_send_gripper_command();
+  void set_has_send_gpio_command();
+  void set_has_stop_action();
+  void set_has_play_pre_computed_trajectory();
+  void set_has_execute_sequence();
+  void set_has_execute_waypoint_list();
+
+  inline bool has_action_parameters() const;
+  void clear_action_parameters();
+  inline void clear_has_action_parameters();
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::internal::ArenaStringPtr name_;
+  ::google::protobuf::internal::ArenaStringPtr application_data_;
+  ::Kinova::Api::Base::ActionHandle* handle_;
+  union ActionParametersUnion {
+    ActionParametersUnion() {}
+    ::Kinova::Api::Base::TwistCommand* send_twist_command_;
+    ::Kinova::Api::Base::WrenchCommand* send_wrench_command_;
+    ::Kinova::Api::Base::JointSpeeds* send_joint_speeds_;
+    ::Kinova::Api::Base::ConstrainedPose* reach_pose_;
+    ::Kinova::Api::Base::ConstrainedJointAngles* reach_joint_angles_;
+    int toggle_admittance_mode_;
+    ::Kinova::Api::Base::Snapshot* snapshot_;
+    ::Kinova::Api::Base::SwitchControlMapping* switch_control_mapping_;
+    int navigate_joints_;
+    int navigate_mappings_;
+    ::Kinova::Api::Base::ChangeTwist* change_twist_;
+    ::Kinova::Api::Base::ChangeJointSpeeds* change_joint_speeds_;
+    ::Kinova::Api::Base::ChangeWrench* change_wrench_;
+    ::Kinova::Api::Base::EmergencyStop* apply_emergency_stop_;
+    ::Kinova::Api::Base::Faults* clear_faults_;
+    ::Kinova::Api::Base::Delay* delay_;
+    ::Kinova::Api::Base::ActionHandle* execute_action_;
+    ::Kinova::Api::Base::GripperCommand* send_gripper_command_;
+    ::Kinova::Api::Base::GpioCommand* send_gpio_command_;
+    ::Kinova::Api::Base::Stop* stop_action_;
+    ::Kinova::Api::Base::PreComputedJointTrajectory* play_pre_computed_trajectory_;
+    ::Kinova::Api::Base::SequenceHandle* execute_sequence_;
+    ::Kinova::Api::Base::WaypointList* execute_waypoint_list_;
+  } action_parameters_;
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _oneof_case_[1];
+
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsActionImpl();
+};
+// -------------------------------------------------------------------
+
+class Snapshot : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.Snapshot) */ {
+ public:
+  Snapshot();
+  virtual ~Snapshot();
+
+  Snapshot(const Snapshot& from);
+
+  inline Snapshot& operator=(const Snapshot& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Snapshot(Snapshot&& from) noexcept
+    : Snapshot() {
+    *this = ::std::move(from);
+  }
+
+  inline Snapshot& operator=(Snapshot&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Snapshot& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Snapshot* internal_default_instance() {
+    return reinterpret_cast<const Snapshot*>(
+               &_Snapshot_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    22;
+
+  void Swap(Snapshot* other);
+  friend void swap(Snapshot& a, Snapshot& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Snapshot* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Snapshot* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Snapshot& from);
+  void MergeFrom(const Snapshot& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Snapshot* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Base.SnapshotType snapshot_type = 1;
+  void clear_snapshot_type();
+  static const int kSnapshotTypeFieldNumber = 1;
+  ::Kinova::Api::Base::SnapshotType snapshot_type() const;
+  void set_snapshot_type(::Kinova::Api::Base::SnapshotType value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.Snapshot)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  int snapshot_type_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsSnapshotImpl();
+};
+// -------------------------------------------------------------------
+
+class SwitchControlMapping : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.SwitchControlMapping) */ {
+ public:
+  SwitchControlMapping();
+  virtual ~SwitchControlMapping();
+
+  SwitchControlMapping(const SwitchControlMapping& from);
+
+  inline SwitchControlMapping& operator=(const SwitchControlMapping& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  SwitchControlMapping(SwitchControlMapping&& from) noexcept
+    : SwitchControlMapping() {
+    *this = ::std::move(from);
+  }
+
+  inline SwitchControlMapping& operator=(SwitchControlMapping&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SwitchControlMapping& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const SwitchControlMapping* internal_default_instance() {
+    return reinterpret_cast<const SwitchControlMapping*>(
+               &_SwitchControlMapping_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    23;
+
+  void Swap(SwitchControlMapping* other);
+  friend void swap(SwitchControlMapping& a, SwitchControlMapping& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SwitchControlMapping* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  SwitchControlMapping* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const SwitchControlMapping& from);
+  void MergeFrom(const SwitchControlMapping& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(SwitchControlMapping* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Base.MapGroupHandle map_group_handle = 2;
+  bool has_map_group_handle() const;
+  void clear_map_group_handle();
+  static const int kMapGroupHandleFieldNumber = 2;
+  const ::Kinova::Api::Base::MapGroupHandle& map_group_handle() const;
+  ::Kinova::Api::Base::MapGroupHandle* release_map_group_handle();
+  ::Kinova::Api::Base::MapGroupHandle* mutable_map_group_handle();
+  void set_allocated_map_group_handle(::Kinova::Api::Base::MapGroupHandle* map_group_handle);
+
+  // .Kinova.Api.Base.MapHandle map_handle = 3;
+  bool has_map_handle() const;
+  void clear_map_handle();
+  static const int kMapHandleFieldNumber = 3;
+  const ::Kinova::Api::Base::MapHandle& map_handle() const;
+  ::Kinova::Api::Base::MapHandle* release_map_handle();
+  ::Kinova::Api::Base::MapHandle* mutable_map_handle();
+  void set_allocated_map_handle(::Kinova::Api::Base::MapHandle* map_handle);
+
+  // uint32 controller_identifier = 1;
+  void clear_controller_identifier();
+  static const int kControllerIdentifierFieldNumber = 1;
+  ::google::protobuf::uint32 controller_identifier() const;
+  void set_controller_identifier(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.SwitchControlMapping)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::Base::MapGroupHandle* map_group_handle_;
+  ::Kinova::Api::Base::MapHandle* map_handle_;
+  ::google::protobuf::uint32 controller_identifier_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsSwitchControlMappingImpl();
+};
+// -------------------------------------------------------------------
+
+class ChangeTwist : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.ChangeTwist) */ {
+ public:
+  ChangeTwist();
+  virtual ~ChangeTwist();
+
+  ChangeTwist(const ChangeTwist& from);
+
+  inline ChangeTwist& operator=(const ChangeTwist& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ChangeTwist(ChangeTwist&& from) noexcept
+    : ChangeTwist() {
+    *this = ::std::move(from);
+  }
+
+  inline ChangeTwist& operator=(ChangeTwist&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ChangeTwist& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ChangeTwist* internal_default_instance() {
+    return reinterpret_cast<const ChangeTwist*>(
+               &_ChangeTwist_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    24;
+
+  void Swap(ChangeTwist* other);
+  friend void swap(ChangeTwist& a, ChangeTwist& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ChangeTwist* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ChangeTwist* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ChangeTwist& from);
+  void MergeFrom(const ChangeTwist& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ChangeTwist* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // float linear = 1;
+  void clear_linear();
+  static const int kLinearFieldNumber = 1;
+  float linear() const;
+  void set_linear(float value);
+
+  // float angular = 2;
+  void clear_angular();
+  static const int kAngularFieldNumber = 2;
+  float angular() const;
+  void set_angular(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.ChangeTwist)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  float linear_;
+  float angular_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsChangeTwistImpl();
+};
+// -------------------------------------------------------------------
+
+class ChangeJointSpeeds : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.ChangeJointSpeeds) */ {
+ public:
+  ChangeJointSpeeds();
+  virtual ~ChangeJointSpeeds();
+
+  ChangeJointSpeeds(const ChangeJointSpeeds& from);
+
+  inline ChangeJointSpeeds& operator=(const ChangeJointSpeeds& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ChangeJointSpeeds(ChangeJointSpeeds&& from) noexcept
+    : ChangeJointSpeeds() {
+    *this = ::std::move(from);
+  }
+
+  inline ChangeJointSpeeds& operator=(ChangeJointSpeeds&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ChangeJointSpeeds& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ChangeJointSpeeds* internal_default_instance() {
+    return reinterpret_cast<const ChangeJointSpeeds*>(
+               &_ChangeJointSpeeds_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    25;
+
+  void Swap(ChangeJointSpeeds* other);
+  friend void swap(ChangeJointSpeeds& a, ChangeJointSpeeds& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ChangeJointSpeeds* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ChangeJointSpeeds* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ChangeJointSpeeds& from);
+  void MergeFrom(const ChangeJointSpeeds& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ChangeJointSpeeds* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Base.JointSpeeds joint_speeds = 1;
+  bool has_joint_speeds() const;
+  void clear_joint_speeds();
+  static const int kJointSpeedsFieldNumber = 1;
+  const ::Kinova::Api::Base::JointSpeeds& joint_speeds() const;
+  ::Kinova::Api::Base::JointSpeeds* release_joint_speeds();
+  ::Kinova::Api::Base::JointSpeeds* mutable_joint_speeds();
+  void set_allocated_joint_speeds(::Kinova::Api::Base::JointSpeeds* joint_speeds);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.ChangeJointSpeeds)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::Base::JointSpeeds* joint_speeds_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsChangeJointSpeedsImpl();
+};
+// -------------------------------------------------------------------
+
+class ChangeWrench : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.ChangeWrench) */ {
+ public:
+  ChangeWrench();
+  virtual ~ChangeWrench();
+
+  ChangeWrench(const ChangeWrench& from);
+
+  inline ChangeWrench& operator=(const ChangeWrench& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ChangeWrench(ChangeWrench&& from) noexcept
+    : ChangeWrench() {
+    *this = ::std::move(from);
+  }
+
+  inline ChangeWrench& operator=(ChangeWrench&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ChangeWrench& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ChangeWrench* internal_default_instance() {
+    return reinterpret_cast<const ChangeWrench*>(
+               &_ChangeWrench_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    26;
+
+  void Swap(ChangeWrench* other);
+  friend void swap(ChangeWrench& a, ChangeWrench& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ChangeWrench* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ChangeWrench* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ChangeWrench& from);
+  void MergeFrom(const ChangeWrench& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ChangeWrench* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // float force = 1;
+  void clear_force();
+  static const int kForceFieldNumber = 1;
+  float force() const;
+  void set_force(float value);
+
+  // float torque = 2;
+  void clear_torque();
+  static const int kTorqueFieldNumber = 2;
+  float torque() const;
+  void set_torque(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.ChangeWrench)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  float force_;
+  float torque_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsChangeWrenchImpl();
+};
+// -------------------------------------------------------------------
+
+class EmergencyStop : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.EmergencyStop) */ {
+ public:
+  EmergencyStop();
+  virtual ~EmergencyStop();
+
+  EmergencyStop(const EmergencyStop& from);
+
+  inline EmergencyStop& operator=(const EmergencyStop& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  EmergencyStop(EmergencyStop&& from) noexcept
+    : EmergencyStop() {
+    *this = ::std::move(from);
+  }
+
+  inline EmergencyStop& operator=(EmergencyStop&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const EmergencyStop& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const EmergencyStop* internal_default_instance() {
+    return reinterpret_cast<const EmergencyStop*>(
+               &_EmergencyStop_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    27;
+
+  void Swap(EmergencyStop* other);
+  friend void swap(EmergencyStop& a, EmergencyStop& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline EmergencyStop* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  EmergencyStop* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const EmergencyStop& from);
+  void MergeFrom(const EmergencyStop& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(EmergencyStop* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.EmergencyStop)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsEmergencyStopImpl();
+};
+// -------------------------------------------------------------------
+
+class Faults : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.Faults) */ {
+ public:
+  Faults();
+  virtual ~Faults();
+
+  Faults(const Faults& from);
+
+  inline Faults& operator=(const Faults& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Faults(Faults&& from) noexcept
+    : Faults() {
+    *this = ::std::move(from);
+  }
+
+  inline Faults& operator=(Faults&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Faults& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Faults* internal_default_instance() {
+    return reinterpret_cast<const Faults*>(
+               &_Faults_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    28;
+
+  void Swap(Faults* other);
+  friend void swap(Faults& a, Faults& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Faults* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Faults* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Faults& from);
+  void MergeFrom(const Faults& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Faults* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.Faults)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsFaultsImpl();
+};
+// -------------------------------------------------------------------
+
+class Delay : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.Delay) */ {
+ public:
+  Delay();
+  virtual ~Delay();
+
+  Delay(const Delay& from);
+
+  inline Delay& operator=(const Delay& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Delay(Delay&& from) noexcept
+    : Delay() {
+    *this = ::std::move(from);
+  }
+
+  inline Delay& operator=(Delay&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Delay& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Delay* internal_default_instance() {
+    return reinterpret_cast<const Delay*>(
+               &_Delay_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    29;
+
+  void Swap(Delay* other);
+  friend void swap(Delay& a, Delay& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Delay* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Delay* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Delay& from);
+  void MergeFrom(const Delay& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Delay* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // uint32 duration = 1;
+  void clear_duration();
+  static const int kDurationFieldNumber = 1;
+  ::google::protobuf::uint32 duration() const;
+  void set_duration(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.Delay)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 duration_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsDelayImpl();
+};
+// -------------------------------------------------------------------
+
+class Stop : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.Stop) */ {
+ public:
+  Stop();
+  virtual ~Stop();
+
+  Stop(const Stop& from);
+
+  inline Stop& operator=(const Stop& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Stop(Stop&& from) noexcept
+    : Stop() {
+    *this = ::std::move(from);
+  }
+
+  inline Stop& operator=(Stop&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Stop& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Stop* internal_default_instance() {
+    return reinterpret_cast<const Stop*>(
+               &_Stop_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    30;
+
+  void Swap(Stop* other);
+  friend void swap(Stop& a, Stop& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Stop* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Stop* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Stop& from);
+  void MergeFrom(const Stop& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Stop* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.Stop)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsStopImpl();
+};
+// -------------------------------------------------------------------
+
+class ActionList : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.ActionList) */ {
+ public:
+  ActionList();
+  virtual ~ActionList();
+
+  ActionList(const ActionList& from);
+
+  inline ActionList& operator=(const ActionList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ActionList(ActionList&& from) noexcept
+    : ActionList() {
+    *this = ::std::move(from);
+  }
+
+  inline ActionList& operator=(ActionList&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ActionList& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ActionList* internal_default_instance() {
+    return reinterpret_cast<const ActionList*>(
+               &_ActionList_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    31;
+
+  void Swap(ActionList* other);
+  friend void swap(ActionList& a, ActionList& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ActionList* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ActionList* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ActionList& from);
+  void MergeFrom(const ActionList& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ActionList* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .Kinova.Api.Base.Action action_list = 1;
+  int action_list_size() const;
+  void clear_action_list();
+  static const int kActionListFieldNumber = 1;
+  const ::Kinova::Api::Base::Action& action_list(int index) const;
+  ::Kinova::Api::Base::Action* mutable_action_list(int index);
+  ::Kinova::Api::Base::Action* add_action_list();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::Action >*
+      mutable_action_list();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::Action >&
+      action_list() const;
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.ActionList)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::Action > action_list_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsActionListImpl();
+};
+// -------------------------------------------------------------------
+
+class Timeout : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.Timeout) */ {
+ public:
+  Timeout();
+  virtual ~Timeout();
+
+  Timeout(const Timeout& from);
+
+  inline Timeout& operator=(const Timeout& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Timeout(Timeout&& from) noexcept
+    : Timeout() {
+    *this = ::std::move(from);
+  }
+
+  inline Timeout& operator=(Timeout&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Timeout& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Timeout* internal_default_instance() {
+    return reinterpret_cast<const Timeout*>(
+               &_Timeout_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    32;
+
+  void Swap(Timeout* other);
+  friend void swap(Timeout& a, Timeout& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Timeout* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Timeout* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Timeout& from);
+  void MergeFrom(const Timeout& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Timeout* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // uint32 value = 1;
+  void clear_value();
+  static const int kValueFieldNumber = 1;
+  ::google::protobuf::uint32 value() const;
+  void set_value(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.Timeout)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 value_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsTimeoutImpl();
+};
+// -------------------------------------------------------------------
+
+class Ssid : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.Ssid) */ {
+ public:
+  Ssid();
+  virtual ~Ssid();
+
+  Ssid(const Ssid& from);
+
+  inline Ssid& operator=(const Ssid& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Ssid(Ssid&& from) noexcept
+    : Ssid() {
+    *this = ::std::move(from);
+  }
+
+  inline Ssid& operator=(Ssid&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Ssid& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Ssid* internal_default_instance() {
+    return reinterpret_cast<const Ssid*>(
+               &_Ssid_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    33;
+
+  void Swap(Ssid* other);
+  friend void swap(Ssid& a, Ssid& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Ssid* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Ssid* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Ssid& from);
+  void MergeFrom(const Ssid& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Ssid* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // string identifier = 1;
+  void clear_identifier();
+  static const int kIdentifierFieldNumber = 1;
+  const ::std::string& identifier() const;
+  void set_identifier(const ::std::string& value);
+  #if LANG_CXX11
+  void set_identifier(::std::string&& value);
+  #endif
+  void set_identifier(const char* value);
+  void set_identifier(const char* value, size_t size);
+  ::std::string* mutable_identifier();
+  ::std::string* release_identifier();
+  void set_allocated_identifier(::std::string* identifier);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.Ssid)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::internal::ArenaStringPtr identifier_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsSsidImpl();
+};
+// -------------------------------------------------------------------
+
+class CommunicationInterfaceConfiguration : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.CommunicationInterfaceConfiguration) */ {
+ public:
+  CommunicationInterfaceConfiguration();
+  virtual ~CommunicationInterfaceConfiguration();
+
+  CommunicationInterfaceConfiguration(const CommunicationInterfaceConfiguration& from);
+
+  inline CommunicationInterfaceConfiguration& operator=(const CommunicationInterfaceConfiguration& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  CommunicationInterfaceConfiguration(CommunicationInterfaceConfiguration&& from) noexcept
+    : CommunicationInterfaceConfiguration() {
+    *this = ::std::move(from);
+  }
+
+  inline CommunicationInterfaceConfiguration& operator=(CommunicationInterfaceConfiguration&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const CommunicationInterfaceConfiguration& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const CommunicationInterfaceConfiguration* internal_default_instance() {
+    return reinterpret_cast<const CommunicationInterfaceConfiguration*>(
+               &_CommunicationInterfaceConfiguration_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    34;
+
+  void Swap(CommunicationInterfaceConfiguration* other);
+  friend void swap(CommunicationInterfaceConfiguration& a, CommunicationInterfaceConfiguration& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline CommunicationInterfaceConfiguration* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  CommunicationInterfaceConfiguration* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const CommunicationInterfaceConfiguration& from);
+  void MergeFrom(const CommunicationInterfaceConfiguration& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(CommunicationInterfaceConfiguration* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Base.NetworkType type = 1;
+  void clear_type();
+  static const int kTypeFieldNumber = 1;
+  ::Kinova::Api::Base::NetworkType type() const;
+  void set_type(::Kinova::Api::Base::NetworkType value);
+
+  // bool enable = 2;
+  void clear_enable();
+  static const int kEnableFieldNumber = 2;
+  bool enable() const;
+  void set_enable(bool value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.CommunicationInterfaceConfiguration)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  int type_;
+  bool enable_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsCommunicationInterfaceConfigurationImpl();
+};
+// -------------------------------------------------------------------
+
+class NetworkHandle : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.NetworkHandle) */ {
+ public:
+  NetworkHandle();
+  virtual ~NetworkHandle();
+
+  NetworkHandle(const NetworkHandle& from);
+
+  inline NetworkHandle& operator=(const NetworkHandle& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  NetworkHandle(NetworkHandle&& from) noexcept
+    : NetworkHandle() {
+    *this = ::std::move(from);
+  }
+
+  inline NetworkHandle& operator=(NetworkHandle&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const NetworkHandle& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const NetworkHandle* internal_default_instance() {
+    return reinterpret_cast<const NetworkHandle*>(
+               &_NetworkHandle_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    35;
+
+  void Swap(NetworkHandle* other);
+  friend void swap(NetworkHandle& a, NetworkHandle& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline NetworkHandle* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  NetworkHandle* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const NetworkHandle& from);
+  void MergeFrom(const NetworkHandle& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(NetworkHandle* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Base.NetworkType type = 1;
+  void clear_type();
+  static const int kTypeFieldNumber = 1;
+  ::Kinova::Api::Base::NetworkType type() const;
+  void set_type(::Kinova::Api::Base::NetworkType value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.NetworkHandle)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  int type_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsNetworkHandleImpl();
+};
+// -------------------------------------------------------------------
+
+class IPv4Configuration : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.IPv4Configuration) */ {
+ public:
+  IPv4Configuration();
+  virtual ~IPv4Configuration();
+
+  IPv4Configuration(const IPv4Configuration& from);
+
+  inline IPv4Configuration& operator=(const IPv4Configuration& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  IPv4Configuration(IPv4Configuration&& from) noexcept
+    : IPv4Configuration() {
+    *this = ::std::move(from);
+  }
+
+  inline IPv4Configuration& operator=(IPv4Configuration&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const IPv4Configuration& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const IPv4Configuration* internal_default_instance() {
+    return reinterpret_cast<const IPv4Configuration*>(
+               &_IPv4Configuration_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    36;
+
+  void Swap(IPv4Configuration* other);
+  friend void swap(IPv4Configuration& a, IPv4Configuration& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline IPv4Configuration* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  IPv4Configuration* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const IPv4Configuration& from);
+  void MergeFrom(const IPv4Configuration& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(IPv4Configuration* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // uint32 ip_address = 1;
+  void clear_ip_address();
+  static const int kIpAddressFieldNumber = 1;
+  ::google::protobuf::uint32 ip_address() const;
+  void set_ip_address(::google::protobuf::uint32 value);
+
+  // uint32 subnet_mask = 2;
+  void clear_subnet_mask();
+  static const int kSubnetMaskFieldNumber = 2;
+  ::google::protobuf::uint32 subnet_mask() const;
+  void set_subnet_mask(::google::protobuf::uint32 value);
+
+  // uint32 default_gateway = 3;
+  void clear_default_gateway();
+  static const int kDefaultGatewayFieldNumber = 3;
+  ::google::protobuf::uint32 default_gateway() const;
+  void set_default_gateway(::google::protobuf::uint32 value);
+
+  // bool dhcp_enabled = 4;
+  void clear_dhcp_enabled();
+  static const int kDhcpEnabledFieldNumber = 4;
+  bool dhcp_enabled() const;
+  void set_dhcp_enabled(bool value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.IPv4Configuration)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 ip_address_;
+  ::google::protobuf::uint32 subnet_mask_;
+  ::google::protobuf::uint32 default_gateway_;
+  bool dhcp_enabled_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsIPv4ConfigurationImpl();
+};
+// -------------------------------------------------------------------
+
+class IPv4Information : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.IPv4Information) */ {
+ public:
+  IPv4Information();
+  virtual ~IPv4Information();
+
+  IPv4Information(const IPv4Information& from);
+
+  inline IPv4Information& operator=(const IPv4Information& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  IPv4Information(IPv4Information&& from) noexcept
+    : IPv4Information() {
+    *this = ::std::move(from);
+  }
+
+  inline IPv4Information& operator=(IPv4Information&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const IPv4Information& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const IPv4Information* internal_default_instance() {
+    return reinterpret_cast<const IPv4Information*>(
+               &_IPv4Information_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    37;
+
+  void Swap(IPv4Information* other);
+  friend void swap(IPv4Information& a, IPv4Information& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline IPv4Information* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  IPv4Information* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const IPv4Information& from);
+  void MergeFrom(const IPv4Information& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(IPv4Information* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // uint32 ip_address = 1;
+  void clear_ip_address();
+  static const int kIpAddressFieldNumber = 1;
+  ::google::protobuf::uint32 ip_address() const;
+  void set_ip_address(::google::protobuf::uint32 value);
+
+  // uint32 subnet_mask = 2;
+  void clear_subnet_mask();
+  static const int kSubnetMaskFieldNumber = 2;
+  ::google::protobuf::uint32 subnet_mask() const;
+  void set_subnet_mask(::google::protobuf::uint32 value);
+
+  // uint32 default_gateway = 3;
+  void clear_default_gateway();
+  static const int kDefaultGatewayFieldNumber = 3;
+  ::google::protobuf::uint32 default_gateway() const;
+  void set_default_gateway(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.IPv4Information)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 ip_address_;
+  ::google::protobuf::uint32 subnet_mask_;
+  ::google::protobuf::uint32 default_gateway_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsIPv4InformationImpl();
+};
+// -------------------------------------------------------------------
+
+class FullIPv4Configuration : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.FullIPv4Configuration) */ {
+ public:
+  FullIPv4Configuration();
+  virtual ~FullIPv4Configuration();
+
+  FullIPv4Configuration(const FullIPv4Configuration& from);
+
+  inline FullIPv4Configuration& operator=(const FullIPv4Configuration& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  FullIPv4Configuration(FullIPv4Configuration&& from) noexcept
+    : FullIPv4Configuration() {
+    *this = ::std::move(from);
+  }
+
+  inline FullIPv4Configuration& operator=(FullIPv4Configuration&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const FullIPv4Configuration& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const FullIPv4Configuration* internal_default_instance() {
+    return reinterpret_cast<const FullIPv4Configuration*>(
+               &_FullIPv4Configuration_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    38;
+
+  void Swap(FullIPv4Configuration* other);
+  friend void swap(FullIPv4Configuration& a, FullIPv4Configuration& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline FullIPv4Configuration* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  FullIPv4Configuration* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const FullIPv4Configuration& from);
+  void MergeFrom(const FullIPv4Configuration& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(FullIPv4Configuration* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Base.NetworkHandle handle = 1;
+  bool has_handle() const;
+  void clear_handle();
+  static const int kHandleFieldNumber = 1;
+  const ::Kinova::Api::Base::NetworkHandle& handle() const;
+  ::Kinova::Api::Base::NetworkHandle* release_handle();
+  ::Kinova::Api::Base::NetworkHandle* mutable_handle();
+  void set_allocated_handle(::Kinova::Api::Base::NetworkHandle* handle);
+
+  // .Kinova.Api.Base.IPv4Configuration ipv4_configuration = 2;
+  bool has_ipv4_configuration() const;
+  void clear_ipv4_configuration();
+  static const int kIpv4ConfigurationFieldNumber = 2;
+  const ::Kinova::Api::Base::IPv4Configuration& ipv4_configuration() const;
+  ::Kinova::Api::Base::IPv4Configuration* release_ipv4_configuration();
+  ::Kinova::Api::Base::IPv4Configuration* mutable_ipv4_configuration();
+  void set_allocated_ipv4_configuration(::Kinova::Api::Base::IPv4Configuration* ipv4_configuration);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.FullIPv4Configuration)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::Base::NetworkHandle* handle_;
+  ::Kinova::Api::Base::IPv4Configuration* ipv4_configuration_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsFullIPv4ConfigurationImpl();
+};
+// -------------------------------------------------------------------
+
+class WifiEnableState : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.WifiEnableState) */ {
+ public:
+  WifiEnableState();
+  virtual ~WifiEnableState();
+
+  WifiEnableState(const WifiEnableState& from);
+
+  inline WifiEnableState& operator=(const WifiEnableState& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  WifiEnableState(WifiEnableState&& from) noexcept
+    : WifiEnableState() {
+    *this = ::std::move(from);
+  }
+
+  inline WifiEnableState& operator=(WifiEnableState&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const WifiEnableState& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const WifiEnableState* internal_default_instance() {
+    return reinterpret_cast<const WifiEnableState*>(
+               &_WifiEnableState_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    39;
+
+  void Swap(WifiEnableState* other);
+  friend void swap(WifiEnableState& a, WifiEnableState& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline WifiEnableState* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  WifiEnableState* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const WifiEnableState& from);
+  void MergeFrom(const WifiEnableState& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(WifiEnableState* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // bool enabled = 1;
+  void clear_enabled();
+  static const int kEnabledFieldNumber = 1;
+  bool enabled() const;
+  void set_enabled(bool value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.WifiEnableState)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  bool enabled_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsWifiEnableStateImpl();
+};
+// -------------------------------------------------------------------
+
+class BluetoothEnableState : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.BluetoothEnableState) */ {
+ public:
+  BluetoothEnableState();
+  virtual ~BluetoothEnableState();
+
+  BluetoothEnableState(const BluetoothEnableState& from);
+
+  inline BluetoothEnableState& operator=(const BluetoothEnableState& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  BluetoothEnableState(BluetoothEnableState&& from) noexcept
+    : BluetoothEnableState() {
+    *this = ::std::move(from);
+  }
+
+  inline BluetoothEnableState& operator=(BluetoothEnableState&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const BluetoothEnableState& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const BluetoothEnableState* internal_default_instance() {
+    return reinterpret_cast<const BluetoothEnableState*>(
+               &_BluetoothEnableState_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    40;
+
+  void Swap(BluetoothEnableState* other);
+  friend void swap(BluetoothEnableState& a, BluetoothEnableState& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline BluetoothEnableState* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  BluetoothEnableState* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const BluetoothEnableState& from);
+  void MergeFrom(const BluetoothEnableState& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(BluetoothEnableState* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // bool enabled = 1;
+  void clear_enabled();
+  static const int kEnabledFieldNumber = 1;
+  bool enabled() const;
+  void set_enabled(bool value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.BluetoothEnableState)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  bool enabled_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsBluetoothEnableStateImpl();
+};
+// -------------------------------------------------------------------
+
+class RFConfiguration : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.RFConfiguration) */ {
+ public:
+  RFConfiguration();
+  virtual ~RFConfiguration();
+
+  RFConfiguration(const RFConfiguration& from);
+
+  inline RFConfiguration& operator=(const RFConfiguration& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  RFConfiguration(RFConfiguration&& from) noexcept
+    : RFConfiguration() {
+    *this = ::std::move(from);
+  }
+
+  inline RFConfiguration& operator=(RFConfiguration&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const RFConfiguration& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const RFConfiguration* internal_default_instance() {
+    return reinterpret_cast<const RFConfiguration*>(
+               &_RFConfiguration_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    41;
+
+  void Swap(RFConfiguration* other);
+  friend void swap(RFConfiguration& a, RFConfiguration& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline RFConfiguration* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  RFConfiguration* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const RFConfiguration& from);
+  void MergeFrom(const RFConfiguration& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(RFConfiguration* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Base.WifiEnableState wifi_enable_state = 1;
+  bool has_wifi_enable_state() const;
+  void clear_wifi_enable_state();
+  static const int kWifiEnableStateFieldNumber = 1;
+  const ::Kinova::Api::Base::WifiEnableState& wifi_enable_state() const;
+  ::Kinova::Api::Base::WifiEnableState* release_wifi_enable_state();
+  ::Kinova::Api::Base::WifiEnableState* mutable_wifi_enable_state();
+  void set_allocated_wifi_enable_state(::Kinova::Api::Base::WifiEnableState* wifi_enable_state);
+
+  // .Kinova.Api.Base.BluetoothEnableState bluetooth_enable_state = 2;
+  bool has_bluetooth_enable_state() const;
+  void clear_bluetooth_enable_state();
+  static const int kBluetoothEnableStateFieldNumber = 2;
+  const ::Kinova::Api::Base::BluetoothEnableState& bluetooth_enable_state() const;
+  ::Kinova::Api::Base::BluetoothEnableState* release_bluetooth_enable_state();
+  ::Kinova::Api::Base::BluetoothEnableState* mutable_bluetooth_enable_state();
+  void set_allocated_bluetooth_enable_state(::Kinova::Api::Base::BluetoothEnableState* bluetooth_enable_state);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.RFConfiguration)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::Base::WifiEnableState* wifi_enable_state_;
+  ::Kinova::Api::Base::BluetoothEnableState* bluetooth_enable_state_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsRFConfigurationImpl();
+};
+// -------------------------------------------------------------------
+
+class WifiInformation : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.WifiInformation) */ {
+ public:
+  WifiInformation();
+  virtual ~WifiInformation();
+
+  WifiInformation(const WifiInformation& from);
+
+  inline WifiInformation& operator=(const WifiInformation& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  WifiInformation(WifiInformation&& from) noexcept
+    : WifiInformation() {
+    *this = ::std::move(from);
+  }
+
+  inline WifiInformation& operator=(WifiInformation&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const WifiInformation& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const WifiInformation* internal_default_instance() {
+    return reinterpret_cast<const WifiInformation*>(
+               &_WifiInformation_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    42;
+
+  void Swap(WifiInformation* other);
+  friend void swap(WifiInformation& a, WifiInformation& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline WifiInformation* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  WifiInformation* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const WifiInformation& from);
+  void MergeFrom(const WifiInformation& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(WifiInformation* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Base.Ssid ssid = 1;
+  bool has_ssid() const;
+  void clear_ssid();
+  static const int kSsidFieldNumber = 1;
+  const ::Kinova::Api::Base::Ssid& ssid() const;
+  ::Kinova::Api::Base::Ssid* release_ssid();
+  ::Kinova::Api::Base::Ssid* mutable_ssid();
+  void set_allocated_ssid(::Kinova::Api::Base::Ssid* ssid);
+
+  // fixed32 security_type = 2;
+  void clear_security_type();
+  static const int kSecurityTypeFieldNumber = 2;
+  ::google::protobuf::uint32 security_type() const;
+  void set_security_type(::google::protobuf::uint32 value);
+
+  // fixed32 encryption_type = 3;
+  void clear_encryption_type();
+  static const int kEncryptionTypeFieldNumber = 3;
+  ::google::protobuf::uint32 encryption_type() const;
+  void set_encryption_type(::google::protobuf::uint32 value);
+
+  // .Kinova.Api.Base.SignalQuality signal_quality = 4;
+  void clear_signal_quality();
+  static const int kSignalQualityFieldNumber = 4;
+  ::Kinova::Api::Base::SignalQuality signal_quality() const;
+  void set_signal_quality(::Kinova::Api::Base::SignalQuality value);
+
+  // int32 signal_strength = 5;
+  void clear_signal_strength();
+  static const int kSignalStrengthFieldNumber = 5;
+  ::google::protobuf::int32 signal_strength() const;
+  void set_signal_strength(::google::protobuf::int32 value);
+
+  // uint32 frequency = 6;
+  void clear_frequency();
+  static const int kFrequencyFieldNumber = 6;
+  ::google::protobuf::uint32 frequency() const;
+  void set_frequency(::google::protobuf::uint32 value);
+
+  // uint32 channel = 7;
+  void clear_channel();
+  static const int kChannelFieldNumber = 7;
+  ::google::protobuf::uint32 channel() const;
+  void set_channel(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.WifiInformation)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::Base::Ssid* ssid_;
+  ::google::protobuf::uint32 security_type_;
+  ::google::protobuf::uint32 encryption_type_;
+  int signal_quality_;
+  ::google::protobuf::int32 signal_strength_;
+  ::google::protobuf::uint32 frequency_;
+  ::google::protobuf::uint32 channel_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsWifiInformationImpl();
+};
+// -------------------------------------------------------------------
+
+class WifiInformationList : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.WifiInformationList) */ {
+ public:
+  WifiInformationList();
+  virtual ~WifiInformationList();
+
+  WifiInformationList(const WifiInformationList& from);
+
+  inline WifiInformationList& operator=(const WifiInformationList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  WifiInformationList(WifiInformationList&& from) noexcept
+    : WifiInformationList() {
+    *this = ::std::move(from);
+  }
+
+  inline WifiInformationList& operator=(WifiInformationList&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const WifiInformationList& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const WifiInformationList* internal_default_instance() {
+    return reinterpret_cast<const WifiInformationList*>(
+               &_WifiInformationList_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    43;
+
+  void Swap(WifiInformationList* other);
+  friend void swap(WifiInformationList& a, WifiInformationList& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline WifiInformationList* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  WifiInformationList* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const WifiInformationList& from);
+  void MergeFrom(const WifiInformationList& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(WifiInformationList* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .Kinova.Api.Base.WifiInformation wifi_information_list = 1;
+  int wifi_information_list_size() const;
+  void clear_wifi_information_list();
+  static const int kWifiInformationListFieldNumber = 1;
+  const ::Kinova::Api::Base::WifiInformation& wifi_information_list(int index) const;
+  ::Kinova::Api::Base::WifiInformation* mutable_wifi_information_list(int index);
+  ::Kinova::Api::Base::WifiInformation* add_wifi_information_list();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::WifiInformation >*
+      mutable_wifi_information_list();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::WifiInformation >&
+      wifi_information_list() const;
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.WifiInformationList)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::WifiInformation > wifi_information_list_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsWifiInformationListImpl();
+};
+// -------------------------------------------------------------------
+
+class WifiConfiguration : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.WifiConfiguration) */ {
+ public:
+  WifiConfiguration();
+  virtual ~WifiConfiguration();
+
+  WifiConfiguration(const WifiConfiguration& from);
+
+  inline WifiConfiguration& operator=(const WifiConfiguration& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  WifiConfiguration(WifiConfiguration&& from) noexcept
+    : WifiConfiguration() {
+    *this = ::std::move(from);
+  }
+
+  inline WifiConfiguration& operator=(WifiConfiguration&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const WifiConfiguration& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const WifiConfiguration* internal_default_instance() {
+    return reinterpret_cast<const WifiConfiguration*>(
+               &_WifiConfiguration_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    44;
+
+  void Swap(WifiConfiguration* other);
+  friend void swap(WifiConfiguration& a, WifiConfiguration& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline WifiConfiguration* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  WifiConfiguration* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const WifiConfiguration& from);
+  void MergeFrom(const WifiConfiguration& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(WifiConfiguration* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // string security_key = 2;
+  void clear_security_key();
+  static const int kSecurityKeyFieldNumber = 2;
+  const ::std::string& security_key() const;
+  void set_security_key(const ::std::string& value);
+  #if LANG_CXX11
+  void set_security_key(::std::string&& value);
+  #endif
+  void set_security_key(const char* value);
+  void set_security_key(const char* value, size_t size);
+  ::std::string* mutable_security_key();
+  ::std::string* release_security_key();
+  void set_allocated_security_key(::std::string* security_key);
+
+  // .Kinova.Api.Base.Ssid ssid = 1;
+  bool has_ssid() const;
+  void clear_ssid();
+  static const int kSsidFieldNumber = 1;
+  const ::Kinova::Api::Base::Ssid& ssid() const;
+  ::Kinova::Api::Base::Ssid* release_ssid();
+  ::Kinova::Api::Base::Ssid* mutable_ssid();
+  void set_allocated_ssid(::Kinova::Api::Base::Ssid* ssid);
+
+  // bool connect_automatically = 3;
+  void clear_connect_automatically();
+  static const int kConnectAutomaticallyFieldNumber = 3;
+  bool connect_automatically() const;
+  void set_connect_automatically(bool value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.WifiConfiguration)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::internal::ArenaStringPtr security_key_;
+  ::Kinova::Api::Base::Ssid* ssid_;
+  bool connect_automatically_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsWifiConfigurationImpl();
+};
+// -------------------------------------------------------------------
+
+class WifiConfigurationList : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.WifiConfigurationList) */ {
+ public:
+  WifiConfigurationList();
+  virtual ~WifiConfigurationList();
+
+  WifiConfigurationList(const WifiConfigurationList& from);
+
+  inline WifiConfigurationList& operator=(const WifiConfigurationList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  WifiConfigurationList(WifiConfigurationList&& from) noexcept
+    : WifiConfigurationList() {
+    *this = ::std::move(from);
+  }
+
+  inline WifiConfigurationList& operator=(WifiConfigurationList&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const WifiConfigurationList& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const WifiConfigurationList* internal_default_instance() {
+    return reinterpret_cast<const WifiConfigurationList*>(
+               &_WifiConfigurationList_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    45;
+
+  void Swap(WifiConfigurationList* other);
+  friend void swap(WifiConfigurationList& a, WifiConfigurationList& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline WifiConfigurationList* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  WifiConfigurationList* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const WifiConfigurationList& from);
+  void MergeFrom(const WifiConfigurationList& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(WifiConfigurationList* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .Kinova.Api.Base.WifiConfiguration wifi_configuration_list = 1;
+  int wifi_configuration_list_size() const;
+  void clear_wifi_configuration_list();
+  static const int kWifiConfigurationListFieldNumber = 1;
+  const ::Kinova::Api::Base::WifiConfiguration& wifi_configuration_list(int index) const;
+  ::Kinova::Api::Base::WifiConfiguration* mutable_wifi_configuration_list(int index);
+  ::Kinova::Api::Base::WifiConfiguration* add_wifi_configuration_list();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::WifiConfiguration >*
+      mutable_wifi_configuration_list();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::WifiConfiguration >&
+      wifi_configuration_list() const;
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.WifiConfigurationList)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::WifiConfiguration > wifi_configuration_list_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsWifiConfigurationListImpl();
+};
+// -------------------------------------------------------------------
+
+class ProtectionZoneHandle : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.ProtectionZoneHandle) */ {
+ public:
+  ProtectionZoneHandle();
+  virtual ~ProtectionZoneHandle();
+
+  ProtectionZoneHandle(const ProtectionZoneHandle& from);
+
+  inline ProtectionZoneHandle& operator=(const ProtectionZoneHandle& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ProtectionZoneHandle(ProtectionZoneHandle&& from) noexcept
+    : ProtectionZoneHandle() {
+    *this = ::std::move(from);
+  }
+
+  inline ProtectionZoneHandle& operator=(ProtectionZoneHandle&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ProtectionZoneHandle& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ProtectionZoneHandle* internal_default_instance() {
+    return reinterpret_cast<const ProtectionZoneHandle*>(
+               &_ProtectionZoneHandle_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    46;
+
+  void Swap(ProtectionZoneHandle* other);
+  friend void swap(ProtectionZoneHandle& a, ProtectionZoneHandle& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ProtectionZoneHandle* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ProtectionZoneHandle* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ProtectionZoneHandle& from);
+  void MergeFrom(const ProtectionZoneHandle& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ProtectionZoneHandle* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // uint32 identifier = 1;
+  void clear_identifier();
+  static const int kIdentifierFieldNumber = 1;
+  ::google::protobuf::uint32 identifier() const;
+  void set_identifier(::google::protobuf::uint32 value);
+
+  // fixed32 permission = 2;
+  void clear_permission();
+  static const int kPermissionFieldNumber = 2;
+  ::google::protobuf::uint32 permission() const;
+  void set_permission(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.ProtectionZoneHandle)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 identifier_;
+  ::google::protobuf::uint32 permission_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsProtectionZoneHandleImpl();
+};
+// -------------------------------------------------------------------
+
+class RotationMatrixRow : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.RotationMatrixRow) */ {
+ public:
+  RotationMatrixRow();
+  virtual ~RotationMatrixRow();
+
+  RotationMatrixRow(const RotationMatrixRow& from);
+
+  inline RotationMatrixRow& operator=(const RotationMatrixRow& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  RotationMatrixRow(RotationMatrixRow&& from) noexcept
+    : RotationMatrixRow() {
+    *this = ::std::move(from);
+  }
+
+  inline RotationMatrixRow& operator=(RotationMatrixRow&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const RotationMatrixRow& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const RotationMatrixRow* internal_default_instance() {
+    return reinterpret_cast<const RotationMatrixRow*>(
+               &_RotationMatrixRow_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    47;
+
+  void Swap(RotationMatrixRow* other);
+  friend void swap(RotationMatrixRow& a, RotationMatrixRow& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline RotationMatrixRow* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  RotationMatrixRow* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const RotationMatrixRow& from);
+  void MergeFrom(const RotationMatrixRow& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(RotationMatrixRow* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // float column1 = 1;
+  void clear_column1();
+  static const int kColumn1FieldNumber = 1;
+  float column1() const;
+  void set_column1(float value);
+
+  // float column2 = 2;
+  void clear_column2();
+  static const int kColumn2FieldNumber = 2;
+  float column2() const;
+  void set_column2(float value);
+
+  // float column3 = 3;
+  void clear_column3();
+  static const int kColumn3FieldNumber = 3;
+  float column3() const;
+  void set_column3(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.RotationMatrixRow)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  float column1_;
+  float column2_;
+  float column3_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsRotationMatrixRowImpl();
+};
+// -------------------------------------------------------------------
+
+class RotationMatrix : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.RotationMatrix) */ {
+ public:
+  RotationMatrix();
+  virtual ~RotationMatrix();
+
+  RotationMatrix(const RotationMatrix& from);
+
+  inline RotationMatrix& operator=(const RotationMatrix& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  RotationMatrix(RotationMatrix&& from) noexcept
+    : RotationMatrix() {
+    *this = ::std::move(from);
+  }
+
+  inline RotationMatrix& operator=(RotationMatrix&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const RotationMatrix& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const RotationMatrix* internal_default_instance() {
+    return reinterpret_cast<const RotationMatrix*>(
+               &_RotationMatrix_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    48;
+
+  void Swap(RotationMatrix* other);
+  friend void swap(RotationMatrix& a, RotationMatrix& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline RotationMatrix* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  RotationMatrix* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const RotationMatrix& from);
+  void MergeFrom(const RotationMatrix& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(RotationMatrix* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Base.RotationMatrixRow row1 = 1;
+  bool has_row1() const;
+  void clear_row1();
+  static const int kRow1FieldNumber = 1;
+  const ::Kinova::Api::Base::RotationMatrixRow& row1() const;
+  ::Kinova::Api::Base::RotationMatrixRow* release_row1();
+  ::Kinova::Api::Base::RotationMatrixRow* mutable_row1();
+  void set_allocated_row1(::Kinova::Api::Base::RotationMatrixRow* row1);
+
+  // .Kinova.Api.Base.RotationMatrixRow row2 = 2;
+  bool has_row2() const;
+  void clear_row2();
+  static const int kRow2FieldNumber = 2;
+  const ::Kinova::Api::Base::RotationMatrixRow& row2() const;
+  ::Kinova::Api::Base::RotationMatrixRow* release_row2();
+  ::Kinova::Api::Base::RotationMatrixRow* mutable_row2();
+  void set_allocated_row2(::Kinova::Api::Base::RotationMatrixRow* row2);
+
+  // .Kinova.Api.Base.RotationMatrixRow row3 = 3;
+  bool has_row3() const;
+  void clear_row3();
+  static const int kRow3FieldNumber = 3;
+  const ::Kinova::Api::Base::RotationMatrixRow& row3() const;
+  ::Kinova::Api::Base::RotationMatrixRow* release_row3();
+  ::Kinova::Api::Base::RotationMatrixRow* mutable_row3();
+  void set_allocated_row3(::Kinova::Api::Base::RotationMatrixRow* row3);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.RotationMatrix)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::Base::RotationMatrixRow* row1_;
+  ::Kinova::Api::Base::RotationMatrixRow* row2_;
+  ::Kinova::Api::Base::RotationMatrixRow* row3_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsRotationMatrixImpl();
+};
+// -------------------------------------------------------------------
+
+class Point : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.Point) */ {
+ public:
+  Point();
+  virtual ~Point();
+
+  Point(const Point& from);
+
+  inline Point& operator=(const Point& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Point(Point&& from) noexcept
+    : Point() {
+    *this = ::std::move(from);
+  }
+
+  inline Point& operator=(Point&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Point& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Point* internal_default_instance() {
+    return reinterpret_cast<const Point*>(
+               &_Point_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    49;
+
+  void Swap(Point* other);
+  friend void swap(Point& a, Point& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Point* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Point* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Point& from);
+  void MergeFrom(const Point& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Point* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // float x = 1;
+  void clear_x();
+  static const int kXFieldNumber = 1;
+  float x() const;
+  void set_x(float value);
+
+  // float y = 2;
+  void clear_y();
+  static const int kYFieldNumber = 2;
+  float y() const;
+  void set_y(float value);
+
+  // float z = 3;
+  void clear_z();
+  static const int kZFieldNumber = 3;
+  float z() const;
+  void set_z(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.Point)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  float x_;
+  float y_;
+  float z_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsPointImpl();
+};
+// -------------------------------------------------------------------
+
+class ZoneShape : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.ZoneShape) */ {
+ public:
+  ZoneShape();
+  virtual ~ZoneShape();
+
+  ZoneShape(const ZoneShape& from);
+
+  inline ZoneShape& operator=(const ZoneShape& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ZoneShape(ZoneShape&& from) noexcept
+    : ZoneShape() {
+    *this = ::std::move(from);
+  }
+
+  inline ZoneShape& operator=(ZoneShape&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ZoneShape& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ZoneShape* internal_default_instance() {
+    return reinterpret_cast<const ZoneShape*>(
+               &_ZoneShape_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    50;
+
+  void Swap(ZoneShape* other);
+  friend void swap(ZoneShape& a, ZoneShape& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ZoneShape* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ZoneShape* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ZoneShape& from);
+  void MergeFrom(const ZoneShape& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ZoneShape* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated float dimensions = 4;
+  int dimensions_size() const;
+  void clear_dimensions();
+  static const int kDimensionsFieldNumber = 4;
+  float dimensions(int index) const;
+  void set_dimensions(int index, float value);
+  void add_dimensions(float value);
+  const ::google::protobuf::RepeatedField< float >&
+      dimensions() const;
+  ::google::protobuf::RepeatedField< float >*
+      mutable_dimensions();
+
+  // .Kinova.Api.Base.Point origin = 2;
+  bool has_origin() const;
+  void clear_origin();
+  static const int kOriginFieldNumber = 2;
+  const ::Kinova::Api::Base::Point& origin() const;
+  ::Kinova::Api::Base::Point* release_origin();
+  ::Kinova::Api::Base::Point* mutable_origin();
+  void set_allocated_origin(::Kinova::Api::Base::Point* origin);
+
+  // .Kinova.Api.Base.RotationMatrix orientation = 3;
+  bool has_orientation() const;
+  void clear_orientation();
+  static const int kOrientationFieldNumber = 3;
+  const ::Kinova::Api::Base::RotationMatrix& orientation() const;
+  ::Kinova::Api::Base::RotationMatrix* release_orientation();
+  ::Kinova::Api::Base::RotationMatrix* mutable_orientation();
+  void set_allocated_orientation(::Kinova::Api::Base::RotationMatrix* orientation);
+
+  // .Kinova.Api.Base.ShapeType shape_type = 1;
+  void clear_shape_type();
+  static const int kShapeTypeFieldNumber = 1;
+  ::Kinova::Api::Base::ShapeType shape_type() const;
+  void set_shape_type(::Kinova::Api::Base::ShapeType value);
+
+  // float envelope_thickness = 5;
+  void clear_envelope_thickness();
+  static const int kEnvelopeThicknessFieldNumber = 5;
+  float envelope_thickness() const;
+  void set_envelope_thickness(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.ZoneShape)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedField< float > dimensions_;
+  mutable int _dimensions_cached_byte_size_;
+  ::Kinova::Api::Base::Point* origin_;
+  ::Kinova::Api::Base::RotationMatrix* orientation_;
+  int shape_type_;
+  float envelope_thickness_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsZoneShapeImpl();
+};
+// -------------------------------------------------------------------
+
+class ProtectionZone : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.ProtectionZone) */ {
+ public:
+  ProtectionZone();
+  virtual ~ProtectionZone();
+
+  ProtectionZone(const ProtectionZone& from);
+
+  inline ProtectionZone& operator=(const ProtectionZone& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ProtectionZone(ProtectionZone&& from) noexcept
+    : ProtectionZone() {
+    *this = ::std::move(from);
+  }
+
+  inline ProtectionZone& operator=(ProtectionZone&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ProtectionZone& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ProtectionZone* internal_default_instance() {
+    return reinterpret_cast<const ProtectionZone*>(
+               &_ProtectionZone_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    51;
+
+  void Swap(ProtectionZone* other);
+  friend void swap(ProtectionZone& a, ProtectionZone& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ProtectionZone* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ProtectionZone* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ProtectionZone& from);
+  void MergeFrom(const ProtectionZone& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ProtectionZone* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .Kinova.Api.Base.CartesianLimitation limitations = 6;
+  int limitations_size() const;
+  void clear_limitations();
+  static const int kLimitationsFieldNumber = 6;
+  const ::Kinova::Api::Base::CartesianLimitation& limitations(int index) const;
+  ::Kinova::Api::Base::CartesianLimitation* mutable_limitations(int index);
+  ::Kinova::Api::Base::CartesianLimitation* add_limitations();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::CartesianLimitation >*
+      mutable_limitations();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::CartesianLimitation >&
+      limitations() const;
+
+  // repeated .Kinova.Api.Base.CartesianLimitation envelope_limitations = 7;
+  int envelope_limitations_size() const;
+  void clear_envelope_limitations();
+  static const int kEnvelopeLimitationsFieldNumber = 7;
+  const ::Kinova::Api::Base::CartesianLimitation& envelope_limitations(int index) const;
+  ::Kinova::Api::Base::CartesianLimitation* mutable_envelope_limitations(int index);
+  ::Kinova::Api::Base::CartesianLimitation* add_envelope_limitations();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::CartesianLimitation >*
+      mutable_envelope_limitations();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::CartesianLimitation >&
+      envelope_limitations() const;
+
+  // string name = 2;
+  void clear_name();
+  static const int kNameFieldNumber = 2;
+  const ::std::string& name() const;
+  void set_name(const ::std::string& value);
+  #if LANG_CXX11
+  void set_name(::std::string&& value);
+  #endif
+  void set_name(const char* value);
+  void set_name(const char* value, size_t size);
+  ::std::string* mutable_name();
+  ::std::string* release_name();
+  void set_allocated_name(::std::string* name);
+
+  // string application_data = 3;
+  void clear_application_data();
+  static const int kApplicationDataFieldNumber = 3;
+  const ::std::string& application_data() const;
+  void set_application_data(const ::std::string& value);
+  #if LANG_CXX11
+  void set_application_data(::std::string&& value);
+  #endif
+  void set_application_data(const char* value);
+  void set_application_data(const char* value, size_t size);
+  ::std::string* mutable_application_data();
+  ::std::string* release_application_data();
+  void set_allocated_application_data(::std::string* application_data);
+
+  // .Kinova.Api.Base.ProtectionZoneHandle handle = 1;
+  bool has_handle() const;
+  void clear_handle();
+  static const int kHandleFieldNumber = 1;
+  const ::Kinova::Api::Base::ProtectionZoneHandle& handle() const;
+  ::Kinova::Api::Base::ProtectionZoneHandle* release_handle();
+  ::Kinova::Api::Base::ProtectionZoneHandle* mutable_handle();
+  void set_allocated_handle(::Kinova::Api::Base::ProtectionZoneHandle* handle);
+
+  // .Kinova.Api.Base.ZoneShape shape = 5;
+  bool has_shape() const;
+  void clear_shape();
+  static const int kShapeFieldNumber = 5;
+  const ::Kinova::Api::Base::ZoneShape& shape() const;
+  ::Kinova::Api::Base::ZoneShape* release_shape();
+  ::Kinova::Api::Base::ZoneShape* mutable_shape();
+  void set_allocated_shape(::Kinova::Api::Base::ZoneShape* shape);
+
+  // bool is_enabled = 4;
+  void clear_is_enabled();
+  static const int kIsEnabledFieldNumber = 4;
+  bool is_enabled() const;
+  void set_is_enabled(bool value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.ProtectionZone)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::CartesianLimitation > limitations_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::CartesianLimitation > envelope_limitations_;
+  ::google::protobuf::internal::ArenaStringPtr name_;
+  ::google::protobuf::internal::ArenaStringPtr application_data_;
+  ::Kinova::Api::Base::ProtectionZoneHandle* handle_;
+  ::Kinova::Api::Base::ZoneShape* shape_;
+  bool is_enabled_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsProtectionZoneImpl();
+};
+// -------------------------------------------------------------------
+
+class ProtectionZoneList : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.ProtectionZoneList) */ {
+ public:
+  ProtectionZoneList();
+  virtual ~ProtectionZoneList();
+
+  ProtectionZoneList(const ProtectionZoneList& from);
+
+  inline ProtectionZoneList& operator=(const ProtectionZoneList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ProtectionZoneList(ProtectionZoneList&& from) noexcept
+    : ProtectionZoneList() {
+    *this = ::std::move(from);
+  }
+
+  inline ProtectionZoneList& operator=(ProtectionZoneList&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ProtectionZoneList& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ProtectionZoneList* internal_default_instance() {
+    return reinterpret_cast<const ProtectionZoneList*>(
+               &_ProtectionZoneList_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    52;
+
+  void Swap(ProtectionZoneList* other);
+  friend void swap(ProtectionZoneList& a, ProtectionZoneList& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ProtectionZoneList* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ProtectionZoneList* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ProtectionZoneList& from);
+  void MergeFrom(const ProtectionZoneList& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ProtectionZoneList* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .Kinova.Api.Base.ProtectionZone protection_zones = 1;
+  int protection_zones_size() const;
+  void clear_protection_zones();
+  static const int kProtectionZonesFieldNumber = 1;
+  const ::Kinova::Api::Base::ProtectionZone& protection_zones(int index) const;
+  ::Kinova::Api::Base::ProtectionZone* mutable_protection_zones(int index);
+  ::Kinova::Api::Base::ProtectionZone* add_protection_zones();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::ProtectionZone >*
+      mutable_protection_zones();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::ProtectionZone >&
+      protection_zones() const;
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.ProtectionZoneList)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::ProtectionZone > protection_zones_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsProtectionZoneListImpl();
+};
+// -------------------------------------------------------------------
+
+class CartesianLimitation : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.CartesianLimitation) */ {
+ public:
+  CartesianLimitation();
+  virtual ~CartesianLimitation();
+
+  CartesianLimitation(const CartesianLimitation& from);
+
+  inline CartesianLimitation& operator=(const CartesianLimitation& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  CartesianLimitation(CartesianLimitation&& from) noexcept
+    : CartesianLimitation() {
+    *this = ::std::move(from);
+  }
+
+  inline CartesianLimitation& operator=(CartesianLimitation&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const CartesianLimitation& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const CartesianLimitation* internal_default_instance() {
+    return reinterpret_cast<const CartesianLimitation*>(
+               &_CartesianLimitation_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    53;
+
+  void Swap(CartesianLimitation* other);
+  friend void swap(CartesianLimitation& a, CartesianLimitation& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline CartesianLimitation* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  CartesianLimitation* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const CartesianLimitation& from);
+  void MergeFrom(const CartesianLimitation& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(CartesianLimitation* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Base.LimitationType type = 1;
+  void clear_type();
+  static const int kTypeFieldNumber = 1;
+  ::Kinova::Api::Base::LimitationType type() const;
+  void set_type(::Kinova::Api::Base::LimitationType value);
+
+  // float translation = 2;
+  void clear_translation();
+  static const int kTranslationFieldNumber = 2;
+  float translation() const;
+  void set_translation(float value);
+
+  // float orientation = 3;
+  void clear_orientation();
+  static const int kOrientationFieldNumber = 3;
+  float orientation() const;
+  void set_orientation(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.CartesianLimitation)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  int type_;
+  float translation_;
+  float orientation_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsCartesianLimitationImpl();
+};
+// -------------------------------------------------------------------
+
+class TwistLimitation : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.TwistLimitation) */ {
+ public:
+  TwistLimitation();
+  virtual ~TwistLimitation();
+
+  TwistLimitation(const TwistLimitation& from);
+
+  inline TwistLimitation& operator=(const TwistLimitation& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  TwistLimitation(TwistLimitation&& from) noexcept
+    : TwistLimitation() {
+    *this = ::std::move(from);
+  }
+
+  inline TwistLimitation& operator=(TwistLimitation&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const TwistLimitation& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const TwistLimitation* internal_default_instance() {
+    return reinterpret_cast<const TwistLimitation*>(
+               &_TwistLimitation_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    54;
+
+  void Swap(TwistLimitation* other);
+  friend void swap(TwistLimitation& a, TwistLimitation& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline TwistLimitation* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  TwistLimitation* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const TwistLimitation& from);
+  void MergeFrom(const TwistLimitation& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(TwistLimitation* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // float linear = 1;
+  void clear_linear();
+  static const int kLinearFieldNumber = 1;
+  float linear() const;
+  void set_linear(float value);
+
+  // float angular = 2;
+  void clear_angular();
+  static const int kAngularFieldNumber = 2;
+  float angular() const;
+  void set_angular(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.TwistLimitation)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  float linear_;
+  float angular_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsTwistLimitationImpl();
+};
+// -------------------------------------------------------------------
+
+class WrenchLimitation : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.WrenchLimitation) */ {
+ public:
+  WrenchLimitation();
+  virtual ~WrenchLimitation();
+
+  WrenchLimitation(const WrenchLimitation& from);
+
+  inline WrenchLimitation& operator=(const WrenchLimitation& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  WrenchLimitation(WrenchLimitation&& from) noexcept
+    : WrenchLimitation() {
+    *this = ::std::move(from);
+  }
+
+  inline WrenchLimitation& operator=(WrenchLimitation&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const WrenchLimitation& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const WrenchLimitation* internal_default_instance() {
+    return reinterpret_cast<const WrenchLimitation*>(
+               &_WrenchLimitation_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    55;
+
+  void Swap(WrenchLimitation* other);
+  friend void swap(WrenchLimitation& a, WrenchLimitation& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline WrenchLimitation* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  WrenchLimitation* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const WrenchLimitation& from);
+  void MergeFrom(const WrenchLimitation& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(WrenchLimitation* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // float force = 1;
+  void clear_force();
+  static const int kForceFieldNumber = 1;
+  float force() const;
+  void set_force(float value);
+
+  // float torque = 2;
+  void clear_torque();
+  static const int kTorqueFieldNumber = 2;
+  float torque() const;
+  void set_torque(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.WrenchLimitation)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  float force_;
+  float torque_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsWrenchLimitationImpl();
+};
+// -------------------------------------------------------------------
+
+class CartesianLimitationList : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.CartesianLimitationList) */ {
+ public:
+  CartesianLimitationList();
+  virtual ~CartesianLimitationList();
+
+  CartesianLimitationList(const CartesianLimitationList& from);
+
+  inline CartesianLimitationList& operator=(const CartesianLimitationList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  CartesianLimitationList(CartesianLimitationList&& from) noexcept
+    : CartesianLimitationList() {
+    *this = ::std::move(from);
+  }
+
+  inline CartesianLimitationList& operator=(CartesianLimitationList&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const CartesianLimitationList& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const CartesianLimitationList* internal_default_instance() {
+    return reinterpret_cast<const CartesianLimitationList*>(
+               &_CartesianLimitationList_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    56;
+
+  void Swap(CartesianLimitationList* other);
+  friend void swap(CartesianLimitationList& a, CartesianLimitationList& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline CartesianLimitationList* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  CartesianLimitationList* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const CartesianLimitationList& from);
+  void MergeFrom(const CartesianLimitationList& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(CartesianLimitationList* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .Kinova.Api.Base.CartesianLimitation limitations = 1;
+  int limitations_size() const;
+  void clear_limitations();
+  static const int kLimitationsFieldNumber = 1;
+  const ::Kinova::Api::Base::CartesianLimitation& limitations(int index) const;
+  ::Kinova::Api::Base::CartesianLimitation* mutable_limitations(int index);
+  ::Kinova::Api::Base::CartesianLimitation* add_limitations();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::CartesianLimitation >*
+      mutable_limitations();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::CartesianLimitation >&
+      limitations() const;
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.CartesianLimitationList)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::CartesianLimitation > limitations_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsCartesianLimitationListImpl();
+};
+// -------------------------------------------------------------------
+
+class JointLimitation : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.JointLimitation) */ {
+ public:
+  JointLimitation();
+  virtual ~JointLimitation();
+
+  JointLimitation(const JointLimitation& from);
+
+  inline JointLimitation& operator=(const JointLimitation& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  JointLimitation(JointLimitation&& from) noexcept
+    : JointLimitation() {
+    *this = ::std::move(from);
+  }
+
+  inline JointLimitation& operator=(JointLimitation&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const JointLimitation& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const JointLimitation* internal_default_instance() {
+    return reinterpret_cast<const JointLimitation*>(
+               &_JointLimitation_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    57;
+
+  void Swap(JointLimitation* other);
+  friend void swap(JointLimitation& a, JointLimitation& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline JointLimitation* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  JointLimitation* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const JointLimitation& from);
+  void MergeFrom(const JointLimitation& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(JointLimitation* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // uint32 joint_identifier = 1;
+  void clear_joint_identifier();
+  static const int kJointIdentifierFieldNumber = 1;
+  ::google::protobuf::uint32 joint_identifier() const;
+  void set_joint_identifier(::google::protobuf::uint32 value);
+
+  // .Kinova.Api.Base.LimitationType type = 2;
+  void clear_type();
+  static const int kTypeFieldNumber = 2;
+  ::Kinova::Api::Base::LimitationType type() const;
+  void set_type(::Kinova::Api::Base::LimitationType value);
+
+  // float value = 3;
+  void clear_value();
+  static const int kValueFieldNumber = 3;
+  float value() const;
+  void set_value(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.JointLimitation)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 joint_identifier_;
+  int type_;
+  float value_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsJointLimitationImpl();
+};
+// -------------------------------------------------------------------
+
+class JointsLimitationsList : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.JointsLimitationsList) */ {
+ public:
+  JointsLimitationsList();
+  virtual ~JointsLimitationsList();
+
+  JointsLimitationsList(const JointsLimitationsList& from);
+
+  inline JointsLimitationsList& operator=(const JointsLimitationsList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  JointsLimitationsList(JointsLimitationsList&& from) noexcept
+    : JointsLimitationsList() {
+    *this = ::std::move(from);
+  }
+
+  inline JointsLimitationsList& operator=(JointsLimitationsList&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const JointsLimitationsList& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const JointsLimitationsList* internal_default_instance() {
+    return reinterpret_cast<const JointsLimitationsList*>(
+               &_JointsLimitationsList_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    58;
+
+  void Swap(JointsLimitationsList* other);
+  friend void swap(JointsLimitationsList& a, JointsLimitationsList& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline JointsLimitationsList* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  JointsLimitationsList* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const JointsLimitationsList& from);
+  void MergeFrom(const JointsLimitationsList& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(JointsLimitationsList* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .Kinova.Api.Base.JointLimitation joints_limitations = 1;
+  int joints_limitations_size() const;
+  void clear_joints_limitations();
+  static const int kJointsLimitationsFieldNumber = 1;
+  const ::Kinova::Api::Base::JointLimitation& joints_limitations(int index) const;
+  ::Kinova::Api::Base::JointLimitation* mutable_joints_limitations(int index);
+  ::Kinova::Api::Base::JointLimitation* add_joints_limitations();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::JointLimitation >*
+      mutable_joints_limitations();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::JointLimitation >&
+      joints_limitations() const;
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.JointsLimitationsList)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::JointLimitation > joints_limitations_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsJointsLimitationsListImpl();
+};
+// -------------------------------------------------------------------
+
+class ConfigurationChangeNotification : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.ConfigurationChangeNotification) */ {
+ public:
+  ConfigurationChangeNotification();
+  virtual ~ConfigurationChangeNotification();
+
+  ConfigurationChangeNotification(const ConfigurationChangeNotification& from);
+
+  inline ConfigurationChangeNotification& operator=(const ConfigurationChangeNotification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ConfigurationChangeNotification(ConfigurationChangeNotification&& from) noexcept
+    : ConfigurationChangeNotification() {
+    *this = ::std::move(from);
+  }
+
+  inline ConfigurationChangeNotification& operator=(ConfigurationChangeNotification&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ConfigurationChangeNotification& default_instance();
+
+  enum ConfigurationChangeCase {
+    kSequenceHandle = 4,
+    kActionHandle = 5,
+    kMappingHandle = 6,
+    kMapGroupHandle = 7,
+    kMapHandle = 8,
+    kUserProfileHandle = 9,
+    kProtectionZoneHandle = 10,
+    kSafetyHandle = 11,
+    kNetworkHandle = 12,
+    kSsid = 14,
+    kControllerHandle = 16,
+    CONFIGURATION_CHANGE_NOT_SET = 0,
+  };
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ConfigurationChangeNotification* internal_default_instance() {
+    return reinterpret_cast<const ConfigurationChangeNotification*>(
+               &_ConfigurationChangeNotification_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    59;
+
+  void Swap(ConfigurationChangeNotification* other);
+  friend void swap(ConfigurationChangeNotification& a, ConfigurationChangeNotification& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ConfigurationChangeNotification* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ConfigurationChangeNotification* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ConfigurationChangeNotification& from);
+  void MergeFrom(const ConfigurationChangeNotification& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ConfigurationChangeNotification* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Common.Timestamp timestamp = 2;
+  bool has_timestamp() const;
+  void clear_timestamp();
+  static const int kTimestampFieldNumber = 2;
+  const ::Kinova::Api::Common::Timestamp& timestamp() const;
+  ::Kinova::Api::Common::Timestamp* release_timestamp();
+  ::Kinova::Api::Common::Timestamp* mutable_timestamp();
+  void set_allocated_timestamp(::Kinova::Api::Common::Timestamp* timestamp);
+
+  // .Kinova.Api.Common.UserProfileHandle user_handle = 3;
+  bool has_user_handle() const;
+  void clear_user_handle();
+  static const int kUserHandleFieldNumber = 3;
+  const ::Kinova::Api::Common::UserProfileHandle& user_handle() const;
+  ::Kinova::Api::Common::UserProfileHandle* release_user_handle();
+  ::Kinova::Api::Common::UserProfileHandle* mutable_user_handle();
+  void set_allocated_user_handle(::Kinova::Api::Common::UserProfileHandle* user_handle);
+
+  // .Kinova.Api.Common.Connection connection = 15;
+  bool has_connection() const;
+  void clear_connection();
+  static const int kConnectionFieldNumber = 15;
+  const ::Kinova::Api::Common::Connection& connection() const;
+  ::Kinova::Api::Common::Connection* release_connection();
+  ::Kinova::Api::Common::Connection* mutable_connection();
+  void set_allocated_connection(::Kinova::Api::Common::Connection* connection);
+
+  // .Kinova.Api.Base.ConfigurationNotificationEvent event = 1;
+  void clear_event();
+  static const int kEventFieldNumber = 1;
+  ::Kinova::Api::Base::ConfigurationNotificationEvent event() const;
+  void set_event(::Kinova::Api::Base::ConfigurationNotificationEvent value);
+
+  // .Kinova.Api.Base.SequenceHandle sequence_handle = 4;
+  bool has_sequence_handle() const;
+  void clear_sequence_handle();
+  static const int kSequenceHandleFieldNumber = 4;
+  const ::Kinova::Api::Base::SequenceHandle& sequence_handle() const;
+  ::Kinova::Api::Base::SequenceHandle* release_sequence_handle();
+  ::Kinova::Api::Base::SequenceHandle* mutable_sequence_handle();
+  void set_allocated_sequence_handle(::Kinova::Api::Base::SequenceHandle* sequence_handle);
+
+  // .Kinova.Api.Base.ActionHandle action_handle = 5;
+  bool has_action_handle() const;
+  void clear_action_handle();
+  static const int kActionHandleFieldNumber = 5;
+  const ::Kinova::Api::Base::ActionHandle& action_handle() const;
+  ::Kinova::Api::Base::ActionHandle* release_action_handle();
+  ::Kinova::Api::Base::ActionHandle* mutable_action_handle();
+  void set_allocated_action_handle(::Kinova::Api::Base::ActionHandle* action_handle);
+
+  // .Kinova.Api.Base.MappingHandle mapping_handle = 6;
+  bool has_mapping_handle() const;
+  void clear_mapping_handle();
+  static const int kMappingHandleFieldNumber = 6;
+  const ::Kinova::Api::Base::MappingHandle& mapping_handle() const;
+  ::Kinova::Api::Base::MappingHandle* release_mapping_handle();
+  ::Kinova::Api::Base::MappingHandle* mutable_mapping_handle();
+  void set_allocated_mapping_handle(::Kinova::Api::Base::MappingHandle* mapping_handle);
+
+  // .Kinova.Api.Base.MapGroupHandle map_group_handle = 7;
+  bool has_map_group_handle() const;
+  void clear_map_group_handle();
+  static const int kMapGroupHandleFieldNumber = 7;
+  const ::Kinova::Api::Base::MapGroupHandle& map_group_handle() const;
+  ::Kinova::Api::Base::MapGroupHandle* release_map_group_handle();
+  ::Kinova::Api::Base::MapGroupHandle* mutable_map_group_handle();
+  void set_allocated_map_group_handle(::Kinova::Api::Base::MapGroupHandle* map_group_handle);
+
+  // .Kinova.Api.Base.MapHandle map_handle = 8;
+  bool has_map_handle() const;
+  void clear_map_handle();
+  static const int kMapHandleFieldNumber = 8;
+  const ::Kinova::Api::Base::MapHandle& map_handle() const;
+  ::Kinova::Api::Base::MapHandle* release_map_handle();
+  ::Kinova::Api::Base::MapHandle* mutable_map_handle();
+  void set_allocated_map_handle(::Kinova::Api::Base::MapHandle* map_handle);
+
+  // .Kinova.Api.Common.UserProfileHandle user_profile_handle = 9;
+  bool has_user_profile_handle() const;
+  void clear_user_profile_handle();
+  static const int kUserProfileHandleFieldNumber = 9;
+  const ::Kinova::Api::Common::UserProfileHandle& user_profile_handle() const;
+  ::Kinova::Api::Common::UserProfileHandle* release_user_profile_handle();
+  ::Kinova::Api::Common::UserProfileHandle* mutable_user_profile_handle();
+  void set_allocated_user_profile_handle(::Kinova::Api::Common::UserProfileHandle* user_profile_handle);
+
+  // .Kinova.Api.Base.ProtectionZoneHandle protection_zone_handle = 10;
+  bool has_protection_zone_handle() const;
+  void clear_protection_zone_handle();
+  static const int kProtectionZoneHandleFieldNumber = 10;
+  const ::Kinova::Api::Base::ProtectionZoneHandle& protection_zone_handle() const;
+  ::Kinova::Api::Base::ProtectionZoneHandle* release_protection_zone_handle();
+  ::Kinova::Api::Base::ProtectionZoneHandle* mutable_protection_zone_handle();
+  void set_allocated_protection_zone_handle(::Kinova::Api::Base::ProtectionZoneHandle* protection_zone_handle);
+
+  // .Kinova.Api.Common.SafetyHandle safety_handle = 11;
+  bool has_safety_handle() const;
+  void clear_safety_handle();
+  static const int kSafetyHandleFieldNumber = 11;
+  const ::Kinova::Api::Common::SafetyHandle& safety_handle() const;
+  ::Kinova::Api::Common::SafetyHandle* release_safety_handle();
+  ::Kinova::Api::Common::SafetyHandle* mutable_safety_handle();
+  void set_allocated_safety_handle(::Kinova::Api::Common::SafetyHandle* safety_handle);
+
+  // .Kinova.Api.Base.NetworkHandle network_handle = 12;
+  bool has_network_handle() const;
+  void clear_network_handle();
+  static const int kNetworkHandleFieldNumber = 12;
+  const ::Kinova::Api::Base::NetworkHandle& network_handle() const;
+  ::Kinova::Api::Base::NetworkHandle* release_network_handle();
+  ::Kinova::Api::Base::NetworkHandle* mutable_network_handle();
+  void set_allocated_network_handle(::Kinova::Api::Base::NetworkHandle* network_handle);
+
+  // .Kinova.Api.Base.Ssid ssid = 14;
+  bool has_ssid() const;
+  void clear_ssid();
+  static const int kSsidFieldNumber = 14;
+  const ::Kinova::Api::Base::Ssid& ssid() const;
+  ::Kinova::Api::Base::Ssid* release_ssid();
+  ::Kinova::Api::Base::Ssid* mutable_ssid();
+  void set_allocated_ssid(::Kinova::Api::Base::Ssid* ssid);
+
+  // .Kinova.Api.Base.ControllerHandle controller_handle = 16;
+  bool has_controller_handle() const;
+  void clear_controller_handle();
+  static const int kControllerHandleFieldNumber = 16;
+  const ::Kinova::Api::Base::ControllerHandle& controller_handle() const;
+  ::Kinova::Api::Base::ControllerHandle* release_controller_handle();
+  ::Kinova::Api::Base::ControllerHandle* mutable_controller_handle();
+  void set_allocated_controller_handle(::Kinova::Api::Base::ControllerHandle* controller_handle);
+
+  ConfigurationChangeCase configuration_change_case() const;
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.ConfigurationChangeNotification)
+ private:
+  void set_has_sequence_handle();
+  void set_has_action_handle();
+  void set_has_mapping_handle();
+  void set_has_map_group_handle();
+  void set_has_map_handle();
+  void set_has_user_profile_handle();
+  void set_has_protection_zone_handle();
+  void set_has_safety_handle();
+  void set_has_network_handle();
+  void set_has_ssid();
+  void set_has_controller_handle();
+
+  inline bool has_configuration_change() const;
+  void clear_configuration_change();
+  inline void clear_has_configuration_change();
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::Common::Timestamp* timestamp_;
+  ::Kinova::Api::Common::UserProfileHandle* user_handle_;
+  ::Kinova::Api::Common::Connection* connection_;
+  int event_;
+  union ConfigurationChangeUnion {
+    ConfigurationChangeUnion() {}
+    ::Kinova::Api::Base::SequenceHandle* sequence_handle_;
+    ::Kinova::Api::Base::ActionHandle* action_handle_;
+    ::Kinova::Api::Base::MappingHandle* mapping_handle_;
+    ::Kinova::Api::Base::MapGroupHandle* map_group_handle_;
+    ::Kinova::Api::Base::MapHandle* map_handle_;
+    ::Kinova::Api::Common::UserProfileHandle* user_profile_handle_;
+    ::Kinova::Api::Base::ProtectionZoneHandle* protection_zone_handle_;
+    ::Kinova::Api::Common::SafetyHandle* safety_handle_;
+    ::Kinova::Api::Base::NetworkHandle* network_handle_;
+    ::Kinova::Api::Base::Ssid* ssid_;
+    ::Kinova::Api::Base::ControllerHandle* controller_handle_;
+  } configuration_change_;
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _oneof_case_[1];
+
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsConfigurationChangeNotificationImpl();
+};
+// -------------------------------------------------------------------
+
+class MappingInfoNotification : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.MappingInfoNotification) */ {
+ public:
+  MappingInfoNotification();
+  virtual ~MappingInfoNotification();
+
+  MappingInfoNotification(const MappingInfoNotification& from);
+
+  inline MappingInfoNotification& operator=(const MappingInfoNotification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  MappingInfoNotification(MappingInfoNotification&& from) noexcept
+    : MappingInfoNotification() {
+    *this = ::std::move(from);
+  }
+
+  inline MappingInfoNotification& operator=(MappingInfoNotification&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const MappingInfoNotification& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const MappingInfoNotification* internal_default_instance() {
+    return reinterpret_cast<const MappingInfoNotification*>(
+               &_MappingInfoNotification_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    60;
+
+  void Swap(MappingInfoNotification* other);
+  friend void swap(MappingInfoNotification& a, MappingInfoNotification& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline MappingInfoNotification* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  MappingInfoNotification* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const MappingInfoNotification& from);
+  void MergeFrom(const MappingInfoNotification& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(MappingInfoNotification* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Base.MapHandle active_map_handle = 2;
+  bool has_active_map_handle() const;
+  void clear_active_map_handle();
+  static const int kActiveMapHandleFieldNumber = 2;
+  const ::Kinova::Api::Base::MapHandle& active_map_handle() const;
+  ::Kinova::Api::Base::MapHandle* release_active_map_handle();
+  ::Kinova::Api::Base::MapHandle* mutable_active_map_handle();
+  void set_allocated_active_map_handle(::Kinova::Api::Base::MapHandle* active_map_handle);
+
+  // .Kinova.Api.Common.Timestamp timestamp = 3;
+  bool has_timestamp() const;
+  void clear_timestamp();
+  static const int kTimestampFieldNumber = 3;
+  const ::Kinova::Api::Common::Timestamp& timestamp() const;
+  ::Kinova::Api::Common::Timestamp* release_timestamp();
+  ::Kinova::Api::Common::Timestamp* mutable_timestamp();
+  void set_allocated_timestamp(::Kinova::Api::Common::Timestamp* timestamp);
+
+  // .Kinova.Api.Common.UserProfileHandle user_handle = 4;
+  bool has_user_handle() const;
+  void clear_user_handle();
+  static const int kUserHandleFieldNumber = 4;
+  const ::Kinova::Api::Common::UserProfileHandle& user_handle() const;
+  ::Kinova::Api::Common::UserProfileHandle* release_user_handle();
+  ::Kinova::Api::Common::UserProfileHandle* mutable_user_handle();
+  void set_allocated_user_handle(::Kinova::Api::Common::UserProfileHandle* user_handle);
+
+  // .Kinova.Api.Common.Connection connection = 5;
+  bool has_connection() const;
+  void clear_connection();
+  static const int kConnectionFieldNumber = 5;
+  const ::Kinova::Api::Common::Connection& connection() const;
+  ::Kinova::Api::Common::Connection* release_connection();
+  ::Kinova::Api::Common::Connection* mutable_connection();
+  void set_allocated_connection(::Kinova::Api::Common::Connection* connection);
+
+  // .Kinova.Api.Base.MappingHandle mapping_handle = 6;
+  bool has_mapping_handle() const;
+  void clear_mapping_handle();
+  static const int kMappingHandleFieldNumber = 6;
+  const ::Kinova::Api::Base::MappingHandle& mapping_handle() const;
+  ::Kinova::Api::Base::MappingHandle* release_mapping_handle();
+  ::Kinova::Api::Base::MappingHandle* mutable_mapping_handle();
+  void set_allocated_mapping_handle(::Kinova::Api::Base::MappingHandle* mapping_handle);
+
+  // uint32 controller_identifier = 1;
+  void clear_controller_identifier();
+  static const int kControllerIdentifierFieldNumber = 1;
+  ::google::protobuf::uint32 controller_identifier() const;
+  void set_controller_identifier(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.MappingInfoNotification)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::Base::MapHandle* active_map_handle_;
+  ::Kinova::Api::Common::Timestamp* timestamp_;
+  ::Kinova::Api::Common::UserProfileHandle* user_handle_;
+  ::Kinova::Api::Common::Connection* connection_;
+  ::Kinova::Api::Base::MappingHandle* mapping_handle_;
+  ::google::protobuf::uint32 controller_identifier_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsMappingInfoNotificationImpl();
+};
+// -------------------------------------------------------------------
+
+class ServoingModeInformation : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.ServoingModeInformation) */ {
+ public:
+  ServoingModeInformation();
+  virtual ~ServoingModeInformation();
+
+  ServoingModeInformation(const ServoingModeInformation& from);
+
+  inline ServoingModeInformation& operator=(const ServoingModeInformation& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ServoingModeInformation(ServoingModeInformation&& from) noexcept
+    : ServoingModeInformation() {
+    *this = ::std::move(from);
+  }
+
+  inline ServoingModeInformation& operator=(ServoingModeInformation&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ServoingModeInformation& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ServoingModeInformation* internal_default_instance() {
+    return reinterpret_cast<const ServoingModeInformation*>(
+               &_ServoingModeInformation_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    61;
+
+  void Swap(ServoingModeInformation* other);
+  friend void swap(ServoingModeInformation& a, ServoingModeInformation& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ServoingModeInformation* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ServoingModeInformation* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ServoingModeInformation& from);
+  void MergeFrom(const ServoingModeInformation& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ServoingModeInformation* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Base.ServoingMode servoing_mode = 1;
+  void clear_servoing_mode();
+  static const int kServoingModeFieldNumber = 1;
+  ::Kinova::Api::Base::ServoingMode servoing_mode() const;
+  void set_servoing_mode(::Kinova::Api::Base::ServoingMode value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.ServoingModeInformation)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  int servoing_mode_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsServoingModeInformationImpl();
+};
+// -------------------------------------------------------------------
+
+class OperatingModeInformation : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.OperatingModeInformation) */ {
+ public:
+  OperatingModeInformation();
+  virtual ~OperatingModeInformation();
+
+  OperatingModeInformation(const OperatingModeInformation& from);
+
+  inline OperatingModeInformation& operator=(const OperatingModeInformation& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  OperatingModeInformation(OperatingModeInformation&& from) noexcept
+    : OperatingModeInformation() {
+    *this = ::std::move(from);
+  }
+
+  inline OperatingModeInformation& operator=(OperatingModeInformation&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const OperatingModeInformation& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const OperatingModeInformation* internal_default_instance() {
+    return reinterpret_cast<const OperatingModeInformation*>(
+               &_OperatingModeInformation_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    62;
+
+  void Swap(OperatingModeInformation* other);
+  friend void swap(OperatingModeInformation& a, OperatingModeInformation& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline OperatingModeInformation* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  OperatingModeInformation* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const OperatingModeInformation& from);
+  void MergeFrom(const OperatingModeInformation& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(OperatingModeInformation* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Common.DeviceHandle device_handle = 2;
+  bool has_device_handle() const;
+  void clear_device_handle();
+  static const int kDeviceHandleFieldNumber = 2;
+  const ::Kinova::Api::Common::DeviceHandle& device_handle() const;
+  ::Kinova::Api::Common::DeviceHandle* release_device_handle();
+  ::Kinova::Api::Common::DeviceHandle* mutable_device_handle();
+  void set_allocated_device_handle(::Kinova::Api::Common::DeviceHandle* device_handle);
+
+  // .Kinova.Api.Base.OperatingMode operating_mode = 1;
+  void clear_operating_mode();
+  static const int kOperatingModeFieldNumber = 1;
+  ::Kinova::Api::Base::OperatingMode operating_mode() const;
+  void set_operating_mode(::Kinova::Api::Base::OperatingMode value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.OperatingModeInformation)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::Common::DeviceHandle* device_handle_;
+  int operating_mode_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsOperatingModeInformationImpl();
+};
+// -------------------------------------------------------------------
+
+class OperatingModeNotification : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.OperatingModeNotification) */ {
+ public:
+  OperatingModeNotification();
+  virtual ~OperatingModeNotification();
+
+  OperatingModeNotification(const OperatingModeNotification& from);
+
+  inline OperatingModeNotification& operator=(const OperatingModeNotification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  OperatingModeNotification(OperatingModeNotification&& from) noexcept
+    : OperatingModeNotification() {
+    *this = ::std::move(from);
+  }
+
+  inline OperatingModeNotification& operator=(OperatingModeNotification&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const OperatingModeNotification& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const OperatingModeNotification* internal_default_instance() {
+    return reinterpret_cast<const OperatingModeNotification*>(
+               &_OperatingModeNotification_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    63;
+
+  void Swap(OperatingModeNotification* other);
+  friend void swap(OperatingModeNotification& a, OperatingModeNotification& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline OperatingModeNotification* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  OperatingModeNotification* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const OperatingModeNotification& from);
+  void MergeFrom(const OperatingModeNotification& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(OperatingModeNotification* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Common.Timestamp timestamp = 2;
+  bool has_timestamp() const;
+  void clear_timestamp();
+  static const int kTimestampFieldNumber = 2;
+  const ::Kinova::Api::Common::Timestamp& timestamp() const;
+  ::Kinova::Api::Common::Timestamp* release_timestamp();
+  ::Kinova::Api::Common::Timestamp* mutable_timestamp();
+  void set_allocated_timestamp(::Kinova::Api::Common::Timestamp* timestamp);
+
+  // .Kinova.Api.Common.UserProfileHandle user_handle = 3;
+  bool has_user_handle() const;
+  void clear_user_handle();
+  static const int kUserHandleFieldNumber = 3;
+  const ::Kinova::Api::Common::UserProfileHandle& user_handle() const;
+  ::Kinova::Api::Common::UserProfileHandle* release_user_handle();
+  ::Kinova::Api::Common::UserProfileHandle* mutable_user_handle();
+  void set_allocated_user_handle(::Kinova::Api::Common::UserProfileHandle* user_handle);
+
+  // .Kinova.Api.Common.Connection connection = 4;
+  bool has_connection() const;
+  void clear_connection();
+  static const int kConnectionFieldNumber = 4;
+  const ::Kinova::Api::Common::Connection& connection() const;
+  ::Kinova::Api::Common::Connection* release_connection();
+  ::Kinova::Api::Common::Connection* mutable_connection();
+  void set_allocated_connection(::Kinova::Api::Common::Connection* connection);
+
+  // .Kinova.Api.Common.DeviceHandle device_handle = 5;
+  bool has_device_handle() const;
+  void clear_device_handle();
+  static const int kDeviceHandleFieldNumber = 5;
+  const ::Kinova::Api::Common::DeviceHandle& device_handle() const;
+  ::Kinova::Api::Common::DeviceHandle* release_device_handle();
+  ::Kinova::Api::Common::DeviceHandle* mutable_device_handle();
+  void set_allocated_device_handle(::Kinova::Api::Common::DeviceHandle* device_handle);
+
+  // .Kinova.Api.Base.OperatingMode operating_mode = 1;
+  void clear_operating_mode();
+  static const int kOperatingModeFieldNumber = 1;
+  ::Kinova::Api::Base::OperatingMode operating_mode() const;
+  void set_operating_mode(::Kinova::Api::Base::OperatingMode value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.OperatingModeNotification)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::Common::Timestamp* timestamp_;
+  ::Kinova::Api::Common::UserProfileHandle* user_handle_;
+  ::Kinova::Api::Common::Connection* connection_;
+  ::Kinova::Api::Common::DeviceHandle* device_handle_;
+  int operating_mode_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsOperatingModeNotificationImpl();
+};
+// -------------------------------------------------------------------
+
+class ServoingModeNotification : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.ServoingModeNotification) */ {
+ public:
+  ServoingModeNotification();
+  virtual ~ServoingModeNotification();
+
+  ServoingModeNotification(const ServoingModeNotification& from);
+
+  inline ServoingModeNotification& operator=(const ServoingModeNotification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ServoingModeNotification(ServoingModeNotification&& from) noexcept
+    : ServoingModeNotification() {
+    *this = ::std::move(from);
+  }
+
+  inline ServoingModeNotification& operator=(ServoingModeNotification&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ServoingModeNotification& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ServoingModeNotification* internal_default_instance() {
+    return reinterpret_cast<const ServoingModeNotification*>(
+               &_ServoingModeNotification_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    64;
+
+  void Swap(ServoingModeNotification* other);
+  friend void swap(ServoingModeNotification& a, ServoingModeNotification& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ServoingModeNotification* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ServoingModeNotification* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ServoingModeNotification& from);
+  void MergeFrom(const ServoingModeNotification& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ServoingModeNotification* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Common.Timestamp timestamp = 2;
+  bool has_timestamp() const;
+  void clear_timestamp();
+  static const int kTimestampFieldNumber = 2;
+  const ::Kinova::Api::Common::Timestamp& timestamp() const;
+  ::Kinova::Api::Common::Timestamp* release_timestamp();
+  ::Kinova::Api::Common::Timestamp* mutable_timestamp();
+  void set_allocated_timestamp(::Kinova::Api::Common::Timestamp* timestamp);
+
+  // .Kinova.Api.Common.UserProfileHandle user_handle = 3;
+  bool has_user_handle() const;
+  void clear_user_handle();
+  static const int kUserHandleFieldNumber = 3;
+  const ::Kinova::Api::Common::UserProfileHandle& user_handle() const;
+  ::Kinova::Api::Common::UserProfileHandle* release_user_handle();
+  ::Kinova::Api::Common::UserProfileHandle* mutable_user_handle();
+  void set_allocated_user_handle(::Kinova::Api::Common::UserProfileHandle* user_handle);
+
+  // .Kinova.Api.Common.Connection connection = 4;
+  bool has_connection() const;
+  void clear_connection();
+  static const int kConnectionFieldNumber = 4;
+  const ::Kinova::Api::Common::Connection& connection() const;
+  ::Kinova::Api::Common::Connection* release_connection();
+  ::Kinova::Api::Common::Connection* mutable_connection();
+  void set_allocated_connection(::Kinova::Api::Common::Connection* connection);
+
+  // .Kinova.Api.Base.ServoingMode servoing_mode = 1;
+  void clear_servoing_mode();
+  static const int kServoingModeFieldNumber = 1;
+  ::Kinova::Api::Base::ServoingMode servoing_mode() const;
+  void set_servoing_mode(::Kinova::Api::Base::ServoingMode value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.ServoingModeNotification)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::Common::Timestamp* timestamp_;
+  ::Kinova::Api::Common::UserProfileHandle* user_handle_;
+  ::Kinova::Api::Common::Connection* connection_;
+  int servoing_mode_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsServoingModeNotificationImpl();
+};
+// -------------------------------------------------------------------
+
+class SequenceInfoNotification : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.SequenceInfoNotification) */ {
+ public:
+  SequenceInfoNotification();
+  virtual ~SequenceInfoNotification();
+
+  SequenceInfoNotification(const SequenceInfoNotification& from);
+
+  inline SequenceInfoNotification& operator=(const SequenceInfoNotification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  SequenceInfoNotification(SequenceInfoNotification&& from) noexcept
+    : SequenceInfoNotification() {
+    *this = ::std::move(from);
+  }
+
+  inline SequenceInfoNotification& operator=(SequenceInfoNotification&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SequenceInfoNotification& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const SequenceInfoNotification* internal_default_instance() {
+    return reinterpret_cast<const SequenceInfoNotification*>(
+               &_SequenceInfoNotification_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    65;
+
+  void Swap(SequenceInfoNotification* other);
+  friend void swap(SequenceInfoNotification& a, SequenceInfoNotification& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SequenceInfoNotification* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  SequenceInfoNotification* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const SequenceInfoNotification& from);
+  void MergeFrom(const SequenceInfoNotification& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(SequenceInfoNotification* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Base.SequenceHandle sequence_handle = 2;
+  bool has_sequence_handle() const;
+  void clear_sequence_handle();
+  static const int kSequenceHandleFieldNumber = 2;
+  const ::Kinova::Api::Base::SequenceHandle& sequence_handle() const;
+  ::Kinova::Api::Base::SequenceHandle* release_sequence_handle();
+  ::Kinova::Api::Base::SequenceHandle* mutable_sequence_handle();
+  void set_allocated_sequence_handle(::Kinova::Api::Base::SequenceHandle* sequence_handle);
+
+  // .Kinova.Api.Common.Timestamp timestamp = 5;
+  bool has_timestamp() const;
+  void clear_timestamp();
+  static const int kTimestampFieldNumber = 5;
+  const ::Kinova::Api::Common::Timestamp& timestamp() const;
+  ::Kinova::Api::Common::Timestamp* release_timestamp();
+  ::Kinova::Api::Common::Timestamp* mutable_timestamp();
+  void set_allocated_timestamp(::Kinova::Api::Common::Timestamp* timestamp);
+
+  // .Kinova.Api.Common.UserProfileHandle user_handle = 6;
+  bool has_user_handle() const;
+  void clear_user_handle();
+  static const int kUserHandleFieldNumber = 6;
+  const ::Kinova::Api::Common::UserProfileHandle& user_handle() const;
+  ::Kinova::Api::Common::UserProfileHandle* release_user_handle();
+  ::Kinova::Api::Common::UserProfileHandle* mutable_user_handle();
+  void set_allocated_user_handle(::Kinova::Api::Common::UserProfileHandle* user_handle);
+
+  // .Kinova.Api.Common.Connection connection = 8;
+  bool has_connection() const;
+  void clear_connection();
+  static const int kConnectionFieldNumber = 8;
+  const ::Kinova::Api::Common::Connection& connection() const;
+  ::Kinova::Api::Common::Connection* release_connection();
+  ::Kinova::Api::Common::Connection* mutable_connection();
+  void set_allocated_connection(::Kinova::Api::Common::Connection* connection);
+
+  // .Kinova.Api.Base.EventIdSequenceInfoNotification event_identifier = 1;
+  void clear_event_identifier();
+  static const int kEventIdentifierFieldNumber = 1;
+  ::Kinova::Api::Base::EventIdSequenceInfoNotification event_identifier() const;
+  void set_event_identifier(::Kinova::Api::Base::EventIdSequenceInfoNotification value);
+
+  // uint32 task_index = 3;
+  void clear_task_index();
+  static const int kTaskIndexFieldNumber = 3;
+  ::google::protobuf::uint32 task_index() const;
+  void set_task_index(::google::protobuf::uint32 value);
+
+  // .Kinova.Api.SubErrorCodes abort_details = 7;
+  void clear_abort_details();
+  static const int kAbortDetailsFieldNumber = 7;
+  ::Kinova::Api::SubErrorCodes abort_details() const;
+  void set_abort_details(::Kinova::Api::SubErrorCodes value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.SequenceInfoNotification)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::Base::SequenceHandle* sequence_handle_;
+  ::Kinova::Api::Common::Timestamp* timestamp_;
+  ::Kinova::Api::Common::UserProfileHandle* user_handle_;
+  ::Kinova::Api::Common::Connection* connection_;
+  int event_identifier_;
+  ::google::protobuf::uint32 task_index_;
+  int abort_details_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsSequenceInfoNotificationImpl();
+};
+// -------------------------------------------------------------------
+
+class SequenceInformation : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.SequenceInformation) */ {
+ public:
+  SequenceInformation();
+  virtual ~SequenceInformation();
+
+  SequenceInformation(const SequenceInformation& from);
+
+  inline SequenceInformation& operator=(const SequenceInformation& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  SequenceInformation(SequenceInformation&& from) noexcept
+    : SequenceInformation() {
+    *this = ::std::move(from);
+  }
+
+  inline SequenceInformation& operator=(SequenceInformation&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SequenceInformation& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const SequenceInformation* internal_default_instance() {
+    return reinterpret_cast<const SequenceInformation*>(
+               &_SequenceInformation_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    66;
+
+  void Swap(SequenceInformation* other);
+  friend void swap(SequenceInformation& a, SequenceInformation& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SequenceInformation* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  SequenceInformation* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const SequenceInformation& from);
+  void MergeFrom(const SequenceInformation& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(SequenceInformation* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Base.EventIdSequenceInfoNotification event_identifier = 1;
+  void clear_event_identifier();
+  static const int kEventIdentifierFieldNumber = 1;
+  ::Kinova::Api::Base::EventIdSequenceInfoNotification event_identifier() const;
+  void set_event_identifier(::Kinova::Api::Base::EventIdSequenceInfoNotification value);
+
+  // uint32 task_index = 2;
+  void clear_task_index();
+  static const int kTaskIndexFieldNumber = 2;
+  ::google::protobuf::uint32 task_index() const;
+  void set_task_index(::google::protobuf::uint32 value);
+
+  // uint32 task_identifier = 3;
+  void clear_task_identifier();
+  static const int kTaskIdentifierFieldNumber = 3;
+  ::google::protobuf::uint32 task_identifier() const;
+  void set_task_identifier(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.SequenceInformation)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  int event_identifier_;
+  ::google::protobuf::uint32 task_index_;
+  ::google::protobuf::uint32 task_identifier_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsSequenceInformationImpl();
+};
+// -------------------------------------------------------------------
+
+class ProtectionZoneNotification : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.ProtectionZoneNotification) */ {
+ public:
+  ProtectionZoneNotification();
+  virtual ~ProtectionZoneNotification();
+
+  ProtectionZoneNotification(const ProtectionZoneNotification& from);
+
+  inline ProtectionZoneNotification& operator=(const ProtectionZoneNotification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ProtectionZoneNotification(ProtectionZoneNotification&& from) noexcept
+    : ProtectionZoneNotification() {
+    *this = ::std::move(from);
+  }
+
+  inline ProtectionZoneNotification& operator=(ProtectionZoneNotification&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ProtectionZoneNotification& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ProtectionZoneNotification* internal_default_instance() {
+    return reinterpret_cast<const ProtectionZoneNotification*>(
+               &_ProtectionZoneNotification_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    67;
+
+  void Swap(ProtectionZoneNotification* other);
+  friend void swap(ProtectionZoneNotification& a, ProtectionZoneNotification& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ProtectionZoneNotification* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ProtectionZoneNotification* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ProtectionZoneNotification& from);
+  void MergeFrom(const ProtectionZoneNotification& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ProtectionZoneNotification* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Base.ProtectionZoneHandle handle = 2;
+  bool has_handle() const;
+  void clear_handle();
+  static const int kHandleFieldNumber = 2;
+  const ::Kinova::Api::Base::ProtectionZoneHandle& handle() const;
+  ::Kinova::Api::Base::ProtectionZoneHandle* release_handle();
+  ::Kinova::Api::Base::ProtectionZoneHandle* mutable_handle();
+  void set_allocated_handle(::Kinova::Api::Base::ProtectionZoneHandle* handle);
+
+  // .Kinova.Api.Common.Timestamp timestamp = 3;
+  bool has_timestamp() const;
+  void clear_timestamp();
+  static const int kTimestampFieldNumber = 3;
+  const ::Kinova::Api::Common::Timestamp& timestamp() const;
+  ::Kinova::Api::Common::Timestamp* release_timestamp();
+  ::Kinova::Api::Common::Timestamp* mutable_timestamp();
+  void set_allocated_timestamp(::Kinova::Api::Common::Timestamp* timestamp);
+
+  // .Kinova.Api.Common.UserProfileHandle user_handle = 4;
+  bool has_user_handle() const;
+  void clear_user_handle();
+  static const int kUserHandleFieldNumber = 4;
+  const ::Kinova::Api::Common::UserProfileHandle& user_handle() const;
+  ::Kinova::Api::Common::UserProfileHandle* release_user_handle();
+  ::Kinova::Api::Common::UserProfileHandle* mutable_user_handle();
+  void set_allocated_user_handle(::Kinova::Api::Common::UserProfileHandle* user_handle);
+
+  // .Kinova.Api.Common.Connection connection = 5;
+  bool has_connection() const;
+  void clear_connection();
+  static const int kConnectionFieldNumber = 5;
+  const ::Kinova::Api::Common::Connection& connection() const;
+  ::Kinova::Api::Common::Connection* release_connection();
+  ::Kinova::Api::Common::Connection* mutable_connection();
+  void set_allocated_connection(::Kinova::Api::Common::Connection* connection);
+
+  // .Kinova.Api.Base.ProtectionZoneEvent event = 1;
+  void clear_event();
+  static const int kEventFieldNumber = 1;
+  ::Kinova::Api::Base::ProtectionZoneEvent event() const;
+  void set_event(::Kinova::Api::Base::ProtectionZoneEvent value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.ProtectionZoneNotification)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::Base::ProtectionZoneHandle* handle_;
+  ::Kinova::Api::Common::Timestamp* timestamp_;
+  ::Kinova::Api::Common::UserProfileHandle* user_handle_;
+  ::Kinova::Api::Common::Connection* connection_;
+  int event_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsProtectionZoneNotificationImpl();
+};
+// -------------------------------------------------------------------
+
+class ProtectionZoneInformation : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.ProtectionZoneInformation) */ {
+ public:
+  ProtectionZoneInformation();
+  virtual ~ProtectionZoneInformation();
+
+  ProtectionZoneInformation(const ProtectionZoneInformation& from);
+
+  inline ProtectionZoneInformation& operator=(const ProtectionZoneInformation& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ProtectionZoneInformation(ProtectionZoneInformation&& from) noexcept
+    : ProtectionZoneInformation() {
+    *this = ::std::move(from);
+  }
+
+  inline ProtectionZoneInformation& operator=(ProtectionZoneInformation&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ProtectionZoneInformation& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ProtectionZoneInformation* internal_default_instance() {
+    return reinterpret_cast<const ProtectionZoneInformation*>(
+               &_ProtectionZoneInformation_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    68;
+
+  void Swap(ProtectionZoneInformation* other);
+  friend void swap(ProtectionZoneInformation& a, ProtectionZoneInformation& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ProtectionZoneInformation* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ProtectionZoneInformation* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ProtectionZoneInformation& from);
+  void MergeFrom(const ProtectionZoneInformation& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ProtectionZoneInformation* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Base.ProtectionZoneEvent event = 1;
+  void clear_event();
+  static const int kEventFieldNumber = 1;
+  ::Kinova::Api::Base::ProtectionZoneEvent event() const;
+  void set_event(::Kinova::Api::Base::ProtectionZoneEvent value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.ProtectionZoneInformation)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  int event_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsProtectionZoneInformationImpl();
+};
+// -------------------------------------------------------------------
+
+class UserNotification : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.UserNotification) */ {
+ public:
+  UserNotification();
+  virtual ~UserNotification();
+
+  UserNotification(const UserNotification& from);
+
+  inline UserNotification& operator=(const UserNotification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  UserNotification(UserNotification&& from) noexcept
+    : UserNotification() {
+    *this = ::std::move(from);
+  }
+
+  inline UserNotification& operator=(UserNotification&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const UserNotification& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const UserNotification* internal_default_instance() {
+    return reinterpret_cast<const UserNotification*>(
+               &_UserNotification_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    69;
+
+  void Swap(UserNotification* other);
+  friend void swap(UserNotification& a, UserNotification& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline UserNotification* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  UserNotification* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const UserNotification& from);
+  void MergeFrom(const UserNotification& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(UserNotification* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Common.UserProfileHandle modified_user = 2;
+  bool has_modified_user() const;
+  void clear_modified_user();
+  static const int kModifiedUserFieldNumber = 2;
+  const ::Kinova::Api::Common::UserProfileHandle& modified_user() const;
+  ::Kinova::Api::Common::UserProfileHandle* release_modified_user();
+  ::Kinova::Api::Common::UserProfileHandle* mutable_modified_user();
+  void set_allocated_modified_user(::Kinova::Api::Common::UserProfileHandle* modified_user);
+
+  // .Kinova.Api.Common.Timestamp timestamp = 3;
+  bool has_timestamp() const;
+  void clear_timestamp();
+  static const int kTimestampFieldNumber = 3;
+  const ::Kinova::Api::Common::Timestamp& timestamp() const;
+  ::Kinova::Api::Common::Timestamp* release_timestamp();
+  ::Kinova::Api::Common::Timestamp* mutable_timestamp();
+  void set_allocated_timestamp(::Kinova::Api::Common::Timestamp* timestamp);
+
+  // .Kinova.Api.Common.UserProfileHandle user_handle = 4;
+  bool has_user_handle() const;
+  void clear_user_handle();
+  static const int kUserHandleFieldNumber = 4;
+  const ::Kinova::Api::Common::UserProfileHandle& user_handle() const;
+  ::Kinova::Api::Common::UserProfileHandle* release_user_handle();
+  ::Kinova::Api::Common::UserProfileHandle* mutable_user_handle();
+  void set_allocated_user_handle(::Kinova::Api::Common::UserProfileHandle* user_handle);
+
+  // .Kinova.Api.Common.Connection connection = 5;
+  bool has_connection() const;
+  void clear_connection();
+  static const int kConnectionFieldNumber = 5;
+  const ::Kinova::Api::Common::Connection& connection() const;
+  ::Kinova::Api::Common::Connection* release_connection();
+  ::Kinova::Api::Common::Connection* mutable_connection();
+  void set_allocated_connection(::Kinova::Api::Common::Connection* connection);
+
+  // .Kinova.Api.Base.UserEvent user_event = 1;
+  void clear_user_event();
+  static const int kUserEventFieldNumber = 1;
+  ::Kinova::Api::Base::UserEvent user_event() const;
+  void set_user_event(::Kinova::Api::Base::UserEvent value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.UserNotification)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::Common::UserProfileHandle* modified_user_;
+  ::Kinova::Api::Common::Timestamp* timestamp_;
+  ::Kinova::Api::Common::UserProfileHandle* user_handle_;
+  ::Kinova::Api::Common::Connection* connection_;
+  int user_event_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsUserNotificationImpl();
+};
+// -------------------------------------------------------------------
+
+class ControllerHandle : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.ControllerHandle) */ {
+ public:
+  ControllerHandle();
+  virtual ~ControllerHandle();
+
+  ControllerHandle(const ControllerHandle& from);
+
+  inline ControllerHandle& operator=(const ControllerHandle& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ControllerHandle(ControllerHandle&& from) noexcept
+    : ControllerHandle() {
+    *this = ::std::move(from);
+  }
+
+  inline ControllerHandle& operator=(ControllerHandle&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ControllerHandle& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ControllerHandle* internal_default_instance() {
+    return reinterpret_cast<const ControllerHandle*>(
+               &_ControllerHandle_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    70;
+
+  void Swap(ControllerHandle* other);
+  friend void swap(ControllerHandle& a, ControllerHandle& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ControllerHandle* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ControllerHandle* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ControllerHandle& from);
+  void MergeFrom(const ControllerHandle& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ControllerHandle* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Base.ControllerType type = 1;
+  void clear_type();
+  static const int kTypeFieldNumber = 1;
+  ::Kinova::Api::Base::ControllerType type() const;
+  void set_type(::Kinova::Api::Base::ControllerType value);
+
+  // uint32 controller_identifier = 2;
+  void clear_controller_identifier();
+  static const int kControllerIdentifierFieldNumber = 2;
+  ::google::protobuf::uint32 controller_identifier() const;
+  void set_controller_identifier(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.ControllerHandle)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  int type_;
+  ::google::protobuf::uint32 controller_identifier_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsControllerHandleImpl();
+};
+// -------------------------------------------------------------------
+
+class ControllerElementHandle : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.ControllerElementHandle) */ {
+ public:
+  ControllerElementHandle();
+  virtual ~ControllerElementHandle();
+
+  ControllerElementHandle(const ControllerElementHandle& from);
+
+  inline ControllerElementHandle& operator=(const ControllerElementHandle& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ControllerElementHandle(ControllerElementHandle&& from) noexcept
+    : ControllerElementHandle() {
+    *this = ::std::move(from);
+  }
+
+  inline ControllerElementHandle& operator=(ControllerElementHandle&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ControllerElementHandle& default_instance();
+
+  enum IdentifierCase {
+    kButton = 2,
+    kAxis = 3,
+    IDENTIFIER_NOT_SET = 0,
+  };
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ControllerElementHandle* internal_default_instance() {
+    return reinterpret_cast<const ControllerElementHandle*>(
+               &_ControllerElementHandle_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    71;
+
+  void Swap(ControllerElementHandle* other);
+  friend void swap(ControllerElementHandle& a, ControllerElementHandle& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ControllerElementHandle* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ControllerElementHandle* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ControllerElementHandle& from);
+  void MergeFrom(const ControllerElementHandle& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ControllerElementHandle* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Base.ControllerHandle controller_handle = 1;
+  bool has_controller_handle() const;
+  void clear_controller_handle();
+  static const int kControllerHandleFieldNumber = 1;
+  const ::Kinova::Api::Base::ControllerHandle& controller_handle() const;
+  ::Kinova::Api::Base::ControllerHandle* release_controller_handle();
+  ::Kinova::Api::Base::ControllerHandle* mutable_controller_handle();
+  void set_allocated_controller_handle(::Kinova::Api::Base::ControllerHandle* controller_handle);
+
+  // uint32 button = 2;
+  private:
+  bool has_button() const;
+  public:
+  void clear_button();
+  static const int kButtonFieldNumber = 2;
+  ::google::protobuf::uint32 button() const;
+  void set_button(::google::protobuf::uint32 value);
+
+  // uint32 axis = 3;
+  private:
+  bool has_axis() const;
+  public:
+  void clear_axis();
+  static const int kAxisFieldNumber = 3;
+  ::google::protobuf::uint32 axis() const;
+  void set_axis(::google::protobuf::uint32 value);
+
+  IdentifierCase identifier_case() const;
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.ControllerElementHandle)
+ private:
+  void set_has_button();
+  void set_has_axis();
+
+  inline bool has_identifier() const;
+  void clear_identifier();
+  inline void clear_has_identifier();
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::Base::ControllerHandle* controller_handle_;
+  union IdentifierUnion {
+    IdentifierUnion() {}
+    ::google::protobuf::uint32 button_;
+    ::google::protobuf::uint32 axis_;
+  } identifier_;
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _oneof_case_[1];
+
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsControllerElementHandleImpl();
+};
+// -------------------------------------------------------------------
+
+class ControllerNotification : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.ControllerNotification) */ {
+ public:
+  ControllerNotification();
+  virtual ~ControllerNotification();
+
+  ControllerNotification(const ControllerNotification& from);
+
+  inline ControllerNotification& operator=(const ControllerNotification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ControllerNotification(ControllerNotification&& from) noexcept
+    : ControllerNotification() {
+    *this = ::std::move(from);
+  }
+
+  inline ControllerNotification& operator=(ControllerNotification&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ControllerNotification& default_instance();
+
+  enum StateCase {
+    kControllerState = 1,
+    kControllerElement = 2,
+    STATE_NOT_SET = 0,
+  };
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ControllerNotification* internal_default_instance() {
+    return reinterpret_cast<const ControllerNotification*>(
+               &_ControllerNotification_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    72;
+
+  void Swap(ControllerNotification* other);
+  friend void swap(ControllerNotification& a, ControllerNotification& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ControllerNotification* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ControllerNotification* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ControllerNotification& from);
+  void MergeFrom(const ControllerNotification& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ControllerNotification* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Common.Timestamp timestamp = 3;
+  bool has_timestamp() const;
+  void clear_timestamp();
+  static const int kTimestampFieldNumber = 3;
+  const ::Kinova::Api::Common::Timestamp& timestamp() const;
+  ::Kinova::Api::Common::Timestamp* release_timestamp();
+  ::Kinova::Api::Common::Timestamp* mutable_timestamp();
+  void set_allocated_timestamp(::Kinova::Api::Common::Timestamp* timestamp);
+
+  // .Kinova.Api.Common.UserProfileHandle user_handle = 4;
+  bool has_user_handle() const;
+  void clear_user_handle();
+  static const int kUserHandleFieldNumber = 4;
+  const ::Kinova::Api::Common::UserProfileHandle& user_handle() const;
+  ::Kinova::Api::Common::UserProfileHandle* release_user_handle();
+  ::Kinova::Api::Common::UserProfileHandle* mutable_user_handle();
+  void set_allocated_user_handle(::Kinova::Api::Common::UserProfileHandle* user_handle);
+
+  // .Kinova.Api.Common.Connection connection = 5;
+  bool has_connection() const;
+  void clear_connection();
+  static const int kConnectionFieldNumber = 5;
+  const ::Kinova::Api::Common::Connection& connection() const;
+  ::Kinova::Api::Common::Connection* release_connection();
+  ::Kinova::Api::Common::Connection* mutable_connection();
+  void set_allocated_connection(::Kinova::Api::Common::Connection* connection);
+
+  // .Kinova.Api.Base.ControllerState controller_state = 1;
+  bool has_controller_state() const;
+  void clear_controller_state();
+  static const int kControllerStateFieldNumber = 1;
+  const ::Kinova::Api::Base::ControllerState& controller_state() const;
+  ::Kinova::Api::Base::ControllerState* release_controller_state();
+  ::Kinova::Api::Base::ControllerState* mutable_controller_state();
+  void set_allocated_controller_state(::Kinova::Api::Base::ControllerState* controller_state);
+
+  // .Kinova.Api.Base.ControllerElementState controller_element = 2;
+  bool has_controller_element() const;
+  void clear_controller_element();
+  static const int kControllerElementFieldNumber = 2;
+  const ::Kinova::Api::Base::ControllerElementState& controller_element() const;
+  ::Kinova::Api::Base::ControllerElementState* release_controller_element();
+  ::Kinova::Api::Base::ControllerElementState* mutable_controller_element();
+  void set_allocated_controller_element(::Kinova::Api::Base::ControllerElementState* controller_element);
+
+  StateCase state_case() const;
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.ControllerNotification)
+ private:
+  void set_has_controller_state();
+  void set_has_controller_element();
+
+  inline bool has_state() const;
+  void clear_state();
+  inline void clear_has_state();
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::Common::Timestamp* timestamp_;
+  ::Kinova::Api::Common::UserProfileHandle* user_handle_;
+  ::Kinova::Api::Common::Connection* connection_;
+  union StateUnion {
+    StateUnion() {}
+    ::Kinova::Api::Base::ControllerState* controller_state_;
+    ::Kinova::Api::Base::ControllerElementState* controller_element_;
+  } state_;
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _oneof_case_[1];
+
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsControllerNotificationImpl();
+};
+// -------------------------------------------------------------------
+
+class ControllerList : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.ControllerList) */ {
+ public:
+  ControllerList();
+  virtual ~ControllerList();
+
+  ControllerList(const ControllerList& from);
+
+  inline ControllerList& operator=(const ControllerList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ControllerList(ControllerList&& from) noexcept
+    : ControllerList() {
+    *this = ::std::move(from);
+  }
+
+  inline ControllerList& operator=(ControllerList&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ControllerList& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ControllerList* internal_default_instance() {
+    return reinterpret_cast<const ControllerList*>(
+               &_ControllerList_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    73;
+
+  void Swap(ControllerList* other);
+  friend void swap(ControllerList& a, ControllerList& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ControllerList* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ControllerList* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ControllerList& from);
+  void MergeFrom(const ControllerList& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ControllerList* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .Kinova.Api.Base.ControllerHandle handles = 1;
+  int handles_size() const;
+  void clear_handles();
+  static const int kHandlesFieldNumber = 1;
+  const ::Kinova::Api::Base::ControllerHandle& handles(int index) const;
+  ::Kinova::Api::Base::ControllerHandle* mutable_handles(int index);
+  ::Kinova::Api::Base::ControllerHandle* add_handles();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::ControllerHandle >*
+      mutable_handles();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::ControllerHandle >&
+      handles() const;
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.ControllerList)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::ControllerHandle > handles_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsControllerListImpl();
+};
+// -------------------------------------------------------------------
+
+class ControllerState : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.ControllerState) */ {
+ public:
+  ControllerState();
+  virtual ~ControllerState();
+
+  ControllerState(const ControllerState& from);
+
+  inline ControllerState& operator=(const ControllerState& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ControllerState(ControllerState&& from) noexcept
+    : ControllerState() {
+    *this = ::std::move(from);
+  }
+
+  inline ControllerState& operator=(ControllerState&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ControllerState& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ControllerState* internal_default_instance() {
+    return reinterpret_cast<const ControllerState*>(
+               &_ControllerState_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    74;
+
+  void Swap(ControllerState* other);
+  friend void swap(ControllerState& a, ControllerState& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ControllerState* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ControllerState* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ControllerState& from);
+  void MergeFrom(const ControllerState& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ControllerState* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Base.ControllerHandle handle = 1;
+  bool has_handle() const;
+  void clear_handle();
+  static const int kHandleFieldNumber = 1;
+  const ::Kinova::Api::Base::ControllerHandle& handle() const;
+  ::Kinova::Api::Base::ControllerHandle* release_handle();
+  ::Kinova::Api::Base::ControllerHandle* mutable_handle();
+  void set_allocated_handle(::Kinova::Api::Base::ControllerHandle* handle);
+
+  // .Kinova.Api.Base.ControllerEventType event_type = 2;
+  void clear_event_type();
+  static const int kEventTypeFieldNumber = 2;
+  ::Kinova::Api::Base::ControllerEventType event_type() const;
+  void set_event_type(::Kinova::Api::Base::ControllerEventType value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.ControllerState)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::Base::ControllerHandle* handle_;
+  int event_type_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsControllerStateImpl();
+};
+// -------------------------------------------------------------------
+
+class ControllerElementState : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.ControllerElementState) */ {
+ public:
+  ControllerElementState();
+  virtual ~ControllerElementState();
+
+  ControllerElementState(const ControllerElementState& from);
+
+  inline ControllerElementState& operator=(const ControllerElementState& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ControllerElementState(ControllerElementState&& from) noexcept
+    : ControllerElementState() {
+    *this = ::std::move(from);
+  }
+
+  inline ControllerElementState& operator=(ControllerElementState&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ControllerElementState& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ControllerElementState* internal_default_instance() {
+    return reinterpret_cast<const ControllerElementState*>(
+               &_ControllerElementState_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    75;
+
+  void Swap(ControllerElementState* other);
+  friend void swap(ControllerElementState& a, ControllerElementState& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ControllerElementState* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ControllerElementState* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ControllerElementState& from);
+  void MergeFrom(const ControllerElementState& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ControllerElementState* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Base.ControllerElementHandle handle = 1;
+  bool has_handle() const;
+  void clear_handle();
+  static const int kHandleFieldNumber = 1;
+  const ::Kinova::Api::Base::ControllerElementHandle& handle() const;
+  ::Kinova::Api::Base::ControllerElementHandle* release_handle();
+  ::Kinova::Api::Base::ControllerElementHandle* mutable_handle();
+  void set_allocated_handle(::Kinova::Api::Base::ControllerElementHandle* handle);
+
+  // .Kinova.Api.Base.ControllerElementEventType event_type = 2;
+  void clear_event_type();
+  static const int kEventTypeFieldNumber = 2;
+  ::Kinova::Api::Base::ControllerElementEventType event_type() const;
+  void set_event_type(::Kinova::Api::Base::ControllerElementEventType value);
+
+  // float axis_value = 3;
+  void clear_axis_value();
+  static const int kAxisValueFieldNumber = 3;
+  float axis_value() const;
+  void set_axis_value(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.ControllerElementState)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::Base::ControllerElementHandle* handle_;
+  int event_type_;
+  float axis_value_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsControllerElementStateImpl();
+};
+// -------------------------------------------------------------------
+
+class ActionNotification : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.ActionNotification) */ {
+ public:
+  ActionNotification();
+  virtual ~ActionNotification();
+
+  ActionNotification(const ActionNotification& from);
+
+  inline ActionNotification& operator=(const ActionNotification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ActionNotification(ActionNotification&& from) noexcept
+    : ActionNotification() {
+    *this = ::std::move(from);
+  }
+
+  inline ActionNotification& operator=(ActionNotification&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ActionNotification& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ActionNotification* internal_default_instance() {
+    return reinterpret_cast<const ActionNotification*>(
+               &_ActionNotification_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    76;
+
+  void Swap(ActionNotification* other);
+  friend void swap(ActionNotification& a, ActionNotification& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ActionNotification* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ActionNotification* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ActionNotification& from);
+  void MergeFrom(const ActionNotification& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ActionNotification* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .Kinova.Api.Base.TrajectoryInfo trajectory_info = 7;
+  int trajectory_info_size() const;
+  void clear_trajectory_info();
+  static const int kTrajectoryInfoFieldNumber = 7;
+  const ::Kinova::Api::Base::TrajectoryInfo& trajectory_info(int index) const;
+  ::Kinova::Api::Base::TrajectoryInfo* mutable_trajectory_info(int index);
+  ::Kinova::Api::Base::TrajectoryInfo* add_trajectory_info();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::TrajectoryInfo >*
+      mutable_trajectory_info();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::TrajectoryInfo >&
+      trajectory_info() const;
+
+  // .Kinova.Api.Base.ActionHandle handle = 2;
+  bool has_handle() const;
+  void clear_handle();
+  static const int kHandleFieldNumber = 2;
+  const ::Kinova::Api::Base::ActionHandle& handle() const;
+  ::Kinova::Api::Base::ActionHandle* release_handle();
+  ::Kinova::Api::Base::ActionHandle* mutable_handle();
+  void set_allocated_handle(::Kinova::Api::Base::ActionHandle* handle);
+
+  // .Kinova.Api.Common.Timestamp timestamp = 3;
+  bool has_timestamp() const;
+  void clear_timestamp();
+  static const int kTimestampFieldNumber = 3;
+  const ::Kinova::Api::Common::Timestamp& timestamp() const;
+  ::Kinova::Api::Common::Timestamp* release_timestamp();
+  ::Kinova::Api::Common::Timestamp* mutable_timestamp();
+  void set_allocated_timestamp(::Kinova::Api::Common::Timestamp* timestamp);
+
+  // .Kinova.Api.Common.UserProfileHandle user_handle = 4;
+  bool has_user_handle() const;
+  void clear_user_handle();
+  static const int kUserHandleFieldNumber = 4;
+  const ::Kinova::Api::Common::UserProfileHandle& user_handle() const;
+  ::Kinova::Api::Common::UserProfileHandle* release_user_handle();
+  ::Kinova::Api::Common::UserProfileHandle* mutable_user_handle();
+  void set_allocated_user_handle(::Kinova::Api::Common::UserProfileHandle* user_handle);
+
+  // .Kinova.Api.Common.Connection connection = 6;
+  bool has_connection() const;
+  void clear_connection();
+  static const int kConnectionFieldNumber = 6;
+  const ::Kinova::Api::Common::Connection& connection() const;
+  ::Kinova::Api::Common::Connection* release_connection();
+  ::Kinova::Api::Common::Connection* mutable_connection();
+  void set_allocated_connection(::Kinova::Api::Common::Connection* connection);
+
+  // .Kinova.Api.Base.ActionEvent action_event = 1;
+  void clear_action_event();
+  static const int kActionEventFieldNumber = 1;
+  ::Kinova::Api::Base::ActionEvent action_event() const;
+  void set_action_event(::Kinova::Api::Base::ActionEvent value);
+
+  // .Kinova.Api.SubErrorCodes abort_details = 5;
+  void clear_abort_details();
+  static const int kAbortDetailsFieldNumber = 5;
+  ::Kinova::Api::SubErrorCodes abort_details() const;
+  void set_abort_details(::Kinova::Api::SubErrorCodes value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.ActionNotification)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::TrajectoryInfo > trajectory_info_;
+  ::Kinova::Api::Base::ActionHandle* handle_;
+  ::Kinova::Api::Common::Timestamp* timestamp_;
+  ::Kinova::Api::Common::UserProfileHandle* user_handle_;
+  ::Kinova::Api::Common::Connection* connection_;
+  int action_event_;
+  int abort_details_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsActionNotificationImpl();
+};
+// -------------------------------------------------------------------
+
+class TrajectoryInfo : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.TrajectoryInfo) */ {
+ public:
+  TrajectoryInfo();
+  virtual ~TrajectoryInfo();
+
+  TrajectoryInfo(const TrajectoryInfo& from);
+
+  inline TrajectoryInfo& operator=(const TrajectoryInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  TrajectoryInfo(TrajectoryInfo&& from) noexcept
+    : TrajectoryInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline TrajectoryInfo& operator=(TrajectoryInfo&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const TrajectoryInfo& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const TrajectoryInfo* internal_default_instance() {
+    return reinterpret_cast<const TrajectoryInfo*>(
+               &_TrajectoryInfo_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    77;
+
+  void Swap(TrajectoryInfo* other);
+  friend void swap(TrajectoryInfo& a, TrajectoryInfo& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline TrajectoryInfo* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  TrajectoryInfo* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const TrajectoryInfo& from);
+  void MergeFrom(const TrajectoryInfo& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(TrajectoryInfo* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Base.TrajectoryInfoType trajectory_info_type = 1;
+  void clear_trajectory_info_type();
+  static const int kTrajectoryInfoTypeFieldNumber = 1;
+  ::Kinova::Api::Base::TrajectoryInfoType trajectory_info_type() const;
+  void set_trajectory_info_type(::Kinova::Api::Base::TrajectoryInfoType value);
+
+  // uint32 waypoint_index = 2;
+  void clear_waypoint_index();
+  static const int kWaypointIndexFieldNumber = 2;
+  ::google::protobuf::uint32 waypoint_index() const;
+  void set_waypoint_index(::google::protobuf::uint32 value);
+
+  // uint32 joint_index = 3;
+  void clear_joint_index();
+  static const int kJointIndexFieldNumber = 3;
+  ::google::protobuf::uint32 joint_index() const;
+  void set_joint_index(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.TrajectoryInfo)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  int trajectory_info_type_;
+  ::google::protobuf::uint32 waypoint_index_;
+  ::google::protobuf::uint32 joint_index_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsTrajectoryInfoImpl();
+};
+// -------------------------------------------------------------------
+
+class RobotEventNotification : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.RobotEventNotification) */ {
+ public:
+  RobotEventNotification();
+  virtual ~RobotEventNotification();
+
+  RobotEventNotification(const RobotEventNotification& from);
+
+  inline RobotEventNotification& operator=(const RobotEventNotification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  RobotEventNotification(RobotEventNotification&& from) noexcept
+    : RobotEventNotification() {
+    *this = ::std::move(from);
+  }
+
+  inline RobotEventNotification& operator=(RobotEventNotification&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const RobotEventNotification& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const RobotEventNotification* internal_default_instance() {
+    return reinterpret_cast<const RobotEventNotification*>(
+               &_RobotEventNotification_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    78;
+
+  void Swap(RobotEventNotification* other);
+  friend void swap(RobotEventNotification& a, RobotEventNotification& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline RobotEventNotification* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  RobotEventNotification* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const RobotEventNotification& from);
+  void MergeFrom(const RobotEventNotification& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(RobotEventNotification* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Common.DeviceHandle handle = 2;
+  bool has_handle() const;
+  void clear_handle();
+  static const int kHandleFieldNumber = 2;
+  const ::Kinova::Api::Common::DeviceHandle& handle() const;
+  ::Kinova::Api::Common::DeviceHandle* release_handle();
+  ::Kinova::Api::Common::DeviceHandle* mutable_handle();
+  void set_allocated_handle(::Kinova::Api::Common::DeviceHandle* handle);
+
+  // .Kinova.Api.Common.Timestamp timestamp = 3;
+  bool has_timestamp() const;
+  void clear_timestamp();
+  static const int kTimestampFieldNumber = 3;
+  const ::Kinova::Api::Common::Timestamp& timestamp() const;
+  ::Kinova::Api::Common::Timestamp* release_timestamp();
+  ::Kinova::Api::Common::Timestamp* mutable_timestamp();
+  void set_allocated_timestamp(::Kinova::Api::Common::Timestamp* timestamp);
+
+  // .Kinova.Api.Common.UserProfileHandle user_handle = 4;
+  bool has_user_handle() const;
+  void clear_user_handle();
+  static const int kUserHandleFieldNumber = 4;
+  const ::Kinova::Api::Common::UserProfileHandle& user_handle() const;
+  ::Kinova::Api::Common::UserProfileHandle* release_user_handle();
+  ::Kinova::Api::Common::UserProfileHandle* mutable_user_handle();
+  void set_allocated_user_handle(::Kinova::Api::Common::UserProfileHandle* user_handle);
+
+  // .Kinova.Api.Common.Connection connection = 6;
+  bool has_connection() const;
+  void clear_connection();
+  static const int kConnectionFieldNumber = 6;
+  const ::Kinova::Api::Common::Connection& connection() const;
+  ::Kinova::Api::Common::Connection* release_connection();
+  ::Kinova::Api::Common::Connection* mutable_connection();
+  void set_allocated_connection(::Kinova::Api::Common::Connection* connection);
+
+  // .Kinova.Api.Base.RobotEvent event = 1;
+  void clear_event();
+  static const int kEventFieldNumber = 1;
+  ::Kinova::Api::Base::RobotEvent event() const;
+  void set_event(::Kinova::Api::Base::RobotEvent value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.RobotEventNotification)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::Common::DeviceHandle* handle_;
+  ::Kinova::Api::Common::Timestamp* timestamp_;
+  ::Kinova::Api::Common::UserProfileHandle* user_handle_;
+  ::Kinova::Api::Common::Connection* connection_;
+  int event_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsRobotEventNotificationImpl();
+};
+// -------------------------------------------------------------------
+
+class FactoryNotification : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.FactoryNotification) */ {
+ public:
+  FactoryNotification();
+  virtual ~FactoryNotification();
+
+  FactoryNotification(const FactoryNotification& from);
+
+  inline FactoryNotification& operator=(const FactoryNotification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  FactoryNotification(FactoryNotification&& from) noexcept
+    : FactoryNotification() {
+    *this = ::std::move(from);
+  }
+
+  inline FactoryNotification& operator=(FactoryNotification&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const FactoryNotification& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const FactoryNotification* internal_default_instance() {
+    return reinterpret_cast<const FactoryNotification*>(
+               &_FactoryNotification_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    79;
+
+  void Swap(FactoryNotification* other);
+  friend void swap(FactoryNotification& a, FactoryNotification& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline FactoryNotification* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  FactoryNotification* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const FactoryNotification& from);
+  void MergeFrom(const FactoryNotification& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(FactoryNotification* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Common.Timestamp timestamp = 2;
+  bool has_timestamp() const;
+  void clear_timestamp();
+  static const int kTimestampFieldNumber = 2;
+  const ::Kinova::Api::Common::Timestamp& timestamp() const;
+  ::Kinova::Api::Common::Timestamp* release_timestamp();
+  ::Kinova::Api::Common::Timestamp* mutable_timestamp();
+  void set_allocated_timestamp(::Kinova::Api::Common::Timestamp* timestamp);
+
+  // .Kinova.Api.Common.UserProfileHandle user_handle = 3;
+  bool has_user_handle() const;
+  void clear_user_handle();
+  static const int kUserHandleFieldNumber = 3;
+  const ::Kinova::Api::Common::UserProfileHandle& user_handle() const;
+  ::Kinova::Api::Common::UserProfileHandle* release_user_handle();
+  ::Kinova::Api::Common::UserProfileHandle* mutable_user_handle();
+  void set_allocated_user_handle(::Kinova::Api::Common::UserProfileHandle* user_handle);
+
+  // .Kinova.Api.Common.Connection connection = 4;
+  bool has_connection() const;
+  void clear_connection();
+  static const int kConnectionFieldNumber = 4;
+  const ::Kinova::Api::Common::Connection& connection() const;
+  ::Kinova::Api::Common::Connection* release_connection();
+  ::Kinova::Api::Common::Connection* mutable_connection();
+  void set_allocated_connection(::Kinova::Api::Common::Connection* connection);
+
+  // .Kinova.Api.Base.FactoryEvent event = 1;
+  void clear_event();
+  static const int kEventFieldNumber = 1;
+  ::Kinova::Api::Base::FactoryEvent event() const;
+  void set_event(::Kinova::Api::Base::FactoryEvent value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.FactoryNotification)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::Common::Timestamp* timestamp_;
+  ::Kinova::Api::Common::UserProfileHandle* user_handle_;
+  ::Kinova::Api::Common::Connection* connection_;
+  int event_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsFactoryNotificationImpl();
+};
+// -------------------------------------------------------------------
+
+class NetworkNotification : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.NetworkNotification) */ {
+ public:
+  NetworkNotification();
+  virtual ~NetworkNotification();
+
+  NetworkNotification(const NetworkNotification& from);
+
+  inline NetworkNotification& operator=(const NetworkNotification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  NetworkNotification(NetworkNotification&& from) noexcept
+    : NetworkNotification() {
+    *this = ::std::move(from);
+  }
+
+  inline NetworkNotification& operator=(NetworkNotification&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const NetworkNotification& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const NetworkNotification* internal_default_instance() {
+    return reinterpret_cast<const NetworkNotification*>(
+               &_NetworkNotification_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    80;
+
+  void Swap(NetworkNotification* other);
+  friend void swap(NetworkNotification& a, NetworkNotification& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline NetworkNotification* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  NetworkNotification* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const NetworkNotification& from);
+  void MergeFrom(const NetworkNotification& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(NetworkNotification* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Common.Timestamp timestamp = 2;
+  bool has_timestamp() const;
+  void clear_timestamp();
+  static const int kTimestampFieldNumber = 2;
+  const ::Kinova::Api::Common::Timestamp& timestamp() const;
+  ::Kinova::Api::Common::Timestamp* release_timestamp();
+  ::Kinova::Api::Common::Timestamp* mutable_timestamp();
+  void set_allocated_timestamp(::Kinova::Api::Common::Timestamp* timestamp);
+
+  // .Kinova.Api.Common.UserProfileHandle user_handle = 3;
+  bool has_user_handle() const;
+  void clear_user_handle();
+  static const int kUserHandleFieldNumber = 3;
+  const ::Kinova::Api::Common::UserProfileHandle& user_handle() const;
+  ::Kinova::Api::Common::UserProfileHandle* release_user_handle();
+  ::Kinova::Api::Common::UserProfileHandle* mutable_user_handle();
+  void set_allocated_user_handle(::Kinova::Api::Common::UserProfileHandle* user_handle);
+
+  // .Kinova.Api.Common.Connection connection = 4;
+  bool has_connection() const;
+  void clear_connection();
+  static const int kConnectionFieldNumber = 4;
+  const ::Kinova::Api::Common::Connection& connection() const;
+  ::Kinova::Api::Common::Connection* release_connection();
+  ::Kinova::Api::Common::Connection* mutable_connection();
+  void set_allocated_connection(::Kinova::Api::Common::Connection* connection);
+
+  // .Kinova.Api.Base.NetworkEvent event = 1;
+  void clear_event();
+  static const int kEventFieldNumber = 1;
+  ::Kinova::Api::Base::NetworkEvent event() const;
+  void set_event(::Kinova::Api::Base::NetworkEvent value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.NetworkNotification)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::Common::Timestamp* timestamp_;
+  ::Kinova::Api::Common::UserProfileHandle* user_handle_;
+  ::Kinova::Api::Common::Connection* connection_;
+  int event_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsNetworkNotificationImpl();
+};
+// -------------------------------------------------------------------
+
+class ConfigurationChangeNotificationList : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.ConfigurationChangeNotificationList) */ {
+ public:
+  ConfigurationChangeNotificationList();
+  virtual ~ConfigurationChangeNotificationList();
+
+  ConfigurationChangeNotificationList(const ConfigurationChangeNotificationList& from);
+
+  inline ConfigurationChangeNotificationList& operator=(const ConfigurationChangeNotificationList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ConfigurationChangeNotificationList(ConfigurationChangeNotificationList&& from) noexcept
+    : ConfigurationChangeNotificationList() {
+    *this = ::std::move(from);
+  }
+
+  inline ConfigurationChangeNotificationList& operator=(ConfigurationChangeNotificationList&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ConfigurationChangeNotificationList& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ConfigurationChangeNotificationList* internal_default_instance() {
+    return reinterpret_cast<const ConfigurationChangeNotificationList*>(
+               &_ConfigurationChangeNotificationList_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    81;
+
+  void Swap(ConfigurationChangeNotificationList* other);
+  friend void swap(ConfigurationChangeNotificationList& a, ConfigurationChangeNotificationList& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ConfigurationChangeNotificationList* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ConfigurationChangeNotificationList* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ConfigurationChangeNotificationList& from);
+  void MergeFrom(const ConfigurationChangeNotificationList& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ConfigurationChangeNotificationList* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .Kinova.Api.Base.ConfigurationChangeNotification notifications = 1;
+  int notifications_size() const;
+  void clear_notifications();
+  static const int kNotificationsFieldNumber = 1;
+  const ::Kinova::Api::Base::ConfigurationChangeNotification& notifications(int index) const;
+  ::Kinova::Api::Base::ConfigurationChangeNotification* mutable_notifications(int index);
+  ::Kinova::Api::Base::ConfigurationChangeNotification* add_notifications();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::ConfigurationChangeNotification >*
+      mutable_notifications();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::ConfigurationChangeNotification >&
+      notifications() const;
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.ConfigurationChangeNotificationList)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::ConfigurationChangeNotification > notifications_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsConfigurationChangeNotificationListImpl();
+};
+// -------------------------------------------------------------------
+
+class MappingInfoNotificationList : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.MappingInfoNotificationList) */ {
+ public:
+  MappingInfoNotificationList();
+  virtual ~MappingInfoNotificationList();
+
+  MappingInfoNotificationList(const MappingInfoNotificationList& from);
+
+  inline MappingInfoNotificationList& operator=(const MappingInfoNotificationList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  MappingInfoNotificationList(MappingInfoNotificationList&& from) noexcept
+    : MappingInfoNotificationList() {
+    *this = ::std::move(from);
+  }
+
+  inline MappingInfoNotificationList& operator=(MappingInfoNotificationList&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const MappingInfoNotificationList& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const MappingInfoNotificationList* internal_default_instance() {
+    return reinterpret_cast<const MappingInfoNotificationList*>(
+               &_MappingInfoNotificationList_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    82;
+
+  void Swap(MappingInfoNotificationList* other);
+  friend void swap(MappingInfoNotificationList& a, MappingInfoNotificationList& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline MappingInfoNotificationList* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  MappingInfoNotificationList* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const MappingInfoNotificationList& from);
+  void MergeFrom(const MappingInfoNotificationList& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(MappingInfoNotificationList* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .Kinova.Api.Base.MappingInfoNotification notifications = 1;
+  int notifications_size() const;
+  void clear_notifications();
+  static const int kNotificationsFieldNumber = 1;
+  const ::Kinova::Api::Base::MappingInfoNotification& notifications(int index) const;
+  ::Kinova::Api::Base::MappingInfoNotification* mutable_notifications(int index);
+  ::Kinova::Api::Base::MappingInfoNotification* add_notifications();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::MappingInfoNotification >*
+      mutable_notifications();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::MappingInfoNotification >&
+      notifications() const;
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.MappingInfoNotificationList)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::MappingInfoNotification > notifications_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsMappingInfoNotificationListImpl();
+};
+// -------------------------------------------------------------------
+
+class OperatingModeNotificationList : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.OperatingModeNotificationList) */ {
+ public:
+  OperatingModeNotificationList();
+  virtual ~OperatingModeNotificationList();
+
+  OperatingModeNotificationList(const OperatingModeNotificationList& from);
+
+  inline OperatingModeNotificationList& operator=(const OperatingModeNotificationList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  OperatingModeNotificationList(OperatingModeNotificationList&& from) noexcept
+    : OperatingModeNotificationList() {
+    *this = ::std::move(from);
+  }
+
+  inline OperatingModeNotificationList& operator=(OperatingModeNotificationList&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const OperatingModeNotificationList& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const OperatingModeNotificationList* internal_default_instance() {
+    return reinterpret_cast<const OperatingModeNotificationList*>(
+               &_OperatingModeNotificationList_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    83;
+
+  void Swap(OperatingModeNotificationList* other);
+  friend void swap(OperatingModeNotificationList& a, OperatingModeNotificationList& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline OperatingModeNotificationList* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  OperatingModeNotificationList* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const OperatingModeNotificationList& from);
+  void MergeFrom(const OperatingModeNotificationList& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(OperatingModeNotificationList* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .Kinova.Api.Base.OperatingModeNotification notifications = 1;
+  int notifications_size() const;
+  void clear_notifications();
+  static const int kNotificationsFieldNumber = 1;
+  const ::Kinova::Api::Base::OperatingModeNotification& notifications(int index) const;
+  ::Kinova::Api::Base::OperatingModeNotification* mutable_notifications(int index);
+  ::Kinova::Api::Base::OperatingModeNotification* add_notifications();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::OperatingModeNotification >*
+      mutable_notifications();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::OperatingModeNotification >&
+      notifications() const;
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.OperatingModeNotificationList)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::OperatingModeNotification > notifications_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsOperatingModeNotificationListImpl();
+};
+// -------------------------------------------------------------------
+
+class ServoingModeNotificationList : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.ServoingModeNotificationList) */ {
+ public:
+  ServoingModeNotificationList();
+  virtual ~ServoingModeNotificationList();
+
+  ServoingModeNotificationList(const ServoingModeNotificationList& from);
+
+  inline ServoingModeNotificationList& operator=(const ServoingModeNotificationList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ServoingModeNotificationList(ServoingModeNotificationList&& from) noexcept
+    : ServoingModeNotificationList() {
+    *this = ::std::move(from);
+  }
+
+  inline ServoingModeNotificationList& operator=(ServoingModeNotificationList&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ServoingModeNotificationList& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ServoingModeNotificationList* internal_default_instance() {
+    return reinterpret_cast<const ServoingModeNotificationList*>(
+               &_ServoingModeNotificationList_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    84;
+
+  void Swap(ServoingModeNotificationList* other);
+  friend void swap(ServoingModeNotificationList& a, ServoingModeNotificationList& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ServoingModeNotificationList* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ServoingModeNotificationList* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ServoingModeNotificationList& from);
+  void MergeFrom(const ServoingModeNotificationList& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ServoingModeNotificationList* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .Kinova.Api.Base.ServoingModeNotification notifications = 1;
+  int notifications_size() const;
+  void clear_notifications();
+  static const int kNotificationsFieldNumber = 1;
+  const ::Kinova::Api::Base::ServoingModeNotification& notifications(int index) const;
+  ::Kinova::Api::Base::ServoingModeNotification* mutable_notifications(int index);
+  ::Kinova::Api::Base::ServoingModeNotification* add_notifications();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::ServoingModeNotification >*
+      mutable_notifications();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::ServoingModeNotification >&
+      notifications() const;
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.ServoingModeNotificationList)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::ServoingModeNotification > notifications_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsServoingModeNotificationListImpl();
+};
+// -------------------------------------------------------------------
+
+class SequenceInfoNotificationList : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.SequenceInfoNotificationList) */ {
+ public:
+  SequenceInfoNotificationList();
+  virtual ~SequenceInfoNotificationList();
+
+  SequenceInfoNotificationList(const SequenceInfoNotificationList& from);
+
+  inline SequenceInfoNotificationList& operator=(const SequenceInfoNotificationList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  SequenceInfoNotificationList(SequenceInfoNotificationList&& from) noexcept
+    : SequenceInfoNotificationList() {
+    *this = ::std::move(from);
+  }
+
+  inline SequenceInfoNotificationList& operator=(SequenceInfoNotificationList&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SequenceInfoNotificationList& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const SequenceInfoNotificationList* internal_default_instance() {
+    return reinterpret_cast<const SequenceInfoNotificationList*>(
+               &_SequenceInfoNotificationList_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    85;
+
+  void Swap(SequenceInfoNotificationList* other);
+  friend void swap(SequenceInfoNotificationList& a, SequenceInfoNotificationList& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SequenceInfoNotificationList* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  SequenceInfoNotificationList* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const SequenceInfoNotificationList& from);
+  void MergeFrom(const SequenceInfoNotificationList& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(SequenceInfoNotificationList* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .Kinova.Api.Base.SequenceInfoNotification notifications = 1;
+  int notifications_size() const;
+  void clear_notifications();
+  static const int kNotificationsFieldNumber = 1;
+  const ::Kinova::Api::Base::SequenceInfoNotification& notifications(int index) const;
+  ::Kinova::Api::Base::SequenceInfoNotification* mutable_notifications(int index);
+  ::Kinova::Api::Base::SequenceInfoNotification* add_notifications();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::SequenceInfoNotification >*
+      mutable_notifications();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::SequenceInfoNotification >&
+      notifications() const;
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.SequenceInfoNotificationList)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::SequenceInfoNotification > notifications_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsSequenceInfoNotificationListImpl();
+};
+// -------------------------------------------------------------------
+
+class ProtectionZoneNotificationList : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.ProtectionZoneNotificationList) */ {
+ public:
+  ProtectionZoneNotificationList();
+  virtual ~ProtectionZoneNotificationList();
+
+  ProtectionZoneNotificationList(const ProtectionZoneNotificationList& from);
+
+  inline ProtectionZoneNotificationList& operator=(const ProtectionZoneNotificationList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ProtectionZoneNotificationList(ProtectionZoneNotificationList&& from) noexcept
+    : ProtectionZoneNotificationList() {
+    *this = ::std::move(from);
+  }
+
+  inline ProtectionZoneNotificationList& operator=(ProtectionZoneNotificationList&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ProtectionZoneNotificationList& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ProtectionZoneNotificationList* internal_default_instance() {
+    return reinterpret_cast<const ProtectionZoneNotificationList*>(
+               &_ProtectionZoneNotificationList_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    86;
+
+  void Swap(ProtectionZoneNotificationList* other);
+  friend void swap(ProtectionZoneNotificationList& a, ProtectionZoneNotificationList& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ProtectionZoneNotificationList* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ProtectionZoneNotificationList* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ProtectionZoneNotificationList& from);
+  void MergeFrom(const ProtectionZoneNotificationList& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ProtectionZoneNotificationList* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .Kinova.Api.Base.ProtectionZoneNotification notifications = 1;
+  int notifications_size() const;
+  void clear_notifications();
+  static const int kNotificationsFieldNumber = 1;
+  const ::Kinova::Api::Base::ProtectionZoneNotification& notifications(int index) const;
+  ::Kinova::Api::Base::ProtectionZoneNotification* mutable_notifications(int index);
+  ::Kinova::Api::Base::ProtectionZoneNotification* add_notifications();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::ProtectionZoneNotification >*
+      mutable_notifications();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::ProtectionZoneNotification >&
+      notifications() const;
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.ProtectionZoneNotificationList)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::ProtectionZoneNotification > notifications_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsProtectionZoneNotificationListImpl();
+};
+// -------------------------------------------------------------------
+
+class UserNotificationList : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.UserNotificationList) */ {
+ public:
+  UserNotificationList();
+  virtual ~UserNotificationList();
+
+  UserNotificationList(const UserNotificationList& from);
+
+  inline UserNotificationList& operator=(const UserNotificationList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  UserNotificationList(UserNotificationList&& from) noexcept
+    : UserNotificationList() {
+    *this = ::std::move(from);
+  }
+
+  inline UserNotificationList& operator=(UserNotificationList&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const UserNotificationList& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const UserNotificationList* internal_default_instance() {
+    return reinterpret_cast<const UserNotificationList*>(
+               &_UserNotificationList_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    87;
+
+  void Swap(UserNotificationList* other);
+  friend void swap(UserNotificationList& a, UserNotificationList& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline UserNotificationList* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  UserNotificationList* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const UserNotificationList& from);
+  void MergeFrom(const UserNotificationList& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(UserNotificationList* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .Kinova.Api.Base.UserNotification notifications = 1;
+  int notifications_size() const;
+  void clear_notifications();
+  static const int kNotificationsFieldNumber = 1;
+  const ::Kinova::Api::Base::UserNotification& notifications(int index) const;
+  ::Kinova::Api::Base::UserNotification* mutable_notifications(int index);
+  ::Kinova::Api::Base::UserNotification* add_notifications();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::UserNotification >*
+      mutable_notifications();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::UserNotification >&
+      notifications() const;
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.UserNotificationList)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::UserNotification > notifications_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsUserNotificationListImpl();
+};
+// -------------------------------------------------------------------
+
+class SafetyNotificationList : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.SafetyNotificationList) */ {
+ public:
+  SafetyNotificationList();
+  virtual ~SafetyNotificationList();
+
+  SafetyNotificationList(const SafetyNotificationList& from);
+
+  inline SafetyNotificationList& operator=(const SafetyNotificationList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  SafetyNotificationList(SafetyNotificationList&& from) noexcept
+    : SafetyNotificationList() {
+    *this = ::std::move(from);
+  }
+
+  inline SafetyNotificationList& operator=(SafetyNotificationList&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SafetyNotificationList& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const SafetyNotificationList* internal_default_instance() {
+    return reinterpret_cast<const SafetyNotificationList*>(
+               &_SafetyNotificationList_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    88;
+
+  void Swap(SafetyNotificationList* other);
+  friend void swap(SafetyNotificationList& a, SafetyNotificationList& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SafetyNotificationList* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  SafetyNotificationList* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const SafetyNotificationList& from);
+  void MergeFrom(const SafetyNotificationList& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(SafetyNotificationList* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .Kinova.Api.Common.SafetyNotification notifications = 1;
+  int notifications_size() const;
+  void clear_notifications();
+  static const int kNotificationsFieldNumber = 1;
+  const ::Kinova::Api::Common::SafetyNotification& notifications(int index) const;
+  ::Kinova::Api::Common::SafetyNotification* mutable_notifications(int index);
+  ::Kinova::Api::Common::SafetyNotification* add_notifications();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Common::SafetyNotification >*
+      mutable_notifications();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Common::SafetyNotification >&
+      notifications() const;
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.SafetyNotificationList)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Common::SafetyNotification > notifications_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsSafetyNotificationListImpl();
+};
+// -------------------------------------------------------------------
+
+class ControllerNotificationList : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.ControllerNotificationList) */ {
+ public:
+  ControllerNotificationList();
+  virtual ~ControllerNotificationList();
+
+  ControllerNotificationList(const ControllerNotificationList& from);
+
+  inline ControllerNotificationList& operator=(const ControllerNotificationList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ControllerNotificationList(ControllerNotificationList&& from) noexcept
+    : ControllerNotificationList() {
+    *this = ::std::move(from);
+  }
+
+  inline ControllerNotificationList& operator=(ControllerNotificationList&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ControllerNotificationList& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ControllerNotificationList* internal_default_instance() {
+    return reinterpret_cast<const ControllerNotificationList*>(
+               &_ControllerNotificationList_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    89;
+
+  void Swap(ControllerNotificationList* other);
+  friend void swap(ControllerNotificationList& a, ControllerNotificationList& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ControllerNotificationList* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ControllerNotificationList* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ControllerNotificationList& from);
+  void MergeFrom(const ControllerNotificationList& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ControllerNotificationList* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .Kinova.Api.Base.ControllerNotification notifications = 1;
+  int notifications_size() const;
+  void clear_notifications();
+  static const int kNotificationsFieldNumber = 1;
+  const ::Kinova::Api::Base::ControllerNotification& notifications(int index) const;
+  ::Kinova::Api::Base::ControllerNotification* mutable_notifications(int index);
+  ::Kinova::Api::Base::ControllerNotification* add_notifications();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::ControllerNotification >*
+      mutable_notifications();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::ControllerNotification >&
+      notifications() const;
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.ControllerNotificationList)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::ControllerNotification > notifications_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsControllerNotificationListImpl();
+};
+// -------------------------------------------------------------------
+
+class ActionNotificationList : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.ActionNotificationList) */ {
+ public:
+  ActionNotificationList();
+  virtual ~ActionNotificationList();
+
+  ActionNotificationList(const ActionNotificationList& from);
+
+  inline ActionNotificationList& operator=(const ActionNotificationList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ActionNotificationList(ActionNotificationList&& from) noexcept
+    : ActionNotificationList() {
+    *this = ::std::move(from);
+  }
+
+  inline ActionNotificationList& operator=(ActionNotificationList&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ActionNotificationList& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ActionNotificationList* internal_default_instance() {
+    return reinterpret_cast<const ActionNotificationList*>(
+               &_ActionNotificationList_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    90;
+
+  void Swap(ActionNotificationList* other);
+  friend void swap(ActionNotificationList& a, ActionNotificationList& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ActionNotificationList* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ActionNotificationList* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ActionNotificationList& from);
+  void MergeFrom(const ActionNotificationList& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ActionNotificationList* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .Kinova.Api.Base.ActionNotification notifications = 1;
+  int notifications_size() const;
+  void clear_notifications();
+  static const int kNotificationsFieldNumber = 1;
+  const ::Kinova::Api::Base::ActionNotification& notifications(int index) const;
+  ::Kinova::Api::Base::ActionNotification* mutable_notifications(int index);
+  ::Kinova::Api::Base::ActionNotification* add_notifications();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::ActionNotification >*
+      mutable_notifications();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::ActionNotification >&
+      notifications() const;
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.ActionNotificationList)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::ActionNotification > notifications_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsActionNotificationListImpl();
+};
+// -------------------------------------------------------------------
+
+class RobotEventNotificationList : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.RobotEventNotificationList) */ {
+ public:
+  RobotEventNotificationList();
+  virtual ~RobotEventNotificationList();
+
+  RobotEventNotificationList(const RobotEventNotificationList& from);
+
+  inline RobotEventNotificationList& operator=(const RobotEventNotificationList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  RobotEventNotificationList(RobotEventNotificationList&& from) noexcept
+    : RobotEventNotificationList() {
+    *this = ::std::move(from);
+  }
+
+  inline RobotEventNotificationList& operator=(RobotEventNotificationList&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const RobotEventNotificationList& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const RobotEventNotificationList* internal_default_instance() {
+    return reinterpret_cast<const RobotEventNotificationList*>(
+               &_RobotEventNotificationList_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    91;
+
+  void Swap(RobotEventNotificationList* other);
+  friend void swap(RobotEventNotificationList& a, RobotEventNotificationList& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline RobotEventNotificationList* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  RobotEventNotificationList* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const RobotEventNotificationList& from);
+  void MergeFrom(const RobotEventNotificationList& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(RobotEventNotificationList* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .Kinova.Api.Base.RobotEventNotification notifications = 1;
+  int notifications_size() const;
+  void clear_notifications();
+  static const int kNotificationsFieldNumber = 1;
+  const ::Kinova::Api::Base::RobotEventNotification& notifications(int index) const;
+  ::Kinova::Api::Base::RobotEventNotification* mutable_notifications(int index);
+  ::Kinova::Api::Base::RobotEventNotification* add_notifications();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::RobotEventNotification >*
+      mutable_notifications();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::RobotEventNotification >&
+      notifications() const;
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.RobotEventNotificationList)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::RobotEventNotification > notifications_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsRobotEventNotificationListImpl();
+};
+// -------------------------------------------------------------------
+
+class NetworkNotificationList : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.NetworkNotificationList) */ {
+ public:
+  NetworkNotificationList();
+  virtual ~NetworkNotificationList();
+
+  NetworkNotificationList(const NetworkNotificationList& from);
+
+  inline NetworkNotificationList& operator=(const NetworkNotificationList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  NetworkNotificationList(NetworkNotificationList&& from) noexcept
+    : NetworkNotificationList() {
+    *this = ::std::move(from);
+  }
+
+  inline NetworkNotificationList& operator=(NetworkNotificationList&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const NetworkNotificationList& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const NetworkNotificationList* internal_default_instance() {
+    return reinterpret_cast<const NetworkNotificationList*>(
+               &_NetworkNotificationList_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    92;
+
+  void Swap(NetworkNotificationList* other);
+  friend void swap(NetworkNotificationList& a, NetworkNotificationList& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline NetworkNotificationList* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  NetworkNotificationList* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const NetworkNotificationList& from);
+  void MergeFrom(const NetworkNotificationList& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(NetworkNotificationList* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .Kinova.Api.Base.NetworkNotification notifications = 1;
+  int notifications_size() const;
+  void clear_notifications();
+  static const int kNotificationsFieldNumber = 1;
+  const ::Kinova::Api::Base::NetworkNotification& notifications(int index) const;
+  ::Kinova::Api::Base::NetworkNotification* mutable_notifications(int index);
+  ::Kinova::Api::Base::NetworkNotification* add_notifications();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::NetworkNotification >*
+      mutable_notifications();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::NetworkNotification >&
+      notifications() const;
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.NetworkNotificationList)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::NetworkNotification > notifications_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsNetworkNotificationListImpl();
+};
+// -------------------------------------------------------------------
+
+class MappingHandle : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.MappingHandle) */ {
+ public:
+  MappingHandle();
+  virtual ~MappingHandle();
+
+  MappingHandle(const MappingHandle& from);
+
+  inline MappingHandle& operator=(const MappingHandle& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  MappingHandle(MappingHandle&& from) noexcept
+    : MappingHandle() {
+    *this = ::std::move(from);
+  }
+
+  inline MappingHandle& operator=(MappingHandle&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const MappingHandle& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const MappingHandle* internal_default_instance() {
+    return reinterpret_cast<const MappingHandle*>(
+               &_MappingHandle_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    93;
+
+  void Swap(MappingHandle* other);
+  friend void swap(MappingHandle& a, MappingHandle& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline MappingHandle* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  MappingHandle* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const MappingHandle& from);
+  void MergeFrom(const MappingHandle& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(MappingHandle* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // uint32 identifier = 1;
+  void clear_identifier();
+  static const int kIdentifierFieldNumber = 1;
+  ::google::protobuf::uint32 identifier() const;
+  void set_identifier(::google::protobuf::uint32 value);
+
+  // fixed32 permission = 2;
+  void clear_permission();
+  static const int kPermissionFieldNumber = 2;
+  ::google::protobuf::uint32 permission() const;
+  void set_permission(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.MappingHandle)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 identifier_;
+  ::google::protobuf::uint32 permission_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsMappingHandleImpl();
+};
+// -------------------------------------------------------------------
+
+class ControllerEvent : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.ControllerEvent) */ {
+ public:
+  ControllerEvent();
+  virtual ~ControllerEvent();
+
+  ControllerEvent(const ControllerEvent& from);
+
+  inline ControllerEvent& operator=(const ControllerEvent& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ControllerEvent(ControllerEvent&& from) noexcept
+    : ControllerEvent() {
+    *this = ::std::move(from);
+  }
+
+  inline ControllerEvent& operator=(ControllerEvent&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ControllerEvent& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ControllerEvent* internal_default_instance() {
+    return reinterpret_cast<const ControllerEvent*>(
+               &_ControllerEvent_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    94;
+
+  void Swap(ControllerEvent* other);
+  friend void swap(ControllerEvent& a, ControllerEvent& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ControllerEvent* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ControllerEvent* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ControllerEvent& from);
+  void MergeFrom(const ControllerEvent& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ControllerEvent* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Base.ControllerInputType input_type = 1;
+  void clear_input_type();
+  static const int kInputTypeFieldNumber = 1;
+  ::Kinova::Api::Base::ControllerInputType input_type() const;
+  void set_input_type(::Kinova::Api::Base::ControllerInputType value);
+
+  // .Kinova.Api.Base.ControllerBehavior behavior = 2;
+  void clear_behavior();
+  static const int kBehaviorFieldNumber = 2;
+  ::Kinova::Api::Base::ControllerBehavior behavior() const;
+  void set_behavior(::Kinova::Api::Base::ControllerBehavior value);
+
+  // uint32 input_identifier = 3;
+  void clear_input_identifier();
+  static const int kInputIdentifierFieldNumber = 3;
+  ::google::protobuf::uint32 input_identifier() const;
+  void set_input_identifier(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.ControllerEvent)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  int input_type_;
+  int behavior_;
+  ::google::protobuf::uint32 input_identifier_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsControllerEventImpl();
+};
+// -------------------------------------------------------------------
+
+class GpioEvent : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.GpioEvent) */ {
+ public:
+  GpioEvent();
+  virtual ~GpioEvent();
+
+  GpioEvent(const GpioEvent& from);
+
+  inline GpioEvent& operator=(const GpioEvent& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  GpioEvent(GpioEvent&& from) noexcept
+    : GpioEvent() {
+    *this = ::std::move(from);
+  }
+
+  inline GpioEvent& operator=(GpioEvent&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const GpioEvent& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const GpioEvent* internal_default_instance() {
+    return reinterpret_cast<const GpioEvent*>(
+               &_GpioEvent_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    95;
+
+  void Swap(GpioEvent* other);
+  friend void swap(GpioEvent& a, GpioEvent& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline GpioEvent* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  GpioEvent* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const GpioEvent& from);
+  void MergeFrom(const GpioEvent& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(GpioEvent* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Base.ControllerInputType input_type = 1;
+  void clear_input_type();
+  static const int kInputTypeFieldNumber = 1;
+  ::Kinova::Api::Base::ControllerInputType input_type() const;
+  void set_input_type(::Kinova::Api::Base::ControllerInputType value);
+
+  // .Kinova.Api.Base.GpioBehavior behavior = 2;
+  void clear_behavior();
+  static const int kBehaviorFieldNumber = 2;
+  ::Kinova::Api::Base::GpioBehavior behavior() const;
+  void set_behavior(::Kinova::Api::Base::GpioBehavior value);
+
+  // uint32 input_identifier = 3;
+  void clear_input_identifier();
+  static const int kInputIdentifierFieldNumber = 3;
+  ::google::protobuf::uint32 input_identifier() const;
+  void set_input_identifier(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.GpioEvent)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  int input_type_;
+  int behavior_;
+  ::google::protobuf::uint32 input_identifier_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsGpioEventImpl();
+};
+// -------------------------------------------------------------------
+
+class MapEvent : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.MapEvent) */ {
+ public:
+  MapEvent();
+  virtual ~MapEvent();
+
+  MapEvent(const MapEvent& from);
+
+  inline MapEvent& operator=(const MapEvent& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  MapEvent(MapEvent&& from) noexcept
+    : MapEvent() {
+    *this = ::std::move(from);
+  }
+
+  inline MapEvent& operator=(MapEvent&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const MapEvent& default_instance();
+
+  enum EventsCase {
+    kGpioEvent = 2,
+    kControllerEvent = 3,
+    EVENTS_NOT_SET = 0,
+  };
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const MapEvent* internal_default_instance() {
+    return reinterpret_cast<const MapEvent*>(
+               &_MapEvent_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    96;
+
+  void Swap(MapEvent* other);
+  friend void swap(MapEvent& a, MapEvent& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline MapEvent* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  MapEvent* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const MapEvent& from);
+  void MergeFrom(const MapEvent& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(MapEvent* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // string name = 4;
+  void clear_name();
+  static const int kNameFieldNumber = 4;
+  const ::std::string& name() const;
+  void set_name(const ::std::string& value);
+  #if LANG_CXX11
+  void set_name(::std::string&& value);
+  #endif
+  void set_name(const char* value);
+  void set_name(const char* value, size_t size);
+  ::std::string* mutable_name();
+  ::std::string* release_name();
+  void set_allocated_name(::std::string* name);
+
+  // .Kinova.Api.Base.GpioEvent gpio_event = 2;
+  bool has_gpio_event() const;
+  void clear_gpio_event();
+  static const int kGpioEventFieldNumber = 2;
+  const ::Kinova::Api::Base::GpioEvent& gpio_event() const;
+  ::Kinova::Api::Base::GpioEvent* release_gpio_event();
+  ::Kinova::Api::Base::GpioEvent* mutable_gpio_event();
+  void set_allocated_gpio_event(::Kinova::Api::Base::GpioEvent* gpio_event);
+
+  // .Kinova.Api.Base.ControllerEvent controller_event = 3;
+  bool has_controller_event() const;
+  void clear_controller_event();
+  static const int kControllerEventFieldNumber = 3;
+  const ::Kinova::Api::Base::ControllerEvent& controller_event() const;
+  ::Kinova::Api::Base::ControllerEvent* release_controller_event();
+  ::Kinova::Api::Base::ControllerEvent* mutable_controller_event();
+  void set_allocated_controller_event(::Kinova::Api::Base::ControllerEvent* controller_event);
+
+  EventsCase events_case() const;
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.MapEvent)
+ private:
+  void set_has_gpio_event();
+  void set_has_controller_event();
+
+  inline bool has_events() const;
+  void clear_events();
+  inline void clear_has_events();
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::internal::ArenaStringPtr name_;
+  union EventsUnion {
+    EventsUnion() {}
+    ::Kinova::Api::Base::GpioEvent* gpio_event_;
+    ::Kinova::Api::Base::ControllerEvent* controller_event_;
+  } events_;
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _oneof_case_[1];
+
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsMapEventImpl();
+};
+// -------------------------------------------------------------------
+
+class MapElement : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.MapElement) */ {
+ public:
+  MapElement();
+  virtual ~MapElement();
+
+  MapElement(const MapElement& from);
+
+  inline MapElement& operator=(const MapElement& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  MapElement(MapElement&& from) noexcept
+    : MapElement() {
+    *this = ::std::move(from);
+  }
+
+  inline MapElement& operator=(MapElement&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const MapElement& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const MapElement* internal_default_instance() {
+    return reinterpret_cast<const MapElement*>(
+               &_MapElement_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    97;
+
+  void Swap(MapElement* other);
+  friend void swap(MapElement& a, MapElement& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline MapElement* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  MapElement* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const MapElement& from);
+  void MergeFrom(const MapElement& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(MapElement* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // string name = 3;
+  void clear_name();
+  static const int kNameFieldNumber = 3;
+  const ::std::string& name() const;
+  void set_name(const ::std::string& value);
+  #if LANG_CXX11
+  void set_name(::std::string&& value);
+  #endif
+  void set_name(const char* value);
+  void set_name(const char* value, size_t size);
+  ::std::string* mutable_name();
+  ::std::string* release_name();
+  void set_allocated_name(::std::string* name);
+
+  // .Kinova.Api.Base.MapEvent event = 1;
+  bool has_event() const;
+  void clear_event();
+  static const int kEventFieldNumber = 1;
+  const ::Kinova::Api::Base::MapEvent& event() const;
+  ::Kinova::Api::Base::MapEvent* release_event();
+  ::Kinova::Api::Base::MapEvent* mutable_event();
+  void set_allocated_event(::Kinova::Api::Base::MapEvent* event);
+
+  // .Kinova.Api.Base.Action action = 2;
+  bool has_action() const;
+  void clear_action();
+  static const int kActionFieldNumber = 2;
+  const ::Kinova::Api::Base::Action& action() const;
+  ::Kinova::Api::Base::Action* release_action();
+  ::Kinova::Api::Base::Action* mutable_action();
+  void set_allocated_action(::Kinova::Api::Base::Action* action);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.MapElement)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::internal::ArenaStringPtr name_;
+  ::Kinova::Api::Base::MapEvent* event_;
+  ::Kinova::Api::Base::Action* action_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsMapElementImpl();
+};
+// -------------------------------------------------------------------
+
+class ActivateMapHandle : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.ActivateMapHandle) */ {
+ public:
+  ActivateMapHandle();
+  virtual ~ActivateMapHandle();
+
+  ActivateMapHandle(const ActivateMapHandle& from);
+
+  inline ActivateMapHandle& operator=(const ActivateMapHandle& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ActivateMapHandle(ActivateMapHandle&& from) noexcept
+    : ActivateMapHandle() {
+    *this = ::std::move(from);
+  }
+
+  inline ActivateMapHandle& operator=(ActivateMapHandle&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ActivateMapHandle& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ActivateMapHandle* internal_default_instance() {
+    return reinterpret_cast<const ActivateMapHandle*>(
+               &_ActivateMapHandle_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    98;
+
+  void Swap(ActivateMapHandle* other);
+  friend void swap(ActivateMapHandle& a, ActivateMapHandle& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ActivateMapHandle* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ActivateMapHandle* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ActivateMapHandle& from);
+  void MergeFrom(const ActivateMapHandle& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ActivateMapHandle* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Base.MappingHandle mapping_handle = 1;
+  bool has_mapping_handle() const;
+  void clear_mapping_handle();
+  static const int kMappingHandleFieldNumber = 1;
+  const ::Kinova::Api::Base::MappingHandle& mapping_handle() const;
+  ::Kinova::Api::Base::MappingHandle* release_mapping_handle();
+  ::Kinova::Api::Base::MappingHandle* mutable_mapping_handle();
+  void set_allocated_mapping_handle(::Kinova::Api::Base::MappingHandle* mapping_handle);
+
+  // .Kinova.Api.Base.MapGroupHandle map_group_handle = 2;
+  bool has_map_group_handle() const;
+  void clear_map_group_handle();
+  static const int kMapGroupHandleFieldNumber = 2;
+  const ::Kinova::Api::Base::MapGroupHandle& map_group_handle() const;
+  ::Kinova::Api::Base::MapGroupHandle* release_map_group_handle();
+  ::Kinova::Api::Base::MapGroupHandle* mutable_map_group_handle();
+  void set_allocated_map_group_handle(::Kinova::Api::Base::MapGroupHandle* map_group_handle);
+
+  // .Kinova.Api.Base.MapHandle map_handle = 3;
+  bool has_map_handle() const;
+  void clear_map_handle();
+  static const int kMapHandleFieldNumber = 3;
+  const ::Kinova::Api::Base::MapHandle& map_handle() const;
+  ::Kinova::Api::Base::MapHandle* release_map_handle();
+  ::Kinova::Api::Base::MapHandle* mutable_map_handle();
+  void set_allocated_map_handle(::Kinova::Api::Base::MapHandle* map_handle);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.ActivateMapHandle)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::Base::MappingHandle* mapping_handle_;
+  ::Kinova::Api::Base::MapGroupHandle* map_group_handle_;
+  ::Kinova::Api::Base::MapHandle* map_handle_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsActivateMapHandleImpl();
+};
+// -------------------------------------------------------------------
+
+class Map : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.Map) */ {
+ public:
+  Map();
+  virtual ~Map();
+
+  Map(const Map& from);
+
+  inline Map& operator=(const Map& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Map(Map&& from) noexcept
+    : Map() {
+    *this = ::std::move(from);
+  }
+
+  inline Map& operator=(Map&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Map& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Map* internal_default_instance() {
+    return reinterpret_cast<const Map*>(
+               &_Map_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    99;
+
+  void Swap(Map* other);
+  friend void swap(Map& a, Map& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Map* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Map* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Map& from);
+  void MergeFrom(const Map& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Map* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .Kinova.Api.Base.MapElement elements = 3;
+  int elements_size() const;
+  void clear_elements();
+  static const int kElementsFieldNumber = 3;
+  const ::Kinova::Api::Base::MapElement& elements(int index) const;
+  ::Kinova::Api::Base::MapElement* mutable_elements(int index);
+  ::Kinova::Api::Base::MapElement* add_elements();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::MapElement >*
+      mutable_elements();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::MapElement >&
+      elements() const;
+
+  // string name = 2;
+  void clear_name();
+  static const int kNameFieldNumber = 2;
+  const ::std::string& name() const;
+  void set_name(const ::std::string& value);
+  #if LANG_CXX11
+  void set_name(::std::string&& value);
+  #endif
+  void set_name(const char* value);
+  void set_name(const char* value, size_t size);
+  ::std::string* mutable_name();
+  ::std::string* release_name();
+  void set_allocated_name(::std::string* name);
+
+  // .Kinova.Api.Base.MapHandle handle = 1;
+  bool has_handle() const;
+  void clear_handle();
+  static const int kHandleFieldNumber = 1;
+  const ::Kinova::Api::Base::MapHandle& handle() const;
+  ::Kinova::Api::Base::MapHandle* release_handle();
+  ::Kinova::Api::Base::MapHandle* mutable_handle();
+  void set_allocated_handle(::Kinova::Api::Base::MapHandle* handle);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.Map)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::MapElement > elements_;
+  ::google::protobuf::internal::ArenaStringPtr name_;
+  ::Kinova::Api::Base::MapHandle* handle_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsMapImpl();
+};
+// -------------------------------------------------------------------
+
+class MapHandle : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.MapHandle) */ {
+ public:
+  MapHandle();
+  virtual ~MapHandle();
+
+  MapHandle(const MapHandle& from);
+
+  inline MapHandle& operator=(const MapHandle& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  MapHandle(MapHandle&& from) noexcept
+    : MapHandle() {
+    *this = ::std::move(from);
+  }
+
+  inline MapHandle& operator=(MapHandle&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const MapHandle& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const MapHandle* internal_default_instance() {
+    return reinterpret_cast<const MapHandle*>(
+               &_MapHandle_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    100;
+
+  void Swap(MapHandle* other);
+  friend void swap(MapHandle& a, MapHandle& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline MapHandle* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  MapHandle* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const MapHandle& from);
+  void MergeFrom(const MapHandle& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(MapHandle* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // uint32 identifier = 1;
+  void clear_identifier();
+  static const int kIdentifierFieldNumber = 1;
+  ::google::protobuf::uint32 identifier() const;
+  void set_identifier(::google::protobuf::uint32 value);
+
+  // fixed32 permission = 2;
+  void clear_permission();
+  static const int kPermissionFieldNumber = 2;
+  ::google::protobuf::uint32 permission() const;
+  void set_permission(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.MapHandle)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 identifier_;
+  ::google::protobuf::uint32 permission_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsMapHandleImpl();
+};
+// -------------------------------------------------------------------
+
+class MapList : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.MapList) */ {
+ public:
+  MapList();
+  virtual ~MapList();
+
+  MapList(const MapList& from);
+
+  inline MapList& operator=(const MapList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  MapList(MapList&& from) noexcept
+    : MapList() {
+    *this = ::std::move(from);
+  }
+
+  inline MapList& operator=(MapList&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const MapList& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const MapList* internal_default_instance() {
+    return reinterpret_cast<const MapList*>(
+               &_MapList_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    101;
+
+  void Swap(MapList* other);
+  friend void swap(MapList& a, MapList& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline MapList* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  MapList* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const MapList& from);
+  void MergeFrom(const MapList& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(MapList* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .Kinova.Api.Base.Map map_list = 1;
+  int map_list_size() const;
+  void clear_map_list();
+  static const int kMapListFieldNumber = 1;
+  const ::Kinova::Api::Base::Map& map_list(int index) const;
+  ::Kinova::Api::Base::Map* mutable_map_list(int index);
+  ::Kinova::Api::Base::Map* add_map_list();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::Map >*
+      mutable_map_list();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::Map >&
+      map_list() const;
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.MapList)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::Map > map_list_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsMapListImpl();
+};
+// -------------------------------------------------------------------
+
+class MapGroupHandle : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.MapGroupHandle) */ {
+ public:
+  MapGroupHandle();
+  virtual ~MapGroupHandle();
+
+  MapGroupHandle(const MapGroupHandle& from);
+
+  inline MapGroupHandle& operator=(const MapGroupHandle& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  MapGroupHandle(MapGroupHandle&& from) noexcept
+    : MapGroupHandle() {
+    *this = ::std::move(from);
+  }
+
+  inline MapGroupHandle& operator=(MapGroupHandle&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const MapGroupHandle& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const MapGroupHandle* internal_default_instance() {
+    return reinterpret_cast<const MapGroupHandle*>(
+               &_MapGroupHandle_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    102;
+
+  void Swap(MapGroupHandle* other);
+  friend void swap(MapGroupHandle& a, MapGroupHandle& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline MapGroupHandle* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  MapGroupHandle* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const MapGroupHandle& from);
+  void MergeFrom(const MapGroupHandle& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(MapGroupHandle* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // uint32 identifier = 1;
+  void clear_identifier();
+  static const int kIdentifierFieldNumber = 1;
+  ::google::protobuf::uint32 identifier() const;
+  void set_identifier(::google::protobuf::uint32 value);
+
+  // fixed32 permission = 2;
+  void clear_permission();
+  static const int kPermissionFieldNumber = 2;
+  ::google::protobuf::uint32 permission() const;
+  void set_permission(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.MapGroupHandle)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 identifier_;
+  ::google::protobuf::uint32 permission_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsMapGroupHandleImpl();
+};
+// -------------------------------------------------------------------
+
+class MapGroup : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.MapGroup) */ {
+ public:
+  MapGroup();
+  virtual ~MapGroup();
+
+  MapGroup(const MapGroup& from);
+
+  inline MapGroup& operator=(const MapGroup& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  MapGroup(MapGroup&& from) noexcept
+    : MapGroup() {
+    *this = ::std::move(from);
+  }
+
+  inline MapGroup& operator=(MapGroup&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const MapGroup& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const MapGroup* internal_default_instance() {
+    return reinterpret_cast<const MapGroup*>(
+               &_MapGroup_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    103;
+
+  void Swap(MapGroup* other);
+  friend void swap(MapGroup& a, MapGroup& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline MapGroup* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  MapGroup* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const MapGroup& from);
+  void MergeFrom(const MapGroup& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(MapGroup* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .Kinova.Api.Base.MapGroupHandle children_map_group_handles = 5;
+  int children_map_group_handles_size() const;
+  void clear_children_map_group_handles();
+  static const int kChildrenMapGroupHandlesFieldNumber = 5;
+  const ::Kinova::Api::Base::MapGroupHandle& children_map_group_handles(int index) const;
+  ::Kinova::Api::Base::MapGroupHandle* mutable_children_map_group_handles(int index);
+  ::Kinova::Api::Base::MapGroupHandle* add_children_map_group_handles();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::MapGroupHandle >*
+      mutable_children_map_group_handles();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::MapGroupHandle >&
+      children_map_group_handles() const;
+
+  // repeated .Kinova.Api.Base.MapHandle map_handles = 6;
+  int map_handles_size() const;
+  void clear_map_handles();
+  static const int kMapHandlesFieldNumber = 6;
+  const ::Kinova::Api::Base::MapHandle& map_handles(int index) const;
+  ::Kinova::Api::Base::MapHandle* mutable_map_handles(int index);
+  ::Kinova::Api::Base::MapHandle* add_map_handles();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::MapHandle >*
+      mutable_map_handles();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::MapHandle >&
+      map_handles() const;
+
+  // string name = 2;
+  void clear_name();
+  static const int kNameFieldNumber = 2;
+  const ::std::string& name() const;
+  void set_name(const ::std::string& value);
+  #if LANG_CXX11
+  void set_name(::std::string&& value);
+  #endif
+  void set_name(const char* value);
+  void set_name(const char* value, size_t size);
+  ::std::string* mutable_name();
+  ::std::string* release_name();
+  void set_allocated_name(::std::string* name);
+
+  // string application_data = 7;
+  void clear_application_data();
+  static const int kApplicationDataFieldNumber = 7;
+  const ::std::string& application_data() const;
+  void set_application_data(const ::std::string& value);
+  #if LANG_CXX11
+  void set_application_data(::std::string&& value);
+  #endif
+  void set_application_data(const char* value);
+  void set_application_data(const char* value, size_t size);
+  ::std::string* mutable_application_data();
+  ::std::string* release_application_data();
+  void set_allocated_application_data(::std::string* application_data);
+
+  // .Kinova.Api.Base.MapGroupHandle group_handle = 1;
+  bool has_group_handle() const;
+  void clear_group_handle();
+  static const int kGroupHandleFieldNumber = 1;
+  const ::Kinova::Api::Base::MapGroupHandle& group_handle() const;
+  ::Kinova::Api::Base::MapGroupHandle* release_group_handle();
+  ::Kinova::Api::Base::MapGroupHandle* mutable_group_handle();
+  void set_allocated_group_handle(::Kinova::Api::Base::MapGroupHandle* group_handle);
+
+  // .Kinova.Api.Base.MappingHandle related_mapping_handle = 3;
+  bool has_related_mapping_handle() const;
+  void clear_related_mapping_handle();
+  static const int kRelatedMappingHandleFieldNumber = 3;
+  const ::Kinova::Api::Base::MappingHandle& related_mapping_handle() const;
+  ::Kinova::Api::Base::MappingHandle* release_related_mapping_handle();
+  ::Kinova::Api::Base::MappingHandle* mutable_related_mapping_handle();
+  void set_allocated_related_mapping_handle(::Kinova::Api::Base::MappingHandle* related_mapping_handle);
+
+  // .Kinova.Api.Base.MapGroupHandle parent_group_handle = 4;
+  bool has_parent_group_handle() const;
+  void clear_parent_group_handle();
+  static const int kParentGroupHandleFieldNumber = 4;
+  const ::Kinova::Api::Base::MapGroupHandle& parent_group_handle() const;
+  ::Kinova::Api::Base::MapGroupHandle* release_parent_group_handle();
+  ::Kinova::Api::Base::MapGroupHandle* mutable_parent_group_handle();
+  void set_allocated_parent_group_handle(::Kinova::Api::Base::MapGroupHandle* parent_group_handle);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.MapGroup)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::MapGroupHandle > children_map_group_handles_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::MapHandle > map_handles_;
+  ::google::protobuf::internal::ArenaStringPtr name_;
+  ::google::protobuf::internal::ArenaStringPtr application_data_;
+  ::Kinova::Api::Base::MapGroupHandle* group_handle_;
+  ::Kinova::Api::Base::MappingHandle* related_mapping_handle_;
+  ::Kinova::Api::Base::MapGroupHandle* parent_group_handle_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsMapGroupImpl();
+};
+// -------------------------------------------------------------------
+
+class MapGroupList : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.MapGroupList) */ {
+ public:
+  MapGroupList();
+  virtual ~MapGroupList();
+
+  MapGroupList(const MapGroupList& from);
+
+  inline MapGroupList& operator=(const MapGroupList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  MapGroupList(MapGroupList&& from) noexcept
+    : MapGroupList() {
+    *this = ::std::move(from);
+  }
+
+  inline MapGroupList& operator=(MapGroupList&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const MapGroupList& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const MapGroupList* internal_default_instance() {
+    return reinterpret_cast<const MapGroupList*>(
+               &_MapGroupList_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    104;
+
+  void Swap(MapGroupList* other);
+  friend void swap(MapGroupList& a, MapGroupList& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline MapGroupList* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  MapGroupList* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const MapGroupList& from);
+  void MergeFrom(const MapGroupList& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(MapGroupList* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .Kinova.Api.Base.MapGroup map_groups = 1;
+  int map_groups_size() const;
+  void clear_map_groups();
+  static const int kMapGroupsFieldNumber = 1;
+  const ::Kinova::Api::Base::MapGroup& map_groups(int index) const;
+  ::Kinova::Api::Base::MapGroup* mutable_map_groups(int index);
+  ::Kinova::Api::Base::MapGroup* add_map_groups();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::MapGroup >*
+      mutable_map_groups();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::MapGroup >&
+      map_groups() const;
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.MapGroupList)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::MapGroup > map_groups_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsMapGroupListImpl();
+};
+// -------------------------------------------------------------------
+
+class Mapping : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.Mapping) */ {
+ public:
+  Mapping();
+  virtual ~Mapping();
+
+  Mapping(const Mapping& from);
+
+  inline Mapping& operator=(const Mapping& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Mapping(Mapping&& from) noexcept
+    : Mapping() {
+    *this = ::std::move(from);
+  }
+
+  inline Mapping& operator=(Mapping&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Mapping& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Mapping* internal_default_instance() {
+    return reinterpret_cast<const Mapping*>(
+               &_Mapping_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    105;
+
+  void Swap(Mapping* other);
+  friend void swap(Mapping& a, Mapping& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Mapping* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Mapping* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Mapping& from);
+  void MergeFrom(const Mapping& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Mapping* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .Kinova.Api.Base.MapGroupHandle map_group_handles = 5;
+  int map_group_handles_size() const;
+  void clear_map_group_handles();
+  static const int kMapGroupHandlesFieldNumber = 5;
+  const ::Kinova::Api::Base::MapGroupHandle& map_group_handles(int index) const;
+  ::Kinova::Api::Base::MapGroupHandle* mutable_map_group_handles(int index);
+  ::Kinova::Api::Base::MapGroupHandle* add_map_group_handles();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::MapGroupHandle >*
+      mutable_map_group_handles();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::MapGroupHandle >&
+      map_group_handles() const;
+
+  // repeated .Kinova.Api.Base.MapHandle map_handles = 7;
+  int map_handles_size() const;
+  void clear_map_handles();
+  static const int kMapHandlesFieldNumber = 7;
+  const ::Kinova::Api::Base::MapHandle& map_handles(int index) const;
+  ::Kinova::Api::Base::MapHandle* mutable_map_handles(int index);
+  ::Kinova::Api::Base::MapHandle* add_map_handles();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::MapHandle >*
+      mutable_map_handles();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::MapHandle >&
+      map_handles() const;
+
+  // string name = 2;
+  void clear_name();
+  static const int kNameFieldNumber = 2;
+  const ::std::string& name() const;
+  void set_name(const ::std::string& value);
+  #if LANG_CXX11
+  void set_name(::std::string&& value);
+  #endif
+  void set_name(const char* value);
+  void set_name(const char* value, size_t size);
+  ::std::string* mutable_name();
+  ::std::string* release_name();
+  void set_allocated_name(::std::string* name);
+
+  // string application_data = 8;
+  void clear_application_data();
+  static const int kApplicationDataFieldNumber = 8;
+  const ::std::string& application_data() const;
+  void set_application_data(const ::std::string& value);
+  #if LANG_CXX11
+  void set_application_data(::std::string&& value);
+  #endif
+  void set_application_data(const char* value);
+  void set_application_data(const char* value, size_t size);
+  ::std::string* mutable_application_data();
+  ::std::string* release_application_data();
+  void set_allocated_application_data(::std::string* application_data);
+
+  // .Kinova.Api.Base.MappingHandle handle = 1;
+  bool has_handle() const;
+  void clear_handle();
+  static const int kHandleFieldNumber = 1;
+  const ::Kinova::Api::Base::MappingHandle& handle() const;
+  ::Kinova::Api::Base::MappingHandle* release_handle();
+  ::Kinova::Api::Base::MappingHandle* mutable_handle();
+  void set_allocated_handle(::Kinova::Api::Base::MappingHandle* handle);
+
+  // .Kinova.Api.Base.MapGroupHandle active_map_group_handle = 4;
+  bool has_active_map_group_handle() const;
+  void clear_active_map_group_handle();
+  static const int kActiveMapGroupHandleFieldNumber = 4;
+  const ::Kinova::Api::Base::MapGroupHandle& active_map_group_handle() const;
+  ::Kinova::Api::Base::MapGroupHandle* release_active_map_group_handle();
+  ::Kinova::Api::Base::MapGroupHandle* mutable_active_map_group_handle();
+  void set_allocated_active_map_group_handle(::Kinova::Api::Base::MapGroupHandle* active_map_group_handle);
+
+  // .Kinova.Api.Base.MapHandle active_map_handle = 6;
+  bool has_active_map_handle() const;
+  void clear_active_map_handle();
+  static const int kActiveMapHandleFieldNumber = 6;
+  const ::Kinova::Api::Base::MapHandle& active_map_handle() const;
+  ::Kinova::Api::Base::MapHandle* release_active_map_handle();
+  ::Kinova::Api::Base::MapHandle* mutable_active_map_handle();
+  void set_allocated_active_map_handle(::Kinova::Api::Base::MapHandle* active_map_handle);
+
+  // uint32 controller_identifier = 3;
+  void clear_controller_identifier();
+  static const int kControllerIdentifierFieldNumber = 3;
+  ::google::protobuf::uint32 controller_identifier() const;
+  void set_controller_identifier(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.Mapping)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::MapGroupHandle > map_group_handles_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::MapHandle > map_handles_;
+  ::google::protobuf::internal::ArenaStringPtr name_;
+  ::google::protobuf::internal::ArenaStringPtr application_data_;
+  ::Kinova::Api::Base::MappingHandle* handle_;
+  ::Kinova::Api::Base::MapGroupHandle* active_map_group_handle_;
+  ::Kinova::Api::Base::MapHandle* active_map_handle_;
+  ::google::protobuf::uint32 controller_identifier_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsMappingImpl();
+};
+// -------------------------------------------------------------------
+
+class MappingList : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.MappingList) */ {
+ public:
+  MappingList();
+  virtual ~MappingList();
+
+  MappingList(const MappingList& from);
+
+  inline MappingList& operator=(const MappingList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  MappingList(MappingList&& from) noexcept
+    : MappingList() {
+    *this = ::std::move(from);
+  }
+
+  inline MappingList& operator=(MappingList&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const MappingList& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const MappingList* internal_default_instance() {
+    return reinterpret_cast<const MappingList*>(
+               &_MappingList_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    106;
+
+  void Swap(MappingList* other);
+  friend void swap(MappingList& a, MappingList& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline MappingList* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  MappingList* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const MappingList& from);
+  void MergeFrom(const MappingList& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(MappingList* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .Kinova.Api.Base.Mapping mappings = 1;
+  int mappings_size() const;
+  void clear_mappings();
+  static const int kMappingsFieldNumber = 1;
+  const ::Kinova::Api::Base::Mapping& mappings(int index) const;
+  ::Kinova::Api::Base::Mapping* mutable_mappings(int index);
+  ::Kinova::Api::Base::Mapping* add_mappings();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::Mapping >*
+      mutable_mappings();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::Mapping >&
+      mappings() const;
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.MappingList)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::Mapping > mappings_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsMappingListImpl();
+};
+// -------------------------------------------------------------------
+
+class TransformationMatrix : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.TransformationMatrix) */ {
+ public:
+  TransformationMatrix();
+  virtual ~TransformationMatrix();
+
+  TransformationMatrix(const TransformationMatrix& from);
+
+  inline TransformationMatrix& operator=(const TransformationMatrix& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  TransformationMatrix(TransformationMatrix&& from) noexcept
+    : TransformationMatrix() {
+    *this = ::std::move(from);
+  }
+
+  inline TransformationMatrix& operator=(TransformationMatrix&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const TransformationMatrix& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const TransformationMatrix* internal_default_instance() {
+    return reinterpret_cast<const TransformationMatrix*>(
+               &_TransformationMatrix_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    107;
+
+  void Swap(TransformationMatrix* other);
+  friend void swap(TransformationMatrix& a, TransformationMatrix& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline TransformationMatrix* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  TransformationMatrix* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const TransformationMatrix& from);
+  void MergeFrom(const TransformationMatrix& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(TransformationMatrix* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Base.TransformationRow r0 = 1;
+  bool has_r0() const;
+  void clear_r0();
+  static const int kR0FieldNumber = 1;
+  const ::Kinova::Api::Base::TransformationRow& r0() const;
+  ::Kinova::Api::Base::TransformationRow* release_r0();
+  ::Kinova::Api::Base::TransformationRow* mutable_r0();
+  void set_allocated_r0(::Kinova::Api::Base::TransformationRow* r0);
+
+  // .Kinova.Api.Base.TransformationRow r1 = 2;
+  bool has_r1() const;
+  void clear_r1();
+  static const int kR1FieldNumber = 2;
+  const ::Kinova::Api::Base::TransformationRow& r1() const;
+  ::Kinova::Api::Base::TransformationRow* release_r1();
+  ::Kinova::Api::Base::TransformationRow* mutable_r1();
+  void set_allocated_r1(::Kinova::Api::Base::TransformationRow* r1);
+
+  // .Kinova.Api.Base.TransformationRow r2 = 3;
+  bool has_r2() const;
+  void clear_r2();
+  static const int kR2FieldNumber = 3;
+  const ::Kinova::Api::Base::TransformationRow& r2() const;
+  ::Kinova::Api::Base::TransformationRow* release_r2();
+  ::Kinova::Api::Base::TransformationRow* mutable_r2();
+  void set_allocated_r2(::Kinova::Api::Base::TransformationRow* r2);
+
+  // .Kinova.Api.Base.TransformationRow r3 = 4;
+  bool has_r3() const;
+  void clear_r3();
+  static const int kR3FieldNumber = 4;
+  const ::Kinova::Api::Base::TransformationRow& r3() const;
+  ::Kinova::Api::Base::TransformationRow* release_r3();
+  ::Kinova::Api::Base::TransformationRow* mutable_r3();
+  void set_allocated_r3(::Kinova::Api::Base::TransformationRow* r3);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.TransformationMatrix)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::Base::TransformationRow* r0_;
+  ::Kinova::Api::Base::TransformationRow* r1_;
+  ::Kinova::Api::Base::TransformationRow* r2_;
+  ::Kinova::Api::Base::TransformationRow* r3_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsTransformationMatrixImpl();
+};
+// -------------------------------------------------------------------
+
+class TransformationRow : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.TransformationRow) */ {
+ public:
+  TransformationRow();
+  virtual ~TransformationRow();
+
+  TransformationRow(const TransformationRow& from);
+
+  inline TransformationRow& operator=(const TransformationRow& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  TransformationRow(TransformationRow&& from) noexcept
+    : TransformationRow() {
+    *this = ::std::move(from);
+  }
+
+  inline TransformationRow& operator=(TransformationRow&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const TransformationRow& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const TransformationRow* internal_default_instance() {
+    return reinterpret_cast<const TransformationRow*>(
+               &_TransformationRow_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    108;
+
+  void Swap(TransformationRow* other);
+  friend void swap(TransformationRow& a, TransformationRow& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline TransformationRow* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  TransformationRow* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const TransformationRow& from);
+  void MergeFrom(const TransformationRow& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(TransformationRow* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // float c0 = 1;
+  void clear_c0();
+  static const int kC0FieldNumber = 1;
+  float c0() const;
+  void set_c0(float value);
+
+  // float c1 = 2;
+  void clear_c1();
+  static const int kC1FieldNumber = 2;
+  float c1() const;
+  void set_c1(float value);
+
+  // float c2 = 3;
+  void clear_c2();
+  static const int kC2FieldNumber = 3;
+  float c2() const;
+  void set_c2(float value);
+
+  // float c3 = 4;
+  void clear_c3();
+  static const int kC3FieldNumber = 4;
+  float c3() const;
+  void set_c3(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.TransformationRow)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  float c0_;
+  float c1_;
+  float c2_;
+  float c3_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsTransformationRowImpl();
+};
+// -------------------------------------------------------------------
+
+class Pose : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.Pose) */ {
+ public:
+  Pose();
+  virtual ~Pose();
+
+  Pose(const Pose& from);
+
+  inline Pose& operator=(const Pose& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Pose(Pose&& from) noexcept
+    : Pose() {
+    *this = ::std::move(from);
+  }
+
+  inline Pose& operator=(Pose&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Pose& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Pose* internal_default_instance() {
+    return reinterpret_cast<const Pose*>(
+               &_Pose_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    109;
+
+  void Swap(Pose* other);
+  friend void swap(Pose& a, Pose& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Pose* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Pose* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Pose& from);
+  void MergeFrom(const Pose& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Pose* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // float x = 1;
+  void clear_x();
+  static const int kXFieldNumber = 1;
+  float x() const;
+  void set_x(float value);
+
+  // float y = 2;
+  void clear_y();
+  static const int kYFieldNumber = 2;
+  float y() const;
+  void set_y(float value);
+
+  // float z = 3;
+  void clear_z();
+  static const int kZFieldNumber = 3;
+  float z() const;
+  void set_z(float value);
+
+  // float theta_x = 4;
+  void clear_theta_x();
+  static const int kThetaXFieldNumber = 4;
+  float theta_x() const;
+  void set_theta_x(float value);
+
+  // float theta_y = 5;
+  void clear_theta_y();
+  static const int kThetaYFieldNumber = 5;
+  float theta_y() const;
+  void set_theta_y(float value);
+
+  // float theta_z = 6;
+  void clear_theta_z();
+  static const int kThetaZFieldNumber = 6;
+  float theta_z() const;
+  void set_theta_z(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.Pose)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  float x_;
+  float y_;
+  float z_;
+  float theta_x_;
+  float theta_y_;
+  float theta_z_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsPoseImpl();
+};
+// -------------------------------------------------------------------
+
+class Position : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.Position) */ {
+ public:
+  Position();
+  virtual ~Position();
+
+  Position(const Position& from);
+
+  inline Position& operator=(const Position& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Position(Position&& from) noexcept
+    : Position() {
+    *this = ::std::move(from);
+  }
+
+  inline Position& operator=(Position&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Position& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Position* internal_default_instance() {
+    return reinterpret_cast<const Position*>(
+               &_Position_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    110;
+
+  void Swap(Position* other);
+  friend void swap(Position& a, Position& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Position* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Position* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Position& from);
+  void MergeFrom(const Position& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Position* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // float x = 1;
+  void clear_x();
+  static const int kXFieldNumber = 1;
+  float x() const;
+  void set_x(float value);
+
+  // float y = 2;
+  void clear_y();
+  static const int kYFieldNumber = 2;
+  float y() const;
+  void set_y(float value);
+
+  // float z = 3;
+  void clear_z();
+  static const int kZFieldNumber = 3;
+  float z() const;
+  void set_z(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.Position)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  float x_;
+  float y_;
+  float z_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsPositionImpl();
+};
+// -------------------------------------------------------------------
+
+class Orientation : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.Orientation) */ {
+ public:
+  Orientation();
+  virtual ~Orientation();
+
+  Orientation(const Orientation& from);
+
+  inline Orientation& operator=(const Orientation& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Orientation(Orientation&& from) noexcept
+    : Orientation() {
+    *this = ::std::move(from);
+  }
+
+  inline Orientation& operator=(Orientation&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Orientation& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Orientation* internal_default_instance() {
+    return reinterpret_cast<const Orientation*>(
+               &_Orientation_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    111;
+
+  void Swap(Orientation* other);
+  friend void swap(Orientation& a, Orientation& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Orientation* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Orientation* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Orientation& from);
+  void MergeFrom(const Orientation& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Orientation* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // float theta_x = 1;
+  void clear_theta_x();
+  static const int kThetaXFieldNumber = 1;
+  float theta_x() const;
+  void set_theta_x(float value);
+
+  // float theta_y = 2;
+  void clear_theta_y();
+  static const int kThetaYFieldNumber = 2;
+  float theta_y() const;
+  void set_theta_y(float value);
+
+  // float theta_z = 3;
+  void clear_theta_z();
+  static const int kThetaZFieldNumber = 3;
+  float theta_z() const;
+  void set_theta_z(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.Orientation)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  float theta_x_;
+  float theta_y_;
+  float theta_z_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsOrientationImpl();
+};
+// -------------------------------------------------------------------
+
+class CartesianSpeed : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.CartesianSpeed) */ {
+ public:
+  CartesianSpeed();
+  virtual ~CartesianSpeed();
+
+  CartesianSpeed(const CartesianSpeed& from);
+
+  inline CartesianSpeed& operator=(const CartesianSpeed& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  CartesianSpeed(CartesianSpeed&& from) noexcept
+    : CartesianSpeed() {
+    *this = ::std::move(from);
+  }
+
+  inline CartesianSpeed& operator=(CartesianSpeed&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const CartesianSpeed& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const CartesianSpeed* internal_default_instance() {
+    return reinterpret_cast<const CartesianSpeed*>(
+               &_CartesianSpeed_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    112;
+
+  void Swap(CartesianSpeed* other);
+  friend void swap(CartesianSpeed& a, CartesianSpeed& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline CartesianSpeed* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  CartesianSpeed* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const CartesianSpeed& from);
+  void MergeFrom(const CartesianSpeed& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(CartesianSpeed* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // float translation = 1;
+  void clear_translation();
+  static const int kTranslationFieldNumber = 1;
+  float translation() const;
+  void set_translation(float value);
+
+  // float orientation = 2;
+  void clear_orientation();
+  static const int kOrientationFieldNumber = 2;
+  float orientation() const;
+  void set_orientation(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.CartesianSpeed)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  float translation_;
+  float orientation_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsCartesianSpeedImpl();
+};
+// -------------------------------------------------------------------
+
+class CartesianTrajectoryConstraint : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.CartesianTrajectoryConstraint) */ {
+ public:
+  CartesianTrajectoryConstraint();
+  virtual ~CartesianTrajectoryConstraint();
+
+  CartesianTrajectoryConstraint(const CartesianTrajectoryConstraint& from);
+
+  inline CartesianTrajectoryConstraint& operator=(const CartesianTrajectoryConstraint& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  CartesianTrajectoryConstraint(CartesianTrajectoryConstraint&& from) noexcept
+    : CartesianTrajectoryConstraint() {
+    *this = ::std::move(from);
+  }
+
+  inline CartesianTrajectoryConstraint& operator=(CartesianTrajectoryConstraint&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const CartesianTrajectoryConstraint& default_instance();
+
+  enum TypeCase {
+    kSpeed = 1,
+    kDuration = 2,
+    TYPE_NOT_SET = 0,
+  };
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const CartesianTrajectoryConstraint* internal_default_instance() {
+    return reinterpret_cast<const CartesianTrajectoryConstraint*>(
+               &_CartesianTrajectoryConstraint_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    113;
+
+  void Swap(CartesianTrajectoryConstraint* other);
+  friend void swap(CartesianTrajectoryConstraint& a, CartesianTrajectoryConstraint& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline CartesianTrajectoryConstraint* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  CartesianTrajectoryConstraint* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const CartesianTrajectoryConstraint& from);
+  void MergeFrom(const CartesianTrajectoryConstraint& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(CartesianTrajectoryConstraint* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Base.CartesianSpeed speed = 1;
+  bool has_speed() const;
+  void clear_speed();
+  static const int kSpeedFieldNumber = 1;
+  const ::Kinova::Api::Base::CartesianSpeed& speed() const;
+  ::Kinova::Api::Base::CartesianSpeed* release_speed();
+  ::Kinova::Api::Base::CartesianSpeed* mutable_speed();
+  void set_allocated_speed(::Kinova::Api::Base::CartesianSpeed* speed);
+
+  // float duration = 2;
+  private:
+  bool has_duration() const;
+  public:
+  void clear_duration();
+  static const int kDurationFieldNumber = 2;
+  float duration() const;
+  void set_duration(float value);
+
+  TypeCase type_case() const;
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.CartesianTrajectoryConstraint)
+ private:
+  void set_has_speed();
+  void set_has_duration();
+
+  inline bool has_type() const;
+  void clear_type();
+  inline void clear_has_type();
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  union TypeUnion {
+    TypeUnion() {}
+    ::Kinova::Api::Base::CartesianSpeed* speed_;
+    float duration_;
+  } type_;
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _oneof_case_[1];
+
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsCartesianTrajectoryConstraintImpl();
+};
+// -------------------------------------------------------------------
+
+class JointTrajectoryConstraint : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.JointTrajectoryConstraint) */ {
+ public:
+  JointTrajectoryConstraint();
+  virtual ~JointTrajectoryConstraint();
+
+  JointTrajectoryConstraint(const JointTrajectoryConstraint& from);
+
+  inline JointTrajectoryConstraint& operator=(const JointTrajectoryConstraint& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  JointTrajectoryConstraint(JointTrajectoryConstraint&& from) noexcept
+    : JointTrajectoryConstraint() {
+    *this = ::std::move(from);
+  }
+
+  inline JointTrajectoryConstraint& operator=(JointTrajectoryConstraint&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const JointTrajectoryConstraint& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const JointTrajectoryConstraint* internal_default_instance() {
+    return reinterpret_cast<const JointTrajectoryConstraint*>(
+               &_JointTrajectoryConstraint_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    114;
+
+  void Swap(JointTrajectoryConstraint* other);
+  friend void swap(JointTrajectoryConstraint& a, JointTrajectoryConstraint& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline JointTrajectoryConstraint* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  JointTrajectoryConstraint* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const JointTrajectoryConstraint& from);
+  void MergeFrom(const JointTrajectoryConstraint& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(JointTrajectoryConstraint* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Base.JointTrajectoryConstraintType type = 1;
+  void clear_type();
+  static const int kTypeFieldNumber = 1;
+  ::Kinova::Api::Base::JointTrajectoryConstraintType type() const;
+  void set_type(::Kinova::Api::Base::JointTrajectoryConstraintType value);
+
+  // float value = 2;
+  void clear_value();
+  static const int kValueFieldNumber = 2;
+  float value() const;
+  void set_value(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.JointTrajectoryConstraint)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  int type_;
+  float value_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsJointTrajectoryConstraintImpl();
+};
+// -------------------------------------------------------------------
+
+class Wrench : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.Wrench) */ {
+ public:
+  Wrench();
+  virtual ~Wrench();
+
+  Wrench(const Wrench& from);
+
+  inline Wrench& operator=(const Wrench& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Wrench(Wrench&& from) noexcept
+    : Wrench() {
+    *this = ::std::move(from);
+  }
+
+  inline Wrench& operator=(Wrench&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Wrench& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Wrench* internal_default_instance() {
+    return reinterpret_cast<const Wrench*>(
+               &_Wrench_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    115;
+
+  void Swap(Wrench* other);
+  friend void swap(Wrench& a, Wrench& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Wrench* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Wrench* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Wrench& from);
+  void MergeFrom(const Wrench& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Wrench* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // float force_x = 1;
+  void clear_force_x();
+  static const int kForceXFieldNumber = 1;
+  float force_x() const;
+  void set_force_x(float value);
+
+  // float force_y = 2;
+  void clear_force_y();
+  static const int kForceYFieldNumber = 2;
+  float force_y() const;
+  void set_force_y(float value);
+
+  // float force_z = 3;
+  void clear_force_z();
+  static const int kForceZFieldNumber = 3;
+  float force_z() const;
+  void set_force_z(float value);
+
+  // float torque_x = 4;
+  void clear_torque_x();
+  static const int kTorqueXFieldNumber = 4;
+  float torque_x() const;
+  void set_torque_x(float value);
+
+  // float torque_y = 5;
+  void clear_torque_y();
+  static const int kTorqueYFieldNumber = 5;
+  float torque_y() const;
+  void set_torque_y(float value);
+
+  // float torque_z = 6;
+  void clear_torque_z();
+  static const int kTorqueZFieldNumber = 6;
+  float torque_z() const;
+  void set_torque_z(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.Wrench)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  float force_x_;
+  float force_y_;
+  float force_z_;
+  float torque_x_;
+  float torque_y_;
+  float torque_z_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsWrenchImpl();
+};
+// -------------------------------------------------------------------
+
+class Twist : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.Twist) */ {
+ public:
+  Twist();
+  virtual ~Twist();
+
+  Twist(const Twist& from);
+
+  inline Twist& operator=(const Twist& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Twist(Twist&& from) noexcept
+    : Twist() {
+    *this = ::std::move(from);
+  }
+
+  inline Twist& operator=(Twist&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Twist& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Twist* internal_default_instance() {
+    return reinterpret_cast<const Twist*>(
+               &_Twist_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    116;
+
+  void Swap(Twist* other);
+  friend void swap(Twist& a, Twist& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Twist* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Twist* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Twist& from);
+  void MergeFrom(const Twist& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Twist* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // float linear_x = 1;
+  void clear_linear_x();
+  static const int kLinearXFieldNumber = 1;
+  float linear_x() const;
+  void set_linear_x(float value);
+
+  // float linear_y = 2;
+  void clear_linear_y();
+  static const int kLinearYFieldNumber = 2;
+  float linear_y() const;
+  void set_linear_y(float value);
+
+  // float linear_z = 3;
+  void clear_linear_z();
+  static const int kLinearZFieldNumber = 3;
+  float linear_z() const;
+  void set_linear_z(float value);
+
+  // float angular_x = 4;
+  void clear_angular_x();
+  static const int kAngularXFieldNumber = 4;
+  float angular_x() const;
+  void set_angular_x(float value);
+
+  // float angular_y = 5;
+  void clear_angular_y();
+  static const int kAngularYFieldNumber = 5;
+  float angular_y() const;
+  void set_angular_y(float value);
+
+  // float angular_z = 6;
+  void clear_angular_z();
+  static const int kAngularZFieldNumber = 6;
+  float angular_z() const;
+  void set_angular_z(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.Twist)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  float linear_x_;
+  float linear_y_;
+  float linear_z_;
+  float angular_x_;
+  float angular_y_;
+  float angular_z_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsTwistImpl();
+};
+// -------------------------------------------------------------------
+
+class Admittance : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.Admittance) */ {
+ public:
+  Admittance();
+  virtual ~Admittance();
+
+  Admittance(const Admittance& from);
+
+  inline Admittance& operator=(const Admittance& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Admittance(Admittance&& from) noexcept
+    : Admittance() {
+    *this = ::std::move(from);
+  }
+
+  inline Admittance& operator=(Admittance&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Admittance& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Admittance* internal_default_instance() {
+    return reinterpret_cast<const Admittance*>(
+               &_Admittance_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    117;
+
+  void Swap(Admittance* other);
+  friend void swap(Admittance& a, Admittance& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Admittance* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Admittance* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Admittance& from);
+  void MergeFrom(const Admittance& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Admittance* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Base.AdmittanceMode admittance_mode = 1;
+  void clear_admittance_mode();
+  static const int kAdmittanceModeFieldNumber = 1;
+  ::Kinova::Api::Base::AdmittanceMode admittance_mode() const;
+  void set_admittance_mode(::Kinova::Api::Base::AdmittanceMode value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.Admittance)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  int admittance_mode_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsAdmittanceImpl();
+};
+// -------------------------------------------------------------------
+
+class ConstrainedPose : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.ConstrainedPose) */ {
+ public:
+  ConstrainedPose();
+  virtual ~ConstrainedPose();
+
+  ConstrainedPose(const ConstrainedPose& from);
+
+  inline ConstrainedPose& operator=(const ConstrainedPose& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ConstrainedPose(ConstrainedPose&& from) noexcept
+    : ConstrainedPose() {
+    *this = ::std::move(from);
+  }
+
+  inline ConstrainedPose& operator=(ConstrainedPose&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ConstrainedPose& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ConstrainedPose* internal_default_instance() {
+    return reinterpret_cast<const ConstrainedPose*>(
+               &_ConstrainedPose_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    118;
+
+  void Swap(ConstrainedPose* other);
+  friend void swap(ConstrainedPose& a, ConstrainedPose& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ConstrainedPose* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ConstrainedPose* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ConstrainedPose& from);
+  void MergeFrom(const ConstrainedPose& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ConstrainedPose* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Base.Pose target_pose = 1;
+  bool has_target_pose() const;
+  void clear_target_pose();
+  static const int kTargetPoseFieldNumber = 1;
+  const ::Kinova::Api::Base::Pose& target_pose() const;
+  ::Kinova::Api::Base::Pose* release_target_pose();
+  ::Kinova::Api::Base::Pose* mutable_target_pose();
+  void set_allocated_target_pose(::Kinova::Api::Base::Pose* target_pose);
+
+  // .Kinova.Api.Base.CartesianTrajectoryConstraint constraint = 2;
+  bool has_constraint() const;
+  void clear_constraint();
+  static const int kConstraintFieldNumber = 2;
+  const ::Kinova::Api::Base::CartesianTrajectoryConstraint& constraint() const;
+  ::Kinova::Api::Base::CartesianTrajectoryConstraint* release_constraint();
+  ::Kinova::Api::Base::CartesianTrajectoryConstraint* mutable_constraint();
+  void set_allocated_constraint(::Kinova::Api::Base::CartesianTrajectoryConstraint* constraint);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.ConstrainedPose)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::Base::Pose* target_pose_;
+  ::Kinova::Api::Base::CartesianTrajectoryConstraint* constraint_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsConstrainedPoseImpl();
+};
+// -------------------------------------------------------------------
+
+class ConstrainedPosition : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.ConstrainedPosition) */ {
+ public:
+  ConstrainedPosition();
+  virtual ~ConstrainedPosition();
+
+  ConstrainedPosition(const ConstrainedPosition& from);
+
+  inline ConstrainedPosition& operator=(const ConstrainedPosition& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ConstrainedPosition(ConstrainedPosition&& from) noexcept
+    : ConstrainedPosition() {
+    *this = ::std::move(from);
+  }
+
+  inline ConstrainedPosition& operator=(ConstrainedPosition&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ConstrainedPosition& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ConstrainedPosition* internal_default_instance() {
+    return reinterpret_cast<const ConstrainedPosition*>(
+               &_ConstrainedPosition_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    119;
+
+  void Swap(ConstrainedPosition* other);
+  friend void swap(ConstrainedPosition& a, ConstrainedPosition& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ConstrainedPosition* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ConstrainedPosition* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ConstrainedPosition& from);
+  void MergeFrom(const ConstrainedPosition& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ConstrainedPosition* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Base.Position target_position = 1;
+  bool has_target_position() const;
+  void clear_target_position();
+  static const int kTargetPositionFieldNumber = 1;
+  const ::Kinova::Api::Base::Position& target_position() const;
+  ::Kinova::Api::Base::Position* release_target_position();
+  ::Kinova::Api::Base::Position* mutable_target_position();
+  void set_allocated_target_position(::Kinova::Api::Base::Position* target_position);
+
+  // .Kinova.Api.Base.CartesianTrajectoryConstraint constraint = 2;
+  bool has_constraint() const;
+  void clear_constraint();
+  static const int kConstraintFieldNumber = 2;
+  const ::Kinova::Api::Base::CartesianTrajectoryConstraint& constraint() const;
+  ::Kinova::Api::Base::CartesianTrajectoryConstraint* release_constraint();
+  ::Kinova::Api::Base::CartesianTrajectoryConstraint* mutable_constraint();
+  void set_allocated_constraint(::Kinova::Api::Base::CartesianTrajectoryConstraint* constraint);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.ConstrainedPosition)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::Base::Position* target_position_;
+  ::Kinova::Api::Base::CartesianTrajectoryConstraint* constraint_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsConstrainedPositionImpl();
+};
+// -------------------------------------------------------------------
+
+class ConstrainedOrientation : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.ConstrainedOrientation) */ {
+ public:
+  ConstrainedOrientation();
+  virtual ~ConstrainedOrientation();
+
+  ConstrainedOrientation(const ConstrainedOrientation& from);
+
+  inline ConstrainedOrientation& operator=(const ConstrainedOrientation& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ConstrainedOrientation(ConstrainedOrientation&& from) noexcept
+    : ConstrainedOrientation() {
+    *this = ::std::move(from);
+  }
+
+  inline ConstrainedOrientation& operator=(ConstrainedOrientation&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ConstrainedOrientation& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ConstrainedOrientation* internal_default_instance() {
+    return reinterpret_cast<const ConstrainedOrientation*>(
+               &_ConstrainedOrientation_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    120;
+
+  void Swap(ConstrainedOrientation* other);
+  friend void swap(ConstrainedOrientation& a, ConstrainedOrientation& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ConstrainedOrientation* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ConstrainedOrientation* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ConstrainedOrientation& from);
+  void MergeFrom(const ConstrainedOrientation& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ConstrainedOrientation* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Base.Orientation target_orientation = 1;
+  bool has_target_orientation() const;
+  void clear_target_orientation();
+  static const int kTargetOrientationFieldNumber = 1;
+  const ::Kinova::Api::Base::Orientation& target_orientation() const;
+  ::Kinova::Api::Base::Orientation* release_target_orientation();
+  ::Kinova::Api::Base::Orientation* mutable_target_orientation();
+  void set_allocated_target_orientation(::Kinova::Api::Base::Orientation* target_orientation);
+
+  // .Kinova.Api.Base.CartesianTrajectoryConstraint constraint = 2;
+  bool has_constraint() const;
+  void clear_constraint();
+  static const int kConstraintFieldNumber = 2;
+  const ::Kinova::Api::Base::CartesianTrajectoryConstraint& constraint() const;
+  ::Kinova::Api::Base::CartesianTrajectoryConstraint* release_constraint();
+  ::Kinova::Api::Base::CartesianTrajectoryConstraint* mutable_constraint();
+  void set_allocated_constraint(::Kinova::Api::Base::CartesianTrajectoryConstraint* constraint);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.ConstrainedOrientation)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::Base::Orientation* target_orientation_;
+  ::Kinova::Api::Base::CartesianTrajectoryConstraint* constraint_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsConstrainedOrientationImpl();
+};
+// -------------------------------------------------------------------
+
+class WrenchCommand : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.WrenchCommand) */ {
+ public:
+  WrenchCommand();
+  virtual ~WrenchCommand();
+
+  WrenchCommand(const WrenchCommand& from);
+
+  inline WrenchCommand& operator=(const WrenchCommand& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  WrenchCommand(WrenchCommand&& from) noexcept
+    : WrenchCommand() {
+    *this = ::std::move(from);
+  }
+
+  inline WrenchCommand& operator=(WrenchCommand&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const WrenchCommand& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const WrenchCommand* internal_default_instance() {
+    return reinterpret_cast<const WrenchCommand*>(
+               &_WrenchCommand_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    121;
+
+  void Swap(WrenchCommand* other);
+  friend void swap(WrenchCommand& a, WrenchCommand& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline WrenchCommand* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  WrenchCommand* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const WrenchCommand& from);
+  void MergeFrom(const WrenchCommand& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(WrenchCommand* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Base.Wrench wrench = 3;
+  bool has_wrench() const;
+  void clear_wrench();
+  static const int kWrenchFieldNumber = 3;
+  const ::Kinova::Api::Base::Wrench& wrench() const;
+  ::Kinova::Api::Base::Wrench* release_wrench();
+  ::Kinova::Api::Base::Wrench* mutable_wrench();
+  void set_allocated_wrench(::Kinova::Api::Base::Wrench* wrench);
+
+  // .Kinova.Api.Common.CartesianReferenceFrame reference_frame = 1;
+  void clear_reference_frame();
+  static const int kReferenceFrameFieldNumber = 1;
+  ::Kinova::Api::Common::CartesianReferenceFrame reference_frame() const;
+  void set_reference_frame(::Kinova::Api::Common::CartesianReferenceFrame value);
+
+  // .Kinova.Api.Base.WrenchMode mode = 2;
+  void clear_mode();
+  static const int kModeFieldNumber = 2;
+  ::Kinova::Api::Base::WrenchMode mode() const;
+  void set_mode(::Kinova::Api::Base::WrenchMode value);
+
+  // uint32 duration = 4;
+  void clear_duration();
+  static const int kDurationFieldNumber = 4;
+  ::google::protobuf::uint32 duration() const;
+  void set_duration(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.WrenchCommand)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::Base::Wrench* wrench_;
+  int reference_frame_;
+  int mode_;
+  ::google::protobuf::uint32 duration_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsWrenchCommandImpl();
+};
+// -------------------------------------------------------------------
+
+class TwistCommand : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.TwistCommand) */ {
+ public:
+  TwistCommand();
+  virtual ~TwistCommand();
+
+  TwistCommand(const TwistCommand& from);
+
+  inline TwistCommand& operator=(const TwistCommand& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  TwistCommand(TwistCommand&& from) noexcept
+    : TwistCommand() {
+    *this = ::std::move(from);
+  }
+
+  inline TwistCommand& operator=(TwistCommand&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const TwistCommand& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const TwistCommand* internal_default_instance() {
+    return reinterpret_cast<const TwistCommand*>(
+               &_TwistCommand_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    122;
+
+  void Swap(TwistCommand* other);
+  friend void swap(TwistCommand& a, TwistCommand& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline TwistCommand* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  TwistCommand* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const TwistCommand& from);
+  void MergeFrom(const TwistCommand& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(TwistCommand* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Base.Twist twist = 2;
+  bool has_twist() const;
+  void clear_twist();
+  static const int kTwistFieldNumber = 2;
+  const ::Kinova::Api::Base::Twist& twist() const;
+  ::Kinova::Api::Base::Twist* release_twist();
+  ::Kinova::Api::Base::Twist* mutable_twist();
+  void set_allocated_twist(::Kinova::Api::Base::Twist* twist);
+
+  // .Kinova.Api.Common.CartesianReferenceFrame reference_frame = 1;
+  void clear_reference_frame();
+  static const int kReferenceFrameFieldNumber = 1;
+  ::Kinova::Api::Common::CartesianReferenceFrame reference_frame() const;
+  void set_reference_frame(::Kinova::Api::Common::CartesianReferenceFrame value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.TwistCommand)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::Base::Twist* twist_;
+  int reference_frame_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsTwistCommandImpl();
+};
+// -------------------------------------------------------------------
+
+class ConstrainedJointAngles : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.ConstrainedJointAngles) */ {
+ public:
+  ConstrainedJointAngles();
+  virtual ~ConstrainedJointAngles();
+
+  ConstrainedJointAngles(const ConstrainedJointAngles& from);
+
+  inline ConstrainedJointAngles& operator=(const ConstrainedJointAngles& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ConstrainedJointAngles(ConstrainedJointAngles&& from) noexcept
+    : ConstrainedJointAngles() {
+    *this = ::std::move(from);
+  }
+
+  inline ConstrainedJointAngles& operator=(ConstrainedJointAngles&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ConstrainedJointAngles& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ConstrainedJointAngles* internal_default_instance() {
+    return reinterpret_cast<const ConstrainedJointAngles*>(
+               &_ConstrainedJointAngles_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    123;
+
+  void Swap(ConstrainedJointAngles* other);
+  friend void swap(ConstrainedJointAngles& a, ConstrainedJointAngles& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ConstrainedJointAngles* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ConstrainedJointAngles* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ConstrainedJointAngles& from);
+  void MergeFrom(const ConstrainedJointAngles& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ConstrainedJointAngles* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Base.JointAngles joint_angles = 1;
+  bool has_joint_angles() const;
+  void clear_joint_angles();
+  static const int kJointAnglesFieldNumber = 1;
+  const ::Kinova::Api::Base::JointAngles& joint_angles() const;
+  ::Kinova::Api::Base::JointAngles* release_joint_angles();
+  ::Kinova::Api::Base::JointAngles* mutable_joint_angles();
+  void set_allocated_joint_angles(::Kinova::Api::Base::JointAngles* joint_angles);
+
+  // .Kinova.Api.Base.JointTrajectoryConstraint constraint = 2;
+  bool has_constraint() const;
+  void clear_constraint();
+  static const int kConstraintFieldNumber = 2;
+  const ::Kinova::Api::Base::JointTrajectoryConstraint& constraint() const;
+  ::Kinova::Api::Base::JointTrajectoryConstraint* release_constraint();
+  ::Kinova::Api::Base::JointTrajectoryConstraint* mutable_constraint();
+  void set_allocated_constraint(::Kinova::Api::Base::JointTrajectoryConstraint* constraint);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.ConstrainedJointAngles)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::Base::JointAngles* joint_angles_;
+  ::Kinova::Api::Base::JointTrajectoryConstraint* constraint_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsConstrainedJointAnglesImpl();
+};
+// -------------------------------------------------------------------
+
+class ConstrainedJointAngle : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.ConstrainedJointAngle) */ {
+ public:
+  ConstrainedJointAngle();
+  virtual ~ConstrainedJointAngle();
+
+  ConstrainedJointAngle(const ConstrainedJointAngle& from);
+
+  inline ConstrainedJointAngle& operator=(const ConstrainedJointAngle& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ConstrainedJointAngle(ConstrainedJointAngle&& from) noexcept
+    : ConstrainedJointAngle() {
+    *this = ::std::move(from);
+  }
+
+  inline ConstrainedJointAngle& operator=(ConstrainedJointAngle&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ConstrainedJointAngle& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ConstrainedJointAngle* internal_default_instance() {
+    return reinterpret_cast<const ConstrainedJointAngle*>(
+               &_ConstrainedJointAngle_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    124;
+
+  void Swap(ConstrainedJointAngle* other);
+  friend void swap(ConstrainedJointAngle& a, ConstrainedJointAngle& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ConstrainedJointAngle* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ConstrainedJointAngle* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ConstrainedJointAngle& from);
+  void MergeFrom(const ConstrainedJointAngle& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ConstrainedJointAngle* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Base.JointTrajectoryConstraint constraint = 3;
+  bool has_constraint() const;
+  void clear_constraint();
+  static const int kConstraintFieldNumber = 3;
+  const ::Kinova::Api::Base::JointTrajectoryConstraint& constraint() const;
+  ::Kinova::Api::Base::JointTrajectoryConstraint* release_constraint();
+  ::Kinova::Api::Base::JointTrajectoryConstraint* mutable_constraint();
+  void set_allocated_constraint(::Kinova::Api::Base::JointTrajectoryConstraint* constraint);
+
+  // uint32 joint_identifier = 1;
+  void clear_joint_identifier();
+  static const int kJointIdentifierFieldNumber = 1;
+  ::google::protobuf::uint32 joint_identifier() const;
+  void set_joint_identifier(::google::protobuf::uint32 value);
+
+  // float value = 2;
+  void clear_value();
+  static const int kValueFieldNumber = 2;
+  float value() const;
+  void set_value(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.ConstrainedJointAngle)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::Base::JointTrajectoryConstraint* constraint_;
+  ::google::protobuf::uint32 joint_identifier_;
+  float value_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsConstrainedJointAngleImpl();
+};
+// -------------------------------------------------------------------
+
+class JointAngles : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.JointAngles) */ {
+ public:
+  JointAngles();
+  virtual ~JointAngles();
+
+  JointAngles(const JointAngles& from);
+
+  inline JointAngles& operator=(const JointAngles& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  JointAngles(JointAngles&& from) noexcept
+    : JointAngles() {
+    *this = ::std::move(from);
+  }
+
+  inline JointAngles& operator=(JointAngles&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const JointAngles& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const JointAngles* internal_default_instance() {
+    return reinterpret_cast<const JointAngles*>(
+               &_JointAngles_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    125;
+
+  void Swap(JointAngles* other);
+  friend void swap(JointAngles& a, JointAngles& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline JointAngles* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  JointAngles* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const JointAngles& from);
+  void MergeFrom(const JointAngles& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(JointAngles* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .Kinova.Api.Base.JointAngle joint_angles = 1;
+  int joint_angles_size() const;
+  void clear_joint_angles();
+  static const int kJointAnglesFieldNumber = 1;
+  const ::Kinova::Api::Base::JointAngle& joint_angles(int index) const;
+  ::Kinova::Api::Base::JointAngle* mutable_joint_angles(int index);
+  ::Kinova::Api::Base::JointAngle* add_joint_angles();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::JointAngle >*
+      mutable_joint_angles();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::JointAngle >&
+      joint_angles() const;
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.JointAngles)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::JointAngle > joint_angles_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsJointAnglesImpl();
+};
+// -------------------------------------------------------------------
+
+class JointAngle : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.JointAngle) */ {
+ public:
+  JointAngle();
+  virtual ~JointAngle();
+
+  JointAngle(const JointAngle& from);
+
+  inline JointAngle& operator=(const JointAngle& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  JointAngle(JointAngle&& from) noexcept
+    : JointAngle() {
+    *this = ::std::move(from);
+  }
+
+  inline JointAngle& operator=(JointAngle&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const JointAngle& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const JointAngle* internal_default_instance() {
+    return reinterpret_cast<const JointAngle*>(
+               &_JointAngle_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    126;
+
+  void Swap(JointAngle* other);
+  friend void swap(JointAngle& a, JointAngle& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline JointAngle* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  JointAngle* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const JointAngle& from);
+  void MergeFrom(const JointAngle& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(JointAngle* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // uint32 joint_identifier = 1;
+  void clear_joint_identifier();
+  static const int kJointIdentifierFieldNumber = 1;
+  ::google::protobuf::uint32 joint_identifier() const;
+  void set_joint_identifier(::google::protobuf::uint32 value);
+
+  // float value = 2;
+  void clear_value();
+  static const int kValueFieldNumber = 2;
+  float value() const;
+  void set_value(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.JointAngle)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 joint_identifier_;
+  float value_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsJointAngleImpl();
+};
+// -------------------------------------------------------------------
+
+class JointSpeeds : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.JointSpeeds) */ {
+ public:
+  JointSpeeds();
+  virtual ~JointSpeeds();
+
+  JointSpeeds(const JointSpeeds& from);
+
+  inline JointSpeeds& operator=(const JointSpeeds& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  JointSpeeds(JointSpeeds&& from) noexcept
+    : JointSpeeds() {
+    *this = ::std::move(from);
+  }
+
+  inline JointSpeeds& operator=(JointSpeeds&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const JointSpeeds& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const JointSpeeds* internal_default_instance() {
+    return reinterpret_cast<const JointSpeeds*>(
+               &_JointSpeeds_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    127;
+
+  void Swap(JointSpeeds* other);
+  friend void swap(JointSpeeds& a, JointSpeeds& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline JointSpeeds* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  JointSpeeds* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const JointSpeeds& from);
+  void MergeFrom(const JointSpeeds& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(JointSpeeds* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .Kinova.Api.Base.JointSpeed joint_speeds = 1;
+  int joint_speeds_size() const;
+  void clear_joint_speeds();
+  static const int kJointSpeedsFieldNumber = 1;
+  const ::Kinova::Api::Base::JointSpeed& joint_speeds(int index) const;
+  ::Kinova::Api::Base::JointSpeed* mutable_joint_speeds(int index);
+  ::Kinova::Api::Base::JointSpeed* add_joint_speeds();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::JointSpeed >*
+      mutable_joint_speeds();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::JointSpeed >&
+      joint_speeds() const;
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.JointSpeeds)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::JointSpeed > joint_speeds_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsJointSpeedsImpl();
+};
+// -------------------------------------------------------------------
+
+class JointSpeed : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.JointSpeed) */ {
+ public:
+  JointSpeed();
+  virtual ~JointSpeed();
+
+  JointSpeed(const JointSpeed& from);
+
+  inline JointSpeed& operator=(const JointSpeed& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  JointSpeed(JointSpeed&& from) noexcept
+    : JointSpeed() {
+    *this = ::std::move(from);
+  }
+
+  inline JointSpeed& operator=(JointSpeed&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const JointSpeed& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const JointSpeed* internal_default_instance() {
+    return reinterpret_cast<const JointSpeed*>(
+               &_JointSpeed_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    128;
+
+  void Swap(JointSpeed* other);
+  friend void swap(JointSpeed& a, JointSpeed& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline JointSpeed* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  JointSpeed* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const JointSpeed& from);
+  void MergeFrom(const JointSpeed& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(JointSpeed* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // uint32 joint_identifier = 1;
+  void clear_joint_identifier();
+  static const int kJointIdentifierFieldNumber = 1;
+  ::google::protobuf::uint32 joint_identifier() const;
+  void set_joint_identifier(::google::protobuf::uint32 value);
+
+  // float value = 2;
+  void clear_value();
+  static const int kValueFieldNumber = 2;
+  float value() const;
+  void set_value(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.JointSpeed)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 joint_identifier_;
+  float value_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsJointSpeedImpl();
+};
+// -------------------------------------------------------------------
+
+class GripperCommand : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.GripperCommand) */ {
+ public:
+  GripperCommand();
+  virtual ~GripperCommand();
+
+  GripperCommand(const GripperCommand& from);
+
+  inline GripperCommand& operator=(const GripperCommand& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  GripperCommand(GripperCommand&& from) noexcept
+    : GripperCommand() {
+    *this = ::std::move(from);
+  }
+
+  inline GripperCommand& operator=(GripperCommand&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const GripperCommand& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const GripperCommand* internal_default_instance() {
+    return reinterpret_cast<const GripperCommand*>(
+               &_GripperCommand_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    129;
+
+  void Swap(GripperCommand* other);
+  friend void swap(GripperCommand& a, GripperCommand& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline GripperCommand* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  GripperCommand* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const GripperCommand& from);
+  void MergeFrom(const GripperCommand& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(GripperCommand* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Base.Gripper gripper = 2;
+  bool has_gripper() const;
+  void clear_gripper();
+  static const int kGripperFieldNumber = 2;
+  const ::Kinova::Api::Base::Gripper& gripper() const;
+  ::Kinova::Api::Base::Gripper* release_gripper();
+  ::Kinova::Api::Base::Gripper* mutable_gripper();
+  void set_allocated_gripper(::Kinova::Api::Base::Gripper* gripper);
+
+  // .Kinova.Api.Base.GripperMode mode = 1;
+  void clear_mode();
+  static const int kModeFieldNumber = 1;
+  ::Kinova::Api::Base::GripperMode mode() const;
+  void set_mode(::Kinova::Api::Base::GripperMode value);
+
+  // uint32 duration = 3;
+  void clear_duration();
+  static const int kDurationFieldNumber = 3;
+  ::google::protobuf::uint32 duration() const;
+  void set_duration(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.GripperCommand)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::Base::Gripper* gripper_;
+  int mode_;
+  ::google::protobuf::uint32 duration_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsGripperCommandImpl();
+};
+// -------------------------------------------------------------------
+
+class GripperRequest : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.GripperRequest) */ {
+ public:
+  GripperRequest();
+  virtual ~GripperRequest();
+
+  GripperRequest(const GripperRequest& from);
+
+  inline GripperRequest& operator=(const GripperRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  GripperRequest(GripperRequest&& from) noexcept
+    : GripperRequest() {
+    *this = ::std::move(from);
+  }
+
+  inline GripperRequest& operator=(GripperRequest&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const GripperRequest& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const GripperRequest* internal_default_instance() {
+    return reinterpret_cast<const GripperRequest*>(
+               &_GripperRequest_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    130;
+
+  void Swap(GripperRequest* other);
+  friend void swap(GripperRequest& a, GripperRequest& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline GripperRequest* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  GripperRequest* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const GripperRequest& from);
+  void MergeFrom(const GripperRequest& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(GripperRequest* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Base.GripperMode mode = 1;
+  void clear_mode();
+  static const int kModeFieldNumber = 1;
+  ::Kinova::Api::Base::GripperMode mode() const;
+  void set_mode(::Kinova::Api::Base::GripperMode value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.GripperRequest)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  int mode_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsGripperRequestImpl();
+};
+// -------------------------------------------------------------------
+
+class Gripper : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.Gripper) */ {
+ public:
+  Gripper();
+  virtual ~Gripper();
+
+  Gripper(const Gripper& from);
+
+  inline Gripper& operator=(const Gripper& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Gripper(Gripper&& from) noexcept
+    : Gripper() {
+    *this = ::std::move(from);
+  }
+
+  inline Gripper& operator=(Gripper&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Gripper& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Gripper* internal_default_instance() {
+    return reinterpret_cast<const Gripper*>(
+               &_Gripper_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    131;
+
+  void Swap(Gripper* other);
+  friend void swap(Gripper& a, Gripper& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Gripper* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Gripper* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Gripper& from);
+  void MergeFrom(const Gripper& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Gripper* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .Kinova.Api.Base.Finger finger = 1;
+  int finger_size() const;
+  void clear_finger();
+  static const int kFingerFieldNumber = 1;
+  const ::Kinova::Api::Base::Finger& finger(int index) const;
+  ::Kinova::Api::Base::Finger* mutable_finger(int index);
+  ::Kinova::Api::Base::Finger* add_finger();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::Finger >*
+      mutable_finger();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::Finger >&
+      finger() const;
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.Gripper)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::Finger > finger_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsGripperImpl();
+};
+// -------------------------------------------------------------------
+
+class Finger : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.Finger) */ {
+ public:
+  Finger();
+  virtual ~Finger();
+
+  Finger(const Finger& from);
+
+  inline Finger& operator=(const Finger& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Finger(Finger&& from) noexcept
+    : Finger() {
+    *this = ::std::move(from);
+  }
+
+  inline Finger& operator=(Finger&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Finger& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Finger* internal_default_instance() {
+    return reinterpret_cast<const Finger*>(
+               &_Finger_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    132;
+
+  void Swap(Finger* other);
+  friend void swap(Finger& a, Finger& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Finger* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Finger* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Finger& from);
+  void MergeFrom(const Finger& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Finger* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // uint32 finger_identifier = 1;
+  void clear_finger_identifier();
+  static const int kFingerIdentifierFieldNumber = 1;
+  ::google::protobuf::uint32 finger_identifier() const;
+  void set_finger_identifier(::google::protobuf::uint32 value);
+
+  // float value = 2;
+  void clear_value();
+  static const int kValueFieldNumber = 2;
+  float value() const;
+  void set_value(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.Finger)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 finger_identifier_;
+  float value_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsFingerImpl();
+};
+// -------------------------------------------------------------------
+
+class GpioCommand : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.GpioCommand) */ {
+ public:
+  GpioCommand();
+  virtual ~GpioCommand();
+
+  GpioCommand(const GpioCommand& from);
+
+  inline GpioCommand& operator=(const GpioCommand& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  GpioCommand(GpioCommand&& from) noexcept
+    : GpioCommand() {
+    *this = ::std::move(from);
+  }
+
+  inline GpioCommand& operator=(GpioCommand&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const GpioCommand& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const GpioCommand* internal_default_instance() {
+    return reinterpret_cast<const GpioCommand*>(
+               &_GpioCommand_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    133;
+
+  void Swap(GpioCommand* other);
+  friend void swap(GpioCommand& a, GpioCommand& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline GpioCommand* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  GpioCommand* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const GpioCommand& from);
+  void MergeFrom(const GpioCommand& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(GpioCommand* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // uint32 port_identifier = 1;
+  void clear_port_identifier();
+  static const int kPortIdentifierFieldNumber = 1;
+  ::google::protobuf::uint32 port_identifier() const;
+  void set_port_identifier(::google::protobuf::uint32 value);
+
+  // uint32 pin_identifier = 2;
+  void clear_pin_identifier();
+  static const int kPinIdentifierFieldNumber = 2;
+  ::google::protobuf::uint32 pin_identifier() const;
+  void set_pin_identifier(::google::protobuf::uint32 value);
+
+  // .Kinova.Api.Base.GpioAction action = 3;
+  void clear_action();
+  static const int kActionFieldNumber = 3;
+  ::Kinova::Api::Base::GpioAction action() const;
+  void set_action(::Kinova::Api::Base::GpioAction value);
+
+  // uint32 period = 4;
+  void clear_period();
+  static const int kPeriodFieldNumber = 4;
+  ::google::protobuf::uint32 period() const;
+  void set_period(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.GpioCommand)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 port_identifier_;
+  ::google::protobuf::uint32 pin_identifier_;
+  int action_;
+  ::google::protobuf::uint32 period_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsGpioCommandImpl();
+};
+// -------------------------------------------------------------------
+
+class ControllerConfigurationMode : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.ControllerConfigurationMode) */ {
+ public:
+  ControllerConfigurationMode();
+  virtual ~ControllerConfigurationMode();
+
+  ControllerConfigurationMode(const ControllerConfigurationMode& from);
+
+  inline ControllerConfigurationMode& operator=(const ControllerConfigurationMode& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ControllerConfigurationMode(ControllerConfigurationMode&& from) noexcept
+    : ControllerConfigurationMode() {
+    *this = ::std::move(from);
+  }
+
+  inline ControllerConfigurationMode& operator=(ControllerConfigurationMode&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ControllerConfigurationMode& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ControllerConfigurationMode* internal_default_instance() {
+    return reinterpret_cast<const ControllerConfigurationMode*>(
+               &_ControllerConfigurationMode_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    134;
+
+  void Swap(ControllerConfigurationMode* other);
+  friend void swap(ControllerConfigurationMode& a, ControllerConfigurationMode& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ControllerConfigurationMode* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ControllerConfigurationMode* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ControllerConfigurationMode& from);
+  void MergeFrom(const ControllerConfigurationMode& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ControllerConfigurationMode* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // bool enable = 1;
+  void clear_enable();
+  static const int kEnableFieldNumber = 1;
+  bool enable() const;
+  void set_enable(bool value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.ControllerConfigurationMode)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  bool enable_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsControllerConfigurationModeImpl();
+};
+// -------------------------------------------------------------------
+
+class ControllerConfiguration : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.ControllerConfiguration) */ {
+ public:
+  ControllerConfiguration();
+  virtual ~ControllerConfiguration();
+
+  ControllerConfiguration(const ControllerConfiguration& from);
+
+  inline ControllerConfiguration& operator=(const ControllerConfiguration& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ControllerConfiguration(ControllerConfiguration&& from) noexcept
+    : ControllerConfiguration() {
+    *this = ::std::move(from);
+  }
+
+  inline ControllerConfiguration& operator=(ControllerConfiguration&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ControllerConfiguration& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ControllerConfiguration* internal_default_instance() {
+    return reinterpret_cast<const ControllerConfiguration*>(
+               &_ControllerConfiguration_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    135;
+
+  void Swap(ControllerConfiguration* other);
+  friend void swap(ControllerConfiguration& a, ControllerConfiguration& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ControllerConfiguration* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ControllerConfiguration* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ControllerConfiguration& from);
+  void MergeFrom(const ControllerConfiguration& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ControllerConfiguration* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // string name = 2;
+  void clear_name();
+  static const int kNameFieldNumber = 2;
+  const ::std::string& name() const;
+  void set_name(const ::std::string& value);
+  #if LANG_CXX11
+  void set_name(::std::string&& value);
+  #endif
+  void set_name(const char* value);
+  void set_name(const char* value, size_t size);
+  ::std::string* mutable_name();
+  ::std::string* release_name();
+  void set_allocated_name(::std::string* name);
+
+  // string analog_input_identifier_enum = 4;
+  void clear_analog_input_identifier_enum();
+  static const int kAnalogInputIdentifierEnumFieldNumber = 4;
+  const ::std::string& analog_input_identifier_enum() const;
+  void set_analog_input_identifier_enum(const ::std::string& value);
+  #if LANG_CXX11
+  void set_analog_input_identifier_enum(::std::string&& value);
+  #endif
+  void set_analog_input_identifier_enum(const char* value);
+  void set_analog_input_identifier_enum(const char* value, size_t size);
+  ::std::string* mutable_analog_input_identifier_enum();
+  ::std::string* release_analog_input_identifier_enum();
+  void set_allocated_analog_input_identifier_enum(::std::string* analog_input_identifier_enum);
+
+  // string digital_input_identifier_enum = 5;
+  void clear_digital_input_identifier_enum();
+  static const int kDigitalInputIdentifierEnumFieldNumber = 5;
+  const ::std::string& digital_input_identifier_enum() const;
+  void set_digital_input_identifier_enum(const ::std::string& value);
+  #if LANG_CXX11
+  void set_digital_input_identifier_enum(::std::string&& value);
+  #endif
+  void set_digital_input_identifier_enum(const char* value);
+  void set_digital_input_identifier_enum(const char* value, size_t size);
+  ::std::string* mutable_digital_input_identifier_enum();
+  ::std::string* release_digital_input_identifier_enum();
+  void set_allocated_digital_input_identifier_enum(::std::string* digital_input_identifier_enum);
+
+  // .Kinova.Api.Base.ControllerHandle handle = 1;
+  bool has_handle() const;
+  void clear_handle();
+  static const int kHandleFieldNumber = 1;
+  const ::Kinova::Api::Base::ControllerHandle& handle() const;
+  ::Kinova::Api::Base::ControllerHandle* release_handle();
+  ::Kinova::Api::Base::ControllerHandle* mutable_handle();
+  void set_allocated_handle(::Kinova::Api::Base::ControllerHandle* handle);
+
+  // .Kinova.Api.Base.MappingHandle active_mapping_handle = 3;
+  bool has_active_mapping_handle() const;
+  void clear_active_mapping_handle();
+  static const int kActiveMappingHandleFieldNumber = 3;
+  const ::Kinova::Api::Base::MappingHandle& active_mapping_handle() const;
+  ::Kinova::Api::Base::MappingHandle* release_active_mapping_handle();
+  ::Kinova::Api::Base::MappingHandle* mutable_active_mapping_handle();
+  void set_allocated_active_mapping_handle(::Kinova::Api::Base::MappingHandle* active_mapping_handle);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.ControllerConfiguration)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::internal::ArenaStringPtr name_;
+  ::google::protobuf::internal::ArenaStringPtr analog_input_identifier_enum_;
+  ::google::protobuf::internal::ArenaStringPtr digital_input_identifier_enum_;
+  ::Kinova::Api::Base::ControllerHandle* handle_;
+  ::Kinova::Api::Base::MappingHandle* active_mapping_handle_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsControllerConfigurationImpl();
+};
+// -------------------------------------------------------------------
+
+class ControllerConfigurationList : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.ControllerConfigurationList) */ {
+ public:
+  ControllerConfigurationList();
+  virtual ~ControllerConfigurationList();
+
+  ControllerConfigurationList(const ControllerConfigurationList& from);
+
+  inline ControllerConfigurationList& operator=(const ControllerConfigurationList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ControllerConfigurationList(ControllerConfigurationList&& from) noexcept
+    : ControllerConfigurationList() {
+    *this = ::std::move(from);
+  }
+
+  inline ControllerConfigurationList& operator=(ControllerConfigurationList&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ControllerConfigurationList& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ControllerConfigurationList* internal_default_instance() {
+    return reinterpret_cast<const ControllerConfigurationList*>(
+               &_ControllerConfigurationList_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    136;
+
+  void Swap(ControllerConfigurationList* other);
+  friend void swap(ControllerConfigurationList& a, ControllerConfigurationList& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ControllerConfigurationList* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ControllerConfigurationList* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ControllerConfigurationList& from);
+  void MergeFrom(const ControllerConfigurationList& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ControllerConfigurationList* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .Kinova.Api.Base.ControllerConfiguration controller_configurations = 1;
+  int controller_configurations_size() const;
+  void clear_controller_configurations();
+  static const int kControllerConfigurationsFieldNumber = 1;
+  const ::Kinova::Api::Base::ControllerConfiguration& controller_configurations(int index) const;
+  ::Kinova::Api::Base::ControllerConfiguration* mutable_controller_configurations(int index);
+  ::Kinova::Api::Base::ControllerConfiguration* add_controller_configurations();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::ControllerConfiguration >*
+      mutable_controller_configurations();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::ControllerConfiguration >&
+      controller_configurations() const;
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.ControllerConfigurationList)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::ControllerConfiguration > controller_configurations_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsControllerConfigurationListImpl();
+};
+// -------------------------------------------------------------------
+
+class ActuatorInformation : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.ActuatorInformation) */ {
+ public:
+  ActuatorInformation();
+  virtual ~ActuatorInformation();
+
+  ActuatorInformation(const ActuatorInformation& from);
+
+  inline ActuatorInformation& operator=(const ActuatorInformation& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ActuatorInformation(ActuatorInformation&& from) noexcept
+    : ActuatorInformation() {
+    *this = ::std::move(from);
+  }
+
+  inline ActuatorInformation& operator=(ActuatorInformation&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ActuatorInformation& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ActuatorInformation* internal_default_instance() {
+    return reinterpret_cast<const ActuatorInformation*>(
+               &_ActuatorInformation_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    137;
+
+  void Swap(ActuatorInformation* other);
+  friend void swap(ActuatorInformation& a, ActuatorInformation& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ActuatorInformation* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ActuatorInformation* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ActuatorInformation& from);
+  void MergeFrom(const ActuatorInformation& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ActuatorInformation* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // uint32 count = 1;
+  void clear_count();
+  static const int kCountFieldNumber = 1;
+  ::google::protobuf::uint32 count() const;
+  void set_count(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.ActuatorInformation)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 count_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsActuatorInformationImpl();
+};
+// -------------------------------------------------------------------
+
+class ArmStateInformation : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.ArmStateInformation) */ {
+ public:
+  ArmStateInformation();
+  virtual ~ArmStateInformation();
+
+  ArmStateInformation(const ArmStateInformation& from);
+
+  inline ArmStateInformation& operator=(const ArmStateInformation& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ArmStateInformation(ArmStateInformation&& from) noexcept
+    : ArmStateInformation() {
+    *this = ::std::move(from);
+  }
+
+  inline ArmStateInformation& operator=(ArmStateInformation&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ArmStateInformation& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ArmStateInformation* internal_default_instance() {
+    return reinterpret_cast<const ArmStateInformation*>(
+               &_ArmStateInformation_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    138;
+
+  void Swap(ArmStateInformation* other);
+  friend void swap(ArmStateInformation& a, ArmStateInformation& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ArmStateInformation* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ArmStateInformation* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ArmStateInformation& from);
+  void MergeFrom(const ArmStateInformation& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ArmStateInformation* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Common.Connection connection = 2;
+  bool has_connection() const;
+  void clear_connection();
+  static const int kConnectionFieldNumber = 2;
+  const ::Kinova::Api::Common::Connection& connection() const;
+  ::Kinova::Api::Common::Connection* release_connection();
+  ::Kinova::Api::Common::Connection* mutable_connection();
+  void set_allocated_connection(::Kinova::Api::Common::Connection* connection);
+
+  // .Kinova.Api.Common.ArmState active_state = 1;
+  void clear_active_state();
+  static const int kActiveStateFieldNumber = 1;
+  ::Kinova::Api::Common::ArmState active_state() const;
+  void set_active_state(::Kinova::Api::Common::ArmState value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.ArmStateInformation)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::Common::Connection* connection_;
+  int active_state_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsArmStateInformationImpl();
+};
+// -------------------------------------------------------------------
+
+class ArmStateNotification : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.ArmStateNotification) */ {
+ public:
+  ArmStateNotification();
+  virtual ~ArmStateNotification();
+
+  ArmStateNotification(const ArmStateNotification& from);
+
+  inline ArmStateNotification& operator=(const ArmStateNotification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ArmStateNotification(ArmStateNotification&& from) noexcept
+    : ArmStateNotification() {
+    *this = ::std::move(from);
+  }
+
+  inline ArmStateNotification& operator=(ArmStateNotification&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ArmStateNotification& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ArmStateNotification* internal_default_instance() {
+    return reinterpret_cast<const ArmStateNotification*>(
+               &_ArmStateNotification_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    139;
+
+  void Swap(ArmStateNotification* other);
+  friend void swap(ArmStateNotification& a, ArmStateNotification& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ArmStateNotification* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ArmStateNotification* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ArmStateNotification& from);
+  void MergeFrom(const ArmStateNotification& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ArmStateNotification* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Common.Timestamp timestamp = 2;
+  bool has_timestamp() const;
+  void clear_timestamp();
+  static const int kTimestampFieldNumber = 2;
+  const ::Kinova::Api::Common::Timestamp& timestamp() const;
+  ::Kinova::Api::Common::Timestamp* release_timestamp();
+  ::Kinova::Api::Common::Timestamp* mutable_timestamp();
+  void set_allocated_timestamp(::Kinova::Api::Common::Timestamp* timestamp);
+
+  // .Kinova.Api.Common.Connection connection = 3;
+  bool has_connection() const;
+  void clear_connection();
+  static const int kConnectionFieldNumber = 3;
+  const ::Kinova::Api::Common::Connection& connection() const;
+  ::Kinova::Api::Common::Connection* release_connection();
+  ::Kinova::Api::Common::Connection* mutable_connection();
+  void set_allocated_connection(::Kinova::Api::Common::Connection* connection);
+
+  // .Kinova.Api.Common.ArmState active_state = 1;
+  void clear_active_state();
+  static const int kActiveStateFieldNumber = 1;
+  ::Kinova::Api::Common::ArmState active_state() const;
+  void set_active_state(::Kinova::Api::Common::ArmState value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.ArmStateNotification)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::Common::Timestamp* timestamp_;
+  ::Kinova::Api::Common::Connection* connection_;
+  int active_state_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsArmStateNotificationImpl();
+};
+// -------------------------------------------------------------------
+
+class CapSenseConfig : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.CapSenseConfig) */ {
+ public:
+  CapSenseConfig();
+  virtual ~CapSenseConfig();
+
+  CapSenseConfig(const CapSenseConfig& from);
+
+  inline CapSenseConfig& operator=(const CapSenseConfig& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  CapSenseConfig(CapSenseConfig&& from) noexcept
+    : CapSenseConfig() {
+    *this = ::std::move(from);
+  }
+
+  inline CapSenseConfig& operator=(CapSenseConfig&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const CapSenseConfig& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const CapSenseConfig* internal_default_instance() {
+    return reinterpret_cast<const CapSenseConfig*>(
+               &_CapSenseConfig_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    140;
+
+  void Swap(CapSenseConfig* other);
+  friend void swap(CapSenseConfig& a, CapSenseConfig& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline CapSenseConfig* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  CapSenseConfig* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const CapSenseConfig& from);
+  void MergeFrom(const CapSenseConfig& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(CapSenseConfig* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // uint32 identifier = 1;
+  void clear_identifier();
+  static const int kIdentifierFieldNumber = 1;
+  ::google::protobuf::uint32 identifier() const;
+  void set_identifier(::google::protobuf::uint32 value);
+
+  // .Kinova.Api.Base.CapSenseMode mode = 2;
+  void clear_mode();
+  static const int kModeFieldNumber = 2;
+  ::Kinova::Api::Base::CapSenseMode mode() const;
+  void set_mode(::Kinova::Api::Base::CapSenseMode value);
+
+  // float threshold_a = 3;
+  void clear_threshold_a();
+  static const int kThresholdAFieldNumber = 3;
+  float threshold_a() const;
+  void set_threshold_a(float value);
+
+  // float threshold_b = 4;
+  void clear_threshold_b();
+  static const int kThresholdBFieldNumber = 4;
+  float threshold_b() const;
+  void set_threshold_b(float value);
+
+  // float sensitivity_a = 5;
+  void clear_sensitivity_a();
+  static const int kSensitivityAFieldNumber = 5;
+  float sensitivity_a() const;
+  void set_sensitivity_a(float value);
+
+  // float sensitivity_b = 6;
+  void clear_sensitivity_b();
+  static const int kSensitivityBFieldNumber = 6;
+  float sensitivity_b() const;
+  void set_sensitivity_b(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.CapSenseConfig)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 identifier_;
+  int mode_;
+  float threshold_a_;
+  float threshold_b_;
+  float sensitivity_a_;
+  float sensitivity_b_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsCapSenseConfigImpl();
+};
+// -------------------------------------------------------------------
+
+class BridgeList : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.BridgeList) */ {
+ public:
+  BridgeList();
+  virtual ~BridgeList();
+
+  BridgeList(const BridgeList& from);
+
+  inline BridgeList& operator=(const BridgeList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  BridgeList(BridgeList&& from) noexcept
+    : BridgeList() {
+    *this = ::std::move(from);
+  }
+
+  inline BridgeList& operator=(BridgeList&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const BridgeList& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const BridgeList* internal_default_instance() {
+    return reinterpret_cast<const BridgeList*>(
+               &_BridgeList_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    141;
+
+  void Swap(BridgeList* other);
+  friend void swap(BridgeList& a, BridgeList& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline BridgeList* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  BridgeList* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const BridgeList& from);
+  void MergeFrom(const BridgeList& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(BridgeList* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .Kinova.Api.Base.BridgeConfig bridgeConfig = 1;
+  int bridgeconfig_size() const;
+  void clear_bridgeconfig();
+  static const int kBridgeConfigFieldNumber = 1;
+  const ::Kinova::Api::Base::BridgeConfig& bridgeconfig(int index) const;
+  ::Kinova::Api::Base::BridgeConfig* mutable_bridgeconfig(int index);
+  ::Kinova::Api::Base::BridgeConfig* add_bridgeconfig();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::BridgeConfig >*
+      mutable_bridgeconfig();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::BridgeConfig >&
+      bridgeconfig() const;
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.BridgeList)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::BridgeConfig > bridgeconfig_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsBridgeListImpl();
+};
+// -------------------------------------------------------------------
+
+class BridgeResult : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.BridgeResult) */ {
+ public:
+  BridgeResult();
+  virtual ~BridgeResult();
+
+  BridgeResult(const BridgeResult& from);
+
+  inline BridgeResult& operator=(const BridgeResult& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  BridgeResult(BridgeResult&& from) noexcept
+    : BridgeResult() {
+    *this = ::std::move(from);
+  }
+
+  inline BridgeResult& operator=(BridgeResult&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const BridgeResult& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const BridgeResult* internal_default_instance() {
+    return reinterpret_cast<const BridgeResult*>(
+               &_BridgeResult_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    142;
+
+  void Swap(BridgeResult* other);
+  friend void swap(BridgeResult& a, BridgeResult& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline BridgeResult* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  BridgeResult* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const BridgeResult& from);
+  void MergeFrom(const BridgeResult& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(BridgeResult* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Base.BridgeIdentifier bridge_id = 1;
+  bool has_bridge_id() const;
+  void clear_bridge_id();
+  static const int kBridgeIdFieldNumber = 1;
+  const ::Kinova::Api::Base::BridgeIdentifier& bridge_id() const;
+  ::Kinova::Api::Base::BridgeIdentifier* release_bridge_id();
+  ::Kinova::Api::Base::BridgeIdentifier* mutable_bridge_id();
+  void set_allocated_bridge_id(::Kinova::Api::Base::BridgeIdentifier* bridge_id);
+
+  // .Kinova.Api.Base.BridgeStatus status = 2;
+  void clear_status();
+  static const int kStatusFieldNumber = 2;
+  ::Kinova::Api::Base::BridgeStatus status() const;
+  void set_status(::Kinova::Api::Base::BridgeStatus value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.BridgeResult)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::Base::BridgeIdentifier* bridge_id_;
+  int status_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsBridgeResultImpl();
+};
+// -------------------------------------------------------------------
+
+class BridgeIdentifier : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.BridgeIdentifier) */ {
+ public:
+  BridgeIdentifier();
+  virtual ~BridgeIdentifier();
+
+  BridgeIdentifier(const BridgeIdentifier& from);
+
+  inline BridgeIdentifier& operator=(const BridgeIdentifier& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  BridgeIdentifier(BridgeIdentifier&& from) noexcept
+    : BridgeIdentifier() {
+    *this = ::std::move(from);
+  }
+
+  inline BridgeIdentifier& operator=(BridgeIdentifier&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const BridgeIdentifier& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const BridgeIdentifier* internal_default_instance() {
+    return reinterpret_cast<const BridgeIdentifier*>(
+               &_BridgeIdentifier_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    143;
+
+  void Swap(BridgeIdentifier* other);
+  friend void swap(BridgeIdentifier& a, BridgeIdentifier& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline BridgeIdentifier* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  BridgeIdentifier* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const BridgeIdentifier& from);
+  void MergeFrom(const BridgeIdentifier& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(BridgeIdentifier* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // uint32 bridge_id = 1;
+  void clear_bridge_id();
+  static const int kBridgeIdFieldNumber = 1;
+  ::google::protobuf::uint32 bridge_id() const;
+  void set_bridge_id(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.BridgeIdentifier)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 bridge_id_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsBridgeIdentifierImpl();
+};
+// -------------------------------------------------------------------
+
+class BridgeConfig : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.BridgeConfig) */ {
+ public:
+  BridgeConfig();
+  virtual ~BridgeConfig();
+
+  BridgeConfig(const BridgeConfig& from);
+
+  inline BridgeConfig& operator=(const BridgeConfig& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  BridgeConfig(BridgeConfig&& from) noexcept
+    : BridgeConfig() {
+    *this = ::std::move(from);
+  }
+
+  inline BridgeConfig& operator=(BridgeConfig&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const BridgeConfig& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const BridgeConfig* internal_default_instance() {
+    return reinterpret_cast<const BridgeConfig*>(
+               &_BridgeConfig_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    144;
+
+  void Swap(BridgeConfig* other);
+  friend void swap(BridgeConfig& a, BridgeConfig& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline BridgeConfig* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  BridgeConfig* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const BridgeConfig& from);
+  void MergeFrom(const BridgeConfig& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(BridgeConfig* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Base.BridgePortConfig port_config = 3;
+  bool has_port_config() const;
+  void clear_port_config();
+  static const int kPortConfigFieldNumber = 3;
+  const ::Kinova::Api::Base::BridgePortConfig& port_config() const;
+  ::Kinova::Api::Base::BridgePortConfig* release_port_config();
+  ::Kinova::Api::Base::BridgePortConfig* mutable_port_config();
+  void set_allocated_port_config(::Kinova::Api::Base::BridgePortConfig* port_config);
+
+  // .Kinova.Api.Base.BridgeIdentifier bridge_id = 4;
+  bool has_bridge_id() const;
+  void clear_bridge_id();
+  static const int kBridgeIdFieldNumber = 4;
+  const ::Kinova::Api::Base::BridgeIdentifier& bridge_id() const;
+  ::Kinova::Api::Base::BridgeIdentifier* release_bridge_id();
+  ::Kinova::Api::Base::BridgeIdentifier* mutable_bridge_id();
+  void set_allocated_bridge_id(::Kinova::Api::Base::BridgeIdentifier* bridge_id);
+
+  // uint32 device_identifier = 1;
+  void clear_device_identifier();
+  static const int kDeviceIdentifierFieldNumber = 1;
+  ::google::protobuf::uint32 device_identifier() const;
+  void set_device_identifier(::google::protobuf::uint32 value);
+
+  // .Kinova.Api.Base.BridgeType bridgetype = 2;
+  void clear_bridgetype();
+  static const int kBridgetypeFieldNumber = 2;
+  ::Kinova::Api::Base::BridgeType bridgetype() const;
+  void set_bridgetype(::Kinova::Api::Base::BridgeType value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.BridgeConfig)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::Base::BridgePortConfig* port_config_;
+  ::Kinova::Api::Base::BridgeIdentifier* bridge_id_;
+  ::google::protobuf::uint32 device_identifier_;
+  int bridgetype_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsBridgeConfigImpl();
+};
+// -------------------------------------------------------------------
+
+class BridgePortConfig : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.BridgePortConfig) */ {
+ public:
+  BridgePortConfig();
+  virtual ~BridgePortConfig();
+
+  BridgePortConfig(const BridgePortConfig& from);
+
+  inline BridgePortConfig& operator=(const BridgePortConfig& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  BridgePortConfig(BridgePortConfig&& from) noexcept
+    : BridgePortConfig() {
+    *this = ::std::move(from);
+  }
+
+  inline BridgePortConfig& operator=(BridgePortConfig&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const BridgePortConfig& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const BridgePortConfig* internal_default_instance() {
+    return reinterpret_cast<const BridgePortConfig*>(
+               &_BridgePortConfig_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    145;
+
+  void Swap(BridgePortConfig* other);
+  friend void swap(BridgePortConfig& a, BridgePortConfig& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline BridgePortConfig* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  BridgePortConfig* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const BridgePortConfig& from);
+  void MergeFrom(const BridgePortConfig& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(BridgePortConfig* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // uint32 target_port = 1;
+  void clear_target_port();
+  static const int kTargetPortFieldNumber = 1;
+  ::google::protobuf::uint32 target_port() const;
+  void set_target_port(::google::protobuf::uint32 value);
+
+  // uint32 out_port = 2;
+  void clear_out_port();
+  static const int kOutPortFieldNumber = 2;
+  ::google::protobuf::uint32 out_port() const;
+  void set_out_port(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.BridgePortConfig)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 target_port_;
+  ::google::protobuf::uint32 out_port_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsBridgePortConfigImpl();
+};
+// -------------------------------------------------------------------
+
+class PreComputedJointTrajectory : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.PreComputedJointTrajectory) */ {
+ public:
+  PreComputedJointTrajectory();
+  virtual ~PreComputedJointTrajectory();
+
+  PreComputedJointTrajectory(const PreComputedJointTrajectory& from);
+
+  inline PreComputedJointTrajectory& operator=(const PreComputedJointTrajectory& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  PreComputedJointTrajectory(PreComputedJointTrajectory&& from) noexcept
+    : PreComputedJointTrajectory() {
+    *this = ::std::move(from);
+  }
+
+  inline PreComputedJointTrajectory& operator=(PreComputedJointTrajectory&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const PreComputedJointTrajectory& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const PreComputedJointTrajectory* internal_default_instance() {
+    return reinterpret_cast<const PreComputedJointTrajectory*>(
+               &_PreComputedJointTrajectory_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    146;
+
+  void Swap(PreComputedJointTrajectory* other);
+  friend void swap(PreComputedJointTrajectory& a, PreComputedJointTrajectory& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline PreComputedJointTrajectory* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  PreComputedJointTrajectory* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const PreComputedJointTrajectory& from);
+  void MergeFrom(const PreComputedJointTrajectory& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(PreComputedJointTrajectory* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .Kinova.Api.Base.PreComputedJointTrajectoryElement trajectory_elements = 2;
+  int trajectory_elements_size() const;
+  void clear_trajectory_elements();
+  static const int kTrajectoryElementsFieldNumber = 2;
+  const ::Kinova::Api::Base::PreComputedJointTrajectoryElement& trajectory_elements(int index) const;
+  ::Kinova::Api::Base::PreComputedJointTrajectoryElement* mutable_trajectory_elements(int index);
+  ::Kinova::Api::Base::PreComputedJointTrajectoryElement* add_trajectory_elements();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::PreComputedJointTrajectoryElement >*
+      mutable_trajectory_elements();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::PreComputedJointTrajectoryElement >&
+      trajectory_elements() const;
+
+  // .Kinova.Api.Base.TrajectoryContinuityMode mode = 1;
+  void clear_mode();
+  static const int kModeFieldNumber = 1;
+  ::Kinova::Api::Base::TrajectoryContinuityMode mode() const;
+  void set_mode(::Kinova::Api::Base::TrajectoryContinuityMode value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.PreComputedJointTrajectory)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::PreComputedJointTrajectoryElement > trajectory_elements_;
+  int mode_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsPreComputedJointTrajectoryImpl();
+};
+// -------------------------------------------------------------------
+
+class PreComputedJointTrajectoryElement : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.PreComputedJointTrajectoryElement) */ {
+ public:
+  PreComputedJointTrajectoryElement();
+  virtual ~PreComputedJointTrajectoryElement();
+
+  PreComputedJointTrajectoryElement(const PreComputedJointTrajectoryElement& from);
+
+  inline PreComputedJointTrajectoryElement& operator=(const PreComputedJointTrajectoryElement& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  PreComputedJointTrajectoryElement(PreComputedJointTrajectoryElement&& from) noexcept
+    : PreComputedJointTrajectoryElement() {
+    *this = ::std::move(from);
+  }
+
+  inline PreComputedJointTrajectoryElement& operator=(PreComputedJointTrajectoryElement&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const PreComputedJointTrajectoryElement& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const PreComputedJointTrajectoryElement* internal_default_instance() {
+    return reinterpret_cast<const PreComputedJointTrajectoryElement*>(
+               &_PreComputedJointTrajectoryElement_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    147;
+
+  void Swap(PreComputedJointTrajectoryElement* other);
+  friend void swap(PreComputedJointTrajectoryElement& a, PreComputedJointTrajectoryElement& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline PreComputedJointTrajectoryElement* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  PreComputedJointTrajectoryElement* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const PreComputedJointTrajectoryElement& from);
+  void MergeFrom(const PreComputedJointTrajectoryElement& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(PreComputedJointTrajectoryElement* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated float joint_angles = 1;
+  int joint_angles_size() const;
+  void clear_joint_angles();
+  static const int kJointAnglesFieldNumber = 1;
+  float joint_angles(int index) const;
+  void set_joint_angles(int index, float value);
+  void add_joint_angles(float value);
+  const ::google::protobuf::RepeatedField< float >&
+      joint_angles() const;
+  ::google::protobuf::RepeatedField< float >*
+      mutable_joint_angles();
+
+  // repeated float joint_speeds = 2;
+  int joint_speeds_size() const;
+  void clear_joint_speeds();
+  static const int kJointSpeedsFieldNumber = 2;
+  float joint_speeds(int index) const;
+  void set_joint_speeds(int index, float value);
+  void add_joint_speeds(float value);
+  const ::google::protobuf::RepeatedField< float >&
+      joint_speeds() const;
+  ::google::protobuf::RepeatedField< float >*
+      mutable_joint_speeds();
+
+  // repeated float joint_accelerations = 3;
+  int joint_accelerations_size() const;
+  void clear_joint_accelerations();
+  static const int kJointAccelerationsFieldNumber = 3;
+  float joint_accelerations(int index) const;
+  void set_joint_accelerations(int index, float value);
+  void add_joint_accelerations(float value);
+  const ::google::protobuf::RepeatedField< float >&
+      joint_accelerations() const;
+  ::google::protobuf::RepeatedField< float >*
+      mutable_joint_accelerations();
+
+  // float time_from_start = 4;
+  void clear_time_from_start();
+  static const int kTimeFromStartFieldNumber = 4;
+  float time_from_start() const;
+  void set_time_from_start(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.PreComputedJointTrajectoryElement)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedField< float > joint_angles_;
+  mutable int _joint_angles_cached_byte_size_;
+  ::google::protobuf::RepeatedField< float > joint_speeds_;
+  mutable int _joint_speeds_cached_byte_size_;
+  ::google::protobuf::RepeatedField< float > joint_accelerations_;
+  mutable int _joint_accelerations_cached_byte_size_;
+  float time_from_start_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsPreComputedJointTrajectoryElementImpl();
+};
+// -------------------------------------------------------------------
+
+class TrajectoryErrorElement : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.TrajectoryErrorElement) */ {
+ public:
+  TrajectoryErrorElement();
+  virtual ~TrajectoryErrorElement();
+
+  TrajectoryErrorElement(const TrajectoryErrorElement& from);
+
+  inline TrajectoryErrorElement& operator=(const TrajectoryErrorElement& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  TrajectoryErrorElement(TrajectoryErrorElement&& from) noexcept
+    : TrajectoryErrorElement() {
+    *this = ::std::move(from);
+  }
+
+  inline TrajectoryErrorElement& operator=(TrajectoryErrorElement&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const TrajectoryErrorElement& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const TrajectoryErrorElement* internal_default_instance() {
+    return reinterpret_cast<const TrajectoryErrorElement*>(
+               &_TrajectoryErrorElement_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    148;
+
+  void Swap(TrajectoryErrorElement* other);
+  friend void swap(TrajectoryErrorElement& a, TrajectoryErrorElement& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline TrajectoryErrorElement* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  TrajectoryErrorElement* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const TrajectoryErrorElement& from);
+  void MergeFrom(const TrajectoryErrorElement& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(TrajectoryErrorElement* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // string message = 7;
+  void clear_message();
+  static const int kMessageFieldNumber = 7;
+  const ::std::string& message() const;
+  void set_message(const ::std::string& value);
+  #if LANG_CXX11
+  void set_message(::std::string&& value);
+  #endif
+  void set_message(const char* value);
+  void set_message(const char* value, size_t size);
+  ::std::string* mutable_message();
+  ::std::string* release_message();
+  void set_allocated_message(::std::string* message);
+
+  // .Kinova.Api.Base.TrajectoryErrorType error_type = 1;
+  void clear_error_type();
+  static const int kErrorTypeFieldNumber = 1;
+  ::Kinova::Api::Base::TrajectoryErrorType error_type() const;
+  void set_error_type(::Kinova::Api::Base::TrajectoryErrorType value);
+
+  // float error_value = 3;
+  void clear_error_value();
+  static const int kErrorValueFieldNumber = 3;
+  float error_value() const;
+  void set_error_value(float value);
+
+  // float min_value = 4;
+  void clear_min_value();
+  static const int kMinValueFieldNumber = 4;
+  float min_value() const;
+  void set_min_value(float value);
+
+  // float max_value = 5;
+  void clear_max_value();
+  static const int kMaxValueFieldNumber = 5;
+  float max_value() const;
+  void set_max_value(float value);
+
+  // uint32 index = 6;
+  void clear_index();
+  static const int kIndexFieldNumber = 6;
+  ::google::protobuf::uint32 index() const;
+  void set_index(::google::protobuf::uint32 value);
+
+  // uint32 waypoint_index = 8;
+  void clear_waypoint_index();
+  static const int kWaypointIndexFieldNumber = 8;
+  ::google::protobuf::uint32 waypoint_index() const;
+  void set_waypoint_index(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.TrajectoryErrorElement)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::internal::ArenaStringPtr message_;
+  int error_type_;
+  float error_value_;
+  float min_value_;
+  float max_value_;
+  ::google::protobuf::uint32 index_;
+  ::google::protobuf::uint32 waypoint_index_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsTrajectoryErrorElementImpl();
+};
+// -------------------------------------------------------------------
+
+class TrajectoryErrorReport : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.TrajectoryErrorReport) */ {
+ public:
+  TrajectoryErrorReport();
+  virtual ~TrajectoryErrorReport();
+
+  TrajectoryErrorReport(const TrajectoryErrorReport& from);
+
+  inline TrajectoryErrorReport& operator=(const TrajectoryErrorReport& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  TrajectoryErrorReport(TrajectoryErrorReport&& from) noexcept
+    : TrajectoryErrorReport() {
+    *this = ::std::move(from);
+  }
+
+  inline TrajectoryErrorReport& operator=(TrajectoryErrorReport&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const TrajectoryErrorReport& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const TrajectoryErrorReport* internal_default_instance() {
+    return reinterpret_cast<const TrajectoryErrorReport*>(
+               &_TrajectoryErrorReport_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    149;
+
+  void Swap(TrajectoryErrorReport* other);
+  friend void swap(TrajectoryErrorReport& a, TrajectoryErrorReport& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline TrajectoryErrorReport* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  TrajectoryErrorReport* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const TrajectoryErrorReport& from);
+  void MergeFrom(const TrajectoryErrorReport& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(TrajectoryErrorReport* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .Kinova.Api.Base.TrajectoryErrorElement trajectory_error_elements = 1;
+  int trajectory_error_elements_size() const;
+  void clear_trajectory_error_elements();
+  static const int kTrajectoryErrorElementsFieldNumber = 1;
+  const ::Kinova::Api::Base::TrajectoryErrorElement& trajectory_error_elements(int index) const;
+  ::Kinova::Api::Base::TrajectoryErrorElement* mutable_trajectory_error_elements(int index);
+  ::Kinova::Api::Base::TrajectoryErrorElement* add_trajectory_error_elements();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::TrajectoryErrorElement >*
+      mutable_trajectory_error_elements();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::TrajectoryErrorElement >&
+      trajectory_error_elements() const;
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.TrajectoryErrorReport)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::TrajectoryErrorElement > trajectory_error_elements_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsTrajectoryErrorReportImpl();
+};
+// -------------------------------------------------------------------
+
+class WaypointValidationReport : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.WaypointValidationReport) */ {
+ public:
+  WaypointValidationReport();
+  virtual ~WaypointValidationReport();
+
+  WaypointValidationReport(const WaypointValidationReport& from);
+
+  inline WaypointValidationReport& operator=(const WaypointValidationReport& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  WaypointValidationReport(WaypointValidationReport&& from) noexcept
+    : WaypointValidationReport() {
+    *this = ::std::move(from);
+  }
+
+  inline WaypointValidationReport& operator=(WaypointValidationReport&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const WaypointValidationReport& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const WaypointValidationReport* internal_default_instance() {
+    return reinterpret_cast<const WaypointValidationReport*>(
+               &_WaypointValidationReport_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    150;
+
+  void Swap(WaypointValidationReport* other);
+  friend void swap(WaypointValidationReport& a, WaypointValidationReport& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline WaypointValidationReport* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  WaypointValidationReport* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const WaypointValidationReport& from);
+  void MergeFrom(const WaypointValidationReport& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(WaypointValidationReport* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Base.TrajectoryErrorReport trajectory_error_report = 1;
+  bool has_trajectory_error_report() const;
+  void clear_trajectory_error_report();
+  static const int kTrajectoryErrorReportFieldNumber = 1;
+  const ::Kinova::Api::Base::TrajectoryErrorReport& trajectory_error_report() const;
+  ::Kinova::Api::Base::TrajectoryErrorReport* release_trajectory_error_report();
+  ::Kinova::Api::Base::TrajectoryErrorReport* mutable_trajectory_error_report();
+  void set_allocated_trajectory_error_report(::Kinova::Api::Base::TrajectoryErrorReport* trajectory_error_report);
+
+  // .Kinova.Api.Base.WaypointList optimal_waypoint_list = 2;
+  bool has_optimal_waypoint_list() const;
+  void clear_optimal_waypoint_list();
+  static const int kOptimalWaypointListFieldNumber = 2;
+  const ::Kinova::Api::Base::WaypointList& optimal_waypoint_list() const;
+  ::Kinova::Api::Base::WaypointList* release_optimal_waypoint_list();
+  ::Kinova::Api::Base::WaypointList* mutable_optimal_waypoint_list();
+  void set_allocated_optimal_waypoint_list(::Kinova::Api::Base::WaypointList* optimal_waypoint_list);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.WaypointValidationReport)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::Base::TrajectoryErrorReport* trajectory_error_report_;
+  ::Kinova::Api::Base::WaypointList* optimal_waypoint_list_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsWaypointValidationReportImpl();
+};
+// -------------------------------------------------------------------
+
+class Waypoint : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.Waypoint) */ {
+ public:
+  Waypoint();
+  virtual ~Waypoint();
+
+  Waypoint(const Waypoint& from);
+
+  inline Waypoint& operator=(const Waypoint& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Waypoint(Waypoint&& from) noexcept
+    : Waypoint() {
+    *this = ::std::move(from);
+  }
+
+  inline Waypoint& operator=(Waypoint&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Waypoint& default_instance();
+
+  enum TypeOfWaypointCase {
+    kAngularWaypoint = 2,
+    kCartesianWaypoint = 3,
+    TYPE_OF_WAYPOINT_NOT_SET = 0,
+  };
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Waypoint* internal_default_instance() {
+    return reinterpret_cast<const Waypoint*>(
+               &_Waypoint_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    151;
+
+  void Swap(Waypoint* other);
+  friend void swap(Waypoint& a, Waypoint& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Waypoint* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Waypoint* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Waypoint& from);
+  void MergeFrom(const Waypoint& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Waypoint* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // string name = 1;
+  void clear_name();
+  static const int kNameFieldNumber = 1;
+  const ::std::string& name() const;
+  void set_name(const ::std::string& value);
+  #if LANG_CXX11
+  void set_name(::std::string&& value);
+  #endif
+  void set_name(const char* value);
+  void set_name(const char* value, size_t size);
+  ::std::string* mutable_name();
+  ::std::string* release_name();
+  void set_allocated_name(::std::string* name);
+
+  // .Kinova.Api.Base.AngularWaypoint angular_waypoint = 2;
+  bool has_angular_waypoint() const;
+  void clear_angular_waypoint();
+  static const int kAngularWaypointFieldNumber = 2;
+  const ::Kinova::Api::Base::AngularWaypoint& angular_waypoint() const;
+  ::Kinova::Api::Base::AngularWaypoint* release_angular_waypoint();
+  ::Kinova::Api::Base::AngularWaypoint* mutable_angular_waypoint();
+  void set_allocated_angular_waypoint(::Kinova::Api::Base::AngularWaypoint* angular_waypoint);
+
+  // .Kinova.Api.Base.CartesianWaypoint cartesian_waypoint = 3;
+  bool has_cartesian_waypoint() const;
+  void clear_cartesian_waypoint();
+  static const int kCartesianWaypointFieldNumber = 3;
+  const ::Kinova::Api::Base::CartesianWaypoint& cartesian_waypoint() const;
+  ::Kinova::Api::Base::CartesianWaypoint* release_cartesian_waypoint();
+  ::Kinova::Api::Base::CartesianWaypoint* mutable_cartesian_waypoint();
+  void set_allocated_cartesian_waypoint(::Kinova::Api::Base::CartesianWaypoint* cartesian_waypoint);
+
+  TypeOfWaypointCase type_of_waypoint_case() const;
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.Waypoint)
+ private:
+  void set_has_angular_waypoint();
+  void set_has_cartesian_waypoint();
+
+  inline bool has_type_of_waypoint() const;
+  void clear_type_of_waypoint();
+  inline void clear_has_type_of_waypoint();
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::internal::ArenaStringPtr name_;
+  union TypeOfWaypointUnion {
+    TypeOfWaypointUnion() {}
+    ::Kinova::Api::Base::AngularWaypoint* angular_waypoint_;
+    ::Kinova::Api::Base::CartesianWaypoint* cartesian_waypoint_;
+  } type_of_waypoint_;
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _oneof_case_[1];
+
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsWaypointImpl();
+};
+// -------------------------------------------------------------------
+
+class AngularWaypoint : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.AngularWaypoint) */ {
+ public:
+  AngularWaypoint();
+  virtual ~AngularWaypoint();
+
+  AngularWaypoint(const AngularWaypoint& from);
+
+  inline AngularWaypoint& operator=(const AngularWaypoint& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  AngularWaypoint(AngularWaypoint&& from) noexcept
+    : AngularWaypoint() {
+    *this = ::std::move(from);
+  }
+
+  inline AngularWaypoint& operator=(AngularWaypoint&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const AngularWaypoint& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const AngularWaypoint* internal_default_instance() {
+    return reinterpret_cast<const AngularWaypoint*>(
+               &_AngularWaypoint_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    152;
+
+  void Swap(AngularWaypoint* other);
+  friend void swap(AngularWaypoint& a, AngularWaypoint& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline AngularWaypoint* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  AngularWaypoint* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const AngularWaypoint& from);
+  void MergeFrom(const AngularWaypoint& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(AngularWaypoint* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated float angles = 1;
+  int angles_size() const;
+  void clear_angles();
+  static const int kAnglesFieldNumber = 1;
+  float angles(int index) const;
+  void set_angles(int index, float value);
+  void add_angles(float value);
+  const ::google::protobuf::RepeatedField< float >&
+      angles() const;
+  ::google::protobuf::RepeatedField< float >*
+      mutable_angles();
+
+  // repeated float maximum_velocities = 2;
+  int maximum_velocities_size() const;
+  void clear_maximum_velocities();
+  static const int kMaximumVelocitiesFieldNumber = 2;
+  float maximum_velocities(int index) const;
+  void set_maximum_velocities(int index, float value);
+  void add_maximum_velocities(float value);
+  const ::google::protobuf::RepeatedField< float >&
+      maximum_velocities() const;
+  ::google::protobuf::RepeatedField< float >*
+      mutable_maximum_velocities();
+
+  // float duration = 3;
+  void clear_duration();
+  static const int kDurationFieldNumber = 3;
+  float duration() const;
+  void set_duration(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.AngularWaypoint)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedField< float > angles_;
+  mutable int _angles_cached_byte_size_;
+  ::google::protobuf::RepeatedField< float > maximum_velocities_;
+  mutable int _maximum_velocities_cached_byte_size_;
+  float duration_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsAngularWaypointImpl();
+};
+// -------------------------------------------------------------------
+
+class CartesianWaypoint : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.CartesianWaypoint) */ {
+ public:
+  CartesianWaypoint();
+  virtual ~CartesianWaypoint();
+
+  CartesianWaypoint(const CartesianWaypoint& from);
+
+  inline CartesianWaypoint& operator=(const CartesianWaypoint& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  CartesianWaypoint(CartesianWaypoint&& from) noexcept
+    : CartesianWaypoint() {
+    *this = ::std::move(from);
+  }
+
+  inline CartesianWaypoint& operator=(CartesianWaypoint&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const CartesianWaypoint& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const CartesianWaypoint* internal_default_instance() {
+    return reinterpret_cast<const CartesianWaypoint*>(
+               &_CartesianWaypoint_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    153;
+
+  void Swap(CartesianWaypoint* other);
+  friend void swap(CartesianWaypoint& a, CartesianWaypoint& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline CartesianWaypoint* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  CartesianWaypoint* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const CartesianWaypoint& from);
+  void MergeFrom(const CartesianWaypoint& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(CartesianWaypoint* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Base.Pose pose = 1;
+  bool has_pose() const;
+  void clear_pose();
+  static const int kPoseFieldNumber = 1;
+  const ::Kinova::Api::Base::Pose& pose() const;
+  ::Kinova::Api::Base::Pose* release_pose();
+  ::Kinova::Api::Base::Pose* mutable_pose();
+  void set_allocated_pose(::Kinova::Api::Base::Pose* pose);
+
+  // .Kinova.Api.Common.CartesianReferenceFrame reference_frame = 2;
+  void clear_reference_frame();
+  static const int kReferenceFrameFieldNumber = 2;
+  ::Kinova::Api::Common::CartesianReferenceFrame reference_frame() const;
+  void set_reference_frame(::Kinova::Api::Common::CartesianReferenceFrame value);
+
+  // float maximum_linear_velocity = 3;
+  void clear_maximum_linear_velocity();
+  static const int kMaximumLinearVelocityFieldNumber = 3;
+  float maximum_linear_velocity() const;
+  void set_maximum_linear_velocity(float value);
+
+  // float maximum_angular_velocity = 4;
+  void clear_maximum_angular_velocity();
+  static const int kMaximumAngularVelocityFieldNumber = 4;
+  float maximum_angular_velocity() const;
+  void set_maximum_angular_velocity(float value);
+
+  // float blending_radius = 5;
+  void clear_blending_radius();
+  static const int kBlendingRadiusFieldNumber = 5;
+  float blending_radius() const;
+  void set_blending_radius(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.CartesianWaypoint)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::Base::Pose* pose_;
+  int reference_frame_;
+  float maximum_linear_velocity_;
+  float maximum_angular_velocity_;
+  float blending_radius_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsCartesianWaypointImpl();
+};
+// -------------------------------------------------------------------
+
+class WaypointList : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.WaypointList) */ {
+ public:
+  WaypointList();
+  virtual ~WaypointList();
+
+  WaypointList(const WaypointList& from);
+
+  inline WaypointList& operator=(const WaypointList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  WaypointList(WaypointList&& from) noexcept
+    : WaypointList() {
+    *this = ::std::move(from);
+  }
+
+  inline WaypointList& operator=(WaypointList&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const WaypointList& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const WaypointList* internal_default_instance() {
+    return reinterpret_cast<const WaypointList*>(
+               &_WaypointList_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    154;
+
+  void Swap(WaypointList* other);
+  friend void swap(WaypointList& a, WaypointList& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline WaypointList* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  WaypointList* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const WaypointList& from);
+  void MergeFrom(const WaypointList& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(WaypointList* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .Kinova.Api.Base.Waypoint waypoints = 1;
+  int waypoints_size() const;
+  void clear_waypoints();
+  static const int kWaypointsFieldNumber = 1;
+  const ::Kinova::Api::Base::Waypoint& waypoints(int index) const;
+  ::Kinova::Api::Base::Waypoint* mutable_waypoints(int index);
+  ::Kinova::Api::Base::Waypoint* add_waypoints();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::Waypoint >*
+      mutable_waypoints();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::Waypoint >&
+      waypoints() const;
+
+  // float duration = 2;
+  void clear_duration();
+  static const int kDurationFieldNumber = 2;
+  float duration() const;
+  void set_duration(float value);
+
+  // bool use_optimal_blending = 3;
+  void clear_use_optimal_blending();
+  static const int kUseOptimalBlendingFieldNumber = 3;
+  bool use_optimal_blending() const;
+  void set_use_optimal_blending(bool value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.WaypointList)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::Waypoint > waypoints_;
+  float duration_;
+  bool use_optimal_blending_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsWaypointListImpl();
+};
+// -------------------------------------------------------------------
+
+class KinematicTrajectoryConstraints : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.KinematicTrajectoryConstraints) */ {
+ public:
+  KinematicTrajectoryConstraints();
+  virtual ~KinematicTrajectoryConstraints();
+
+  KinematicTrajectoryConstraints(const KinematicTrajectoryConstraints& from);
+
+  inline KinematicTrajectoryConstraints& operator=(const KinematicTrajectoryConstraints& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  KinematicTrajectoryConstraints(KinematicTrajectoryConstraints&& from) noexcept
+    : KinematicTrajectoryConstraints() {
+    *this = ::std::move(from);
+  }
+
+  inline KinematicTrajectoryConstraints& operator=(KinematicTrajectoryConstraints&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const KinematicTrajectoryConstraints& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const KinematicTrajectoryConstraints* internal_default_instance() {
+    return reinterpret_cast<const KinematicTrajectoryConstraints*>(
+               &_KinematicTrajectoryConstraints_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    155;
+
+  void Swap(KinematicTrajectoryConstraints* other);
+  friend void swap(KinematicTrajectoryConstraints& a, KinematicTrajectoryConstraints& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline KinematicTrajectoryConstraints* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  KinematicTrajectoryConstraints* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const KinematicTrajectoryConstraints& from);
+  void MergeFrom(const KinematicTrajectoryConstraints& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(KinematicTrajectoryConstraints* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated float angular_velocities = 1;
+  int angular_velocities_size() const;
+  void clear_angular_velocities();
+  static const int kAngularVelocitiesFieldNumber = 1;
+  float angular_velocities(int index) const;
+  void set_angular_velocities(int index, float value);
+  void add_angular_velocities(float value);
+  const ::google::protobuf::RepeatedField< float >&
+      angular_velocities() const;
+  ::google::protobuf::RepeatedField< float >*
+      mutable_angular_velocities();
+
+  // float linear_velocity = 2;
+  void clear_linear_velocity();
+  static const int kLinearVelocityFieldNumber = 2;
+  float linear_velocity() const;
+  void set_linear_velocity(float value);
+
+  // float angular_velocity = 3;
+  void clear_angular_velocity();
+  static const int kAngularVelocityFieldNumber = 3;
+  float angular_velocity() const;
+  void set_angular_velocity(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.KinematicTrajectoryConstraints)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedField< float > angular_velocities_;
+  mutable int _angular_velocities_cached_byte_size_;
+  float linear_velocity_;
+  float angular_velocity_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsKinematicTrajectoryConstraintsImpl();
+};
+// -------------------------------------------------------------------
+
+class FirmwareBundleVersions : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.FirmwareBundleVersions) */ {
+ public:
+  FirmwareBundleVersions();
+  virtual ~FirmwareBundleVersions();
+
+  FirmwareBundleVersions(const FirmwareBundleVersions& from);
+
+  inline FirmwareBundleVersions& operator=(const FirmwareBundleVersions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  FirmwareBundleVersions(FirmwareBundleVersions&& from) noexcept
+    : FirmwareBundleVersions() {
+    *this = ::std::move(from);
+  }
+
+  inline FirmwareBundleVersions& operator=(FirmwareBundleVersions&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const FirmwareBundleVersions& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const FirmwareBundleVersions* internal_default_instance() {
+    return reinterpret_cast<const FirmwareBundleVersions*>(
+               &_FirmwareBundleVersions_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    156;
+
+  void Swap(FirmwareBundleVersions* other);
+  friend void swap(FirmwareBundleVersions& a, FirmwareBundleVersions& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline FirmwareBundleVersions* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  FirmwareBundleVersions* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const FirmwareBundleVersions& from);
+  void MergeFrom(const FirmwareBundleVersions& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(FirmwareBundleVersions* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .Kinova.Api.Base.FirmwareComponentVersion components_versions = 2;
+  int components_versions_size() const;
+  void clear_components_versions();
+  static const int kComponentsVersionsFieldNumber = 2;
+  const ::Kinova::Api::Base::FirmwareComponentVersion& components_versions(int index) const;
+  ::Kinova::Api::Base::FirmwareComponentVersion* mutable_components_versions(int index);
+  ::Kinova::Api::Base::FirmwareComponentVersion* add_components_versions();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::FirmwareComponentVersion >*
+      mutable_components_versions();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::FirmwareComponentVersion >&
+      components_versions() const;
+
+  // string main_bundle_version = 1;
+  void clear_main_bundle_version();
+  static const int kMainBundleVersionFieldNumber = 1;
+  const ::std::string& main_bundle_version() const;
+  void set_main_bundle_version(const ::std::string& value);
+  #if LANG_CXX11
+  void set_main_bundle_version(::std::string&& value);
+  #endif
+  void set_main_bundle_version(const char* value);
+  void set_main_bundle_version(const char* value, size_t size);
+  ::std::string* mutable_main_bundle_version();
+  ::std::string* release_main_bundle_version();
+  void set_allocated_main_bundle_version(::std::string* main_bundle_version);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.FirmwareBundleVersions)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::FirmwareComponentVersion > components_versions_;
+  ::google::protobuf::internal::ArenaStringPtr main_bundle_version_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsFirmwareBundleVersionsImpl();
+};
+// -------------------------------------------------------------------
+
+class FirmwareComponentVersion : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.FirmwareComponentVersion) */ {
+ public:
+  FirmwareComponentVersion();
+  virtual ~FirmwareComponentVersion();
+
+  FirmwareComponentVersion(const FirmwareComponentVersion& from);
+
+  inline FirmwareComponentVersion& operator=(const FirmwareComponentVersion& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  FirmwareComponentVersion(FirmwareComponentVersion&& from) noexcept
+    : FirmwareComponentVersion() {
+    *this = ::std::move(from);
+  }
+
+  inline FirmwareComponentVersion& operator=(FirmwareComponentVersion&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const FirmwareComponentVersion& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const FirmwareComponentVersion* internal_default_instance() {
+    return reinterpret_cast<const FirmwareComponentVersion*>(
+               &_FirmwareComponentVersion_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    157;
+
+  void Swap(FirmwareComponentVersion* other);
+  friend void swap(FirmwareComponentVersion& a, FirmwareComponentVersion& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline FirmwareComponentVersion* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  FirmwareComponentVersion* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const FirmwareComponentVersion& from);
+  void MergeFrom(const FirmwareComponentVersion& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(FirmwareComponentVersion* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // string name = 1;
+  void clear_name();
+  static const int kNameFieldNumber = 1;
+  const ::std::string& name() const;
+  void set_name(const ::std::string& value);
+  #if LANG_CXX11
+  void set_name(::std::string&& value);
+  #endif
+  void set_name(const char* value);
+  void set_name(const char* value, size_t size);
+  ::std::string* mutable_name();
+  ::std::string* release_name();
+  void set_allocated_name(::std::string* name);
+
+  // string version = 2;
+  void clear_version();
+  static const int kVersionFieldNumber = 2;
+  const ::std::string& version() const;
+  void set_version(const ::std::string& value);
+  #if LANG_CXX11
+  void set_version(::std::string&& value);
+  #endif
+  void set_version(const char* value);
+  void set_version(const char* value, size_t size);
+  ::std::string* mutable_version();
+  ::std::string* release_version();
+  void set_allocated_version(::std::string* version);
+
+  // uint32 device_id = 3;
+  void clear_device_id();
+  static const int kDeviceIdFieldNumber = 3;
+  ::google::protobuf::uint32 device_id() const;
+  void set_device_id(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.FirmwareComponentVersion)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::internal::ArenaStringPtr name_;
+  ::google::protobuf::internal::ArenaStringPtr version_;
+  ::google::protobuf::uint32 device_id_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsFirmwareComponentVersionImpl();
+};
+// -------------------------------------------------------------------
+
+class IKData : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Base.IKData) */ {
+ public:
+  IKData();
+  virtual ~IKData();
+
+  IKData(const IKData& from);
+
+  inline IKData& operator=(const IKData& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  IKData(IKData&& from) noexcept
+    : IKData() {
+    *this = ::std::move(from);
+  }
+
+  inline IKData& operator=(IKData&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const IKData& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const IKData* internal_default_instance() {
+    return reinterpret_cast<const IKData*>(
+               &_IKData_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    158;
+
+  void Swap(IKData* other);
+  friend void swap(IKData& a, IKData& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline IKData* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  IKData* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const IKData& from);
+  void MergeFrom(const IKData& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(IKData* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Base.Pose cartesian_pose = 1;
+  bool has_cartesian_pose() const;
+  void clear_cartesian_pose();
+  static const int kCartesianPoseFieldNumber = 1;
+  const ::Kinova::Api::Base::Pose& cartesian_pose() const;
+  ::Kinova::Api::Base::Pose* release_cartesian_pose();
+  ::Kinova::Api::Base::Pose* mutable_cartesian_pose();
+  void set_allocated_cartesian_pose(::Kinova::Api::Base::Pose* cartesian_pose);
+
+  // .Kinova.Api.Base.JointAngles guess = 2;
+  bool has_guess() const;
+  void clear_guess();
+  static const int kGuessFieldNumber = 2;
+  const ::Kinova::Api::Base::JointAngles& guess() const;
+  ::Kinova::Api::Base::JointAngles* release_guess();
+  ::Kinova::Api::Base::JointAngles* mutable_guess();
+  void set_allocated_guess(::Kinova::Api::Base::JointAngles* guess);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Base.IKData)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::Base::Pose* cartesian_pose_;
+  ::Kinova::Api::Base::JointAngles* guess_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Base_2eproto::TableStruct;
+  friend void ::protobuf_Base_2eproto::InitDefaultsIKDataImpl();
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// GpioConfigurationList
+
+// repeated .Kinova.Api.Base.GpioConfiguration port_configurations = 1;
+inline int GpioConfigurationList::port_configurations_size() const {
+  return port_configurations_.size();
+}
+inline void GpioConfigurationList::clear_port_configurations() {
+  port_configurations_.Clear();
+}
+inline const ::Kinova::Api::Base::GpioConfiguration& GpioConfigurationList::port_configurations(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.GpioConfigurationList.port_configurations)
+  return port_configurations_.Get(index);
+}
+inline ::Kinova::Api::Base::GpioConfiguration* GpioConfigurationList::mutable_port_configurations(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.GpioConfigurationList.port_configurations)
+  return port_configurations_.Mutable(index);
+}
+inline ::Kinova::Api::Base::GpioConfiguration* GpioConfigurationList::add_port_configurations() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.Base.GpioConfigurationList.port_configurations)
+  return port_configurations_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::GpioConfiguration >*
+GpioConfigurationList::mutable_port_configurations() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.Base.GpioConfigurationList.port_configurations)
+  return &port_configurations_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::GpioConfiguration >&
+GpioConfigurationList::port_configurations() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.Base.GpioConfigurationList.port_configurations)
+  return port_configurations_;
+}
+
+// -------------------------------------------------------------------
+
+// GpioConfiguration
+
+// uint32 port_number = 1;
+inline void GpioConfiguration::clear_port_number() {
+  port_number_ = 0u;
+}
+inline ::google::protobuf::uint32 GpioConfiguration::port_number() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.GpioConfiguration.port_number)
+  return port_number_;
+}
+inline void GpioConfiguration::set_port_number(::google::protobuf::uint32 value) {
+  
+  port_number_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.GpioConfiguration.port_number)
+}
+
+// repeated .Kinova.Api.Base.GpioPinConfiguration pin_configurations = 2;
+inline int GpioConfiguration::pin_configurations_size() const {
+  return pin_configurations_.size();
+}
+inline void GpioConfiguration::clear_pin_configurations() {
+  pin_configurations_.Clear();
+}
+inline const ::Kinova::Api::Base::GpioPinConfiguration& GpioConfiguration::pin_configurations(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.GpioConfiguration.pin_configurations)
+  return pin_configurations_.Get(index);
+}
+inline ::Kinova::Api::Base::GpioPinConfiguration* GpioConfiguration::mutable_pin_configurations(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.GpioConfiguration.pin_configurations)
+  return pin_configurations_.Mutable(index);
+}
+inline ::Kinova::Api::Base::GpioPinConfiguration* GpioConfiguration::add_pin_configurations() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.Base.GpioConfiguration.pin_configurations)
+  return pin_configurations_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::GpioPinConfiguration >*
+GpioConfiguration::mutable_pin_configurations() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.Base.GpioConfiguration.pin_configurations)
+  return &pin_configurations_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::GpioPinConfiguration >&
+GpioConfiguration::pin_configurations() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.Base.GpioConfiguration.pin_configurations)
+  return pin_configurations_;
+}
+
+// -------------------------------------------------------------------
+
+// GpioPinConfiguration
+
+// uint32 pin_id = 1;
+inline void GpioPinConfiguration::clear_pin_id() {
+  pin_id_ = 0u;
+}
+inline ::google::protobuf::uint32 GpioPinConfiguration::pin_id() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.GpioPinConfiguration.pin_id)
+  return pin_id_;
+}
+inline void GpioPinConfiguration::set_pin_id(::google::protobuf::uint32 value) {
+  
+  pin_id_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.GpioPinConfiguration.pin_id)
+}
+
+// .Kinova.Api.Base.GpioPinPropertyFlags pin_property = 2;
+inline void GpioPinConfiguration::clear_pin_property() {
+  pin_property_ = 0;
+}
+inline ::Kinova::Api::Base::GpioPinPropertyFlags GpioPinConfiguration::pin_property() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.GpioPinConfiguration.pin_property)
+  return static_cast< ::Kinova::Api::Base::GpioPinPropertyFlags >(pin_property_);
+}
+inline void GpioPinConfiguration::set_pin_property(::Kinova::Api::Base::GpioPinPropertyFlags value) {
+  
+  pin_property_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.GpioPinConfiguration.pin_property)
+}
+
+// bool output_enable = 3;
+inline void GpioPinConfiguration::clear_output_enable() {
+  output_enable_ = false;
+}
+inline bool GpioPinConfiguration::output_enable() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.GpioPinConfiguration.output_enable)
+  return output_enable_;
+}
+inline void GpioPinConfiguration::set_output_enable(bool value) {
+  
+  output_enable_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.GpioPinConfiguration.output_enable)
+}
+
+// bool default_output_value = 4;
+inline void GpioPinConfiguration::clear_default_output_value() {
+  default_output_value_ = false;
+}
+inline bool GpioPinConfiguration::default_output_value() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.GpioPinConfiguration.default_output_value)
+  return default_output_value_;
+}
+inline void GpioPinConfiguration::set_default_output_value(bool value) {
+  
+  default_output_value_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.GpioPinConfiguration.default_output_value)
+}
+
+// -------------------------------------------------------------------
+
+// FullUserProfile
+
+// .Kinova.Api.Base.UserProfile user_profile = 1;
+inline bool FullUserProfile::has_user_profile() const {
+  return this != internal_default_instance() && user_profile_ != NULL;
+}
+inline void FullUserProfile::clear_user_profile() {
+  if (GetArenaNoVirtual() == NULL && user_profile_ != NULL) {
+    delete user_profile_;
+  }
+  user_profile_ = NULL;
+}
+inline const ::Kinova::Api::Base::UserProfile& FullUserProfile::user_profile() const {
+  const ::Kinova::Api::Base::UserProfile* p = user_profile_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.FullUserProfile.user_profile)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::UserProfile*>(
+      &::Kinova::Api::Base::_UserProfile_default_instance_);
+}
+inline ::Kinova::Api::Base::UserProfile* FullUserProfile::release_user_profile() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.FullUserProfile.user_profile)
+  
+  ::Kinova::Api::Base::UserProfile* temp = user_profile_;
+  user_profile_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::UserProfile* FullUserProfile::mutable_user_profile() {
+  
+  if (user_profile_ == NULL) {
+    user_profile_ = new ::Kinova::Api::Base::UserProfile;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.FullUserProfile.user_profile)
+  return user_profile_;
+}
+inline void FullUserProfile::set_allocated_user_profile(::Kinova::Api::Base::UserProfile* user_profile) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete user_profile_;
+  }
+  if (user_profile) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      user_profile = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, user_profile, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  user_profile_ = user_profile;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.FullUserProfile.user_profile)
+}
+
+// string password = 2;
+inline void FullUserProfile::clear_password() {
+  password_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& FullUserProfile::password() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.FullUserProfile.password)
+  return password_.GetNoArena();
+}
+inline void FullUserProfile::set_password(const ::std::string& value) {
+  
+  password_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.FullUserProfile.password)
+}
+#if LANG_CXX11
+inline void FullUserProfile::set_password(::std::string&& value) {
+  
+  password_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:Kinova.Api.Base.FullUserProfile.password)
+}
+#endif
+inline void FullUserProfile::set_password(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  password_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:Kinova.Api.Base.FullUserProfile.password)
+}
+inline void FullUserProfile::set_password(const char* value, size_t size) {
+  
+  password_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:Kinova.Api.Base.FullUserProfile.password)
+}
+inline ::std::string* FullUserProfile::mutable_password() {
+  
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.FullUserProfile.password)
+  return password_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* FullUserProfile::release_password() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.FullUserProfile.password)
+  
+  return password_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void FullUserProfile::set_allocated_password(::std::string* password) {
+  if (password != NULL) {
+    
+  } else {
+    
+  }
+  password_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), password);
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.FullUserProfile.password)
+}
+
+// -------------------------------------------------------------------
+
+// UserProfile
+
+// .Kinova.Api.Common.UserProfileHandle handle = 1;
+inline bool UserProfile::has_handle() const {
+  return this != internal_default_instance() && handle_ != NULL;
+}
+inline const ::Kinova::Api::Common::UserProfileHandle& UserProfile::handle() const {
+  const ::Kinova::Api::Common::UserProfileHandle* p = handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.UserProfile.handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::UserProfileHandle*>(
+      &::Kinova::Api::Common::_UserProfileHandle_default_instance_);
+}
+inline ::Kinova::Api::Common::UserProfileHandle* UserProfile::release_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.UserProfile.handle)
+  
+  ::Kinova::Api::Common::UserProfileHandle* temp = handle_;
+  handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::UserProfileHandle* UserProfile::mutable_handle() {
+  
+  if (handle_ == NULL) {
+    handle_ = new ::Kinova::Api::Common::UserProfileHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.UserProfile.handle)
+  return handle_;
+}
+inline void UserProfile::set_allocated_handle(::Kinova::Api::Common::UserProfileHandle* handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(handle_);
+  }
+  if (handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  handle_ = handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.UserProfile.handle)
+}
+
+// string username = 2;
+inline void UserProfile::clear_username() {
+  username_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& UserProfile::username() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.UserProfile.username)
+  return username_.GetNoArena();
+}
+inline void UserProfile::set_username(const ::std::string& value) {
+  
+  username_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.UserProfile.username)
+}
+#if LANG_CXX11
+inline void UserProfile::set_username(::std::string&& value) {
+  
+  username_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:Kinova.Api.Base.UserProfile.username)
+}
+#endif
+inline void UserProfile::set_username(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  username_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:Kinova.Api.Base.UserProfile.username)
+}
+inline void UserProfile::set_username(const char* value, size_t size) {
+  
+  username_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:Kinova.Api.Base.UserProfile.username)
+}
+inline ::std::string* UserProfile::mutable_username() {
+  
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.UserProfile.username)
+  return username_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* UserProfile::release_username() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.UserProfile.username)
+  
+  return username_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void UserProfile::set_allocated_username(::std::string* username) {
+  if (username != NULL) {
+    
+  } else {
+    
+  }
+  username_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), username);
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.UserProfile.username)
+}
+
+// string firstname = 3;
+inline void UserProfile::clear_firstname() {
+  firstname_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& UserProfile::firstname() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.UserProfile.firstname)
+  return firstname_.GetNoArena();
+}
+inline void UserProfile::set_firstname(const ::std::string& value) {
+  
+  firstname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.UserProfile.firstname)
+}
+#if LANG_CXX11
+inline void UserProfile::set_firstname(::std::string&& value) {
+  
+  firstname_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:Kinova.Api.Base.UserProfile.firstname)
+}
+#endif
+inline void UserProfile::set_firstname(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  firstname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:Kinova.Api.Base.UserProfile.firstname)
+}
+inline void UserProfile::set_firstname(const char* value, size_t size) {
+  
+  firstname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:Kinova.Api.Base.UserProfile.firstname)
+}
+inline ::std::string* UserProfile::mutable_firstname() {
+  
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.UserProfile.firstname)
+  return firstname_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* UserProfile::release_firstname() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.UserProfile.firstname)
+  
+  return firstname_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void UserProfile::set_allocated_firstname(::std::string* firstname) {
+  if (firstname != NULL) {
+    
+  } else {
+    
+  }
+  firstname_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), firstname);
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.UserProfile.firstname)
+}
+
+// string lastname = 4;
+inline void UserProfile::clear_lastname() {
+  lastname_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& UserProfile::lastname() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.UserProfile.lastname)
+  return lastname_.GetNoArena();
+}
+inline void UserProfile::set_lastname(const ::std::string& value) {
+  
+  lastname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.UserProfile.lastname)
+}
+#if LANG_CXX11
+inline void UserProfile::set_lastname(::std::string&& value) {
+  
+  lastname_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:Kinova.Api.Base.UserProfile.lastname)
+}
+#endif
+inline void UserProfile::set_lastname(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  lastname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:Kinova.Api.Base.UserProfile.lastname)
+}
+inline void UserProfile::set_lastname(const char* value, size_t size) {
+  
+  lastname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:Kinova.Api.Base.UserProfile.lastname)
+}
+inline ::std::string* UserProfile::mutable_lastname() {
+  
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.UserProfile.lastname)
+  return lastname_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* UserProfile::release_lastname() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.UserProfile.lastname)
+  
+  return lastname_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void UserProfile::set_allocated_lastname(::std::string* lastname) {
+  if (lastname != NULL) {
+    
+  } else {
+    
+  }
+  lastname_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), lastname);
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.UserProfile.lastname)
+}
+
+// string application_data = 5;
+inline void UserProfile::clear_application_data() {
+  application_data_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& UserProfile::application_data() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.UserProfile.application_data)
+  return application_data_.GetNoArena();
+}
+inline void UserProfile::set_application_data(const ::std::string& value) {
+  
+  application_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.UserProfile.application_data)
+}
+#if LANG_CXX11
+inline void UserProfile::set_application_data(::std::string&& value) {
+  
+  application_data_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:Kinova.Api.Base.UserProfile.application_data)
+}
+#endif
+inline void UserProfile::set_application_data(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  application_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:Kinova.Api.Base.UserProfile.application_data)
+}
+inline void UserProfile::set_application_data(const char* value, size_t size) {
+  
+  application_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:Kinova.Api.Base.UserProfile.application_data)
+}
+inline ::std::string* UserProfile::mutable_application_data() {
+  
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.UserProfile.application_data)
+  return application_data_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* UserProfile::release_application_data() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.UserProfile.application_data)
+  
+  return application_data_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void UserProfile::set_allocated_application_data(::std::string* application_data) {
+  if (application_data != NULL) {
+    
+  } else {
+    
+  }
+  application_data_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), application_data);
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.UserProfile.application_data)
+}
+
+// -------------------------------------------------------------------
+
+// UserProfileList
+
+// repeated .Kinova.Api.Base.UserProfile user_profiles = 1;
+inline int UserProfileList::user_profiles_size() const {
+  return user_profiles_.size();
+}
+inline void UserProfileList::clear_user_profiles() {
+  user_profiles_.Clear();
+}
+inline const ::Kinova::Api::Base::UserProfile& UserProfileList::user_profiles(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.UserProfileList.user_profiles)
+  return user_profiles_.Get(index);
+}
+inline ::Kinova::Api::Base::UserProfile* UserProfileList::mutable_user_profiles(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.UserProfileList.user_profiles)
+  return user_profiles_.Mutable(index);
+}
+inline ::Kinova::Api::Base::UserProfile* UserProfileList::add_user_profiles() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.Base.UserProfileList.user_profiles)
+  return user_profiles_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::UserProfile >*
+UserProfileList::mutable_user_profiles() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.Base.UserProfileList.user_profiles)
+  return &user_profiles_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::UserProfile >&
+UserProfileList::user_profiles() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.Base.UserProfileList.user_profiles)
+  return user_profiles_;
+}
+
+// -------------------------------------------------------------------
+
+// UserList
+
+// repeated .Kinova.Api.Common.UserProfileHandle user_handles = 1;
+inline int UserList::user_handles_size() const {
+  return user_handles_.size();
+}
+inline const ::Kinova::Api::Common::UserProfileHandle& UserList::user_handles(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.UserList.user_handles)
+  return user_handles_.Get(index);
+}
+inline ::Kinova::Api::Common::UserProfileHandle* UserList::mutable_user_handles(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.UserList.user_handles)
+  return user_handles_.Mutable(index);
+}
+inline ::Kinova::Api::Common::UserProfileHandle* UserList::add_user_handles() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.Base.UserList.user_handles)
+  return user_handles_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Common::UserProfileHandle >*
+UserList::mutable_user_handles() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.Base.UserList.user_handles)
+  return &user_handles_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Common::UserProfileHandle >&
+UserList::user_handles() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.Base.UserList.user_handles)
+  return user_handles_;
+}
+
+// -------------------------------------------------------------------
+
+// PasswordChange
+
+// .Kinova.Api.Common.UserProfileHandle handle = 1;
+inline bool PasswordChange::has_handle() const {
+  return this != internal_default_instance() && handle_ != NULL;
+}
+inline const ::Kinova::Api::Common::UserProfileHandle& PasswordChange::handle() const {
+  const ::Kinova::Api::Common::UserProfileHandle* p = handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.PasswordChange.handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::UserProfileHandle*>(
+      &::Kinova::Api::Common::_UserProfileHandle_default_instance_);
+}
+inline ::Kinova::Api::Common::UserProfileHandle* PasswordChange::release_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.PasswordChange.handle)
+  
+  ::Kinova::Api::Common::UserProfileHandle* temp = handle_;
+  handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::UserProfileHandle* PasswordChange::mutable_handle() {
+  
+  if (handle_ == NULL) {
+    handle_ = new ::Kinova::Api::Common::UserProfileHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.PasswordChange.handle)
+  return handle_;
+}
+inline void PasswordChange::set_allocated_handle(::Kinova::Api::Common::UserProfileHandle* handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(handle_);
+  }
+  if (handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  handle_ = handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.PasswordChange.handle)
+}
+
+// string old_password = 2;
+inline void PasswordChange::clear_old_password() {
+  old_password_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& PasswordChange::old_password() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.PasswordChange.old_password)
+  return old_password_.GetNoArena();
+}
+inline void PasswordChange::set_old_password(const ::std::string& value) {
+  
+  old_password_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.PasswordChange.old_password)
+}
+#if LANG_CXX11
+inline void PasswordChange::set_old_password(::std::string&& value) {
+  
+  old_password_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:Kinova.Api.Base.PasswordChange.old_password)
+}
+#endif
+inline void PasswordChange::set_old_password(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  old_password_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:Kinova.Api.Base.PasswordChange.old_password)
+}
+inline void PasswordChange::set_old_password(const char* value, size_t size) {
+  
+  old_password_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:Kinova.Api.Base.PasswordChange.old_password)
+}
+inline ::std::string* PasswordChange::mutable_old_password() {
+  
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.PasswordChange.old_password)
+  return old_password_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* PasswordChange::release_old_password() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.PasswordChange.old_password)
+  
+  return old_password_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void PasswordChange::set_allocated_old_password(::std::string* old_password) {
+  if (old_password != NULL) {
+    
+  } else {
+    
+  }
+  old_password_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), old_password);
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.PasswordChange.old_password)
+}
+
+// string new_password = 3;
+inline void PasswordChange::clear_new_password() {
+  new_password_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& PasswordChange::new_password() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.PasswordChange.new_password)
+  return new_password_.GetNoArena();
+}
+inline void PasswordChange::set_new_password(const ::std::string& value) {
+  
+  new_password_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.PasswordChange.new_password)
+}
+#if LANG_CXX11
+inline void PasswordChange::set_new_password(::std::string&& value) {
+  
+  new_password_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:Kinova.Api.Base.PasswordChange.new_password)
+}
+#endif
+inline void PasswordChange::set_new_password(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  new_password_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:Kinova.Api.Base.PasswordChange.new_password)
+}
+inline void PasswordChange::set_new_password(const char* value, size_t size) {
+  
+  new_password_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:Kinova.Api.Base.PasswordChange.new_password)
+}
+inline ::std::string* PasswordChange::mutable_new_password() {
+  
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.PasswordChange.new_password)
+  return new_password_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* PasswordChange::release_new_password() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.PasswordChange.new_password)
+  
+  return new_password_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void PasswordChange::set_allocated_new_password(::std::string* new_password) {
+  if (new_password != NULL) {
+    
+  } else {
+    
+  }
+  new_password_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), new_password);
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.PasswordChange.new_password)
+}
+
+// -------------------------------------------------------------------
+
+// SequenceHandle
+
+// uint32 identifier = 1;
+inline void SequenceHandle::clear_identifier() {
+  identifier_ = 0u;
+}
+inline ::google::protobuf::uint32 SequenceHandle::identifier() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.SequenceHandle.identifier)
+  return identifier_;
+}
+inline void SequenceHandle::set_identifier(::google::protobuf::uint32 value) {
+  
+  identifier_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.SequenceHandle.identifier)
+}
+
+// fixed32 permission = 2;
+inline void SequenceHandle::clear_permission() {
+  permission_ = 0u;
+}
+inline ::google::protobuf::uint32 SequenceHandle::permission() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.SequenceHandle.permission)
+  return permission_;
+}
+inline void SequenceHandle::set_permission(::google::protobuf::uint32 value) {
+  
+  permission_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.SequenceHandle.permission)
+}
+
+// -------------------------------------------------------------------
+
+// AdvancedSequenceHandle
+
+// .Kinova.Api.Base.SequenceHandle handle = 1;
+inline bool AdvancedSequenceHandle::has_handle() const {
+  return this != internal_default_instance() && handle_ != NULL;
+}
+inline void AdvancedSequenceHandle::clear_handle() {
+  if (GetArenaNoVirtual() == NULL && handle_ != NULL) {
+    delete handle_;
+  }
+  handle_ = NULL;
+}
+inline const ::Kinova::Api::Base::SequenceHandle& AdvancedSequenceHandle::handle() const {
+  const ::Kinova::Api::Base::SequenceHandle* p = handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.AdvancedSequenceHandle.handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::SequenceHandle*>(
+      &::Kinova::Api::Base::_SequenceHandle_default_instance_);
+}
+inline ::Kinova::Api::Base::SequenceHandle* AdvancedSequenceHandle::release_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.AdvancedSequenceHandle.handle)
+  
+  ::Kinova::Api::Base::SequenceHandle* temp = handle_;
+  handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::SequenceHandle* AdvancedSequenceHandle::mutable_handle() {
+  
+  if (handle_ == NULL) {
+    handle_ = new ::Kinova::Api::Base::SequenceHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.AdvancedSequenceHandle.handle)
+  return handle_;
+}
+inline void AdvancedSequenceHandle::set_allocated_handle(::Kinova::Api::Base::SequenceHandle* handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete handle_;
+  }
+  if (handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  handle_ = handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.AdvancedSequenceHandle.handle)
+}
+
+// bool in_loop = 2;
+inline void AdvancedSequenceHandle::clear_in_loop() {
+  in_loop_ = false;
+}
+inline bool AdvancedSequenceHandle::in_loop() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.AdvancedSequenceHandle.in_loop)
+  return in_loop_;
+}
+inline void AdvancedSequenceHandle::set_in_loop(bool value) {
+  
+  in_loop_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.AdvancedSequenceHandle.in_loop)
+}
+
+// -------------------------------------------------------------------
+
+// SequenceTaskHandle
+
+// .Kinova.Api.Base.SequenceHandle sequence_handle = 1;
+inline bool SequenceTaskHandle::has_sequence_handle() const {
+  return this != internal_default_instance() && sequence_handle_ != NULL;
+}
+inline void SequenceTaskHandle::clear_sequence_handle() {
+  if (GetArenaNoVirtual() == NULL && sequence_handle_ != NULL) {
+    delete sequence_handle_;
+  }
+  sequence_handle_ = NULL;
+}
+inline const ::Kinova::Api::Base::SequenceHandle& SequenceTaskHandle::sequence_handle() const {
+  const ::Kinova::Api::Base::SequenceHandle* p = sequence_handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.SequenceTaskHandle.sequence_handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::SequenceHandle*>(
+      &::Kinova::Api::Base::_SequenceHandle_default_instance_);
+}
+inline ::Kinova::Api::Base::SequenceHandle* SequenceTaskHandle::release_sequence_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.SequenceTaskHandle.sequence_handle)
+  
+  ::Kinova::Api::Base::SequenceHandle* temp = sequence_handle_;
+  sequence_handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::SequenceHandle* SequenceTaskHandle::mutable_sequence_handle() {
+  
+  if (sequence_handle_ == NULL) {
+    sequence_handle_ = new ::Kinova::Api::Base::SequenceHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.SequenceTaskHandle.sequence_handle)
+  return sequence_handle_;
+}
+inline void SequenceTaskHandle::set_allocated_sequence_handle(::Kinova::Api::Base::SequenceHandle* sequence_handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete sequence_handle_;
+  }
+  if (sequence_handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      sequence_handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, sequence_handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  sequence_handle_ = sequence_handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.SequenceTaskHandle.sequence_handle)
+}
+
+// uint32 task_index = 2;
+inline void SequenceTaskHandle::clear_task_index() {
+  task_index_ = 0u;
+}
+inline ::google::protobuf::uint32 SequenceTaskHandle::task_index() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.SequenceTaskHandle.task_index)
+  return task_index_;
+}
+inline void SequenceTaskHandle::set_task_index(::google::protobuf::uint32 value) {
+  
+  task_index_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.SequenceTaskHandle.task_index)
+}
+
+// -------------------------------------------------------------------
+
+// SequenceTask
+
+// uint32 group_identifier = 1;
+inline void SequenceTask::clear_group_identifier() {
+  group_identifier_ = 0u;
+}
+inline ::google::protobuf::uint32 SequenceTask::group_identifier() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.SequenceTask.group_identifier)
+  return group_identifier_;
+}
+inline void SequenceTask::set_group_identifier(::google::protobuf::uint32 value) {
+  
+  group_identifier_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.SequenceTask.group_identifier)
+}
+
+// .Kinova.Api.Base.Action action = 2;
+inline bool SequenceTask::has_action() const {
+  return this != internal_default_instance() && action_ != NULL;
+}
+inline void SequenceTask::clear_action() {
+  if (GetArenaNoVirtual() == NULL && action_ != NULL) {
+    delete action_;
+  }
+  action_ = NULL;
+}
+inline const ::Kinova::Api::Base::Action& SequenceTask::action() const {
+  const ::Kinova::Api::Base::Action* p = action_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.SequenceTask.action)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::Action*>(
+      &::Kinova::Api::Base::_Action_default_instance_);
+}
+inline ::Kinova::Api::Base::Action* SequenceTask::release_action() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.SequenceTask.action)
+  
+  ::Kinova::Api::Base::Action* temp = action_;
+  action_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::Action* SequenceTask::mutable_action() {
+  
+  if (action_ == NULL) {
+    action_ = new ::Kinova::Api::Base::Action;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.SequenceTask.action)
+  return action_;
+}
+inline void SequenceTask::set_allocated_action(::Kinova::Api::Base::Action* action) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete action_;
+  }
+  if (action) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      action = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, action, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  action_ = action;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.SequenceTask.action)
+}
+
+// string application_data = 3;
+inline void SequenceTask::clear_application_data() {
+  application_data_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& SequenceTask::application_data() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.SequenceTask.application_data)
+  return application_data_.GetNoArena();
+}
+inline void SequenceTask::set_application_data(const ::std::string& value) {
+  
+  application_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.SequenceTask.application_data)
+}
+#if LANG_CXX11
+inline void SequenceTask::set_application_data(::std::string&& value) {
+  
+  application_data_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:Kinova.Api.Base.SequenceTask.application_data)
+}
+#endif
+inline void SequenceTask::set_application_data(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  application_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:Kinova.Api.Base.SequenceTask.application_data)
+}
+inline void SequenceTask::set_application_data(const char* value, size_t size) {
+  
+  application_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:Kinova.Api.Base.SequenceTask.application_data)
+}
+inline ::std::string* SequenceTask::mutable_application_data() {
+  
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.SequenceTask.application_data)
+  return application_data_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* SequenceTask::release_application_data() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.SequenceTask.application_data)
+  
+  return application_data_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void SequenceTask::set_allocated_application_data(::std::string* application_data) {
+  if (application_data != NULL) {
+    
+  } else {
+    
+  }
+  application_data_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), application_data);
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.SequenceTask.application_data)
+}
+
+// -------------------------------------------------------------------
+
+// SequenceTasks
+
+// repeated .Kinova.Api.Base.SequenceTask sequence_tasks = 1;
+inline int SequenceTasks::sequence_tasks_size() const {
+  return sequence_tasks_.size();
+}
+inline void SequenceTasks::clear_sequence_tasks() {
+  sequence_tasks_.Clear();
+}
+inline const ::Kinova::Api::Base::SequenceTask& SequenceTasks::sequence_tasks(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.SequenceTasks.sequence_tasks)
+  return sequence_tasks_.Get(index);
+}
+inline ::Kinova::Api::Base::SequenceTask* SequenceTasks::mutable_sequence_tasks(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.SequenceTasks.sequence_tasks)
+  return sequence_tasks_.Mutable(index);
+}
+inline ::Kinova::Api::Base::SequenceTask* SequenceTasks::add_sequence_tasks() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.Base.SequenceTasks.sequence_tasks)
+  return sequence_tasks_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::SequenceTask >*
+SequenceTasks::mutable_sequence_tasks() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.Base.SequenceTasks.sequence_tasks)
+  return &sequence_tasks_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::SequenceTask >&
+SequenceTasks::sequence_tasks() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.Base.SequenceTasks.sequence_tasks)
+  return sequence_tasks_;
+}
+
+// -------------------------------------------------------------------
+
+// SequenceTasksConfiguration
+
+// .Kinova.Api.Base.SequenceTaskHandle sequence_task_handle = 1;
+inline bool SequenceTasksConfiguration::has_sequence_task_handle() const {
+  return this != internal_default_instance() && sequence_task_handle_ != NULL;
+}
+inline void SequenceTasksConfiguration::clear_sequence_task_handle() {
+  if (GetArenaNoVirtual() == NULL && sequence_task_handle_ != NULL) {
+    delete sequence_task_handle_;
+  }
+  sequence_task_handle_ = NULL;
+}
+inline const ::Kinova::Api::Base::SequenceTaskHandle& SequenceTasksConfiguration::sequence_task_handle() const {
+  const ::Kinova::Api::Base::SequenceTaskHandle* p = sequence_task_handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.SequenceTasksConfiguration.sequence_task_handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::SequenceTaskHandle*>(
+      &::Kinova::Api::Base::_SequenceTaskHandle_default_instance_);
+}
+inline ::Kinova::Api::Base::SequenceTaskHandle* SequenceTasksConfiguration::release_sequence_task_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.SequenceTasksConfiguration.sequence_task_handle)
+  
+  ::Kinova::Api::Base::SequenceTaskHandle* temp = sequence_task_handle_;
+  sequence_task_handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::SequenceTaskHandle* SequenceTasksConfiguration::mutable_sequence_task_handle() {
+  
+  if (sequence_task_handle_ == NULL) {
+    sequence_task_handle_ = new ::Kinova::Api::Base::SequenceTaskHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.SequenceTasksConfiguration.sequence_task_handle)
+  return sequence_task_handle_;
+}
+inline void SequenceTasksConfiguration::set_allocated_sequence_task_handle(::Kinova::Api::Base::SequenceTaskHandle* sequence_task_handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete sequence_task_handle_;
+  }
+  if (sequence_task_handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      sequence_task_handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, sequence_task_handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  sequence_task_handle_ = sequence_task_handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.SequenceTasksConfiguration.sequence_task_handle)
+}
+
+// repeated .Kinova.Api.Base.SequenceTask sequence_tasks = 2;
+inline int SequenceTasksConfiguration::sequence_tasks_size() const {
+  return sequence_tasks_.size();
+}
+inline void SequenceTasksConfiguration::clear_sequence_tasks() {
+  sequence_tasks_.Clear();
+}
+inline const ::Kinova::Api::Base::SequenceTask& SequenceTasksConfiguration::sequence_tasks(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.SequenceTasksConfiguration.sequence_tasks)
+  return sequence_tasks_.Get(index);
+}
+inline ::Kinova::Api::Base::SequenceTask* SequenceTasksConfiguration::mutable_sequence_tasks(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.SequenceTasksConfiguration.sequence_tasks)
+  return sequence_tasks_.Mutable(index);
+}
+inline ::Kinova::Api::Base::SequenceTask* SequenceTasksConfiguration::add_sequence_tasks() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.Base.SequenceTasksConfiguration.sequence_tasks)
+  return sequence_tasks_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::SequenceTask >*
+SequenceTasksConfiguration::mutable_sequence_tasks() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.Base.SequenceTasksConfiguration.sequence_tasks)
+  return &sequence_tasks_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::SequenceTask >&
+SequenceTasksConfiguration::sequence_tasks() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.Base.SequenceTasksConfiguration.sequence_tasks)
+  return sequence_tasks_;
+}
+
+// -------------------------------------------------------------------
+
+// SequenceTaskConfiguration
+
+// .Kinova.Api.Base.SequenceTaskHandle sequence_task_handle = 1;
+inline bool SequenceTaskConfiguration::has_sequence_task_handle() const {
+  return this != internal_default_instance() && sequence_task_handle_ != NULL;
+}
+inline void SequenceTaskConfiguration::clear_sequence_task_handle() {
+  if (GetArenaNoVirtual() == NULL && sequence_task_handle_ != NULL) {
+    delete sequence_task_handle_;
+  }
+  sequence_task_handle_ = NULL;
+}
+inline const ::Kinova::Api::Base::SequenceTaskHandle& SequenceTaskConfiguration::sequence_task_handle() const {
+  const ::Kinova::Api::Base::SequenceTaskHandle* p = sequence_task_handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.SequenceTaskConfiguration.sequence_task_handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::SequenceTaskHandle*>(
+      &::Kinova::Api::Base::_SequenceTaskHandle_default_instance_);
+}
+inline ::Kinova::Api::Base::SequenceTaskHandle* SequenceTaskConfiguration::release_sequence_task_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.SequenceTaskConfiguration.sequence_task_handle)
+  
+  ::Kinova::Api::Base::SequenceTaskHandle* temp = sequence_task_handle_;
+  sequence_task_handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::SequenceTaskHandle* SequenceTaskConfiguration::mutable_sequence_task_handle() {
+  
+  if (sequence_task_handle_ == NULL) {
+    sequence_task_handle_ = new ::Kinova::Api::Base::SequenceTaskHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.SequenceTaskConfiguration.sequence_task_handle)
+  return sequence_task_handle_;
+}
+inline void SequenceTaskConfiguration::set_allocated_sequence_task_handle(::Kinova::Api::Base::SequenceTaskHandle* sequence_task_handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete sequence_task_handle_;
+  }
+  if (sequence_task_handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      sequence_task_handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, sequence_task_handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  sequence_task_handle_ = sequence_task_handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.SequenceTaskConfiguration.sequence_task_handle)
+}
+
+// .Kinova.Api.Base.SequenceTask sequence_task = 2;
+inline bool SequenceTaskConfiguration::has_sequence_task() const {
+  return this != internal_default_instance() && sequence_task_ != NULL;
+}
+inline void SequenceTaskConfiguration::clear_sequence_task() {
+  if (GetArenaNoVirtual() == NULL && sequence_task_ != NULL) {
+    delete sequence_task_;
+  }
+  sequence_task_ = NULL;
+}
+inline const ::Kinova::Api::Base::SequenceTask& SequenceTaskConfiguration::sequence_task() const {
+  const ::Kinova::Api::Base::SequenceTask* p = sequence_task_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.SequenceTaskConfiguration.sequence_task)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::SequenceTask*>(
+      &::Kinova::Api::Base::_SequenceTask_default_instance_);
+}
+inline ::Kinova::Api::Base::SequenceTask* SequenceTaskConfiguration::release_sequence_task() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.SequenceTaskConfiguration.sequence_task)
+  
+  ::Kinova::Api::Base::SequenceTask* temp = sequence_task_;
+  sequence_task_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::SequenceTask* SequenceTaskConfiguration::mutable_sequence_task() {
+  
+  if (sequence_task_ == NULL) {
+    sequence_task_ = new ::Kinova::Api::Base::SequenceTask;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.SequenceTaskConfiguration.sequence_task)
+  return sequence_task_;
+}
+inline void SequenceTaskConfiguration::set_allocated_sequence_task(::Kinova::Api::Base::SequenceTask* sequence_task) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete sequence_task_;
+  }
+  if (sequence_task) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      sequence_task = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, sequence_task, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  sequence_task_ = sequence_task;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.SequenceTaskConfiguration.sequence_task)
+}
+
+// -------------------------------------------------------------------
+
+// SequenceTasksRange
+
+// uint32 first_task_index = 1;
+inline void SequenceTasksRange::clear_first_task_index() {
+  first_task_index_ = 0u;
+}
+inline ::google::protobuf::uint32 SequenceTasksRange::first_task_index() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.SequenceTasksRange.first_task_index)
+  return first_task_index_;
+}
+inline void SequenceTasksRange::set_first_task_index(::google::protobuf::uint32 value) {
+  
+  first_task_index_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.SequenceTasksRange.first_task_index)
+}
+
+// uint32 second_task_index = 2;
+inline void SequenceTasksRange::clear_second_task_index() {
+  second_task_index_ = 0u;
+}
+inline ::google::protobuf::uint32 SequenceTasksRange::second_task_index() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.SequenceTasksRange.second_task_index)
+  return second_task_index_;
+}
+inline void SequenceTasksRange::set_second_task_index(::google::protobuf::uint32 value) {
+  
+  second_task_index_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.SequenceTasksRange.second_task_index)
+}
+
+// -------------------------------------------------------------------
+
+// SequenceTasksPair
+
+// .Kinova.Api.Base.SequenceHandle sequence_handle = 1;
+inline bool SequenceTasksPair::has_sequence_handle() const {
+  return this != internal_default_instance() && sequence_handle_ != NULL;
+}
+inline void SequenceTasksPair::clear_sequence_handle() {
+  if (GetArenaNoVirtual() == NULL && sequence_handle_ != NULL) {
+    delete sequence_handle_;
+  }
+  sequence_handle_ = NULL;
+}
+inline const ::Kinova::Api::Base::SequenceHandle& SequenceTasksPair::sequence_handle() const {
+  const ::Kinova::Api::Base::SequenceHandle* p = sequence_handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.SequenceTasksPair.sequence_handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::SequenceHandle*>(
+      &::Kinova::Api::Base::_SequenceHandle_default_instance_);
+}
+inline ::Kinova::Api::Base::SequenceHandle* SequenceTasksPair::release_sequence_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.SequenceTasksPair.sequence_handle)
+  
+  ::Kinova::Api::Base::SequenceHandle* temp = sequence_handle_;
+  sequence_handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::SequenceHandle* SequenceTasksPair::mutable_sequence_handle() {
+  
+  if (sequence_handle_ == NULL) {
+    sequence_handle_ = new ::Kinova::Api::Base::SequenceHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.SequenceTasksPair.sequence_handle)
+  return sequence_handle_;
+}
+inline void SequenceTasksPair::set_allocated_sequence_handle(::Kinova::Api::Base::SequenceHandle* sequence_handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete sequence_handle_;
+  }
+  if (sequence_handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      sequence_handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, sequence_handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  sequence_handle_ = sequence_handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.SequenceTasksPair.sequence_handle)
+}
+
+// uint32 first_task_index = 2;
+inline void SequenceTasksPair::clear_first_task_index() {
+  first_task_index_ = 0u;
+}
+inline ::google::protobuf::uint32 SequenceTasksPair::first_task_index() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.SequenceTasksPair.first_task_index)
+  return first_task_index_;
+}
+inline void SequenceTasksPair::set_first_task_index(::google::protobuf::uint32 value) {
+  
+  first_task_index_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.SequenceTasksPair.first_task_index)
+}
+
+// uint32 second_task_index = 3;
+inline void SequenceTasksPair::clear_second_task_index() {
+  second_task_index_ = 0u;
+}
+inline ::google::protobuf::uint32 SequenceTasksPair::second_task_index() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.SequenceTasksPair.second_task_index)
+  return second_task_index_;
+}
+inline void SequenceTasksPair::set_second_task_index(::google::protobuf::uint32 value) {
+  
+  second_task_index_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.SequenceTasksPair.second_task_index)
+}
+
+// -------------------------------------------------------------------
+
+// Sequence
+
+// .Kinova.Api.Base.SequenceHandle handle = 1;
+inline bool Sequence::has_handle() const {
+  return this != internal_default_instance() && handle_ != NULL;
+}
+inline void Sequence::clear_handle() {
+  if (GetArenaNoVirtual() == NULL && handle_ != NULL) {
+    delete handle_;
+  }
+  handle_ = NULL;
+}
+inline const ::Kinova::Api::Base::SequenceHandle& Sequence::handle() const {
+  const ::Kinova::Api::Base::SequenceHandle* p = handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Sequence.handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::SequenceHandle*>(
+      &::Kinova::Api::Base::_SequenceHandle_default_instance_);
+}
+inline ::Kinova::Api::Base::SequenceHandle* Sequence::release_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.Sequence.handle)
+  
+  ::Kinova::Api::Base::SequenceHandle* temp = handle_;
+  handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::SequenceHandle* Sequence::mutable_handle() {
+  
+  if (handle_ == NULL) {
+    handle_ = new ::Kinova::Api::Base::SequenceHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.Sequence.handle)
+  return handle_;
+}
+inline void Sequence::set_allocated_handle(::Kinova::Api::Base::SequenceHandle* handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete handle_;
+  }
+  if (handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  handle_ = handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.Sequence.handle)
+}
+
+// string name = 2;
+inline void Sequence::clear_name() {
+  name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& Sequence::name() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Sequence.name)
+  return name_.GetNoArena();
+}
+inline void Sequence::set_name(const ::std::string& value) {
+  
+  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.Sequence.name)
+}
+#if LANG_CXX11
+inline void Sequence::set_name(::std::string&& value) {
+  
+  name_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:Kinova.Api.Base.Sequence.name)
+}
+#endif
+inline void Sequence::set_name(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:Kinova.Api.Base.Sequence.name)
+}
+inline void Sequence::set_name(const char* value, size_t size) {
+  
+  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:Kinova.Api.Base.Sequence.name)
+}
+inline ::std::string* Sequence::mutable_name() {
+  
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.Sequence.name)
+  return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* Sequence::release_name() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.Sequence.name)
+  
+  return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void Sequence::set_allocated_name(::std::string* name) {
+  if (name != NULL) {
+    
+  } else {
+    
+  }
+  name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.Sequence.name)
+}
+
+// string application_data = 3;
+inline void Sequence::clear_application_data() {
+  application_data_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& Sequence::application_data() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Sequence.application_data)
+  return application_data_.GetNoArena();
+}
+inline void Sequence::set_application_data(const ::std::string& value) {
+  
+  application_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.Sequence.application_data)
+}
+#if LANG_CXX11
+inline void Sequence::set_application_data(::std::string&& value) {
+  
+  application_data_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:Kinova.Api.Base.Sequence.application_data)
+}
+#endif
+inline void Sequence::set_application_data(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  application_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:Kinova.Api.Base.Sequence.application_data)
+}
+inline void Sequence::set_application_data(const char* value, size_t size) {
+  
+  application_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:Kinova.Api.Base.Sequence.application_data)
+}
+inline ::std::string* Sequence::mutable_application_data() {
+  
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.Sequence.application_data)
+  return application_data_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* Sequence::release_application_data() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.Sequence.application_data)
+  
+  return application_data_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void Sequence::set_allocated_application_data(::std::string* application_data) {
+  if (application_data != NULL) {
+    
+  } else {
+    
+  }
+  application_data_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), application_data);
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.Sequence.application_data)
+}
+
+// repeated .Kinova.Api.Base.SequenceTask tasks = 4;
+inline int Sequence::tasks_size() const {
+  return tasks_.size();
+}
+inline void Sequence::clear_tasks() {
+  tasks_.Clear();
+}
+inline const ::Kinova::Api::Base::SequenceTask& Sequence::tasks(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Sequence.tasks)
+  return tasks_.Get(index);
+}
+inline ::Kinova::Api::Base::SequenceTask* Sequence::mutable_tasks(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.Sequence.tasks)
+  return tasks_.Mutable(index);
+}
+inline ::Kinova::Api::Base::SequenceTask* Sequence::add_tasks() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.Base.Sequence.tasks)
+  return tasks_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::SequenceTask >*
+Sequence::mutable_tasks() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.Base.Sequence.tasks)
+  return &tasks_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::SequenceTask >&
+Sequence::tasks() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.Base.Sequence.tasks)
+  return tasks_;
+}
+
+// -------------------------------------------------------------------
+
+// SequenceList
+
+// repeated .Kinova.Api.Base.Sequence sequence_list = 1;
+inline int SequenceList::sequence_list_size() const {
+  return sequence_list_.size();
+}
+inline void SequenceList::clear_sequence_list() {
+  sequence_list_.Clear();
+}
+inline const ::Kinova::Api::Base::Sequence& SequenceList::sequence_list(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.SequenceList.sequence_list)
+  return sequence_list_.Get(index);
+}
+inline ::Kinova::Api::Base::Sequence* SequenceList::mutable_sequence_list(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.SequenceList.sequence_list)
+  return sequence_list_.Mutable(index);
+}
+inline ::Kinova::Api::Base::Sequence* SequenceList::add_sequence_list() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.Base.SequenceList.sequence_list)
+  return sequence_list_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::Sequence >*
+SequenceList::mutable_sequence_list() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.Base.SequenceList.sequence_list)
+  return &sequence_list_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::Sequence >&
+SequenceList::sequence_list() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.Base.SequenceList.sequence_list)
+  return sequence_list_;
+}
+
+// -------------------------------------------------------------------
+
+// ActionHandle
+
+// uint32 identifier = 1;
+inline void ActionHandle::clear_identifier() {
+  identifier_ = 0u;
+}
+inline ::google::protobuf::uint32 ActionHandle::identifier() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ActionHandle.identifier)
+  return identifier_;
+}
+inline void ActionHandle::set_identifier(::google::protobuf::uint32 value) {
+  
+  identifier_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.ActionHandle.identifier)
+}
+
+// .Kinova.Api.Base.ActionType action_type = 2;
+inline void ActionHandle::clear_action_type() {
+  action_type_ = 0;
+}
+inline ::Kinova::Api::Base::ActionType ActionHandle::action_type() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ActionHandle.action_type)
+  return static_cast< ::Kinova::Api::Base::ActionType >(action_type_);
+}
+inline void ActionHandle::set_action_type(::Kinova::Api::Base::ActionType value) {
+  
+  action_type_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.ActionHandle.action_type)
+}
+
+// fixed32 permission = 3;
+inline void ActionHandle::clear_permission() {
+  permission_ = 0u;
+}
+inline ::google::protobuf::uint32 ActionHandle::permission() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ActionHandle.permission)
+  return permission_;
+}
+inline void ActionHandle::set_permission(::google::protobuf::uint32 value) {
+  
+  permission_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.ActionHandle.permission)
+}
+
+// -------------------------------------------------------------------
+
+// RequestedActionType
+
+// .Kinova.Api.Base.ActionType action_type = 1;
+inline void RequestedActionType::clear_action_type() {
+  action_type_ = 0;
+}
+inline ::Kinova::Api::Base::ActionType RequestedActionType::action_type() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.RequestedActionType.action_type)
+  return static_cast< ::Kinova::Api::Base::ActionType >(action_type_);
+}
+inline void RequestedActionType::set_action_type(::Kinova::Api::Base::ActionType value) {
+  
+  action_type_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.RequestedActionType.action_type)
+}
+
+// -------------------------------------------------------------------
+
+// Action
+
+// .Kinova.Api.Base.ActionHandle handle = 1;
+inline bool Action::has_handle() const {
+  return this != internal_default_instance() && handle_ != NULL;
+}
+inline void Action::clear_handle() {
+  if (GetArenaNoVirtual() == NULL && handle_ != NULL) {
+    delete handle_;
+  }
+  handle_ = NULL;
+}
+inline const ::Kinova::Api::Base::ActionHandle& Action::handle() const {
+  const ::Kinova::Api::Base::ActionHandle* p = handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Action.handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::ActionHandle*>(
+      &::Kinova::Api::Base::_ActionHandle_default_instance_);
+}
+inline ::Kinova::Api::Base::ActionHandle* Action::release_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.Action.handle)
+  
+  ::Kinova::Api::Base::ActionHandle* temp = handle_;
+  handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::ActionHandle* Action::mutable_handle() {
+  
+  if (handle_ == NULL) {
+    handle_ = new ::Kinova::Api::Base::ActionHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.Action.handle)
+  return handle_;
+}
+inline void Action::set_allocated_handle(::Kinova::Api::Base::ActionHandle* handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete handle_;
+  }
+  if (handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  handle_ = handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.Action.handle)
+}
+
+// string name = 2;
+inline void Action::clear_name() {
+  name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& Action::name() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Action.name)
+  return name_.GetNoArena();
+}
+inline void Action::set_name(const ::std::string& value) {
+  
+  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.Action.name)
+}
+#if LANG_CXX11
+inline void Action::set_name(::std::string&& value) {
+  
+  name_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:Kinova.Api.Base.Action.name)
+}
+#endif
+inline void Action::set_name(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:Kinova.Api.Base.Action.name)
+}
+inline void Action::set_name(const char* value, size_t size) {
+  
+  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:Kinova.Api.Base.Action.name)
+}
+inline ::std::string* Action::mutable_name() {
+  
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.Action.name)
+  return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* Action::release_name() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.Action.name)
+  
+  return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void Action::set_allocated_name(::std::string* name) {
+  if (name != NULL) {
+    
+  } else {
+    
+  }
+  name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.Action.name)
+}
+
+// string application_data = 3;
+inline void Action::clear_application_data() {
+  application_data_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& Action::application_data() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Action.application_data)
+  return application_data_.GetNoArena();
+}
+inline void Action::set_application_data(const ::std::string& value) {
+  
+  application_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.Action.application_data)
+}
+#if LANG_CXX11
+inline void Action::set_application_data(::std::string&& value) {
+  
+  application_data_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:Kinova.Api.Base.Action.application_data)
+}
+#endif
+inline void Action::set_application_data(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  application_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:Kinova.Api.Base.Action.application_data)
+}
+inline void Action::set_application_data(const char* value, size_t size) {
+  
+  application_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:Kinova.Api.Base.Action.application_data)
+}
+inline ::std::string* Action::mutable_application_data() {
+  
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.Action.application_data)
+  return application_data_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* Action::release_application_data() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.Action.application_data)
+  
+  return application_data_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void Action::set_allocated_application_data(::std::string* application_data) {
+  if (application_data != NULL) {
+    
+  } else {
+    
+  }
+  application_data_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), application_data);
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.Action.application_data)
+}
+
+// .Kinova.Api.Base.TwistCommand send_twist_command = 4;
+inline bool Action::has_send_twist_command() const {
+  return action_parameters_case() == kSendTwistCommand;
+}
+inline void Action::set_has_send_twist_command() {
+  _oneof_case_[0] = kSendTwistCommand;
+}
+inline void Action::clear_send_twist_command() {
+  if (has_send_twist_command()) {
+    delete action_parameters_.send_twist_command_;
+    clear_has_action_parameters();
+  }
+}
+inline ::Kinova::Api::Base::TwistCommand* Action::release_send_twist_command() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.Action.send_twist_command)
+  if (has_send_twist_command()) {
+    clear_has_action_parameters();
+      ::Kinova::Api::Base::TwistCommand* temp = action_parameters_.send_twist_command_;
+    action_parameters_.send_twist_command_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline const ::Kinova::Api::Base::TwistCommand& Action::send_twist_command() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Action.send_twist_command)
+  return has_send_twist_command()
+      ? *action_parameters_.send_twist_command_
+      : *reinterpret_cast< ::Kinova::Api::Base::TwistCommand*>(&::Kinova::Api::Base::_TwistCommand_default_instance_);
+}
+inline ::Kinova::Api::Base::TwistCommand* Action::mutable_send_twist_command() {
+  if (!has_send_twist_command()) {
+    clear_action_parameters();
+    set_has_send_twist_command();
+    action_parameters_.send_twist_command_ = new ::Kinova::Api::Base::TwistCommand;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.Action.send_twist_command)
+  return action_parameters_.send_twist_command_;
+}
+
+// .Kinova.Api.Base.WrenchCommand send_wrench_command = 5;
+inline bool Action::has_send_wrench_command() const {
+  return action_parameters_case() == kSendWrenchCommand;
+}
+inline void Action::set_has_send_wrench_command() {
+  _oneof_case_[0] = kSendWrenchCommand;
+}
+inline void Action::clear_send_wrench_command() {
+  if (has_send_wrench_command()) {
+    delete action_parameters_.send_wrench_command_;
+    clear_has_action_parameters();
+  }
+}
+inline ::Kinova::Api::Base::WrenchCommand* Action::release_send_wrench_command() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.Action.send_wrench_command)
+  if (has_send_wrench_command()) {
+    clear_has_action_parameters();
+      ::Kinova::Api::Base::WrenchCommand* temp = action_parameters_.send_wrench_command_;
+    action_parameters_.send_wrench_command_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline const ::Kinova::Api::Base::WrenchCommand& Action::send_wrench_command() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Action.send_wrench_command)
+  return has_send_wrench_command()
+      ? *action_parameters_.send_wrench_command_
+      : *reinterpret_cast< ::Kinova::Api::Base::WrenchCommand*>(&::Kinova::Api::Base::_WrenchCommand_default_instance_);
+}
+inline ::Kinova::Api::Base::WrenchCommand* Action::mutable_send_wrench_command() {
+  if (!has_send_wrench_command()) {
+    clear_action_parameters();
+    set_has_send_wrench_command();
+    action_parameters_.send_wrench_command_ = new ::Kinova::Api::Base::WrenchCommand;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.Action.send_wrench_command)
+  return action_parameters_.send_wrench_command_;
+}
+
+// .Kinova.Api.Base.JointSpeeds send_joint_speeds = 7;
+inline bool Action::has_send_joint_speeds() const {
+  return action_parameters_case() == kSendJointSpeeds;
+}
+inline void Action::set_has_send_joint_speeds() {
+  _oneof_case_[0] = kSendJointSpeeds;
+}
+inline void Action::clear_send_joint_speeds() {
+  if (has_send_joint_speeds()) {
+    delete action_parameters_.send_joint_speeds_;
+    clear_has_action_parameters();
+  }
+}
+inline ::Kinova::Api::Base::JointSpeeds* Action::release_send_joint_speeds() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.Action.send_joint_speeds)
+  if (has_send_joint_speeds()) {
+    clear_has_action_parameters();
+      ::Kinova::Api::Base::JointSpeeds* temp = action_parameters_.send_joint_speeds_;
+    action_parameters_.send_joint_speeds_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline const ::Kinova::Api::Base::JointSpeeds& Action::send_joint_speeds() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Action.send_joint_speeds)
+  return has_send_joint_speeds()
+      ? *action_parameters_.send_joint_speeds_
+      : *reinterpret_cast< ::Kinova::Api::Base::JointSpeeds*>(&::Kinova::Api::Base::_JointSpeeds_default_instance_);
+}
+inline ::Kinova::Api::Base::JointSpeeds* Action::mutable_send_joint_speeds() {
+  if (!has_send_joint_speeds()) {
+    clear_action_parameters();
+    set_has_send_joint_speeds();
+    action_parameters_.send_joint_speeds_ = new ::Kinova::Api::Base::JointSpeeds;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.Action.send_joint_speeds)
+  return action_parameters_.send_joint_speeds_;
+}
+
+// .Kinova.Api.Base.ConstrainedPose reach_pose = 9;
+inline bool Action::has_reach_pose() const {
+  return action_parameters_case() == kReachPose;
+}
+inline void Action::set_has_reach_pose() {
+  _oneof_case_[0] = kReachPose;
+}
+inline void Action::clear_reach_pose() {
+  if (has_reach_pose()) {
+    delete action_parameters_.reach_pose_;
+    clear_has_action_parameters();
+  }
+}
+inline ::Kinova::Api::Base::ConstrainedPose* Action::release_reach_pose() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.Action.reach_pose)
+  if (has_reach_pose()) {
+    clear_has_action_parameters();
+      ::Kinova::Api::Base::ConstrainedPose* temp = action_parameters_.reach_pose_;
+    action_parameters_.reach_pose_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline const ::Kinova::Api::Base::ConstrainedPose& Action::reach_pose() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Action.reach_pose)
+  return has_reach_pose()
+      ? *action_parameters_.reach_pose_
+      : *reinterpret_cast< ::Kinova::Api::Base::ConstrainedPose*>(&::Kinova::Api::Base::_ConstrainedPose_default_instance_);
+}
+inline ::Kinova::Api::Base::ConstrainedPose* Action::mutable_reach_pose() {
+  if (!has_reach_pose()) {
+    clear_action_parameters();
+    set_has_reach_pose();
+    action_parameters_.reach_pose_ = new ::Kinova::Api::Base::ConstrainedPose;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.Action.reach_pose)
+  return action_parameters_.reach_pose_;
+}
+
+// .Kinova.Api.Base.ConstrainedJointAngles reach_joint_angles = 10;
+inline bool Action::has_reach_joint_angles() const {
+  return action_parameters_case() == kReachJointAngles;
+}
+inline void Action::set_has_reach_joint_angles() {
+  _oneof_case_[0] = kReachJointAngles;
+}
+inline void Action::clear_reach_joint_angles() {
+  if (has_reach_joint_angles()) {
+    delete action_parameters_.reach_joint_angles_;
+    clear_has_action_parameters();
+  }
+}
+inline ::Kinova::Api::Base::ConstrainedJointAngles* Action::release_reach_joint_angles() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.Action.reach_joint_angles)
+  if (has_reach_joint_angles()) {
+    clear_has_action_parameters();
+      ::Kinova::Api::Base::ConstrainedJointAngles* temp = action_parameters_.reach_joint_angles_;
+    action_parameters_.reach_joint_angles_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline const ::Kinova::Api::Base::ConstrainedJointAngles& Action::reach_joint_angles() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Action.reach_joint_angles)
+  return has_reach_joint_angles()
+      ? *action_parameters_.reach_joint_angles_
+      : *reinterpret_cast< ::Kinova::Api::Base::ConstrainedJointAngles*>(&::Kinova::Api::Base::_ConstrainedJointAngles_default_instance_);
+}
+inline ::Kinova::Api::Base::ConstrainedJointAngles* Action::mutable_reach_joint_angles() {
+  if (!has_reach_joint_angles()) {
+    clear_action_parameters();
+    set_has_reach_joint_angles();
+    action_parameters_.reach_joint_angles_ = new ::Kinova::Api::Base::ConstrainedJointAngles;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.Action.reach_joint_angles)
+  return action_parameters_.reach_joint_angles_;
+}
+
+// .Kinova.Api.Base.AdmittanceMode toggle_admittance_mode = 16;
+inline bool Action::has_toggle_admittance_mode() const {
+  return action_parameters_case() == kToggleAdmittanceMode;
+}
+inline void Action::set_has_toggle_admittance_mode() {
+  _oneof_case_[0] = kToggleAdmittanceMode;
+}
+inline void Action::clear_toggle_admittance_mode() {
+  if (has_toggle_admittance_mode()) {
+    action_parameters_.toggle_admittance_mode_ = 0;
+    clear_has_action_parameters();
+  }
+}
+inline ::Kinova::Api::Base::AdmittanceMode Action::toggle_admittance_mode() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Action.toggle_admittance_mode)
+  if (has_toggle_admittance_mode()) {
+    return static_cast< ::Kinova::Api::Base::AdmittanceMode >(action_parameters_.toggle_admittance_mode_);
+  }
+  return static_cast< ::Kinova::Api::Base::AdmittanceMode >(0);
+}
+inline void Action::set_toggle_admittance_mode(::Kinova::Api::Base::AdmittanceMode value) {
+  if (!has_toggle_admittance_mode()) {
+    clear_action_parameters();
+    set_has_toggle_admittance_mode();
+  }
+  action_parameters_.toggle_admittance_mode_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.Action.toggle_admittance_mode)
+}
+
+// .Kinova.Api.Base.Snapshot snapshot = 17;
+inline bool Action::has_snapshot() const {
+  return action_parameters_case() == kSnapshot;
+}
+inline void Action::set_has_snapshot() {
+  _oneof_case_[0] = kSnapshot;
+}
+inline void Action::clear_snapshot() {
+  if (has_snapshot()) {
+    delete action_parameters_.snapshot_;
+    clear_has_action_parameters();
+  }
+}
+inline ::Kinova::Api::Base::Snapshot* Action::release_snapshot() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.Action.snapshot)
+  if (has_snapshot()) {
+    clear_has_action_parameters();
+      ::Kinova::Api::Base::Snapshot* temp = action_parameters_.snapshot_;
+    action_parameters_.snapshot_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline const ::Kinova::Api::Base::Snapshot& Action::snapshot() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Action.snapshot)
+  return has_snapshot()
+      ? *action_parameters_.snapshot_
+      : *reinterpret_cast< ::Kinova::Api::Base::Snapshot*>(&::Kinova::Api::Base::_Snapshot_default_instance_);
+}
+inline ::Kinova::Api::Base::Snapshot* Action::mutable_snapshot() {
+  if (!has_snapshot()) {
+    clear_action_parameters();
+    set_has_snapshot();
+    action_parameters_.snapshot_ = new ::Kinova::Api::Base::Snapshot;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.Action.snapshot)
+  return action_parameters_.snapshot_;
+}
+
+// .Kinova.Api.Base.SwitchControlMapping switch_control_mapping = 19;
+inline bool Action::has_switch_control_mapping() const {
+  return action_parameters_case() == kSwitchControlMapping;
+}
+inline void Action::set_has_switch_control_mapping() {
+  _oneof_case_[0] = kSwitchControlMapping;
+}
+inline void Action::clear_switch_control_mapping() {
+  if (has_switch_control_mapping()) {
+    delete action_parameters_.switch_control_mapping_;
+    clear_has_action_parameters();
+  }
+}
+inline ::Kinova::Api::Base::SwitchControlMapping* Action::release_switch_control_mapping() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.Action.switch_control_mapping)
+  if (has_switch_control_mapping()) {
+    clear_has_action_parameters();
+      ::Kinova::Api::Base::SwitchControlMapping* temp = action_parameters_.switch_control_mapping_;
+    action_parameters_.switch_control_mapping_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline const ::Kinova::Api::Base::SwitchControlMapping& Action::switch_control_mapping() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Action.switch_control_mapping)
+  return has_switch_control_mapping()
+      ? *action_parameters_.switch_control_mapping_
+      : *reinterpret_cast< ::Kinova::Api::Base::SwitchControlMapping*>(&::Kinova::Api::Base::_SwitchControlMapping_default_instance_);
+}
+inline ::Kinova::Api::Base::SwitchControlMapping* Action::mutable_switch_control_mapping() {
+  if (!has_switch_control_mapping()) {
+    clear_action_parameters();
+    set_has_switch_control_mapping();
+    action_parameters_.switch_control_mapping_ = new ::Kinova::Api::Base::SwitchControlMapping;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.Action.switch_control_mapping)
+  return action_parameters_.switch_control_mapping_;
+}
+
+// .Kinova.Api.Base.JointNavigationDirection navigate_joints = 20;
+inline bool Action::has_navigate_joints() const {
+  return action_parameters_case() == kNavigateJoints;
+}
+inline void Action::set_has_navigate_joints() {
+  _oneof_case_[0] = kNavigateJoints;
+}
+inline void Action::clear_navigate_joints() {
+  if (has_navigate_joints()) {
+    action_parameters_.navigate_joints_ = 0;
+    clear_has_action_parameters();
+  }
+}
+inline ::Kinova::Api::Base::JointNavigationDirection Action::navigate_joints() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Action.navigate_joints)
+  if (has_navigate_joints()) {
+    return static_cast< ::Kinova::Api::Base::JointNavigationDirection >(action_parameters_.navigate_joints_);
+  }
+  return static_cast< ::Kinova::Api::Base::JointNavigationDirection >(0);
+}
+inline void Action::set_navigate_joints(::Kinova::Api::Base::JointNavigationDirection value) {
+  if (!has_navigate_joints()) {
+    clear_action_parameters();
+    set_has_navigate_joints();
+  }
+  action_parameters_.navigate_joints_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.Action.navigate_joints)
+}
+
+// .Kinova.Api.Base.NavigationDirection navigate_mappings = 21;
+inline bool Action::has_navigate_mappings() const {
+  return action_parameters_case() == kNavigateMappings;
+}
+inline void Action::set_has_navigate_mappings() {
+  _oneof_case_[0] = kNavigateMappings;
+}
+inline void Action::clear_navigate_mappings() {
+  if (has_navigate_mappings()) {
+    action_parameters_.navigate_mappings_ = 0;
+    clear_has_action_parameters();
+  }
+}
+inline ::Kinova::Api::Base::NavigationDirection Action::navigate_mappings() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Action.navigate_mappings)
+  if (has_navigate_mappings()) {
+    return static_cast< ::Kinova::Api::Base::NavigationDirection >(action_parameters_.navigate_mappings_);
+  }
+  return static_cast< ::Kinova::Api::Base::NavigationDirection >(0);
+}
+inline void Action::set_navigate_mappings(::Kinova::Api::Base::NavigationDirection value) {
+  if (!has_navigate_mappings()) {
+    clear_action_parameters();
+    set_has_navigate_mappings();
+  }
+  action_parameters_.navigate_mappings_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.Action.navigate_mappings)
+}
+
+// .Kinova.Api.Base.ChangeTwist change_twist = 25;
+inline bool Action::has_change_twist() const {
+  return action_parameters_case() == kChangeTwist;
+}
+inline void Action::set_has_change_twist() {
+  _oneof_case_[0] = kChangeTwist;
+}
+inline void Action::clear_change_twist() {
+  if (has_change_twist()) {
+    delete action_parameters_.change_twist_;
+    clear_has_action_parameters();
+  }
+}
+inline ::Kinova::Api::Base::ChangeTwist* Action::release_change_twist() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.Action.change_twist)
+  if (has_change_twist()) {
+    clear_has_action_parameters();
+      ::Kinova::Api::Base::ChangeTwist* temp = action_parameters_.change_twist_;
+    action_parameters_.change_twist_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline const ::Kinova::Api::Base::ChangeTwist& Action::change_twist() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Action.change_twist)
+  return has_change_twist()
+      ? *action_parameters_.change_twist_
+      : *reinterpret_cast< ::Kinova::Api::Base::ChangeTwist*>(&::Kinova::Api::Base::_ChangeTwist_default_instance_);
+}
+inline ::Kinova::Api::Base::ChangeTwist* Action::mutable_change_twist() {
+  if (!has_change_twist()) {
+    clear_action_parameters();
+    set_has_change_twist();
+    action_parameters_.change_twist_ = new ::Kinova::Api::Base::ChangeTwist;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.Action.change_twist)
+  return action_parameters_.change_twist_;
+}
+
+// .Kinova.Api.Base.ChangeJointSpeeds change_joint_speeds = 26;
+inline bool Action::has_change_joint_speeds() const {
+  return action_parameters_case() == kChangeJointSpeeds;
+}
+inline void Action::set_has_change_joint_speeds() {
+  _oneof_case_[0] = kChangeJointSpeeds;
+}
+inline void Action::clear_change_joint_speeds() {
+  if (has_change_joint_speeds()) {
+    delete action_parameters_.change_joint_speeds_;
+    clear_has_action_parameters();
+  }
+}
+inline ::Kinova::Api::Base::ChangeJointSpeeds* Action::release_change_joint_speeds() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.Action.change_joint_speeds)
+  if (has_change_joint_speeds()) {
+    clear_has_action_parameters();
+      ::Kinova::Api::Base::ChangeJointSpeeds* temp = action_parameters_.change_joint_speeds_;
+    action_parameters_.change_joint_speeds_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline const ::Kinova::Api::Base::ChangeJointSpeeds& Action::change_joint_speeds() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Action.change_joint_speeds)
+  return has_change_joint_speeds()
+      ? *action_parameters_.change_joint_speeds_
+      : *reinterpret_cast< ::Kinova::Api::Base::ChangeJointSpeeds*>(&::Kinova::Api::Base::_ChangeJointSpeeds_default_instance_);
+}
+inline ::Kinova::Api::Base::ChangeJointSpeeds* Action::mutable_change_joint_speeds() {
+  if (!has_change_joint_speeds()) {
+    clear_action_parameters();
+    set_has_change_joint_speeds();
+    action_parameters_.change_joint_speeds_ = new ::Kinova::Api::Base::ChangeJointSpeeds;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.Action.change_joint_speeds)
+  return action_parameters_.change_joint_speeds_;
+}
+
+// .Kinova.Api.Base.ChangeWrench change_wrench = 28;
+inline bool Action::has_change_wrench() const {
+  return action_parameters_case() == kChangeWrench;
+}
+inline void Action::set_has_change_wrench() {
+  _oneof_case_[0] = kChangeWrench;
+}
+inline void Action::clear_change_wrench() {
+  if (has_change_wrench()) {
+    delete action_parameters_.change_wrench_;
+    clear_has_action_parameters();
+  }
+}
+inline ::Kinova::Api::Base::ChangeWrench* Action::release_change_wrench() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.Action.change_wrench)
+  if (has_change_wrench()) {
+    clear_has_action_parameters();
+      ::Kinova::Api::Base::ChangeWrench* temp = action_parameters_.change_wrench_;
+    action_parameters_.change_wrench_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline const ::Kinova::Api::Base::ChangeWrench& Action::change_wrench() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Action.change_wrench)
+  return has_change_wrench()
+      ? *action_parameters_.change_wrench_
+      : *reinterpret_cast< ::Kinova::Api::Base::ChangeWrench*>(&::Kinova::Api::Base::_ChangeWrench_default_instance_);
+}
+inline ::Kinova::Api::Base::ChangeWrench* Action::mutable_change_wrench() {
+  if (!has_change_wrench()) {
+    clear_action_parameters();
+    set_has_change_wrench();
+    action_parameters_.change_wrench_ = new ::Kinova::Api::Base::ChangeWrench;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.Action.change_wrench)
+  return action_parameters_.change_wrench_;
+}
+
+// .Kinova.Api.Base.EmergencyStop apply_emergency_stop = 31;
+inline bool Action::has_apply_emergency_stop() const {
+  return action_parameters_case() == kApplyEmergencyStop;
+}
+inline void Action::set_has_apply_emergency_stop() {
+  _oneof_case_[0] = kApplyEmergencyStop;
+}
+inline void Action::clear_apply_emergency_stop() {
+  if (has_apply_emergency_stop()) {
+    delete action_parameters_.apply_emergency_stop_;
+    clear_has_action_parameters();
+  }
+}
+inline ::Kinova::Api::Base::EmergencyStop* Action::release_apply_emergency_stop() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.Action.apply_emergency_stop)
+  if (has_apply_emergency_stop()) {
+    clear_has_action_parameters();
+      ::Kinova::Api::Base::EmergencyStop* temp = action_parameters_.apply_emergency_stop_;
+    action_parameters_.apply_emergency_stop_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline const ::Kinova::Api::Base::EmergencyStop& Action::apply_emergency_stop() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Action.apply_emergency_stop)
+  return has_apply_emergency_stop()
+      ? *action_parameters_.apply_emergency_stop_
+      : *reinterpret_cast< ::Kinova::Api::Base::EmergencyStop*>(&::Kinova::Api::Base::_EmergencyStop_default_instance_);
+}
+inline ::Kinova::Api::Base::EmergencyStop* Action::mutable_apply_emergency_stop() {
+  if (!has_apply_emergency_stop()) {
+    clear_action_parameters();
+    set_has_apply_emergency_stop();
+    action_parameters_.apply_emergency_stop_ = new ::Kinova::Api::Base::EmergencyStop;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.Action.apply_emergency_stop)
+  return action_parameters_.apply_emergency_stop_;
+}
+
+// .Kinova.Api.Base.Faults clear_faults = 32;
+inline bool Action::has_clear_faults() const {
+  return action_parameters_case() == kClearFaults;
+}
+inline void Action::set_has_clear_faults() {
+  _oneof_case_[0] = kClearFaults;
+}
+inline void Action::clear_clear_faults() {
+  if (has_clear_faults()) {
+    delete action_parameters_.clear_faults_;
+    clear_has_action_parameters();
+  }
+}
+inline ::Kinova::Api::Base::Faults* Action::release_clear_faults() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.Action.clear_faults)
+  if (has_clear_faults()) {
+    clear_has_action_parameters();
+      ::Kinova::Api::Base::Faults* temp = action_parameters_.clear_faults_;
+    action_parameters_.clear_faults_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline const ::Kinova::Api::Base::Faults& Action::clear_faults() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Action.clear_faults)
+  return has_clear_faults()
+      ? *action_parameters_.clear_faults_
+      : *reinterpret_cast< ::Kinova::Api::Base::Faults*>(&::Kinova::Api::Base::_Faults_default_instance_);
+}
+inline ::Kinova::Api::Base::Faults* Action::mutable_clear_faults() {
+  if (!has_clear_faults()) {
+    clear_action_parameters();
+    set_has_clear_faults();
+    action_parameters_.clear_faults_ = new ::Kinova::Api::Base::Faults;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.Action.clear_faults)
+  return action_parameters_.clear_faults_;
+}
+
+// .Kinova.Api.Base.Delay delay = 34;
+inline bool Action::has_delay() const {
+  return action_parameters_case() == kDelay;
+}
+inline void Action::set_has_delay() {
+  _oneof_case_[0] = kDelay;
+}
+inline void Action::clear_delay() {
+  if (has_delay()) {
+    delete action_parameters_.delay_;
+    clear_has_action_parameters();
+  }
+}
+inline ::Kinova::Api::Base::Delay* Action::release_delay() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.Action.delay)
+  if (has_delay()) {
+    clear_has_action_parameters();
+      ::Kinova::Api::Base::Delay* temp = action_parameters_.delay_;
+    action_parameters_.delay_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline const ::Kinova::Api::Base::Delay& Action::delay() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Action.delay)
+  return has_delay()
+      ? *action_parameters_.delay_
+      : *reinterpret_cast< ::Kinova::Api::Base::Delay*>(&::Kinova::Api::Base::_Delay_default_instance_);
+}
+inline ::Kinova::Api::Base::Delay* Action::mutable_delay() {
+  if (!has_delay()) {
+    clear_action_parameters();
+    set_has_delay();
+    action_parameters_.delay_ = new ::Kinova::Api::Base::Delay;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.Action.delay)
+  return action_parameters_.delay_;
+}
+
+// .Kinova.Api.Base.ActionHandle execute_action = 35;
+inline bool Action::has_execute_action() const {
+  return action_parameters_case() == kExecuteAction;
+}
+inline void Action::set_has_execute_action() {
+  _oneof_case_[0] = kExecuteAction;
+}
+inline void Action::clear_execute_action() {
+  if (has_execute_action()) {
+    delete action_parameters_.execute_action_;
+    clear_has_action_parameters();
+  }
+}
+inline ::Kinova::Api::Base::ActionHandle* Action::release_execute_action() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.Action.execute_action)
+  if (has_execute_action()) {
+    clear_has_action_parameters();
+      ::Kinova::Api::Base::ActionHandle* temp = action_parameters_.execute_action_;
+    action_parameters_.execute_action_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline const ::Kinova::Api::Base::ActionHandle& Action::execute_action() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Action.execute_action)
+  return has_execute_action()
+      ? *action_parameters_.execute_action_
+      : *reinterpret_cast< ::Kinova::Api::Base::ActionHandle*>(&::Kinova::Api::Base::_ActionHandle_default_instance_);
+}
+inline ::Kinova::Api::Base::ActionHandle* Action::mutable_execute_action() {
+  if (!has_execute_action()) {
+    clear_action_parameters();
+    set_has_execute_action();
+    action_parameters_.execute_action_ = new ::Kinova::Api::Base::ActionHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.Action.execute_action)
+  return action_parameters_.execute_action_;
+}
+
+// .Kinova.Api.Base.GripperCommand send_gripper_command = 36;
+inline bool Action::has_send_gripper_command() const {
+  return action_parameters_case() == kSendGripperCommand;
+}
+inline void Action::set_has_send_gripper_command() {
+  _oneof_case_[0] = kSendGripperCommand;
+}
+inline void Action::clear_send_gripper_command() {
+  if (has_send_gripper_command()) {
+    delete action_parameters_.send_gripper_command_;
+    clear_has_action_parameters();
+  }
+}
+inline ::Kinova::Api::Base::GripperCommand* Action::release_send_gripper_command() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.Action.send_gripper_command)
+  if (has_send_gripper_command()) {
+    clear_has_action_parameters();
+      ::Kinova::Api::Base::GripperCommand* temp = action_parameters_.send_gripper_command_;
+    action_parameters_.send_gripper_command_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline const ::Kinova::Api::Base::GripperCommand& Action::send_gripper_command() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Action.send_gripper_command)
+  return has_send_gripper_command()
+      ? *action_parameters_.send_gripper_command_
+      : *reinterpret_cast< ::Kinova::Api::Base::GripperCommand*>(&::Kinova::Api::Base::_GripperCommand_default_instance_);
+}
+inline ::Kinova::Api::Base::GripperCommand* Action::mutable_send_gripper_command() {
+  if (!has_send_gripper_command()) {
+    clear_action_parameters();
+    set_has_send_gripper_command();
+    action_parameters_.send_gripper_command_ = new ::Kinova::Api::Base::GripperCommand;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.Action.send_gripper_command)
+  return action_parameters_.send_gripper_command_;
+}
+
+// .Kinova.Api.Base.GpioCommand send_gpio_command = 37;
+inline bool Action::has_send_gpio_command() const {
+  return action_parameters_case() == kSendGpioCommand;
+}
+inline void Action::set_has_send_gpio_command() {
+  _oneof_case_[0] = kSendGpioCommand;
+}
+inline void Action::clear_send_gpio_command() {
+  if (has_send_gpio_command()) {
+    delete action_parameters_.send_gpio_command_;
+    clear_has_action_parameters();
+  }
+}
+inline ::Kinova::Api::Base::GpioCommand* Action::release_send_gpio_command() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.Action.send_gpio_command)
+  if (has_send_gpio_command()) {
+    clear_has_action_parameters();
+      ::Kinova::Api::Base::GpioCommand* temp = action_parameters_.send_gpio_command_;
+    action_parameters_.send_gpio_command_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline const ::Kinova::Api::Base::GpioCommand& Action::send_gpio_command() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Action.send_gpio_command)
+  return has_send_gpio_command()
+      ? *action_parameters_.send_gpio_command_
+      : *reinterpret_cast< ::Kinova::Api::Base::GpioCommand*>(&::Kinova::Api::Base::_GpioCommand_default_instance_);
+}
+inline ::Kinova::Api::Base::GpioCommand* Action::mutable_send_gpio_command() {
+  if (!has_send_gpio_command()) {
+    clear_action_parameters();
+    set_has_send_gpio_command();
+    action_parameters_.send_gpio_command_ = new ::Kinova::Api::Base::GpioCommand;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.Action.send_gpio_command)
+  return action_parameters_.send_gpio_command_;
+}
+
+// .Kinova.Api.Base.Stop stop_action = 38;
+inline bool Action::has_stop_action() const {
+  return action_parameters_case() == kStopAction;
+}
+inline void Action::set_has_stop_action() {
+  _oneof_case_[0] = kStopAction;
+}
+inline void Action::clear_stop_action() {
+  if (has_stop_action()) {
+    delete action_parameters_.stop_action_;
+    clear_has_action_parameters();
+  }
+}
+inline ::Kinova::Api::Base::Stop* Action::release_stop_action() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.Action.stop_action)
+  if (has_stop_action()) {
+    clear_has_action_parameters();
+      ::Kinova::Api::Base::Stop* temp = action_parameters_.stop_action_;
+    action_parameters_.stop_action_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline const ::Kinova::Api::Base::Stop& Action::stop_action() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Action.stop_action)
+  return has_stop_action()
+      ? *action_parameters_.stop_action_
+      : *reinterpret_cast< ::Kinova::Api::Base::Stop*>(&::Kinova::Api::Base::_Stop_default_instance_);
+}
+inline ::Kinova::Api::Base::Stop* Action::mutable_stop_action() {
+  if (!has_stop_action()) {
+    clear_action_parameters();
+    set_has_stop_action();
+    action_parameters_.stop_action_ = new ::Kinova::Api::Base::Stop;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.Action.stop_action)
+  return action_parameters_.stop_action_;
+}
+
+// .Kinova.Api.Base.PreComputedJointTrajectory play_pre_computed_trajectory = 39;
+inline bool Action::has_play_pre_computed_trajectory() const {
+  return action_parameters_case() == kPlayPreComputedTrajectory;
+}
+inline void Action::set_has_play_pre_computed_trajectory() {
+  _oneof_case_[0] = kPlayPreComputedTrajectory;
+}
+inline void Action::clear_play_pre_computed_trajectory() {
+  if (has_play_pre_computed_trajectory()) {
+    delete action_parameters_.play_pre_computed_trajectory_;
+    clear_has_action_parameters();
+  }
+}
+inline ::Kinova::Api::Base::PreComputedJointTrajectory* Action::release_play_pre_computed_trajectory() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.Action.play_pre_computed_trajectory)
+  if (has_play_pre_computed_trajectory()) {
+    clear_has_action_parameters();
+      ::Kinova::Api::Base::PreComputedJointTrajectory* temp = action_parameters_.play_pre_computed_trajectory_;
+    action_parameters_.play_pre_computed_trajectory_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline const ::Kinova::Api::Base::PreComputedJointTrajectory& Action::play_pre_computed_trajectory() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Action.play_pre_computed_trajectory)
+  return has_play_pre_computed_trajectory()
+      ? *action_parameters_.play_pre_computed_trajectory_
+      : *reinterpret_cast< ::Kinova::Api::Base::PreComputedJointTrajectory*>(&::Kinova::Api::Base::_PreComputedJointTrajectory_default_instance_);
+}
+inline ::Kinova::Api::Base::PreComputedJointTrajectory* Action::mutable_play_pre_computed_trajectory() {
+  if (!has_play_pre_computed_trajectory()) {
+    clear_action_parameters();
+    set_has_play_pre_computed_trajectory();
+    action_parameters_.play_pre_computed_trajectory_ = new ::Kinova::Api::Base::PreComputedJointTrajectory;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.Action.play_pre_computed_trajectory)
+  return action_parameters_.play_pre_computed_trajectory_;
+}
+
+// .Kinova.Api.Base.SequenceHandle execute_sequence = 40;
+inline bool Action::has_execute_sequence() const {
+  return action_parameters_case() == kExecuteSequence;
+}
+inline void Action::set_has_execute_sequence() {
+  _oneof_case_[0] = kExecuteSequence;
+}
+inline void Action::clear_execute_sequence() {
+  if (has_execute_sequence()) {
+    delete action_parameters_.execute_sequence_;
+    clear_has_action_parameters();
+  }
+}
+inline ::Kinova::Api::Base::SequenceHandle* Action::release_execute_sequence() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.Action.execute_sequence)
+  if (has_execute_sequence()) {
+    clear_has_action_parameters();
+      ::Kinova::Api::Base::SequenceHandle* temp = action_parameters_.execute_sequence_;
+    action_parameters_.execute_sequence_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline const ::Kinova::Api::Base::SequenceHandle& Action::execute_sequence() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Action.execute_sequence)
+  return has_execute_sequence()
+      ? *action_parameters_.execute_sequence_
+      : *reinterpret_cast< ::Kinova::Api::Base::SequenceHandle*>(&::Kinova::Api::Base::_SequenceHandle_default_instance_);
+}
+inline ::Kinova::Api::Base::SequenceHandle* Action::mutable_execute_sequence() {
+  if (!has_execute_sequence()) {
+    clear_action_parameters();
+    set_has_execute_sequence();
+    action_parameters_.execute_sequence_ = new ::Kinova::Api::Base::SequenceHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.Action.execute_sequence)
+  return action_parameters_.execute_sequence_;
+}
+
+// .Kinova.Api.Base.WaypointList execute_waypoint_list = 41;
+inline bool Action::has_execute_waypoint_list() const {
+  return action_parameters_case() == kExecuteWaypointList;
+}
+inline void Action::set_has_execute_waypoint_list() {
+  _oneof_case_[0] = kExecuteWaypointList;
+}
+inline void Action::clear_execute_waypoint_list() {
+  if (has_execute_waypoint_list()) {
+    delete action_parameters_.execute_waypoint_list_;
+    clear_has_action_parameters();
+  }
+}
+inline ::Kinova::Api::Base::WaypointList* Action::release_execute_waypoint_list() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.Action.execute_waypoint_list)
+  if (has_execute_waypoint_list()) {
+    clear_has_action_parameters();
+      ::Kinova::Api::Base::WaypointList* temp = action_parameters_.execute_waypoint_list_;
+    action_parameters_.execute_waypoint_list_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline const ::Kinova::Api::Base::WaypointList& Action::execute_waypoint_list() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Action.execute_waypoint_list)
+  return has_execute_waypoint_list()
+      ? *action_parameters_.execute_waypoint_list_
+      : *reinterpret_cast< ::Kinova::Api::Base::WaypointList*>(&::Kinova::Api::Base::_WaypointList_default_instance_);
+}
+inline ::Kinova::Api::Base::WaypointList* Action::mutable_execute_waypoint_list() {
+  if (!has_execute_waypoint_list()) {
+    clear_action_parameters();
+    set_has_execute_waypoint_list();
+    action_parameters_.execute_waypoint_list_ = new ::Kinova::Api::Base::WaypointList;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.Action.execute_waypoint_list)
+  return action_parameters_.execute_waypoint_list_;
+}
+
+inline bool Action::has_action_parameters() const {
+  return action_parameters_case() != ACTION_PARAMETERS_NOT_SET;
+}
+inline void Action::clear_has_action_parameters() {
+  _oneof_case_[0] = ACTION_PARAMETERS_NOT_SET;
+}
+inline Action::ActionParametersCase Action::action_parameters_case() const {
+  return Action::ActionParametersCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// Snapshot
+
+// .Kinova.Api.Base.SnapshotType snapshot_type = 1;
+inline void Snapshot::clear_snapshot_type() {
+  snapshot_type_ = 0;
+}
+inline ::Kinova::Api::Base::SnapshotType Snapshot::snapshot_type() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Snapshot.snapshot_type)
+  return static_cast< ::Kinova::Api::Base::SnapshotType >(snapshot_type_);
+}
+inline void Snapshot::set_snapshot_type(::Kinova::Api::Base::SnapshotType value) {
+  
+  snapshot_type_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.Snapshot.snapshot_type)
+}
+
+// -------------------------------------------------------------------
+
+// SwitchControlMapping
+
+// uint32 controller_identifier = 1;
+inline void SwitchControlMapping::clear_controller_identifier() {
+  controller_identifier_ = 0u;
+}
+inline ::google::protobuf::uint32 SwitchControlMapping::controller_identifier() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.SwitchControlMapping.controller_identifier)
+  return controller_identifier_;
+}
+inline void SwitchControlMapping::set_controller_identifier(::google::protobuf::uint32 value) {
+  
+  controller_identifier_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.SwitchControlMapping.controller_identifier)
+}
+
+// .Kinova.Api.Base.MapGroupHandle map_group_handle = 2;
+inline bool SwitchControlMapping::has_map_group_handle() const {
+  return this != internal_default_instance() && map_group_handle_ != NULL;
+}
+inline void SwitchControlMapping::clear_map_group_handle() {
+  if (GetArenaNoVirtual() == NULL && map_group_handle_ != NULL) {
+    delete map_group_handle_;
+  }
+  map_group_handle_ = NULL;
+}
+inline const ::Kinova::Api::Base::MapGroupHandle& SwitchControlMapping::map_group_handle() const {
+  const ::Kinova::Api::Base::MapGroupHandle* p = map_group_handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.SwitchControlMapping.map_group_handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::MapGroupHandle*>(
+      &::Kinova::Api::Base::_MapGroupHandle_default_instance_);
+}
+inline ::Kinova::Api::Base::MapGroupHandle* SwitchControlMapping::release_map_group_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.SwitchControlMapping.map_group_handle)
+  
+  ::Kinova::Api::Base::MapGroupHandle* temp = map_group_handle_;
+  map_group_handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::MapGroupHandle* SwitchControlMapping::mutable_map_group_handle() {
+  
+  if (map_group_handle_ == NULL) {
+    map_group_handle_ = new ::Kinova::Api::Base::MapGroupHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.SwitchControlMapping.map_group_handle)
+  return map_group_handle_;
+}
+inline void SwitchControlMapping::set_allocated_map_group_handle(::Kinova::Api::Base::MapGroupHandle* map_group_handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete map_group_handle_;
+  }
+  if (map_group_handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      map_group_handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, map_group_handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  map_group_handle_ = map_group_handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.SwitchControlMapping.map_group_handle)
+}
+
+// .Kinova.Api.Base.MapHandle map_handle = 3;
+inline bool SwitchControlMapping::has_map_handle() const {
+  return this != internal_default_instance() && map_handle_ != NULL;
+}
+inline void SwitchControlMapping::clear_map_handle() {
+  if (GetArenaNoVirtual() == NULL && map_handle_ != NULL) {
+    delete map_handle_;
+  }
+  map_handle_ = NULL;
+}
+inline const ::Kinova::Api::Base::MapHandle& SwitchControlMapping::map_handle() const {
+  const ::Kinova::Api::Base::MapHandle* p = map_handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.SwitchControlMapping.map_handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::MapHandle*>(
+      &::Kinova::Api::Base::_MapHandle_default_instance_);
+}
+inline ::Kinova::Api::Base::MapHandle* SwitchControlMapping::release_map_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.SwitchControlMapping.map_handle)
+  
+  ::Kinova::Api::Base::MapHandle* temp = map_handle_;
+  map_handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::MapHandle* SwitchControlMapping::mutable_map_handle() {
+  
+  if (map_handle_ == NULL) {
+    map_handle_ = new ::Kinova::Api::Base::MapHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.SwitchControlMapping.map_handle)
+  return map_handle_;
+}
+inline void SwitchControlMapping::set_allocated_map_handle(::Kinova::Api::Base::MapHandle* map_handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete map_handle_;
+  }
+  if (map_handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      map_handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, map_handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  map_handle_ = map_handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.SwitchControlMapping.map_handle)
+}
+
+// -------------------------------------------------------------------
+
+// ChangeTwist
+
+// float linear = 1;
+inline void ChangeTwist::clear_linear() {
+  linear_ = 0;
+}
+inline float ChangeTwist::linear() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ChangeTwist.linear)
+  return linear_;
+}
+inline void ChangeTwist::set_linear(float value) {
+  
+  linear_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.ChangeTwist.linear)
+}
+
+// float angular = 2;
+inline void ChangeTwist::clear_angular() {
+  angular_ = 0;
+}
+inline float ChangeTwist::angular() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ChangeTwist.angular)
+  return angular_;
+}
+inline void ChangeTwist::set_angular(float value) {
+  
+  angular_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.ChangeTwist.angular)
+}
+
+// -------------------------------------------------------------------
+
+// ChangeJointSpeeds
+
+// .Kinova.Api.Base.JointSpeeds joint_speeds = 1;
+inline bool ChangeJointSpeeds::has_joint_speeds() const {
+  return this != internal_default_instance() && joint_speeds_ != NULL;
+}
+inline void ChangeJointSpeeds::clear_joint_speeds() {
+  if (GetArenaNoVirtual() == NULL && joint_speeds_ != NULL) {
+    delete joint_speeds_;
+  }
+  joint_speeds_ = NULL;
+}
+inline const ::Kinova::Api::Base::JointSpeeds& ChangeJointSpeeds::joint_speeds() const {
+  const ::Kinova::Api::Base::JointSpeeds* p = joint_speeds_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ChangeJointSpeeds.joint_speeds)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::JointSpeeds*>(
+      &::Kinova::Api::Base::_JointSpeeds_default_instance_);
+}
+inline ::Kinova::Api::Base::JointSpeeds* ChangeJointSpeeds::release_joint_speeds() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ChangeJointSpeeds.joint_speeds)
+  
+  ::Kinova::Api::Base::JointSpeeds* temp = joint_speeds_;
+  joint_speeds_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::JointSpeeds* ChangeJointSpeeds::mutable_joint_speeds() {
+  
+  if (joint_speeds_ == NULL) {
+    joint_speeds_ = new ::Kinova::Api::Base::JointSpeeds;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ChangeJointSpeeds.joint_speeds)
+  return joint_speeds_;
+}
+inline void ChangeJointSpeeds::set_allocated_joint_speeds(::Kinova::Api::Base::JointSpeeds* joint_speeds) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete joint_speeds_;
+  }
+  if (joint_speeds) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      joint_speeds = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, joint_speeds, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  joint_speeds_ = joint_speeds;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.ChangeJointSpeeds.joint_speeds)
+}
+
+// -------------------------------------------------------------------
+
+// ChangeWrench
+
+// float force = 1;
+inline void ChangeWrench::clear_force() {
+  force_ = 0;
+}
+inline float ChangeWrench::force() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ChangeWrench.force)
+  return force_;
+}
+inline void ChangeWrench::set_force(float value) {
+  
+  force_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.ChangeWrench.force)
+}
+
+// float torque = 2;
+inline void ChangeWrench::clear_torque() {
+  torque_ = 0;
+}
+inline float ChangeWrench::torque() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ChangeWrench.torque)
+  return torque_;
+}
+inline void ChangeWrench::set_torque(float value) {
+  
+  torque_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.ChangeWrench.torque)
+}
+
+// -------------------------------------------------------------------
+
+// EmergencyStop
+
+// -------------------------------------------------------------------
+
+// Faults
+
+// -------------------------------------------------------------------
+
+// Delay
+
+// uint32 duration = 1;
+inline void Delay::clear_duration() {
+  duration_ = 0u;
+}
+inline ::google::protobuf::uint32 Delay::duration() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Delay.duration)
+  return duration_;
+}
+inline void Delay::set_duration(::google::protobuf::uint32 value) {
+  
+  duration_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.Delay.duration)
+}
+
+// -------------------------------------------------------------------
+
+// Stop
+
+// -------------------------------------------------------------------
+
+// ActionList
+
+// repeated .Kinova.Api.Base.Action action_list = 1;
+inline int ActionList::action_list_size() const {
+  return action_list_.size();
+}
+inline void ActionList::clear_action_list() {
+  action_list_.Clear();
+}
+inline const ::Kinova::Api::Base::Action& ActionList::action_list(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ActionList.action_list)
+  return action_list_.Get(index);
+}
+inline ::Kinova::Api::Base::Action* ActionList::mutable_action_list(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ActionList.action_list)
+  return action_list_.Mutable(index);
+}
+inline ::Kinova::Api::Base::Action* ActionList::add_action_list() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.Base.ActionList.action_list)
+  return action_list_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::Action >*
+ActionList::mutable_action_list() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.Base.ActionList.action_list)
+  return &action_list_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::Action >&
+ActionList::action_list() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.Base.ActionList.action_list)
+  return action_list_;
+}
+
+// -------------------------------------------------------------------
+
+// Timeout
+
+// uint32 value = 1;
+inline void Timeout::clear_value() {
+  value_ = 0u;
+}
+inline ::google::protobuf::uint32 Timeout::value() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Timeout.value)
+  return value_;
+}
+inline void Timeout::set_value(::google::protobuf::uint32 value) {
+  
+  value_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.Timeout.value)
+}
+
+// -------------------------------------------------------------------
+
+// Ssid
+
+// string identifier = 1;
+inline void Ssid::clear_identifier() {
+  identifier_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& Ssid::identifier() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Ssid.identifier)
+  return identifier_.GetNoArena();
+}
+inline void Ssid::set_identifier(const ::std::string& value) {
+  
+  identifier_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.Ssid.identifier)
+}
+#if LANG_CXX11
+inline void Ssid::set_identifier(::std::string&& value) {
+  
+  identifier_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:Kinova.Api.Base.Ssid.identifier)
+}
+#endif
+inline void Ssid::set_identifier(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  identifier_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:Kinova.Api.Base.Ssid.identifier)
+}
+inline void Ssid::set_identifier(const char* value, size_t size) {
+  
+  identifier_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:Kinova.Api.Base.Ssid.identifier)
+}
+inline ::std::string* Ssid::mutable_identifier() {
+  
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.Ssid.identifier)
+  return identifier_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* Ssid::release_identifier() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.Ssid.identifier)
+  
+  return identifier_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void Ssid::set_allocated_identifier(::std::string* identifier) {
+  if (identifier != NULL) {
+    
+  } else {
+    
+  }
+  identifier_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), identifier);
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.Ssid.identifier)
+}
+
+// -------------------------------------------------------------------
+
+// CommunicationInterfaceConfiguration
+
+// .Kinova.Api.Base.NetworkType type = 1;
+inline void CommunicationInterfaceConfiguration::clear_type() {
+  type_ = 0;
+}
+inline ::Kinova::Api::Base::NetworkType CommunicationInterfaceConfiguration::type() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.CommunicationInterfaceConfiguration.type)
+  return static_cast< ::Kinova::Api::Base::NetworkType >(type_);
+}
+inline void CommunicationInterfaceConfiguration::set_type(::Kinova::Api::Base::NetworkType value) {
+  
+  type_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.CommunicationInterfaceConfiguration.type)
+}
+
+// bool enable = 2;
+inline void CommunicationInterfaceConfiguration::clear_enable() {
+  enable_ = false;
+}
+inline bool CommunicationInterfaceConfiguration::enable() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.CommunicationInterfaceConfiguration.enable)
+  return enable_;
+}
+inline void CommunicationInterfaceConfiguration::set_enable(bool value) {
+  
+  enable_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.CommunicationInterfaceConfiguration.enable)
+}
+
+// -------------------------------------------------------------------
+
+// NetworkHandle
+
+// .Kinova.Api.Base.NetworkType type = 1;
+inline void NetworkHandle::clear_type() {
+  type_ = 0;
+}
+inline ::Kinova::Api::Base::NetworkType NetworkHandle::type() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.NetworkHandle.type)
+  return static_cast< ::Kinova::Api::Base::NetworkType >(type_);
+}
+inline void NetworkHandle::set_type(::Kinova::Api::Base::NetworkType value) {
+  
+  type_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.NetworkHandle.type)
+}
+
+// -------------------------------------------------------------------
+
+// IPv4Configuration
+
+// uint32 ip_address = 1;
+inline void IPv4Configuration::clear_ip_address() {
+  ip_address_ = 0u;
+}
+inline ::google::protobuf::uint32 IPv4Configuration::ip_address() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.IPv4Configuration.ip_address)
+  return ip_address_;
+}
+inline void IPv4Configuration::set_ip_address(::google::protobuf::uint32 value) {
+  
+  ip_address_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.IPv4Configuration.ip_address)
+}
+
+// uint32 subnet_mask = 2;
+inline void IPv4Configuration::clear_subnet_mask() {
+  subnet_mask_ = 0u;
+}
+inline ::google::protobuf::uint32 IPv4Configuration::subnet_mask() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.IPv4Configuration.subnet_mask)
+  return subnet_mask_;
+}
+inline void IPv4Configuration::set_subnet_mask(::google::protobuf::uint32 value) {
+  
+  subnet_mask_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.IPv4Configuration.subnet_mask)
+}
+
+// uint32 default_gateway = 3;
+inline void IPv4Configuration::clear_default_gateway() {
+  default_gateway_ = 0u;
+}
+inline ::google::protobuf::uint32 IPv4Configuration::default_gateway() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.IPv4Configuration.default_gateway)
+  return default_gateway_;
+}
+inline void IPv4Configuration::set_default_gateway(::google::protobuf::uint32 value) {
+  
+  default_gateway_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.IPv4Configuration.default_gateway)
+}
+
+// bool dhcp_enabled = 4;
+inline void IPv4Configuration::clear_dhcp_enabled() {
+  dhcp_enabled_ = false;
+}
+inline bool IPv4Configuration::dhcp_enabled() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.IPv4Configuration.dhcp_enabled)
+  return dhcp_enabled_;
+}
+inline void IPv4Configuration::set_dhcp_enabled(bool value) {
+  
+  dhcp_enabled_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.IPv4Configuration.dhcp_enabled)
+}
+
+// -------------------------------------------------------------------
+
+// IPv4Information
+
+// uint32 ip_address = 1;
+inline void IPv4Information::clear_ip_address() {
+  ip_address_ = 0u;
+}
+inline ::google::protobuf::uint32 IPv4Information::ip_address() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.IPv4Information.ip_address)
+  return ip_address_;
+}
+inline void IPv4Information::set_ip_address(::google::protobuf::uint32 value) {
+  
+  ip_address_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.IPv4Information.ip_address)
+}
+
+// uint32 subnet_mask = 2;
+inline void IPv4Information::clear_subnet_mask() {
+  subnet_mask_ = 0u;
+}
+inline ::google::protobuf::uint32 IPv4Information::subnet_mask() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.IPv4Information.subnet_mask)
+  return subnet_mask_;
+}
+inline void IPv4Information::set_subnet_mask(::google::protobuf::uint32 value) {
+  
+  subnet_mask_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.IPv4Information.subnet_mask)
+}
+
+// uint32 default_gateway = 3;
+inline void IPv4Information::clear_default_gateway() {
+  default_gateway_ = 0u;
+}
+inline ::google::protobuf::uint32 IPv4Information::default_gateway() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.IPv4Information.default_gateway)
+  return default_gateway_;
+}
+inline void IPv4Information::set_default_gateway(::google::protobuf::uint32 value) {
+  
+  default_gateway_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.IPv4Information.default_gateway)
+}
+
+// -------------------------------------------------------------------
+
+// FullIPv4Configuration
+
+// .Kinova.Api.Base.NetworkHandle handle = 1;
+inline bool FullIPv4Configuration::has_handle() const {
+  return this != internal_default_instance() && handle_ != NULL;
+}
+inline void FullIPv4Configuration::clear_handle() {
+  if (GetArenaNoVirtual() == NULL && handle_ != NULL) {
+    delete handle_;
+  }
+  handle_ = NULL;
+}
+inline const ::Kinova::Api::Base::NetworkHandle& FullIPv4Configuration::handle() const {
+  const ::Kinova::Api::Base::NetworkHandle* p = handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.FullIPv4Configuration.handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::NetworkHandle*>(
+      &::Kinova::Api::Base::_NetworkHandle_default_instance_);
+}
+inline ::Kinova::Api::Base::NetworkHandle* FullIPv4Configuration::release_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.FullIPv4Configuration.handle)
+  
+  ::Kinova::Api::Base::NetworkHandle* temp = handle_;
+  handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::NetworkHandle* FullIPv4Configuration::mutable_handle() {
+  
+  if (handle_ == NULL) {
+    handle_ = new ::Kinova::Api::Base::NetworkHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.FullIPv4Configuration.handle)
+  return handle_;
+}
+inline void FullIPv4Configuration::set_allocated_handle(::Kinova::Api::Base::NetworkHandle* handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete handle_;
+  }
+  if (handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  handle_ = handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.FullIPv4Configuration.handle)
+}
+
+// .Kinova.Api.Base.IPv4Configuration ipv4_configuration = 2;
+inline bool FullIPv4Configuration::has_ipv4_configuration() const {
+  return this != internal_default_instance() && ipv4_configuration_ != NULL;
+}
+inline void FullIPv4Configuration::clear_ipv4_configuration() {
+  if (GetArenaNoVirtual() == NULL && ipv4_configuration_ != NULL) {
+    delete ipv4_configuration_;
+  }
+  ipv4_configuration_ = NULL;
+}
+inline const ::Kinova::Api::Base::IPv4Configuration& FullIPv4Configuration::ipv4_configuration() const {
+  const ::Kinova::Api::Base::IPv4Configuration* p = ipv4_configuration_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.FullIPv4Configuration.ipv4_configuration)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::IPv4Configuration*>(
+      &::Kinova::Api::Base::_IPv4Configuration_default_instance_);
+}
+inline ::Kinova::Api::Base::IPv4Configuration* FullIPv4Configuration::release_ipv4_configuration() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.FullIPv4Configuration.ipv4_configuration)
+  
+  ::Kinova::Api::Base::IPv4Configuration* temp = ipv4_configuration_;
+  ipv4_configuration_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::IPv4Configuration* FullIPv4Configuration::mutable_ipv4_configuration() {
+  
+  if (ipv4_configuration_ == NULL) {
+    ipv4_configuration_ = new ::Kinova::Api::Base::IPv4Configuration;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.FullIPv4Configuration.ipv4_configuration)
+  return ipv4_configuration_;
+}
+inline void FullIPv4Configuration::set_allocated_ipv4_configuration(::Kinova::Api::Base::IPv4Configuration* ipv4_configuration) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete ipv4_configuration_;
+  }
+  if (ipv4_configuration) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      ipv4_configuration = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, ipv4_configuration, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  ipv4_configuration_ = ipv4_configuration;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.FullIPv4Configuration.ipv4_configuration)
+}
+
+// -------------------------------------------------------------------
+
+// WifiEnableState
+
+// bool enabled = 1;
+inline void WifiEnableState::clear_enabled() {
+  enabled_ = false;
+}
+inline bool WifiEnableState::enabled() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.WifiEnableState.enabled)
+  return enabled_;
+}
+inline void WifiEnableState::set_enabled(bool value) {
+  
+  enabled_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.WifiEnableState.enabled)
+}
+
+// -------------------------------------------------------------------
+
+// BluetoothEnableState
+
+// bool enabled = 1;
+inline void BluetoothEnableState::clear_enabled() {
+  enabled_ = false;
+}
+inline bool BluetoothEnableState::enabled() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.BluetoothEnableState.enabled)
+  return enabled_;
+}
+inline void BluetoothEnableState::set_enabled(bool value) {
+  
+  enabled_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.BluetoothEnableState.enabled)
+}
+
+// -------------------------------------------------------------------
+
+// RFConfiguration
+
+// .Kinova.Api.Base.WifiEnableState wifi_enable_state = 1;
+inline bool RFConfiguration::has_wifi_enable_state() const {
+  return this != internal_default_instance() && wifi_enable_state_ != NULL;
+}
+inline void RFConfiguration::clear_wifi_enable_state() {
+  if (GetArenaNoVirtual() == NULL && wifi_enable_state_ != NULL) {
+    delete wifi_enable_state_;
+  }
+  wifi_enable_state_ = NULL;
+}
+inline const ::Kinova::Api::Base::WifiEnableState& RFConfiguration::wifi_enable_state() const {
+  const ::Kinova::Api::Base::WifiEnableState* p = wifi_enable_state_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.RFConfiguration.wifi_enable_state)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::WifiEnableState*>(
+      &::Kinova::Api::Base::_WifiEnableState_default_instance_);
+}
+inline ::Kinova::Api::Base::WifiEnableState* RFConfiguration::release_wifi_enable_state() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.RFConfiguration.wifi_enable_state)
+  
+  ::Kinova::Api::Base::WifiEnableState* temp = wifi_enable_state_;
+  wifi_enable_state_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::WifiEnableState* RFConfiguration::mutable_wifi_enable_state() {
+  
+  if (wifi_enable_state_ == NULL) {
+    wifi_enable_state_ = new ::Kinova::Api::Base::WifiEnableState;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.RFConfiguration.wifi_enable_state)
+  return wifi_enable_state_;
+}
+inline void RFConfiguration::set_allocated_wifi_enable_state(::Kinova::Api::Base::WifiEnableState* wifi_enable_state) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete wifi_enable_state_;
+  }
+  if (wifi_enable_state) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      wifi_enable_state = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, wifi_enable_state, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  wifi_enable_state_ = wifi_enable_state;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.RFConfiguration.wifi_enable_state)
+}
+
+// .Kinova.Api.Base.BluetoothEnableState bluetooth_enable_state = 2;
+inline bool RFConfiguration::has_bluetooth_enable_state() const {
+  return this != internal_default_instance() && bluetooth_enable_state_ != NULL;
+}
+inline void RFConfiguration::clear_bluetooth_enable_state() {
+  if (GetArenaNoVirtual() == NULL && bluetooth_enable_state_ != NULL) {
+    delete bluetooth_enable_state_;
+  }
+  bluetooth_enable_state_ = NULL;
+}
+inline const ::Kinova::Api::Base::BluetoothEnableState& RFConfiguration::bluetooth_enable_state() const {
+  const ::Kinova::Api::Base::BluetoothEnableState* p = bluetooth_enable_state_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.RFConfiguration.bluetooth_enable_state)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::BluetoothEnableState*>(
+      &::Kinova::Api::Base::_BluetoothEnableState_default_instance_);
+}
+inline ::Kinova::Api::Base::BluetoothEnableState* RFConfiguration::release_bluetooth_enable_state() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.RFConfiguration.bluetooth_enable_state)
+  
+  ::Kinova::Api::Base::BluetoothEnableState* temp = bluetooth_enable_state_;
+  bluetooth_enable_state_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::BluetoothEnableState* RFConfiguration::mutable_bluetooth_enable_state() {
+  
+  if (bluetooth_enable_state_ == NULL) {
+    bluetooth_enable_state_ = new ::Kinova::Api::Base::BluetoothEnableState;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.RFConfiguration.bluetooth_enable_state)
+  return bluetooth_enable_state_;
+}
+inline void RFConfiguration::set_allocated_bluetooth_enable_state(::Kinova::Api::Base::BluetoothEnableState* bluetooth_enable_state) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete bluetooth_enable_state_;
+  }
+  if (bluetooth_enable_state) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      bluetooth_enable_state = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, bluetooth_enable_state, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  bluetooth_enable_state_ = bluetooth_enable_state;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.RFConfiguration.bluetooth_enable_state)
+}
+
+// -------------------------------------------------------------------
+
+// WifiInformation
+
+// .Kinova.Api.Base.Ssid ssid = 1;
+inline bool WifiInformation::has_ssid() const {
+  return this != internal_default_instance() && ssid_ != NULL;
+}
+inline void WifiInformation::clear_ssid() {
+  if (GetArenaNoVirtual() == NULL && ssid_ != NULL) {
+    delete ssid_;
+  }
+  ssid_ = NULL;
+}
+inline const ::Kinova::Api::Base::Ssid& WifiInformation::ssid() const {
+  const ::Kinova::Api::Base::Ssid* p = ssid_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.WifiInformation.ssid)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::Ssid*>(
+      &::Kinova::Api::Base::_Ssid_default_instance_);
+}
+inline ::Kinova::Api::Base::Ssid* WifiInformation::release_ssid() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.WifiInformation.ssid)
+  
+  ::Kinova::Api::Base::Ssid* temp = ssid_;
+  ssid_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::Ssid* WifiInformation::mutable_ssid() {
+  
+  if (ssid_ == NULL) {
+    ssid_ = new ::Kinova::Api::Base::Ssid;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.WifiInformation.ssid)
+  return ssid_;
+}
+inline void WifiInformation::set_allocated_ssid(::Kinova::Api::Base::Ssid* ssid) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete ssid_;
+  }
+  if (ssid) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      ssid = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, ssid, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  ssid_ = ssid;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.WifiInformation.ssid)
+}
+
+// fixed32 security_type = 2;
+inline void WifiInformation::clear_security_type() {
+  security_type_ = 0u;
+}
+inline ::google::protobuf::uint32 WifiInformation::security_type() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.WifiInformation.security_type)
+  return security_type_;
+}
+inline void WifiInformation::set_security_type(::google::protobuf::uint32 value) {
+  
+  security_type_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.WifiInformation.security_type)
+}
+
+// fixed32 encryption_type = 3;
+inline void WifiInformation::clear_encryption_type() {
+  encryption_type_ = 0u;
+}
+inline ::google::protobuf::uint32 WifiInformation::encryption_type() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.WifiInformation.encryption_type)
+  return encryption_type_;
+}
+inline void WifiInformation::set_encryption_type(::google::protobuf::uint32 value) {
+  
+  encryption_type_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.WifiInformation.encryption_type)
+}
+
+// .Kinova.Api.Base.SignalQuality signal_quality = 4;
+inline void WifiInformation::clear_signal_quality() {
+  signal_quality_ = 0;
+}
+inline ::Kinova::Api::Base::SignalQuality WifiInformation::signal_quality() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.WifiInformation.signal_quality)
+  return static_cast< ::Kinova::Api::Base::SignalQuality >(signal_quality_);
+}
+inline void WifiInformation::set_signal_quality(::Kinova::Api::Base::SignalQuality value) {
+  
+  signal_quality_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.WifiInformation.signal_quality)
+}
+
+// int32 signal_strength = 5;
+inline void WifiInformation::clear_signal_strength() {
+  signal_strength_ = 0;
+}
+inline ::google::protobuf::int32 WifiInformation::signal_strength() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.WifiInformation.signal_strength)
+  return signal_strength_;
+}
+inline void WifiInformation::set_signal_strength(::google::protobuf::int32 value) {
+  
+  signal_strength_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.WifiInformation.signal_strength)
+}
+
+// uint32 frequency = 6;
+inline void WifiInformation::clear_frequency() {
+  frequency_ = 0u;
+}
+inline ::google::protobuf::uint32 WifiInformation::frequency() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.WifiInformation.frequency)
+  return frequency_;
+}
+inline void WifiInformation::set_frequency(::google::protobuf::uint32 value) {
+  
+  frequency_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.WifiInformation.frequency)
+}
+
+// uint32 channel = 7;
+inline void WifiInformation::clear_channel() {
+  channel_ = 0u;
+}
+inline ::google::protobuf::uint32 WifiInformation::channel() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.WifiInformation.channel)
+  return channel_;
+}
+inline void WifiInformation::set_channel(::google::protobuf::uint32 value) {
+  
+  channel_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.WifiInformation.channel)
+}
+
+// -------------------------------------------------------------------
+
+// WifiInformationList
+
+// repeated .Kinova.Api.Base.WifiInformation wifi_information_list = 1;
+inline int WifiInformationList::wifi_information_list_size() const {
+  return wifi_information_list_.size();
+}
+inline void WifiInformationList::clear_wifi_information_list() {
+  wifi_information_list_.Clear();
+}
+inline const ::Kinova::Api::Base::WifiInformation& WifiInformationList::wifi_information_list(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.WifiInformationList.wifi_information_list)
+  return wifi_information_list_.Get(index);
+}
+inline ::Kinova::Api::Base::WifiInformation* WifiInformationList::mutable_wifi_information_list(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.WifiInformationList.wifi_information_list)
+  return wifi_information_list_.Mutable(index);
+}
+inline ::Kinova::Api::Base::WifiInformation* WifiInformationList::add_wifi_information_list() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.Base.WifiInformationList.wifi_information_list)
+  return wifi_information_list_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::WifiInformation >*
+WifiInformationList::mutable_wifi_information_list() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.Base.WifiInformationList.wifi_information_list)
+  return &wifi_information_list_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::WifiInformation >&
+WifiInformationList::wifi_information_list() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.Base.WifiInformationList.wifi_information_list)
+  return wifi_information_list_;
+}
+
+// -------------------------------------------------------------------
+
+// WifiConfiguration
+
+// .Kinova.Api.Base.Ssid ssid = 1;
+inline bool WifiConfiguration::has_ssid() const {
+  return this != internal_default_instance() && ssid_ != NULL;
+}
+inline void WifiConfiguration::clear_ssid() {
+  if (GetArenaNoVirtual() == NULL && ssid_ != NULL) {
+    delete ssid_;
+  }
+  ssid_ = NULL;
+}
+inline const ::Kinova::Api::Base::Ssid& WifiConfiguration::ssid() const {
+  const ::Kinova::Api::Base::Ssid* p = ssid_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.WifiConfiguration.ssid)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::Ssid*>(
+      &::Kinova::Api::Base::_Ssid_default_instance_);
+}
+inline ::Kinova::Api::Base::Ssid* WifiConfiguration::release_ssid() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.WifiConfiguration.ssid)
+  
+  ::Kinova::Api::Base::Ssid* temp = ssid_;
+  ssid_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::Ssid* WifiConfiguration::mutable_ssid() {
+  
+  if (ssid_ == NULL) {
+    ssid_ = new ::Kinova::Api::Base::Ssid;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.WifiConfiguration.ssid)
+  return ssid_;
+}
+inline void WifiConfiguration::set_allocated_ssid(::Kinova::Api::Base::Ssid* ssid) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete ssid_;
+  }
+  if (ssid) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      ssid = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, ssid, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  ssid_ = ssid;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.WifiConfiguration.ssid)
+}
+
+// string security_key = 2;
+inline void WifiConfiguration::clear_security_key() {
+  security_key_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& WifiConfiguration::security_key() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.WifiConfiguration.security_key)
+  return security_key_.GetNoArena();
+}
+inline void WifiConfiguration::set_security_key(const ::std::string& value) {
+  
+  security_key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.WifiConfiguration.security_key)
+}
+#if LANG_CXX11
+inline void WifiConfiguration::set_security_key(::std::string&& value) {
+  
+  security_key_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:Kinova.Api.Base.WifiConfiguration.security_key)
+}
+#endif
+inline void WifiConfiguration::set_security_key(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  security_key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:Kinova.Api.Base.WifiConfiguration.security_key)
+}
+inline void WifiConfiguration::set_security_key(const char* value, size_t size) {
+  
+  security_key_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:Kinova.Api.Base.WifiConfiguration.security_key)
+}
+inline ::std::string* WifiConfiguration::mutable_security_key() {
+  
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.WifiConfiguration.security_key)
+  return security_key_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* WifiConfiguration::release_security_key() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.WifiConfiguration.security_key)
+  
+  return security_key_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void WifiConfiguration::set_allocated_security_key(::std::string* security_key) {
+  if (security_key != NULL) {
+    
+  } else {
+    
+  }
+  security_key_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), security_key);
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.WifiConfiguration.security_key)
+}
+
+// bool connect_automatically = 3;
+inline void WifiConfiguration::clear_connect_automatically() {
+  connect_automatically_ = false;
+}
+inline bool WifiConfiguration::connect_automatically() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.WifiConfiguration.connect_automatically)
+  return connect_automatically_;
+}
+inline void WifiConfiguration::set_connect_automatically(bool value) {
+  
+  connect_automatically_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.WifiConfiguration.connect_automatically)
+}
+
+// -------------------------------------------------------------------
+
+// WifiConfigurationList
+
+// repeated .Kinova.Api.Base.WifiConfiguration wifi_configuration_list = 1;
+inline int WifiConfigurationList::wifi_configuration_list_size() const {
+  return wifi_configuration_list_.size();
+}
+inline void WifiConfigurationList::clear_wifi_configuration_list() {
+  wifi_configuration_list_.Clear();
+}
+inline const ::Kinova::Api::Base::WifiConfiguration& WifiConfigurationList::wifi_configuration_list(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.WifiConfigurationList.wifi_configuration_list)
+  return wifi_configuration_list_.Get(index);
+}
+inline ::Kinova::Api::Base::WifiConfiguration* WifiConfigurationList::mutable_wifi_configuration_list(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.WifiConfigurationList.wifi_configuration_list)
+  return wifi_configuration_list_.Mutable(index);
+}
+inline ::Kinova::Api::Base::WifiConfiguration* WifiConfigurationList::add_wifi_configuration_list() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.Base.WifiConfigurationList.wifi_configuration_list)
+  return wifi_configuration_list_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::WifiConfiguration >*
+WifiConfigurationList::mutable_wifi_configuration_list() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.Base.WifiConfigurationList.wifi_configuration_list)
+  return &wifi_configuration_list_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::WifiConfiguration >&
+WifiConfigurationList::wifi_configuration_list() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.Base.WifiConfigurationList.wifi_configuration_list)
+  return wifi_configuration_list_;
+}
+
+// -------------------------------------------------------------------
+
+// ProtectionZoneHandle
+
+// uint32 identifier = 1;
+inline void ProtectionZoneHandle::clear_identifier() {
+  identifier_ = 0u;
+}
+inline ::google::protobuf::uint32 ProtectionZoneHandle::identifier() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ProtectionZoneHandle.identifier)
+  return identifier_;
+}
+inline void ProtectionZoneHandle::set_identifier(::google::protobuf::uint32 value) {
+  
+  identifier_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.ProtectionZoneHandle.identifier)
+}
+
+// fixed32 permission = 2;
+inline void ProtectionZoneHandle::clear_permission() {
+  permission_ = 0u;
+}
+inline ::google::protobuf::uint32 ProtectionZoneHandle::permission() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ProtectionZoneHandle.permission)
+  return permission_;
+}
+inline void ProtectionZoneHandle::set_permission(::google::protobuf::uint32 value) {
+  
+  permission_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.ProtectionZoneHandle.permission)
+}
+
+// -------------------------------------------------------------------
+
+// RotationMatrixRow
+
+// float column1 = 1;
+inline void RotationMatrixRow::clear_column1() {
+  column1_ = 0;
+}
+inline float RotationMatrixRow::column1() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.RotationMatrixRow.column1)
+  return column1_;
+}
+inline void RotationMatrixRow::set_column1(float value) {
+  
+  column1_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.RotationMatrixRow.column1)
+}
+
+// float column2 = 2;
+inline void RotationMatrixRow::clear_column2() {
+  column2_ = 0;
+}
+inline float RotationMatrixRow::column2() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.RotationMatrixRow.column2)
+  return column2_;
+}
+inline void RotationMatrixRow::set_column2(float value) {
+  
+  column2_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.RotationMatrixRow.column2)
+}
+
+// float column3 = 3;
+inline void RotationMatrixRow::clear_column3() {
+  column3_ = 0;
+}
+inline float RotationMatrixRow::column3() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.RotationMatrixRow.column3)
+  return column3_;
+}
+inline void RotationMatrixRow::set_column3(float value) {
+  
+  column3_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.RotationMatrixRow.column3)
+}
+
+// -------------------------------------------------------------------
+
+// RotationMatrix
+
+// .Kinova.Api.Base.RotationMatrixRow row1 = 1;
+inline bool RotationMatrix::has_row1() const {
+  return this != internal_default_instance() && row1_ != NULL;
+}
+inline void RotationMatrix::clear_row1() {
+  if (GetArenaNoVirtual() == NULL && row1_ != NULL) {
+    delete row1_;
+  }
+  row1_ = NULL;
+}
+inline const ::Kinova::Api::Base::RotationMatrixRow& RotationMatrix::row1() const {
+  const ::Kinova::Api::Base::RotationMatrixRow* p = row1_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.RotationMatrix.row1)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::RotationMatrixRow*>(
+      &::Kinova::Api::Base::_RotationMatrixRow_default_instance_);
+}
+inline ::Kinova::Api::Base::RotationMatrixRow* RotationMatrix::release_row1() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.RotationMatrix.row1)
+  
+  ::Kinova::Api::Base::RotationMatrixRow* temp = row1_;
+  row1_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::RotationMatrixRow* RotationMatrix::mutable_row1() {
+  
+  if (row1_ == NULL) {
+    row1_ = new ::Kinova::Api::Base::RotationMatrixRow;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.RotationMatrix.row1)
+  return row1_;
+}
+inline void RotationMatrix::set_allocated_row1(::Kinova::Api::Base::RotationMatrixRow* row1) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete row1_;
+  }
+  if (row1) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      row1 = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, row1, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  row1_ = row1;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.RotationMatrix.row1)
+}
+
+// .Kinova.Api.Base.RotationMatrixRow row2 = 2;
+inline bool RotationMatrix::has_row2() const {
+  return this != internal_default_instance() && row2_ != NULL;
+}
+inline void RotationMatrix::clear_row2() {
+  if (GetArenaNoVirtual() == NULL && row2_ != NULL) {
+    delete row2_;
+  }
+  row2_ = NULL;
+}
+inline const ::Kinova::Api::Base::RotationMatrixRow& RotationMatrix::row2() const {
+  const ::Kinova::Api::Base::RotationMatrixRow* p = row2_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.RotationMatrix.row2)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::RotationMatrixRow*>(
+      &::Kinova::Api::Base::_RotationMatrixRow_default_instance_);
+}
+inline ::Kinova::Api::Base::RotationMatrixRow* RotationMatrix::release_row2() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.RotationMatrix.row2)
+  
+  ::Kinova::Api::Base::RotationMatrixRow* temp = row2_;
+  row2_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::RotationMatrixRow* RotationMatrix::mutable_row2() {
+  
+  if (row2_ == NULL) {
+    row2_ = new ::Kinova::Api::Base::RotationMatrixRow;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.RotationMatrix.row2)
+  return row2_;
+}
+inline void RotationMatrix::set_allocated_row2(::Kinova::Api::Base::RotationMatrixRow* row2) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete row2_;
+  }
+  if (row2) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      row2 = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, row2, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  row2_ = row2;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.RotationMatrix.row2)
+}
+
+// .Kinova.Api.Base.RotationMatrixRow row3 = 3;
+inline bool RotationMatrix::has_row3() const {
+  return this != internal_default_instance() && row3_ != NULL;
+}
+inline void RotationMatrix::clear_row3() {
+  if (GetArenaNoVirtual() == NULL && row3_ != NULL) {
+    delete row3_;
+  }
+  row3_ = NULL;
+}
+inline const ::Kinova::Api::Base::RotationMatrixRow& RotationMatrix::row3() const {
+  const ::Kinova::Api::Base::RotationMatrixRow* p = row3_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.RotationMatrix.row3)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::RotationMatrixRow*>(
+      &::Kinova::Api::Base::_RotationMatrixRow_default_instance_);
+}
+inline ::Kinova::Api::Base::RotationMatrixRow* RotationMatrix::release_row3() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.RotationMatrix.row3)
+  
+  ::Kinova::Api::Base::RotationMatrixRow* temp = row3_;
+  row3_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::RotationMatrixRow* RotationMatrix::mutable_row3() {
+  
+  if (row3_ == NULL) {
+    row3_ = new ::Kinova::Api::Base::RotationMatrixRow;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.RotationMatrix.row3)
+  return row3_;
+}
+inline void RotationMatrix::set_allocated_row3(::Kinova::Api::Base::RotationMatrixRow* row3) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete row3_;
+  }
+  if (row3) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      row3 = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, row3, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  row3_ = row3;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.RotationMatrix.row3)
+}
+
+// -------------------------------------------------------------------
+
+// Point
+
+// float x = 1;
+inline void Point::clear_x() {
+  x_ = 0;
+}
+inline float Point::x() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Point.x)
+  return x_;
+}
+inline void Point::set_x(float value) {
+  
+  x_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.Point.x)
+}
+
+// float y = 2;
+inline void Point::clear_y() {
+  y_ = 0;
+}
+inline float Point::y() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Point.y)
+  return y_;
+}
+inline void Point::set_y(float value) {
+  
+  y_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.Point.y)
+}
+
+// float z = 3;
+inline void Point::clear_z() {
+  z_ = 0;
+}
+inline float Point::z() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Point.z)
+  return z_;
+}
+inline void Point::set_z(float value) {
+  
+  z_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.Point.z)
+}
+
+// -------------------------------------------------------------------
+
+// ZoneShape
+
+// .Kinova.Api.Base.ShapeType shape_type = 1;
+inline void ZoneShape::clear_shape_type() {
+  shape_type_ = 0;
+}
+inline ::Kinova::Api::Base::ShapeType ZoneShape::shape_type() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ZoneShape.shape_type)
+  return static_cast< ::Kinova::Api::Base::ShapeType >(shape_type_);
+}
+inline void ZoneShape::set_shape_type(::Kinova::Api::Base::ShapeType value) {
+  
+  shape_type_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.ZoneShape.shape_type)
+}
+
+// .Kinova.Api.Base.Point origin = 2;
+inline bool ZoneShape::has_origin() const {
+  return this != internal_default_instance() && origin_ != NULL;
+}
+inline void ZoneShape::clear_origin() {
+  if (GetArenaNoVirtual() == NULL && origin_ != NULL) {
+    delete origin_;
+  }
+  origin_ = NULL;
+}
+inline const ::Kinova::Api::Base::Point& ZoneShape::origin() const {
+  const ::Kinova::Api::Base::Point* p = origin_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ZoneShape.origin)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::Point*>(
+      &::Kinova::Api::Base::_Point_default_instance_);
+}
+inline ::Kinova::Api::Base::Point* ZoneShape::release_origin() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ZoneShape.origin)
+  
+  ::Kinova::Api::Base::Point* temp = origin_;
+  origin_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::Point* ZoneShape::mutable_origin() {
+  
+  if (origin_ == NULL) {
+    origin_ = new ::Kinova::Api::Base::Point;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ZoneShape.origin)
+  return origin_;
+}
+inline void ZoneShape::set_allocated_origin(::Kinova::Api::Base::Point* origin) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete origin_;
+  }
+  if (origin) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      origin = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, origin, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  origin_ = origin;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.ZoneShape.origin)
+}
+
+// .Kinova.Api.Base.RotationMatrix orientation = 3;
+inline bool ZoneShape::has_orientation() const {
+  return this != internal_default_instance() && orientation_ != NULL;
+}
+inline void ZoneShape::clear_orientation() {
+  if (GetArenaNoVirtual() == NULL && orientation_ != NULL) {
+    delete orientation_;
+  }
+  orientation_ = NULL;
+}
+inline const ::Kinova::Api::Base::RotationMatrix& ZoneShape::orientation() const {
+  const ::Kinova::Api::Base::RotationMatrix* p = orientation_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ZoneShape.orientation)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::RotationMatrix*>(
+      &::Kinova::Api::Base::_RotationMatrix_default_instance_);
+}
+inline ::Kinova::Api::Base::RotationMatrix* ZoneShape::release_orientation() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ZoneShape.orientation)
+  
+  ::Kinova::Api::Base::RotationMatrix* temp = orientation_;
+  orientation_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::RotationMatrix* ZoneShape::mutable_orientation() {
+  
+  if (orientation_ == NULL) {
+    orientation_ = new ::Kinova::Api::Base::RotationMatrix;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ZoneShape.orientation)
+  return orientation_;
+}
+inline void ZoneShape::set_allocated_orientation(::Kinova::Api::Base::RotationMatrix* orientation) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete orientation_;
+  }
+  if (orientation) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      orientation = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, orientation, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  orientation_ = orientation;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.ZoneShape.orientation)
+}
+
+// repeated float dimensions = 4;
+inline int ZoneShape::dimensions_size() const {
+  return dimensions_.size();
+}
+inline void ZoneShape::clear_dimensions() {
+  dimensions_.Clear();
+}
+inline float ZoneShape::dimensions(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ZoneShape.dimensions)
+  return dimensions_.Get(index);
+}
+inline void ZoneShape::set_dimensions(int index, float value) {
+  dimensions_.Set(index, value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.ZoneShape.dimensions)
+}
+inline void ZoneShape::add_dimensions(float value) {
+  dimensions_.Add(value);
+  // @@protoc_insertion_point(field_add:Kinova.Api.Base.ZoneShape.dimensions)
+}
+inline const ::google::protobuf::RepeatedField< float >&
+ZoneShape::dimensions() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.Base.ZoneShape.dimensions)
+  return dimensions_;
+}
+inline ::google::protobuf::RepeatedField< float >*
+ZoneShape::mutable_dimensions() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.Base.ZoneShape.dimensions)
+  return &dimensions_;
+}
+
+// float envelope_thickness = 5;
+inline void ZoneShape::clear_envelope_thickness() {
+  envelope_thickness_ = 0;
+}
+inline float ZoneShape::envelope_thickness() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ZoneShape.envelope_thickness)
+  return envelope_thickness_;
+}
+inline void ZoneShape::set_envelope_thickness(float value) {
+  
+  envelope_thickness_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.ZoneShape.envelope_thickness)
+}
+
+// -------------------------------------------------------------------
+
+// ProtectionZone
+
+// .Kinova.Api.Base.ProtectionZoneHandle handle = 1;
+inline bool ProtectionZone::has_handle() const {
+  return this != internal_default_instance() && handle_ != NULL;
+}
+inline void ProtectionZone::clear_handle() {
+  if (GetArenaNoVirtual() == NULL && handle_ != NULL) {
+    delete handle_;
+  }
+  handle_ = NULL;
+}
+inline const ::Kinova::Api::Base::ProtectionZoneHandle& ProtectionZone::handle() const {
+  const ::Kinova::Api::Base::ProtectionZoneHandle* p = handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ProtectionZone.handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::ProtectionZoneHandle*>(
+      &::Kinova::Api::Base::_ProtectionZoneHandle_default_instance_);
+}
+inline ::Kinova::Api::Base::ProtectionZoneHandle* ProtectionZone::release_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ProtectionZone.handle)
+  
+  ::Kinova::Api::Base::ProtectionZoneHandle* temp = handle_;
+  handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::ProtectionZoneHandle* ProtectionZone::mutable_handle() {
+  
+  if (handle_ == NULL) {
+    handle_ = new ::Kinova::Api::Base::ProtectionZoneHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ProtectionZone.handle)
+  return handle_;
+}
+inline void ProtectionZone::set_allocated_handle(::Kinova::Api::Base::ProtectionZoneHandle* handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete handle_;
+  }
+  if (handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  handle_ = handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.ProtectionZone.handle)
+}
+
+// string name = 2;
+inline void ProtectionZone::clear_name() {
+  name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& ProtectionZone::name() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ProtectionZone.name)
+  return name_.GetNoArena();
+}
+inline void ProtectionZone::set_name(const ::std::string& value) {
+  
+  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.ProtectionZone.name)
+}
+#if LANG_CXX11
+inline void ProtectionZone::set_name(::std::string&& value) {
+  
+  name_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:Kinova.Api.Base.ProtectionZone.name)
+}
+#endif
+inline void ProtectionZone::set_name(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:Kinova.Api.Base.ProtectionZone.name)
+}
+inline void ProtectionZone::set_name(const char* value, size_t size) {
+  
+  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:Kinova.Api.Base.ProtectionZone.name)
+}
+inline ::std::string* ProtectionZone::mutable_name() {
+  
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ProtectionZone.name)
+  return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* ProtectionZone::release_name() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ProtectionZone.name)
+  
+  return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void ProtectionZone::set_allocated_name(::std::string* name) {
+  if (name != NULL) {
+    
+  } else {
+    
+  }
+  name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.ProtectionZone.name)
+}
+
+// string application_data = 3;
+inline void ProtectionZone::clear_application_data() {
+  application_data_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& ProtectionZone::application_data() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ProtectionZone.application_data)
+  return application_data_.GetNoArena();
+}
+inline void ProtectionZone::set_application_data(const ::std::string& value) {
+  
+  application_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.ProtectionZone.application_data)
+}
+#if LANG_CXX11
+inline void ProtectionZone::set_application_data(::std::string&& value) {
+  
+  application_data_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:Kinova.Api.Base.ProtectionZone.application_data)
+}
+#endif
+inline void ProtectionZone::set_application_data(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  application_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:Kinova.Api.Base.ProtectionZone.application_data)
+}
+inline void ProtectionZone::set_application_data(const char* value, size_t size) {
+  
+  application_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:Kinova.Api.Base.ProtectionZone.application_data)
+}
+inline ::std::string* ProtectionZone::mutable_application_data() {
+  
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ProtectionZone.application_data)
+  return application_data_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* ProtectionZone::release_application_data() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ProtectionZone.application_data)
+  
+  return application_data_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void ProtectionZone::set_allocated_application_data(::std::string* application_data) {
+  if (application_data != NULL) {
+    
+  } else {
+    
+  }
+  application_data_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), application_data);
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.ProtectionZone.application_data)
+}
+
+// bool is_enabled = 4;
+inline void ProtectionZone::clear_is_enabled() {
+  is_enabled_ = false;
+}
+inline bool ProtectionZone::is_enabled() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ProtectionZone.is_enabled)
+  return is_enabled_;
+}
+inline void ProtectionZone::set_is_enabled(bool value) {
+  
+  is_enabled_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.ProtectionZone.is_enabled)
+}
+
+// .Kinova.Api.Base.ZoneShape shape = 5;
+inline bool ProtectionZone::has_shape() const {
+  return this != internal_default_instance() && shape_ != NULL;
+}
+inline void ProtectionZone::clear_shape() {
+  if (GetArenaNoVirtual() == NULL && shape_ != NULL) {
+    delete shape_;
+  }
+  shape_ = NULL;
+}
+inline const ::Kinova::Api::Base::ZoneShape& ProtectionZone::shape() const {
+  const ::Kinova::Api::Base::ZoneShape* p = shape_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ProtectionZone.shape)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::ZoneShape*>(
+      &::Kinova::Api::Base::_ZoneShape_default_instance_);
+}
+inline ::Kinova::Api::Base::ZoneShape* ProtectionZone::release_shape() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ProtectionZone.shape)
+  
+  ::Kinova::Api::Base::ZoneShape* temp = shape_;
+  shape_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::ZoneShape* ProtectionZone::mutable_shape() {
+  
+  if (shape_ == NULL) {
+    shape_ = new ::Kinova::Api::Base::ZoneShape;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ProtectionZone.shape)
+  return shape_;
+}
+inline void ProtectionZone::set_allocated_shape(::Kinova::Api::Base::ZoneShape* shape) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete shape_;
+  }
+  if (shape) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      shape = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, shape, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  shape_ = shape;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.ProtectionZone.shape)
+}
+
+// repeated .Kinova.Api.Base.CartesianLimitation limitations = 6;
+inline int ProtectionZone::limitations_size() const {
+  return limitations_.size();
+}
+inline void ProtectionZone::clear_limitations() {
+  limitations_.Clear();
+}
+inline const ::Kinova::Api::Base::CartesianLimitation& ProtectionZone::limitations(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ProtectionZone.limitations)
+  return limitations_.Get(index);
+}
+inline ::Kinova::Api::Base::CartesianLimitation* ProtectionZone::mutable_limitations(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ProtectionZone.limitations)
+  return limitations_.Mutable(index);
+}
+inline ::Kinova::Api::Base::CartesianLimitation* ProtectionZone::add_limitations() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.Base.ProtectionZone.limitations)
+  return limitations_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::CartesianLimitation >*
+ProtectionZone::mutable_limitations() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.Base.ProtectionZone.limitations)
+  return &limitations_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::CartesianLimitation >&
+ProtectionZone::limitations() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.Base.ProtectionZone.limitations)
+  return limitations_;
+}
+
+// repeated .Kinova.Api.Base.CartesianLimitation envelope_limitations = 7;
+inline int ProtectionZone::envelope_limitations_size() const {
+  return envelope_limitations_.size();
+}
+inline void ProtectionZone::clear_envelope_limitations() {
+  envelope_limitations_.Clear();
+}
+inline const ::Kinova::Api::Base::CartesianLimitation& ProtectionZone::envelope_limitations(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ProtectionZone.envelope_limitations)
+  return envelope_limitations_.Get(index);
+}
+inline ::Kinova::Api::Base::CartesianLimitation* ProtectionZone::mutable_envelope_limitations(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ProtectionZone.envelope_limitations)
+  return envelope_limitations_.Mutable(index);
+}
+inline ::Kinova::Api::Base::CartesianLimitation* ProtectionZone::add_envelope_limitations() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.Base.ProtectionZone.envelope_limitations)
+  return envelope_limitations_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::CartesianLimitation >*
+ProtectionZone::mutable_envelope_limitations() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.Base.ProtectionZone.envelope_limitations)
+  return &envelope_limitations_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::CartesianLimitation >&
+ProtectionZone::envelope_limitations() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.Base.ProtectionZone.envelope_limitations)
+  return envelope_limitations_;
+}
+
+// -------------------------------------------------------------------
+
+// ProtectionZoneList
+
+// repeated .Kinova.Api.Base.ProtectionZone protection_zones = 1;
+inline int ProtectionZoneList::protection_zones_size() const {
+  return protection_zones_.size();
+}
+inline void ProtectionZoneList::clear_protection_zones() {
+  protection_zones_.Clear();
+}
+inline const ::Kinova::Api::Base::ProtectionZone& ProtectionZoneList::protection_zones(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ProtectionZoneList.protection_zones)
+  return protection_zones_.Get(index);
+}
+inline ::Kinova::Api::Base::ProtectionZone* ProtectionZoneList::mutable_protection_zones(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ProtectionZoneList.protection_zones)
+  return protection_zones_.Mutable(index);
+}
+inline ::Kinova::Api::Base::ProtectionZone* ProtectionZoneList::add_protection_zones() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.Base.ProtectionZoneList.protection_zones)
+  return protection_zones_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::ProtectionZone >*
+ProtectionZoneList::mutable_protection_zones() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.Base.ProtectionZoneList.protection_zones)
+  return &protection_zones_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::ProtectionZone >&
+ProtectionZoneList::protection_zones() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.Base.ProtectionZoneList.protection_zones)
+  return protection_zones_;
+}
+
+// -------------------------------------------------------------------
+
+// CartesianLimitation
+
+// .Kinova.Api.Base.LimitationType type = 1;
+inline void CartesianLimitation::clear_type() {
+  type_ = 0;
+}
+inline ::Kinova::Api::Base::LimitationType CartesianLimitation::type() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.CartesianLimitation.type)
+  return static_cast< ::Kinova::Api::Base::LimitationType >(type_);
+}
+inline void CartesianLimitation::set_type(::Kinova::Api::Base::LimitationType value) {
+  
+  type_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.CartesianLimitation.type)
+}
+
+// float translation = 2;
+inline void CartesianLimitation::clear_translation() {
+  translation_ = 0;
+}
+inline float CartesianLimitation::translation() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.CartesianLimitation.translation)
+  return translation_;
+}
+inline void CartesianLimitation::set_translation(float value) {
+  
+  translation_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.CartesianLimitation.translation)
+}
+
+// float orientation = 3;
+inline void CartesianLimitation::clear_orientation() {
+  orientation_ = 0;
+}
+inline float CartesianLimitation::orientation() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.CartesianLimitation.orientation)
+  return orientation_;
+}
+inline void CartesianLimitation::set_orientation(float value) {
+  
+  orientation_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.CartesianLimitation.orientation)
+}
+
+// -------------------------------------------------------------------
+
+// TwistLimitation
+
+// float linear = 1;
+inline void TwistLimitation::clear_linear() {
+  linear_ = 0;
+}
+inline float TwistLimitation::linear() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.TwistLimitation.linear)
+  return linear_;
+}
+inline void TwistLimitation::set_linear(float value) {
+  
+  linear_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.TwistLimitation.linear)
+}
+
+// float angular = 2;
+inline void TwistLimitation::clear_angular() {
+  angular_ = 0;
+}
+inline float TwistLimitation::angular() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.TwistLimitation.angular)
+  return angular_;
+}
+inline void TwistLimitation::set_angular(float value) {
+  
+  angular_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.TwistLimitation.angular)
+}
+
+// -------------------------------------------------------------------
+
+// WrenchLimitation
+
+// float force = 1;
+inline void WrenchLimitation::clear_force() {
+  force_ = 0;
+}
+inline float WrenchLimitation::force() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.WrenchLimitation.force)
+  return force_;
+}
+inline void WrenchLimitation::set_force(float value) {
+  
+  force_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.WrenchLimitation.force)
+}
+
+// float torque = 2;
+inline void WrenchLimitation::clear_torque() {
+  torque_ = 0;
+}
+inline float WrenchLimitation::torque() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.WrenchLimitation.torque)
+  return torque_;
+}
+inline void WrenchLimitation::set_torque(float value) {
+  
+  torque_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.WrenchLimitation.torque)
+}
+
+// -------------------------------------------------------------------
+
+// CartesianLimitationList
+
+// repeated .Kinova.Api.Base.CartesianLimitation limitations = 1;
+inline int CartesianLimitationList::limitations_size() const {
+  return limitations_.size();
+}
+inline void CartesianLimitationList::clear_limitations() {
+  limitations_.Clear();
+}
+inline const ::Kinova::Api::Base::CartesianLimitation& CartesianLimitationList::limitations(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.CartesianLimitationList.limitations)
+  return limitations_.Get(index);
+}
+inline ::Kinova::Api::Base::CartesianLimitation* CartesianLimitationList::mutable_limitations(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.CartesianLimitationList.limitations)
+  return limitations_.Mutable(index);
+}
+inline ::Kinova::Api::Base::CartesianLimitation* CartesianLimitationList::add_limitations() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.Base.CartesianLimitationList.limitations)
+  return limitations_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::CartesianLimitation >*
+CartesianLimitationList::mutable_limitations() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.Base.CartesianLimitationList.limitations)
+  return &limitations_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::CartesianLimitation >&
+CartesianLimitationList::limitations() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.Base.CartesianLimitationList.limitations)
+  return limitations_;
+}
+
+// -------------------------------------------------------------------
+
+// JointLimitation
+
+// uint32 joint_identifier = 1;
+inline void JointLimitation::clear_joint_identifier() {
+  joint_identifier_ = 0u;
+}
+inline ::google::protobuf::uint32 JointLimitation::joint_identifier() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.JointLimitation.joint_identifier)
+  return joint_identifier_;
+}
+inline void JointLimitation::set_joint_identifier(::google::protobuf::uint32 value) {
+  
+  joint_identifier_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.JointLimitation.joint_identifier)
+}
+
+// .Kinova.Api.Base.LimitationType type = 2;
+inline void JointLimitation::clear_type() {
+  type_ = 0;
+}
+inline ::Kinova::Api::Base::LimitationType JointLimitation::type() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.JointLimitation.type)
+  return static_cast< ::Kinova::Api::Base::LimitationType >(type_);
+}
+inline void JointLimitation::set_type(::Kinova::Api::Base::LimitationType value) {
+  
+  type_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.JointLimitation.type)
+}
+
+// float value = 3;
+inline void JointLimitation::clear_value() {
+  value_ = 0;
+}
+inline float JointLimitation::value() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.JointLimitation.value)
+  return value_;
+}
+inline void JointLimitation::set_value(float value) {
+  
+  value_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.JointLimitation.value)
+}
+
+// -------------------------------------------------------------------
+
+// JointsLimitationsList
+
+// repeated .Kinova.Api.Base.JointLimitation joints_limitations = 1;
+inline int JointsLimitationsList::joints_limitations_size() const {
+  return joints_limitations_.size();
+}
+inline void JointsLimitationsList::clear_joints_limitations() {
+  joints_limitations_.Clear();
+}
+inline const ::Kinova::Api::Base::JointLimitation& JointsLimitationsList::joints_limitations(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.JointsLimitationsList.joints_limitations)
+  return joints_limitations_.Get(index);
+}
+inline ::Kinova::Api::Base::JointLimitation* JointsLimitationsList::mutable_joints_limitations(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.JointsLimitationsList.joints_limitations)
+  return joints_limitations_.Mutable(index);
+}
+inline ::Kinova::Api::Base::JointLimitation* JointsLimitationsList::add_joints_limitations() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.Base.JointsLimitationsList.joints_limitations)
+  return joints_limitations_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::JointLimitation >*
+JointsLimitationsList::mutable_joints_limitations() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.Base.JointsLimitationsList.joints_limitations)
+  return &joints_limitations_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::JointLimitation >&
+JointsLimitationsList::joints_limitations() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.Base.JointsLimitationsList.joints_limitations)
+  return joints_limitations_;
+}
+
+// -------------------------------------------------------------------
+
+// ConfigurationChangeNotification
+
+// .Kinova.Api.Base.ConfigurationNotificationEvent event = 1;
+inline void ConfigurationChangeNotification::clear_event() {
+  event_ = 0;
+}
+inline ::Kinova::Api::Base::ConfigurationNotificationEvent ConfigurationChangeNotification::event() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ConfigurationChangeNotification.event)
+  return static_cast< ::Kinova::Api::Base::ConfigurationNotificationEvent >(event_);
+}
+inline void ConfigurationChangeNotification::set_event(::Kinova::Api::Base::ConfigurationNotificationEvent value) {
+  
+  event_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.ConfigurationChangeNotification.event)
+}
+
+// .Kinova.Api.Common.Timestamp timestamp = 2;
+inline bool ConfigurationChangeNotification::has_timestamp() const {
+  return this != internal_default_instance() && timestamp_ != NULL;
+}
+inline const ::Kinova::Api::Common::Timestamp& ConfigurationChangeNotification::timestamp() const {
+  const ::Kinova::Api::Common::Timestamp* p = timestamp_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ConfigurationChangeNotification.timestamp)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::Timestamp*>(
+      &::Kinova::Api::Common::_Timestamp_default_instance_);
+}
+inline ::Kinova::Api::Common::Timestamp* ConfigurationChangeNotification::release_timestamp() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ConfigurationChangeNotification.timestamp)
+  
+  ::Kinova::Api::Common::Timestamp* temp = timestamp_;
+  timestamp_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::Timestamp* ConfigurationChangeNotification::mutable_timestamp() {
+  
+  if (timestamp_ == NULL) {
+    timestamp_ = new ::Kinova::Api::Common::Timestamp;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ConfigurationChangeNotification.timestamp)
+  return timestamp_;
+}
+inline void ConfigurationChangeNotification::set_allocated_timestamp(::Kinova::Api::Common::Timestamp* timestamp) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(timestamp_);
+  }
+  if (timestamp) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      timestamp = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, timestamp, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  timestamp_ = timestamp;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.ConfigurationChangeNotification.timestamp)
+}
+
+// .Kinova.Api.Common.UserProfileHandle user_handle = 3;
+inline bool ConfigurationChangeNotification::has_user_handle() const {
+  return this != internal_default_instance() && user_handle_ != NULL;
+}
+inline const ::Kinova::Api::Common::UserProfileHandle& ConfigurationChangeNotification::user_handle() const {
+  const ::Kinova::Api::Common::UserProfileHandle* p = user_handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ConfigurationChangeNotification.user_handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::UserProfileHandle*>(
+      &::Kinova::Api::Common::_UserProfileHandle_default_instance_);
+}
+inline ::Kinova::Api::Common::UserProfileHandle* ConfigurationChangeNotification::release_user_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ConfigurationChangeNotification.user_handle)
+  
+  ::Kinova::Api::Common::UserProfileHandle* temp = user_handle_;
+  user_handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::UserProfileHandle* ConfigurationChangeNotification::mutable_user_handle() {
+  
+  if (user_handle_ == NULL) {
+    user_handle_ = new ::Kinova::Api::Common::UserProfileHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ConfigurationChangeNotification.user_handle)
+  return user_handle_;
+}
+inline void ConfigurationChangeNotification::set_allocated_user_handle(::Kinova::Api::Common::UserProfileHandle* user_handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(user_handle_);
+  }
+  if (user_handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      user_handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, user_handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  user_handle_ = user_handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.ConfigurationChangeNotification.user_handle)
+}
+
+// .Kinova.Api.Base.SequenceHandle sequence_handle = 4;
+inline bool ConfigurationChangeNotification::has_sequence_handle() const {
+  return configuration_change_case() == kSequenceHandle;
+}
+inline void ConfigurationChangeNotification::set_has_sequence_handle() {
+  _oneof_case_[0] = kSequenceHandle;
+}
+inline void ConfigurationChangeNotification::clear_sequence_handle() {
+  if (has_sequence_handle()) {
+    delete configuration_change_.sequence_handle_;
+    clear_has_configuration_change();
+  }
+}
+inline ::Kinova::Api::Base::SequenceHandle* ConfigurationChangeNotification::release_sequence_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ConfigurationChangeNotification.sequence_handle)
+  if (has_sequence_handle()) {
+    clear_has_configuration_change();
+      ::Kinova::Api::Base::SequenceHandle* temp = configuration_change_.sequence_handle_;
+    configuration_change_.sequence_handle_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline const ::Kinova::Api::Base::SequenceHandle& ConfigurationChangeNotification::sequence_handle() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ConfigurationChangeNotification.sequence_handle)
+  return has_sequence_handle()
+      ? *configuration_change_.sequence_handle_
+      : *reinterpret_cast< ::Kinova::Api::Base::SequenceHandle*>(&::Kinova::Api::Base::_SequenceHandle_default_instance_);
+}
+inline ::Kinova::Api::Base::SequenceHandle* ConfigurationChangeNotification::mutable_sequence_handle() {
+  if (!has_sequence_handle()) {
+    clear_configuration_change();
+    set_has_sequence_handle();
+    configuration_change_.sequence_handle_ = new ::Kinova::Api::Base::SequenceHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ConfigurationChangeNotification.sequence_handle)
+  return configuration_change_.sequence_handle_;
+}
+
+// .Kinova.Api.Base.ActionHandle action_handle = 5;
+inline bool ConfigurationChangeNotification::has_action_handle() const {
+  return configuration_change_case() == kActionHandle;
+}
+inline void ConfigurationChangeNotification::set_has_action_handle() {
+  _oneof_case_[0] = kActionHandle;
+}
+inline void ConfigurationChangeNotification::clear_action_handle() {
+  if (has_action_handle()) {
+    delete configuration_change_.action_handle_;
+    clear_has_configuration_change();
+  }
+}
+inline ::Kinova::Api::Base::ActionHandle* ConfigurationChangeNotification::release_action_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ConfigurationChangeNotification.action_handle)
+  if (has_action_handle()) {
+    clear_has_configuration_change();
+      ::Kinova::Api::Base::ActionHandle* temp = configuration_change_.action_handle_;
+    configuration_change_.action_handle_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline const ::Kinova::Api::Base::ActionHandle& ConfigurationChangeNotification::action_handle() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ConfigurationChangeNotification.action_handle)
+  return has_action_handle()
+      ? *configuration_change_.action_handle_
+      : *reinterpret_cast< ::Kinova::Api::Base::ActionHandle*>(&::Kinova::Api::Base::_ActionHandle_default_instance_);
+}
+inline ::Kinova::Api::Base::ActionHandle* ConfigurationChangeNotification::mutable_action_handle() {
+  if (!has_action_handle()) {
+    clear_configuration_change();
+    set_has_action_handle();
+    configuration_change_.action_handle_ = new ::Kinova::Api::Base::ActionHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ConfigurationChangeNotification.action_handle)
+  return configuration_change_.action_handle_;
+}
+
+// .Kinova.Api.Base.MappingHandle mapping_handle = 6;
+inline bool ConfigurationChangeNotification::has_mapping_handle() const {
+  return configuration_change_case() == kMappingHandle;
+}
+inline void ConfigurationChangeNotification::set_has_mapping_handle() {
+  _oneof_case_[0] = kMappingHandle;
+}
+inline void ConfigurationChangeNotification::clear_mapping_handle() {
+  if (has_mapping_handle()) {
+    delete configuration_change_.mapping_handle_;
+    clear_has_configuration_change();
+  }
+}
+inline ::Kinova::Api::Base::MappingHandle* ConfigurationChangeNotification::release_mapping_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ConfigurationChangeNotification.mapping_handle)
+  if (has_mapping_handle()) {
+    clear_has_configuration_change();
+      ::Kinova::Api::Base::MappingHandle* temp = configuration_change_.mapping_handle_;
+    configuration_change_.mapping_handle_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline const ::Kinova::Api::Base::MappingHandle& ConfigurationChangeNotification::mapping_handle() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ConfigurationChangeNotification.mapping_handle)
+  return has_mapping_handle()
+      ? *configuration_change_.mapping_handle_
+      : *reinterpret_cast< ::Kinova::Api::Base::MappingHandle*>(&::Kinova::Api::Base::_MappingHandle_default_instance_);
+}
+inline ::Kinova::Api::Base::MappingHandle* ConfigurationChangeNotification::mutable_mapping_handle() {
+  if (!has_mapping_handle()) {
+    clear_configuration_change();
+    set_has_mapping_handle();
+    configuration_change_.mapping_handle_ = new ::Kinova::Api::Base::MappingHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ConfigurationChangeNotification.mapping_handle)
+  return configuration_change_.mapping_handle_;
+}
+
+// .Kinova.Api.Base.MapGroupHandle map_group_handle = 7;
+inline bool ConfigurationChangeNotification::has_map_group_handle() const {
+  return configuration_change_case() == kMapGroupHandle;
+}
+inline void ConfigurationChangeNotification::set_has_map_group_handle() {
+  _oneof_case_[0] = kMapGroupHandle;
+}
+inline void ConfigurationChangeNotification::clear_map_group_handle() {
+  if (has_map_group_handle()) {
+    delete configuration_change_.map_group_handle_;
+    clear_has_configuration_change();
+  }
+}
+inline ::Kinova::Api::Base::MapGroupHandle* ConfigurationChangeNotification::release_map_group_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ConfigurationChangeNotification.map_group_handle)
+  if (has_map_group_handle()) {
+    clear_has_configuration_change();
+      ::Kinova::Api::Base::MapGroupHandle* temp = configuration_change_.map_group_handle_;
+    configuration_change_.map_group_handle_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline const ::Kinova::Api::Base::MapGroupHandle& ConfigurationChangeNotification::map_group_handle() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ConfigurationChangeNotification.map_group_handle)
+  return has_map_group_handle()
+      ? *configuration_change_.map_group_handle_
+      : *reinterpret_cast< ::Kinova::Api::Base::MapGroupHandle*>(&::Kinova::Api::Base::_MapGroupHandle_default_instance_);
+}
+inline ::Kinova::Api::Base::MapGroupHandle* ConfigurationChangeNotification::mutable_map_group_handle() {
+  if (!has_map_group_handle()) {
+    clear_configuration_change();
+    set_has_map_group_handle();
+    configuration_change_.map_group_handle_ = new ::Kinova::Api::Base::MapGroupHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ConfigurationChangeNotification.map_group_handle)
+  return configuration_change_.map_group_handle_;
+}
+
+// .Kinova.Api.Base.MapHandle map_handle = 8;
+inline bool ConfigurationChangeNotification::has_map_handle() const {
+  return configuration_change_case() == kMapHandle;
+}
+inline void ConfigurationChangeNotification::set_has_map_handle() {
+  _oneof_case_[0] = kMapHandle;
+}
+inline void ConfigurationChangeNotification::clear_map_handle() {
+  if (has_map_handle()) {
+    delete configuration_change_.map_handle_;
+    clear_has_configuration_change();
+  }
+}
+inline ::Kinova::Api::Base::MapHandle* ConfigurationChangeNotification::release_map_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ConfigurationChangeNotification.map_handle)
+  if (has_map_handle()) {
+    clear_has_configuration_change();
+      ::Kinova::Api::Base::MapHandle* temp = configuration_change_.map_handle_;
+    configuration_change_.map_handle_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline const ::Kinova::Api::Base::MapHandle& ConfigurationChangeNotification::map_handle() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ConfigurationChangeNotification.map_handle)
+  return has_map_handle()
+      ? *configuration_change_.map_handle_
+      : *reinterpret_cast< ::Kinova::Api::Base::MapHandle*>(&::Kinova::Api::Base::_MapHandle_default_instance_);
+}
+inline ::Kinova::Api::Base::MapHandle* ConfigurationChangeNotification::mutable_map_handle() {
+  if (!has_map_handle()) {
+    clear_configuration_change();
+    set_has_map_handle();
+    configuration_change_.map_handle_ = new ::Kinova::Api::Base::MapHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ConfigurationChangeNotification.map_handle)
+  return configuration_change_.map_handle_;
+}
+
+// .Kinova.Api.Common.UserProfileHandle user_profile_handle = 9;
+inline bool ConfigurationChangeNotification::has_user_profile_handle() const {
+  return configuration_change_case() == kUserProfileHandle;
+}
+inline void ConfigurationChangeNotification::set_has_user_profile_handle() {
+  _oneof_case_[0] = kUserProfileHandle;
+}
+inline ::Kinova::Api::Common::UserProfileHandle* ConfigurationChangeNotification::release_user_profile_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ConfigurationChangeNotification.user_profile_handle)
+  if (has_user_profile_handle()) {
+    clear_has_configuration_change();
+      ::Kinova::Api::Common::UserProfileHandle* temp = configuration_change_.user_profile_handle_;
+    configuration_change_.user_profile_handle_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline const ::Kinova::Api::Common::UserProfileHandle& ConfigurationChangeNotification::user_profile_handle() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ConfigurationChangeNotification.user_profile_handle)
+  return has_user_profile_handle()
+      ? *configuration_change_.user_profile_handle_
+      : *reinterpret_cast< ::Kinova::Api::Common::UserProfileHandle*>(&::Kinova::Api::Common::_UserProfileHandle_default_instance_);
+}
+inline ::Kinova::Api::Common::UserProfileHandle* ConfigurationChangeNotification::mutable_user_profile_handle() {
+  if (!has_user_profile_handle()) {
+    clear_configuration_change();
+    set_has_user_profile_handle();
+    configuration_change_.user_profile_handle_ = new ::Kinova::Api::Common::UserProfileHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ConfigurationChangeNotification.user_profile_handle)
+  return configuration_change_.user_profile_handle_;
+}
+
+// .Kinova.Api.Base.ProtectionZoneHandle protection_zone_handle = 10;
+inline bool ConfigurationChangeNotification::has_protection_zone_handle() const {
+  return configuration_change_case() == kProtectionZoneHandle;
+}
+inline void ConfigurationChangeNotification::set_has_protection_zone_handle() {
+  _oneof_case_[0] = kProtectionZoneHandle;
+}
+inline void ConfigurationChangeNotification::clear_protection_zone_handle() {
+  if (has_protection_zone_handle()) {
+    delete configuration_change_.protection_zone_handle_;
+    clear_has_configuration_change();
+  }
+}
+inline ::Kinova::Api::Base::ProtectionZoneHandle* ConfigurationChangeNotification::release_protection_zone_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ConfigurationChangeNotification.protection_zone_handle)
+  if (has_protection_zone_handle()) {
+    clear_has_configuration_change();
+      ::Kinova::Api::Base::ProtectionZoneHandle* temp = configuration_change_.protection_zone_handle_;
+    configuration_change_.protection_zone_handle_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline const ::Kinova::Api::Base::ProtectionZoneHandle& ConfigurationChangeNotification::protection_zone_handle() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ConfigurationChangeNotification.protection_zone_handle)
+  return has_protection_zone_handle()
+      ? *configuration_change_.protection_zone_handle_
+      : *reinterpret_cast< ::Kinova::Api::Base::ProtectionZoneHandle*>(&::Kinova::Api::Base::_ProtectionZoneHandle_default_instance_);
+}
+inline ::Kinova::Api::Base::ProtectionZoneHandle* ConfigurationChangeNotification::mutable_protection_zone_handle() {
+  if (!has_protection_zone_handle()) {
+    clear_configuration_change();
+    set_has_protection_zone_handle();
+    configuration_change_.protection_zone_handle_ = new ::Kinova::Api::Base::ProtectionZoneHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ConfigurationChangeNotification.protection_zone_handle)
+  return configuration_change_.protection_zone_handle_;
+}
+
+// .Kinova.Api.Common.SafetyHandle safety_handle = 11;
+inline bool ConfigurationChangeNotification::has_safety_handle() const {
+  return configuration_change_case() == kSafetyHandle;
+}
+inline void ConfigurationChangeNotification::set_has_safety_handle() {
+  _oneof_case_[0] = kSafetyHandle;
+}
+inline ::Kinova::Api::Common::SafetyHandle* ConfigurationChangeNotification::release_safety_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ConfigurationChangeNotification.safety_handle)
+  if (has_safety_handle()) {
+    clear_has_configuration_change();
+      ::Kinova::Api::Common::SafetyHandle* temp = configuration_change_.safety_handle_;
+    configuration_change_.safety_handle_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline const ::Kinova::Api::Common::SafetyHandle& ConfigurationChangeNotification::safety_handle() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ConfigurationChangeNotification.safety_handle)
+  return has_safety_handle()
+      ? *configuration_change_.safety_handle_
+      : *reinterpret_cast< ::Kinova::Api::Common::SafetyHandle*>(&::Kinova::Api::Common::_SafetyHandle_default_instance_);
+}
+inline ::Kinova::Api::Common::SafetyHandle* ConfigurationChangeNotification::mutable_safety_handle() {
+  if (!has_safety_handle()) {
+    clear_configuration_change();
+    set_has_safety_handle();
+    configuration_change_.safety_handle_ = new ::Kinova::Api::Common::SafetyHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ConfigurationChangeNotification.safety_handle)
+  return configuration_change_.safety_handle_;
+}
+
+// .Kinova.Api.Base.NetworkHandle network_handle = 12;
+inline bool ConfigurationChangeNotification::has_network_handle() const {
+  return configuration_change_case() == kNetworkHandle;
+}
+inline void ConfigurationChangeNotification::set_has_network_handle() {
+  _oneof_case_[0] = kNetworkHandle;
+}
+inline void ConfigurationChangeNotification::clear_network_handle() {
+  if (has_network_handle()) {
+    delete configuration_change_.network_handle_;
+    clear_has_configuration_change();
+  }
+}
+inline ::Kinova::Api::Base::NetworkHandle* ConfigurationChangeNotification::release_network_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ConfigurationChangeNotification.network_handle)
+  if (has_network_handle()) {
+    clear_has_configuration_change();
+      ::Kinova::Api::Base::NetworkHandle* temp = configuration_change_.network_handle_;
+    configuration_change_.network_handle_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline const ::Kinova::Api::Base::NetworkHandle& ConfigurationChangeNotification::network_handle() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ConfigurationChangeNotification.network_handle)
+  return has_network_handle()
+      ? *configuration_change_.network_handle_
+      : *reinterpret_cast< ::Kinova::Api::Base::NetworkHandle*>(&::Kinova::Api::Base::_NetworkHandle_default_instance_);
+}
+inline ::Kinova::Api::Base::NetworkHandle* ConfigurationChangeNotification::mutable_network_handle() {
+  if (!has_network_handle()) {
+    clear_configuration_change();
+    set_has_network_handle();
+    configuration_change_.network_handle_ = new ::Kinova::Api::Base::NetworkHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ConfigurationChangeNotification.network_handle)
+  return configuration_change_.network_handle_;
+}
+
+// .Kinova.Api.Base.Ssid ssid = 14;
+inline bool ConfigurationChangeNotification::has_ssid() const {
+  return configuration_change_case() == kSsid;
+}
+inline void ConfigurationChangeNotification::set_has_ssid() {
+  _oneof_case_[0] = kSsid;
+}
+inline void ConfigurationChangeNotification::clear_ssid() {
+  if (has_ssid()) {
+    delete configuration_change_.ssid_;
+    clear_has_configuration_change();
+  }
+}
+inline ::Kinova::Api::Base::Ssid* ConfigurationChangeNotification::release_ssid() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ConfigurationChangeNotification.ssid)
+  if (has_ssid()) {
+    clear_has_configuration_change();
+      ::Kinova::Api::Base::Ssid* temp = configuration_change_.ssid_;
+    configuration_change_.ssid_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline const ::Kinova::Api::Base::Ssid& ConfigurationChangeNotification::ssid() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ConfigurationChangeNotification.ssid)
+  return has_ssid()
+      ? *configuration_change_.ssid_
+      : *reinterpret_cast< ::Kinova::Api::Base::Ssid*>(&::Kinova::Api::Base::_Ssid_default_instance_);
+}
+inline ::Kinova::Api::Base::Ssid* ConfigurationChangeNotification::mutable_ssid() {
+  if (!has_ssid()) {
+    clear_configuration_change();
+    set_has_ssid();
+    configuration_change_.ssid_ = new ::Kinova::Api::Base::Ssid;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ConfigurationChangeNotification.ssid)
+  return configuration_change_.ssid_;
+}
+
+// .Kinova.Api.Base.ControllerHandle controller_handle = 16;
+inline bool ConfigurationChangeNotification::has_controller_handle() const {
+  return configuration_change_case() == kControllerHandle;
+}
+inline void ConfigurationChangeNotification::set_has_controller_handle() {
+  _oneof_case_[0] = kControllerHandle;
+}
+inline void ConfigurationChangeNotification::clear_controller_handle() {
+  if (has_controller_handle()) {
+    delete configuration_change_.controller_handle_;
+    clear_has_configuration_change();
+  }
+}
+inline ::Kinova::Api::Base::ControllerHandle* ConfigurationChangeNotification::release_controller_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ConfigurationChangeNotification.controller_handle)
+  if (has_controller_handle()) {
+    clear_has_configuration_change();
+      ::Kinova::Api::Base::ControllerHandle* temp = configuration_change_.controller_handle_;
+    configuration_change_.controller_handle_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline const ::Kinova::Api::Base::ControllerHandle& ConfigurationChangeNotification::controller_handle() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ConfigurationChangeNotification.controller_handle)
+  return has_controller_handle()
+      ? *configuration_change_.controller_handle_
+      : *reinterpret_cast< ::Kinova::Api::Base::ControllerHandle*>(&::Kinova::Api::Base::_ControllerHandle_default_instance_);
+}
+inline ::Kinova::Api::Base::ControllerHandle* ConfigurationChangeNotification::mutable_controller_handle() {
+  if (!has_controller_handle()) {
+    clear_configuration_change();
+    set_has_controller_handle();
+    configuration_change_.controller_handle_ = new ::Kinova::Api::Base::ControllerHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ConfigurationChangeNotification.controller_handle)
+  return configuration_change_.controller_handle_;
+}
+
+// .Kinova.Api.Common.Connection connection = 15;
+inline bool ConfigurationChangeNotification::has_connection() const {
+  return this != internal_default_instance() && connection_ != NULL;
+}
+inline const ::Kinova::Api::Common::Connection& ConfigurationChangeNotification::connection() const {
+  const ::Kinova::Api::Common::Connection* p = connection_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ConfigurationChangeNotification.connection)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::Connection*>(
+      &::Kinova::Api::Common::_Connection_default_instance_);
+}
+inline ::Kinova::Api::Common::Connection* ConfigurationChangeNotification::release_connection() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ConfigurationChangeNotification.connection)
+  
+  ::Kinova::Api::Common::Connection* temp = connection_;
+  connection_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::Connection* ConfigurationChangeNotification::mutable_connection() {
+  
+  if (connection_ == NULL) {
+    connection_ = new ::Kinova::Api::Common::Connection;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ConfigurationChangeNotification.connection)
+  return connection_;
+}
+inline void ConfigurationChangeNotification::set_allocated_connection(::Kinova::Api::Common::Connection* connection) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(connection_);
+  }
+  if (connection) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      connection = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, connection, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  connection_ = connection;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.ConfigurationChangeNotification.connection)
+}
+
+inline bool ConfigurationChangeNotification::has_configuration_change() const {
+  return configuration_change_case() != CONFIGURATION_CHANGE_NOT_SET;
+}
+inline void ConfigurationChangeNotification::clear_has_configuration_change() {
+  _oneof_case_[0] = CONFIGURATION_CHANGE_NOT_SET;
+}
+inline ConfigurationChangeNotification::ConfigurationChangeCase ConfigurationChangeNotification::configuration_change_case() const {
+  return ConfigurationChangeNotification::ConfigurationChangeCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// MappingInfoNotification
+
+// uint32 controller_identifier = 1;
+inline void MappingInfoNotification::clear_controller_identifier() {
+  controller_identifier_ = 0u;
+}
+inline ::google::protobuf::uint32 MappingInfoNotification::controller_identifier() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.MappingInfoNotification.controller_identifier)
+  return controller_identifier_;
+}
+inline void MappingInfoNotification::set_controller_identifier(::google::protobuf::uint32 value) {
+  
+  controller_identifier_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.MappingInfoNotification.controller_identifier)
+}
+
+// .Kinova.Api.Base.MapHandle active_map_handle = 2;
+inline bool MappingInfoNotification::has_active_map_handle() const {
+  return this != internal_default_instance() && active_map_handle_ != NULL;
+}
+inline void MappingInfoNotification::clear_active_map_handle() {
+  if (GetArenaNoVirtual() == NULL && active_map_handle_ != NULL) {
+    delete active_map_handle_;
+  }
+  active_map_handle_ = NULL;
+}
+inline const ::Kinova::Api::Base::MapHandle& MappingInfoNotification::active_map_handle() const {
+  const ::Kinova::Api::Base::MapHandle* p = active_map_handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.MappingInfoNotification.active_map_handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::MapHandle*>(
+      &::Kinova::Api::Base::_MapHandle_default_instance_);
+}
+inline ::Kinova::Api::Base::MapHandle* MappingInfoNotification::release_active_map_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.MappingInfoNotification.active_map_handle)
+  
+  ::Kinova::Api::Base::MapHandle* temp = active_map_handle_;
+  active_map_handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::MapHandle* MappingInfoNotification::mutable_active_map_handle() {
+  
+  if (active_map_handle_ == NULL) {
+    active_map_handle_ = new ::Kinova::Api::Base::MapHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.MappingInfoNotification.active_map_handle)
+  return active_map_handle_;
+}
+inline void MappingInfoNotification::set_allocated_active_map_handle(::Kinova::Api::Base::MapHandle* active_map_handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete active_map_handle_;
+  }
+  if (active_map_handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      active_map_handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, active_map_handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  active_map_handle_ = active_map_handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.MappingInfoNotification.active_map_handle)
+}
+
+// .Kinova.Api.Common.Timestamp timestamp = 3;
+inline bool MappingInfoNotification::has_timestamp() const {
+  return this != internal_default_instance() && timestamp_ != NULL;
+}
+inline const ::Kinova::Api::Common::Timestamp& MappingInfoNotification::timestamp() const {
+  const ::Kinova::Api::Common::Timestamp* p = timestamp_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.MappingInfoNotification.timestamp)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::Timestamp*>(
+      &::Kinova::Api::Common::_Timestamp_default_instance_);
+}
+inline ::Kinova::Api::Common::Timestamp* MappingInfoNotification::release_timestamp() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.MappingInfoNotification.timestamp)
+  
+  ::Kinova::Api::Common::Timestamp* temp = timestamp_;
+  timestamp_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::Timestamp* MappingInfoNotification::mutable_timestamp() {
+  
+  if (timestamp_ == NULL) {
+    timestamp_ = new ::Kinova::Api::Common::Timestamp;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.MappingInfoNotification.timestamp)
+  return timestamp_;
+}
+inline void MappingInfoNotification::set_allocated_timestamp(::Kinova::Api::Common::Timestamp* timestamp) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(timestamp_);
+  }
+  if (timestamp) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      timestamp = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, timestamp, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  timestamp_ = timestamp;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.MappingInfoNotification.timestamp)
+}
+
+// .Kinova.Api.Common.UserProfileHandle user_handle = 4;
+inline bool MappingInfoNotification::has_user_handle() const {
+  return this != internal_default_instance() && user_handle_ != NULL;
+}
+inline const ::Kinova::Api::Common::UserProfileHandle& MappingInfoNotification::user_handle() const {
+  const ::Kinova::Api::Common::UserProfileHandle* p = user_handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.MappingInfoNotification.user_handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::UserProfileHandle*>(
+      &::Kinova::Api::Common::_UserProfileHandle_default_instance_);
+}
+inline ::Kinova::Api::Common::UserProfileHandle* MappingInfoNotification::release_user_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.MappingInfoNotification.user_handle)
+  
+  ::Kinova::Api::Common::UserProfileHandle* temp = user_handle_;
+  user_handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::UserProfileHandle* MappingInfoNotification::mutable_user_handle() {
+  
+  if (user_handle_ == NULL) {
+    user_handle_ = new ::Kinova::Api::Common::UserProfileHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.MappingInfoNotification.user_handle)
+  return user_handle_;
+}
+inline void MappingInfoNotification::set_allocated_user_handle(::Kinova::Api::Common::UserProfileHandle* user_handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(user_handle_);
+  }
+  if (user_handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      user_handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, user_handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  user_handle_ = user_handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.MappingInfoNotification.user_handle)
+}
+
+// .Kinova.Api.Common.Connection connection = 5;
+inline bool MappingInfoNotification::has_connection() const {
+  return this != internal_default_instance() && connection_ != NULL;
+}
+inline const ::Kinova::Api::Common::Connection& MappingInfoNotification::connection() const {
+  const ::Kinova::Api::Common::Connection* p = connection_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.MappingInfoNotification.connection)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::Connection*>(
+      &::Kinova::Api::Common::_Connection_default_instance_);
+}
+inline ::Kinova::Api::Common::Connection* MappingInfoNotification::release_connection() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.MappingInfoNotification.connection)
+  
+  ::Kinova::Api::Common::Connection* temp = connection_;
+  connection_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::Connection* MappingInfoNotification::mutable_connection() {
+  
+  if (connection_ == NULL) {
+    connection_ = new ::Kinova::Api::Common::Connection;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.MappingInfoNotification.connection)
+  return connection_;
+}
+inline void MappingInfoNotification::set_allocated_connection(::Kinova::Api::Common::Connection* connection) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(connection_);
+  }
+  if (connection) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      connection = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, connection, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  connection_ = connection;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.MappingInfoNotification.connection)
+}
+
+// .Kinova.Api.Base.MappingHandle mapping_handle = 6;
+inline bool MappingInfoNotification::has_mapping_handle() const {
+  return this != internal_default_instance() && mapping_handle_ != NULL;
+}
+inline void MappingInfoNotification::clear_mapping_handle() {
+  if (GetArenaNoVirtual() == NULL && mapping_handle_ != NULL) {
+    delete mapping_handle_;
+  }
+  mapping_handle_ = NULL;
+}
+inline const ::Kinova::Api::Base::MappingHandle& MappingInfoNotification::mapping_handle() const {
+  const ::Kinova::Api::Base::MappingHandle* p = mapping_handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.MappingInfoNotification.mapping_handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::MappingHandle*>(
+      &::Kinova::Api::Base::_MappingHandle_default_instance_);
+}
+inline ::Kinova::Api::Base::MappingHandle* MappingInfoNotification::release_mapping_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.MappingInfoNotification.mapping_handle)
+  
+  ::Kinova::Api::Base::MappingHandle* temp = mapping_handle_;
+  mapping_handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::MappingHandle* MappingInfoNotification::mutable_mapping_handle() {
+  
+  if (mapping_handle_ == NULL) {
+    mapping_handle_ = new ::Kinova::Api::Base::MappingHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.MappingInfoNotification.mapping_handle)
+  return mapping_handle_;
+}
+inline void MappingInfoNotification::set_allocated_mapping_handle(::Kinova::Api::Base::MappingHandle* mapping_handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete mapping_handle_;
+  }
+  if (mapping_handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      mapping_handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, mapping_handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  mapping_handle_ = mapping_handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.MappingInfoNotification.mapping_handle)
+}
+
+// -------------------------------------------------------------------
+
+// ServoingModeInformation
+
+// .Kinova.Api.Base.ServoingMode servoing_mode = 1;
+inline void ServoingModeInformation::clear_servoing_mode() {
+  servoing_mode_ = 0;
+}
+inline ::Kinova::Api::Base::ServoingMode ServoingModeInformation::servoing_mode() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ServoingModeInformation.servoing_mode)
+  return static_cast< ::Kinova::Api::Base::ServoingMode >(servoing_mode_);
+}
+inline void ServoingModeInformation::set_servoing_mode(::Kinova::Api::Base::ServoingMode value) {
+  
+  servoing_mode_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.ServoingModeInformation.servoing_mode)
+}
+
+// -------------------------------------------------------------------
+
+// OperatingModeInformation
+
+// .Kinova.Api.Base.OperatingMode operating_mode = 1;
+inline void OperatingModeInformation::clear_operating_mode() {
+  operating_mode_ = 0;
+}
+inline ::Kinova::Api::Base::OperatingMode OperatingModeInformation::operating_mode() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.OperatingModeInformation.operating_mode)
+  return static_cast< ::Kinova::Api::Base::OperatingMode >(operating_mode_);
+}
+inline void OperatingModeInformation::set_operating_mode(::Kinova::Api::Base::OperatingMode value) {
+  
+  operating_mode_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.OperatingModeInformation.operating_mode)
+}
+
+// .Kinova.Api.Common.DeviceHandle device_handle = 2;
+inline bool OperatingModeInformation::has_device_handle() const {
+  return this != internal_default_instance() && device_handle_ != NULL;
+}
+inline const ::Kinova::Api::Common::DeviceHandle& OperatingModeInformation::device_handle() const {
+  const ::Kinova::Api::Common::DeviceHandle* p = device_handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.OperatingModeInformation.device_handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::DeviceHandle*>(
+      &::Kinova::Api::Common::_DeviceHandle_default_instance_);
+}
+inline ::Kinova::Api::Common::DeviceHandle* OperatingModeInformation::release_device_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.OperatingModeInformation.device_handle)
+  
+  ::Kinova::Api::Common::DeviceHandle* temp = device_handle_;
+  device_handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::DeviceHandle* OperatingModeInformation::mutable_device_handle() {
+  
+  if (device_handle_ == NULL) {
+    device_handle_ = new ::Kinova::Api::Common::DeviceHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.OperatingModeInformation.device_handle)
+  return device_handle_;
+}
+inline void OperatingModeInformation::set_allocated_device_handle(::Kinova::Api::Common::DeviceHandle* device_handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(device_handle_);
+  }
+  if (device_handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      device_handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, device_handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  device_handle_ = device_handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.OperatingModeInformation.device_handle)
+}
+
+// -------------------------------------------------------------------
+
+// OperatingModeNotification
+
+// .Kinova.Api.Base.OperatingMode operating_mode = 1;
+inline void OperatingModeNotification::clear_operating_mode() {
+  operating_mode_ = 0;
+}
+inline ::Kinova::Api::Base::OperatingMode OperatingModeNotification::operating_mode() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.OperatingModeNotification.operating_mode)
+  return static_cast< ::Kinova::Api::Base::OperatingMode >(operating_mode_);
+}
+inline void OperatingModeNotification::set_operating_mode(::Kinova::Api::Base::OperatingMode value) {
+  
+  operating_mode_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.OperatingModeNotification.operating_mode)
+}
+
+// .Kinova.Api.Common.Timestamp timestamp = 2;
+inline bool OperatingModeNotification::has_timestamp() const {
+  return this != internal_default_instance() && timestamp_ != NULL;
+}
+inline const ::Kinova::Api::Common::Timestamp& OperatingModeNotification::timestamp() const {
+  const ::Kinova::Api::Common::Timestamp* p = timestamp_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.OperatingModeNotification.timestamp)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::Timestamp*>(
+      &::Kinova::Api::Common::_Timestamp_default_instance_);
+}
+inline ::Kinova::Api::Common::Timestamp* OperatingModeNotification::release_timestamp() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.OperatingModeNotification.timestamp)
+  
+  ::Kinova::Api::Common::Timestamp* temp = timestamp_;
+  timestamp_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::Timestamp* OperatingModeNotification::mutable_timestamp() {
+  
+  if (timestamp_ == NULL) {
+    timestamp_ = new ::Kinova::Api::Common::Timestamp;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.OperatingModeNotification.timestamp)
+  return timestamp_;
+}
+inline void OperatingModeNotification::set_allocated_timestamp(::Kinova::Api::Common::Timestamp* timestamp) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(timestamp_);
+  }
+  if (timestamp) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      timestamp = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, timestamp, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  timestamp_ = timestamp;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.OperatingModeNotification.timestamp)
+}
+
+// .Kinova.Api.Common.UserProfileHandle user_handle = 3;
+inline bool OperatingModeNotification::has_user_handle() const {
+  return this != internal_default_instance() && user_handle_ != NULL;
+}
+inline const ::Kinova::Api::Common::UserProfileHandle& OperatingModeNotification::user_handle() const {
+  const ::Kinova::Api::Common::UserProfileHandle* p = user_handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.OperatingModeNotification.user_handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::UserProfileHandle*>(
+      &::Kinova::Api::Common::_UserProfileHandle_default_instance_);
+}
+inline ::Kinova::Api::Common::UserProfileHandle* OperatingModeNotification::release_user_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.OperatingModeNotification.user_handle)
+  
+  ::Kinova::Api::Common::UserProfileHandle* temp = user_handle_;
+  user_handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::UserProfileHandle* OperatingModeNotification::mutable_user_handle() {
+  
+  if (user_handle_ == NULL) {
+    user_handle_ = new ::Kinova::Api::Common::UserProfileHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.OperatingModeNotification.user_handle)
+  return user_handle_;
+}
+inline void OperatingModeNotification::set_allocated_user_handle(::Kinova::Api::Common::UserProfileHandle* user_handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(user_handle_);
+  }
+  if (user_handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      user_handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, user_handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  user_handle_ = user_handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.OperatingModeNotification.user_handle)
+}
+
+// .Kinova.Api.Common.Connection connection = 4;
+inline bool OperatingModeNotification::has_connection() const {
+  return this != internal_default_instance() && connection_ != NULL;
+}
+inline const ::Kinova::Api::Common::Connection& OperatingModeNotification::connection() const {
+  const ::Kinova::Api::Common::Connection* p = connection_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.OperatingModeNotification.connection)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::Connection*>(
+      &::Kinova::Api::Common::_Connection_default_instance_);
+}
+inline ::Kinova::Api::Common::Connection* OperatingModeNotification::release_connection() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.OperatingModeNotification.connection)
+  
+  ::Kinova::Api::Common::Connection* temp = connection_;
+  connection_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::Connection* OperatingModeNotification::mutable_connection() {
+  
+  if (connection_ == NULL) {
+    connection_ = new ::Kinova::Api::Common::Connection;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.OperatingModeNotification.connection)
+  return connection_;
+}
+inline void OperatingModeNotification::set_allocated_connection(::Kinova::Api::Common::Connection* connection) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(connection_);
+  }
+  if (connection) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      connection = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, connection, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  connection_ = connection;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.OperatingModeNotification.connection)
+}
+
+// .Kinova.Api.Common.DeviceHandle device_handle = 5;
+inline bool OperatingModeNotification::has_device_handle() const {
+  return this != internal_default_instance() && device_handle_ != NULL;
+}
+inline const ::Kinova::Api::Common::DeviceHandle& OperatingModeNotification::device_handle() const {
+  const ::Kinova::Api::Common::DeviceHandle* p = device_handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.OperatingModeNotification.device_handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::DeviceHandle*>(
+      &::Kinova::Api::Common::_DeviceHandle_default_instance_);
+}
+inline ::Kinova::Api::Common::DeviceHandle* OperatingModeNotification::release_device_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.OperatingModeNotification.device_handle)
+  
+  ::Kinova::Api::Common::DeviceHandle* temp = device_handle_;
+  device_handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::DeviceHandle* OperatingModeNotification::mutable_device_handle() {
+  
+  if (device_handle_ == NULL) {
+    device_handle_ = new ::Kinova::Api::Common::DeviceHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.OperatingModeNotification.device_handle)
+  return device_handle_;
+}
+inline void OperatingModeNotification::set_allocated_device_handle(::Kinova::Api::Common::DeviceHandle* device_handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(device_handle_);
+  }
+  if (device_handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      device_handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, device_handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  device_handle_ = device_handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.OperatingModeNotification.device_handle)
+}
+
+// -------------------------------------------------------------------
+
+// ServoingModeNotification
+
+// .Kinova.Api.Base.ServoingMode servoing_mode = 1;
+inline void ServoingModeNotification::clear_servoing_mode() {
+  servoing_mode_ = 0;
+}
+inline ::Kinova::Api::Base::ServoingMode ServoingModeNotification::servoing_mode() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ServoingModeNotification.servoing_mode)
+  return static_cast< ::Kinova::Api::Base::ServoingMode >(servoing_mode_);
+}
+inline void ServoingModeNotification::set_servoing_mode(::Kinova::Api::Base::ServoingMode value) {
+  
+  servoing_mode_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.ServoingModeNotification.servoing_mode)
+}
+
+// .Kinova.Api.Common.Timestamp timestamp = 2;
+inline bool ServoingModeNotification::has_timestamp() const {
+  return this != internal_default_instance() && timestamp_ != NULL;
+}
+inline const ::Kinova::Api::Common::Timestamp& ServoingModeNotification::timestamp() const {
+  const ::Kinova::Api::Common::Timestamp* p = timestamp_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ServoingModeNotification.timestamp)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::Timestamp*>(
+      &::Kinova::Api::Common::_Timestamp_default_instance_);
+}
+inline ::Kinova::Api::Common::Timestamp* ServoingModeNotification::release_timestamp() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ServoingModeNotification.timestamp)
+  
+  ::Kinova::Api::Common::Timestamp* temp = timestamp_;
+  timestamp_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::Timestamp* ServoingModeNotification::mutable_timestamp() {
+  
+  if (timestamp_ == NULL) {
+    timestamp_ = new ::Kinova::Api::Common::Timestamp;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ServoingModeNotification.timestamp)
+  return timestamp_;
+}
+inline void ServoingModeNotification::set_allocated_timestamp(::Kinova::Api::Common::Timestamp* timestamp) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(timestamp_);
+  }
+  if (timestamp) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      timestamp = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, timestamp, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  timestamp_ = timestamp;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.ServoingModeNotification.timestamp)
+}
+
+// .Kinova.Api.Common.UserProfileHandle user_handle = 3;
+inline bool ServoingModeNotification::has_user_handle() const {
+  return this != internal_default_instance() && user_handle_ != NULL;
+}
+inline const ::Kinova::Api::Common::UserProfileHandle& ServoingModeNotification::user_handle() const {
+  const ::Kinova::Api::Common::UserProfileHandle* p = user_handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ServoingModeNotification.user_handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::UserProfileHandle*>(
+      &::Kinova::Api::Common::_UserProfileHandle_default_instance_);
+}
+inline ::Kinova::Api::Common::UserProfileHandle* ServoingModeNotification::release_user_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ServoingModeNotification.user_handle)
+  
+  ::Kinova::Api::Common::UserProfileHandle* temp = user_handle_;
+  user_handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::UserProfileHandle* ServoingModeNotification::mutable_user_handle() {
+  
+  if (user_handle_ == NULL) {
+    user_handle_ = new ::Kinova::Api::Common::UserProfileHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ServoingModeNotification.user_handle)
+  return user_handle_;
+}
+inline void ServoingModeNotification::set_allocated_user_handle(::Kinova::Api::Common::UserProfileHandle* user_handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(user_handle_);
+  }
+  if (user_handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      user_handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, user_handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  user_handle_ = user_handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.ServoingModeNotification.user_handle)
+}
+
+// .Kinova.Api.Common.Connection connection = 4;
+inline bool ServoingModeNotification::has_connection() const {
+  return this != internal_default_instance() && connection_ != NULL;
+}
+inline const ::Kinova::Api::Common::Connection& ServoingModeNotification::connection() const {
+  const ::Kinova::Api::Common::Connection* p = connection_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ServoingModeNotification.connection)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::Connection*>(
+      &::Kinova::Api::Common::_Connection_default_instance_);
+}
+inline ::Kinova::Api::Common::Connection* ServoingModeNotification::release_connection() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ServoingModeNotification.connection)
+  
+  ::Kinova::Api::Common::Connection* temp = connection_;
+  connection_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::Connection* ServoingModeNotification::mutable_connection() {
+  
+  if (connection_ == NULL) {
+    connection_ = new ::Kinova::Api::Common::Connection;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ServoingModeNotification.connection)
+  return connection_;
+}
+inline void ServoingModeNotification::set_allocated_connection(::Kinova::Api::Common::Connection* connection) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(connection_);
+  }
+  if (connection) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      connection = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, connection, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  connection_ = connection;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.ServoingModeNotification.connection)
+}
+
+// -------------------------------------------------------------------
+
+// SequenceInfoNotification
+
+// .Kinova.Api.Base.EventIdSequenceInfoNotification event_identifier = 1;
+inline void SequenceInfoNotification::clear_event_identifier() {
+  event_identifier_ = 0;
+}
+inline ::Kinova::Api::Base::EventIdSequenceInfoNotification SequenceInfoNotification::event_identifier() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.SequenceInfoNotification.event_identifier)
+  return static_cast< ::Kinova::Api::Base::EventIdSequenceInfoNotification >(event_identifier_);
+}
+inline void SequenceInfoNotification::set_event_identifier(::Kinova::Api::Base::EventIdSequenceInfoNotification value) {
+  
+  event_identifier_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.SequenceInfoNotification.event_identifier)
+}
+
+// .Kinova.Api.Base.SequenceHandle sequence_handle = 2;
+inline bool SequenceInfoNotification::has_sequence_handle() const {
+  return this != internal_default_instance() && sequence_handle_ != NULL;
+}
+inline void SequenceInfoNotification::clear_sequence_handle() {
+  if (GetArenaNoVirtual() == NULL && sequence_handle_ != NULL) {
+    delete sequence_handle_;
+  }
+  sequence_handle_ = NULL;
+}
+inline const ::Kinova::Api::Base::SequenceHandle& SequenceInfoNotification::sequence_handle() const {
+  const ::Kinova::Api::Base::SequenceHandle* p = sequence_handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.SequenceInfoNotification.sequence_handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::SequenceHandle*>(
+      &::Kinova::Api::Base::_SequenceHandle_default_instance_);
+}
+inline ::Kinova::Api::Base::SequenceHandle* SequenceInfoNotification::release_sequence_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.SequenceInfoNotification.sequence_handle)
+  
+  ::Kinova::Api::Base::SequenceHandle* temp = sequence_handle_;
+  sequence_handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::SequenceHandle* SequenceInfoNotification::mutable_sequence_handle() {
+  
+  if (sequence_handle_ == NULL) {
+    sequence_handle_ = new ::Kinova::Api::Base::SequenceHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.SequenceInfoNotification.sequence_handle)
+  return sequence_handle_;
+}
+inline void SequenceInfoNotification::set_allocated_sequence_handle(::Kinova::Api::Base::SequenceHandle* sequence_handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete sequence_handle_;
+  }
+  if (sequence_handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      sequence_handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, sequence_handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  sequence_handle_ = sequence_handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.SequenceInfoNotification.sequence_handle)
+}
+
+// uint32 task_index = 3;
+inline void SequenceInfoNotification::clear_task_index() {
+  task_index_ = 0u;
+}
+inline ::google::protobuf::uint32 SequenceInfoNotification::task_index() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.SequenceInfoNotification.task_index)
+  return task_index_;
+}
+inline void SequenceInfoNotification::set_task_index(::google::protobuf::uint32 value) {
+  
+  task_index_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.SequenceInfoNotification.task_index)
+}
+
+// .Kinova.Api.Common.Timestamp timestamp = 5;
+inline bool SequenceInfoNotification::has_timestamp() const {
+  return this != internal_default_instance() && timestamp_ != NULL;
+}
+inline const ::Kinova::Api::Common::Timestamp& SequenceInfoNotification::timestamp() const {
+  const ::Kinova::Api::Common::Timestamp* p = timestamp_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.SequenceInfoNotification.timestamp)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::Timestamp*>(
+      &::Kinova::Api::Common::_Timestamp_default_instance_);
+}
+inline ::Kinova::Api::Common::Timestamp* SequenceInfoNotification::release_timestamp() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.SequenceInfoNotification.timestamp)
+  
+  ::Kinova::Api::Common::Timestamp* temp = timestamp_;
+  timestamp_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::Timestamp* SequenceInfoNotification::mutable_timestamp() {
+  
+  if (timestamp_ == NULL) {
+    timestamp_ = new ::Kinova::Api::Common::Timestamp;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.SequenceInfoNotification.timestamp)
+  return timestamp_;
+}
+inline void SequenceInfoNotification::set_allocated_timestamp(::Kinova::Api::Common::Timestamp* timestamp) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(timestamp_);
+  }
+  if (timestamp) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      timestamp = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, timestamp, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  timestamp_ = timestamp;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.SequenceInfoNotification.timestamp)
+}
+
+// .Kinova.Api.Common.UserProfileHandle user_handle = 6;
+inline bool SequenceInfoNotification::has_user_handle() const {
+  return this != internal_default_instance() && user_handle_ != NULL;
+}
+inline const ::Kinova::Api::Common::UserProfileHandle& SequenceInfoNotification::user_handle() const {
+  const ::Kinova::Api::Common::UserProfileHandle* p = user_handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.SequenceInfoNotification.user_handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::UserProfileHandle*>(
+      &::Kinova::Api::Common::_UserProfileHandle_default_instance_);
+}
+inline ::Kinova::Api::Common::UserProfileHandle* SequenceInfoNotification::release_user_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.SequenceInfoNotification.user_handle)
+  
+  ::Kinova::Api::Common::UserProfileHandle* temp = user_handle_;
+  user_handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::UserProfileHandle* SequenceInfoNotification::mutable_user_handle() {
+  
+  if (user_handle_ == NULL) {
+    user_handle_ = new ::Kinova::Api::Common::UserProfileHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.SequenceInfoNotification.user_handle)
+  return user_handle_;
+}
+inline void SequenceInfoNotification::set_allocated_user_handle(::Kinova::Api::Common::UserProfileHandle* user_handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(user_handle_);
+  }
+  if (user_handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      user_handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, user_handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  user_handle_ = user_handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.SequenceInfoNotification.user_handle)
+}
+
+// .Kinova.Api.SubErrorCodes abort_details = 7;
+inline void SequenceInfoNotification::clear_abort_details() {
+  abort_details_ = 0;
+}
+inline ::Kinova::Api::SubErrorCodes SequenceInfoNotification::abort_details() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.SequenceInfoNotification.abort_details)
+  return static_cast< ::Kinova::Api::SubErrorCodes >(abort_details_);
+}
+inline void SequenceInfoNotification::set_abort_details(::Kinova::Api::SubErrorCodes value) {
+  
+  abort_details_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.SequenceInfoNotification.abort_details)
+}
+
+// .Kinova.Api.Common.Connection connection = 8;
+inline bool SequenceInfoNotification::has_connection() const {
+  return this != internal_default_instance() && connection_ != NULL;
+}
+inline const ::Kinova::Api::Common::Connection& SequenceInfoNotification::connection() const {
+  const ::Kinova::Api::Common::Connection* p = connection_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.SequenceInfoNotification.connection)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::Connection*>(
+      &::Kinova::Api::Common::_Connection_default_instance_);
+}
+inline ::Kinova::Api::Common::Connection* SequenceInfoNotification::release_connection() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.SequenceInfoNotification.connection)
+  
+  ::Kinova::Api::Common::Connection* temp = connection_;
+  connection_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::Connection* SequenceInfoNotification::mutable_connection() {
+  
+  if (connection_ == NULL) {
+    connection_ = new ::Kinova::Api::Common::Connection;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.SequenceInfoNotification.connection)
+  return connection_;
+}
+inline void SequenceInfoNotification::set_allocated_connection(::Kinova::Api::Common::Connection* connection) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(connection_);
+  }
+  if (connection) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      connection = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, connection, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  connection_ = connection;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.SequenceInfoNotification.connection)
+}
+
+// -------------------------------------------------------------------
+
+// SequenceInformation
+
+// .Kinova.Api.Base.EventIdSequenceInfoNotification event_identifier = 1;
+inline void SequenceInformation::clear_event_identifier() {
+  event_identifier_ = 0;
+}
+inline ::Kinova::Api::Base::EventIdSequenceInfoNotification SequenceInformation::event_identifier() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.SequenceInformation.event_identifier)
+  return static_cast< ::Kinova::Api::Base::EventIdSequenceInfoNotification >(event_identifier_);
+}
+inline void SequenceInformation::set_event_identifier(::Kinova::Api::Base::EventIdSequenceInfoNotification value) {
+  
+  event_identifier_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.SequenceInformation.event_identifier)
+}
+
+// uint32 task_index = 2;
+inline void SequenceInformation::clear_task_index() {
+  task_index_ = 0u;
+}
+inline ::google::protobuf::uint32 SequenceInformation::task_index() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.SequenceInformation.task_index)
+  return task_index_;
+}
+inline void SequenceInformation::set_task_index(::google::protobuf::uint32 value) {
+  
+  task_index_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.SequenceInformation.task_index)
+}
+
+// uint32 task_identifier = 3;
+inline void SequenceInformation::clear_task_identifier() {
+  task_identifier_ = 0u;
+}
+inline ::google::protobuf::uint32 SequenceInformation::task_identifier() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.SequenceInformation.task_identifier)
+  return task_identifier_;
+}
+inline void SequenceInformation::set_task_identifier(::google::protobuf::uint32 value) {
+  
+  task_identifier_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.SequenceInformation.task_identifier)
+}
+
+// -------------------------------------------------------------------
+
+// ProtectionZoneNotification
+
+// .Kinova.Api.Base.ProtectionZoneEvent event = 1;
+inline void ProtectionZoneNotification::clear_event() {
+  event_ = 0;
+}
+inline ::Kinova::Api::Base::ProtectionZoneEvent ProtectionZoneNotification::event() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ProtectionZoneNotification.event)
+  return static_cast< ::Kinova::Api::Base::ProtectionZoneEvent >(event_);
+}
+inline void ProtectionZoneNotification::set_event(::Kinova::Api::Base::ProtectionZoneEvent value) {
+  
+  event_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.ProtectionZoneNotification.event)
+}
+
+// .Kinova.Api.Base.ProtectionZoneHandle handle = 2;
+inline bool ProtectionZoneNotification::has_handle() const {
+  return this != internal_default_instance() && handle_ != NULL;
+}
+inline void ProtectionZoneNotification::clear_handle() {
+  if (GetArenaNoVirtual() == NULL && handle_ != NULL) {
+    delete handle_;
+  }
+  handle_ = NULL;
+}
+inline const ::Kinova::Api::Base::ProtectionZoneHandle& ProtectionZoneNotification::handle() const {
+  const ::Kinova::Api::Base::ProtectionZoneHandle* p = handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ProtectionZoneNotification.handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::ProtectionZoneHandle*>(
+      &::Kinova::Api::Base::_ProtectionZoneHandle_default_instance_);
+}
+inline ::Kinova::Api::Base::ProtectionZoneHandle* ProtectionZoneNotification::release_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ProtectionZoneNotification.handle)
+  
+  ::Kinova::Api::Base::ProtectionZoneHandle* temp = handle_;
+  handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::ProtectionZoneHandle* ProtectionZoneNotification::mutable_handle() {
+  
+  if (handle_ == NULL) {
+    handle_ = new ::Kinova::Api::Base::ProtectionZoneHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ProtectionZoneNotification.handle)
+  return handle_;
+}
+inline void ProtectionZoneNotification::set_allocated_handle(::Kinova::Api::Base::ProtectionZoneHandle* handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete handle_;
+  }
+  if (handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  handle_ = handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.ProtectionZoneNotification.handle)
+}
+
+// .Kinova.Api.Common.Timestamp timestamp = 3;
+inline bool ProtectionZoneNotification::has_timestamp() const {
+  return this != internal_default_instance() && timestamp_ != NULL;
+}
+inline const ::Kinova::Api::Common::Timestamp& ProtectionZoneNotification::timestamp() const {
+  const ::Kinova::Api::Common::Timestamp* p = timestamp_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ProtectionZoneNotification.timestamp)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::Timestamp*>(
+      &::Kinova::Api::Common::_Timestamp_default_instance_);
+}
+inline ::Kinova::Api::Common::Timestamp* ProtectionZoneNotification::release_timestamp() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ProtectionZoneNotification.timestamp)
+  
+  ::Kinova::Api::Common::Timestamp* temp = timestamp_;
+  timestamp_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::Timestamp* ProtectionZoneNotification::mutable_timestamp() {
+  
+  if (timestamp_ == NULL) {
+    timestamp_ = new ::Kinova::Api::Common::Timestamp;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ProtectionZoneNotification.timestamp)
+  return timestamp_;
+}
+inline void ProtectionZoneNotification::set_allocated_timestamp(::Kinova::Api::Common::Timestamp* timestamp) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(timestamp_);
+  }
+  if (timestamp) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      timestamp = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, timestamp, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  timestamp_ = timestamp;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.ProtectionZoneNotification.timestamp)
+}
+
+// .Kinova.Api.Common.UserProfileHandle user_handle = 4;
+inline bool ProtectionZoneNotification::has_user_handle() const {
+  return this != internal_default_instance() && user_handle_ != NULL;
+}
+inline const ::Kinova::Api::Common::UserProfileHandle& ProtectionZoneNotification::user_handle() const {
+  const ::Kinova::Api::Common::UserProfileHandle* p = user_handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ProtectionZoneNotification.user_handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::UserProfileHandle*>(
+      &::Kinova::Api::Common::_UserProfileHandle_default_instance_);
+}
+inline ::Kinova::Api::Common::UserProfileHandle* ProtectionZoneNotification::release_user_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ProtectionZoneNotification.user_handle)
+  
+  ::Kinova::Api::Common::UserProfileHandle* temp = user_handle_;
+  user_handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::UserProfileHandle* ProtectionZoneNotification::mutable_user_handle() {
+  
+  if (user_handle_ == NULL) {
+    user_handle_ = new ::Kinova::Api::Common::UserProfileHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ProtectionZoneNotification.user_handle)
+  return user_handle_;
+}
+inline void ProtectionZoneNotification::set_allocated_user_handle(::Kinova::Api::Common::UserProfileHandle* user_handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(user_handle_);
+  }
+  if (user_handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      user_handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, user_handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  user_handle_ = user_handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.ProtectionZoneNotification.user_handle)
+}
+
+// .Kinova.Api.Common.Connection connection = 5;
+inline bool ProtectionZoneNotification::has_connection() const {
+  return this != internal_default_instance() && connection_ != NULL;
+}
+inline const ::Kinova::Api::Common::Connection& ProtectionZoneNotification::connection() const {
+  const ::Kinova::Api::Common::Connection* p = connection_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ProtectionZoneNotification.connection)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::Connection*>(
+      &::Kinova::Api::Common::_Connection_default_instance_);
+}
+inline ::Kinova::Api::Common::Connection* ProtectionZoneNotification::release_connection() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ProtectionZoneNotification.connection)
+  
+  ::Kinova::Api::Common::Connection* temp = connection_;
+  connection_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::Connection* ProtectionZoneNotification::mutable_connection() {
+  
+  if (connection_ == NULL) {
+    connection_ = new ::Kinova::Api::Common::Connection;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ProtectionZoneNotification.connection)
+  return connection_;
+}
+inline void ProtectionZoneNotification::set_allocated_connection(::Kinova::Api::Common::Connection* connection) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(connection_);
+  }
+  if (connection) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      connection = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, connection, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  connection_ = connection;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.ProtectionZoneNotification.connection)
+}
+
+// -------------------------------------------------------------------
+
+// ProtectionZoneInformation
+
+// .Kinova.Api.Base.ProtectionZoneEvent event = 1;
+inline void ProtectionZoneInformation::clear_event() {
+  event_ = 0;
+}
+inline ::Kinova::Api::Base::ProtectionZoneEvent ProtectionZoneInformation::event() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ProtectionZoneInformation.event)
+  return static_cast< ::Kinova::Api::Base::ProtectionZoneEvent >(event_);
+}
+inline void ProtectionZoneInformation::set_event(::Kinova::Api::Base::ProtectionZoneEvent value) {
+  
+  event_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.ProtectionZoneInformation.event)
+}
+
+// -------------------------------------------------------------------
+
+// UserNotification
+
+// .Kinova.Api.Base.UserEvent user_event = 1;
+inline void UserNotification::clear_user_event() {
+  user_event_ = 0;
+}
+inline ::Kinova::Api::Base::UserEvent UserNotification::user_event() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.UserNotification.user_event)
+  return static_cast< ::Kinova::Api::Base::UserEvent >(user_event_);
+}
+inline void UserNotification::set_user_event(::Kinova::Api::Base::UserEvent value) {
+  
+  user_event_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.UserNotification.user_event)
+}
+
+// .Kinova.Api.Common.UserProfileHandle modified_user = 2;
+inline bool UserNotification::has_modified_user() const {
+  return this != internal_default_instance() && modified_user_ != NULL;
+}
+inline const ::Kinova::Api::Common::UserProfileHandle& UserNotification::modified_user() const {
+  const ::Kinova::Api::Common::UserProfileHandle* p = modified_user_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.UserNotification.modified_user)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::UserProfileHandle*>(
+      &::Kinova::Api::Common::_UserProfileHandle_default_instance_);
+}
+inline ::Kinova::Api::Common::UserProfileHandle* UserNotification::release_modified_user() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.UserNotification.modified_user)
+  
+  ::Kinova::Api::Common::UserProfileHandle* temp = modified_user_;
+  modified_user_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::UserProfileHandle* UserNotification::mutable_modified_user() {
+  
+  if (modified_user_ == NULL) {
+    modified_user_ = new ::Kinova::Api::Common::UserProfileHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.UserNotification.modified_user)
+  return modified_user_;
+}
+inline void UserNotification::set_allocated_modified_user(::Kinova::Api::Common::UserProfileHandle* modified_user) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(modified_user_);
+  }
+  if (modified_user) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      modified_user = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, modified_user, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  modified_user_ = modified_user;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.UserNotification.modified_user)
+}
+
+// .Kinova.Api.Common.Timestamp timestamp = 3;
+inline bool UserNotification::has_timestamp() const {
+  return this != internal_default_instance() && timestamp_ != NULL;
+}
+inline const ::Kinova::Api::Common::Timestamp& UserNotification::timestamp() const {
+  const ::Kinova::Api::Common::Timestamp* p = timestamp_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.UserNotification.timestamp)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::Timestamp*>(
+      &::Kinova::Api::Common::_Timestamp_default_instance_);
+}
+inline ::Kinova::Api::Common::Timestamp* UserNotification::release_timestamp() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.UserNotification.timestamp)
+  
+  ::Kinova::Api::Common::Timestamp* temp = timestamp_;
+  timestamp_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::Timestamp* UserNotification::mutable_timestamp() {
+  
+  if (timestamp_ == NULL) {
+    timestamp_ = new ::Kinova::Api::Common::Timestamp;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.UserNotification.timestamp)
+  return timestamp_;
+}
+inline void UserNotification::set_allocated_timestamp(::Kinova::Api::Common::Timestamp* timestamp) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(timestamp_);
+  }
+  if (timestamp) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      timestamp = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, timestamp, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  timestamp_ = timestamp;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.UserNotification.timestamp)
+}
+
+// .Kinova.Api.Common.UserProfileHandle user_handle = 4;
+inline bool UserNotification::has_user_handle() const {
+  return this != internal_default_instance() && user_handle_ != NULL;
+}
+inline const ::Kinova::Api::Common::UserProfileHandle& UserNotification::user_handle() const {
+  const ::Kinova::Api::Common::UserProfileHandle* p = user_handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.UserNotification.user_handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::UserProfileHandle*>(
+      &::Kinova::Api::Common::_UserProfileHandle_default_instance_);
+}
+inline ::Kinova::Api::Common::UserProfileHandle* UserNotification::release_user_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.UserNotification.user_handle)
+  
+  ::Kinova::Api::Common::UserProfileHandle* temp = user_handle_;
+  user_handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::UserProfileHandle* UserNotification::mutable_user_handle() {
+  
+  if (user_handle_ == NULL) {
+    user_handle_ = new ::Kinova::Api::Common::UserProfileHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.UserNotification.user_handle)
+  return user_handle_;
+}
+inline void UserNotification::set_allocated_user_handle(::Kinova::Api::Common::UserProfileHandle* user_handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(user_handle_);
+  }
+  if (user_handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      user_handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, user_handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  user_handle_ = user_handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.UserNotification.user_handle)
+}
+
+// .Kinova.Api.Common.Connection connection = 5;
+inline bool UserNotification::has_connection() const {
+  return this != internal_default_instance() && connection_ != NULL;
+}
+inline const ::Kinova::Api::Common::Connection& UserNotification::connection() const {
+  const ::Kinova::Api::Common::Connection* p = connection_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.UserNotification.connection)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::Connection*>(
+      &::Kinova::Api::Common::_Connection_default_instance_);
+}
+inline ::Kinova::Api::Common::Connection* UserNotification::release_connection() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.UserNotification.connection)
+  
+  ::Kinova::Api::Common::Connection* temp = connection_;
+  connection_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::Connection* UserNotification::mutable_connection() {
+  
+  if (connection_ == NULL) {
+    connection_ = new ::Kinova::Api::Common::Connection;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.UserNotification.connection)
+  return connection_;
+}
+inline void UserNotification::set_allocated_connection(::Kinova::Api::Common::Connection* connection) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(connection_);
+  }
+  if (connection) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      connection = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, connection, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  connection_ = connection;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.UserNotification.connection)
+}
+
+// -------------------------------------------------------------------
+
+// ControllerHandle
+
+// .Kinova.Api.Base.ControllerType type = 1;
+inline void ControllerHandle::clear_type() {
+  type_ = 0;
+}
+inline ::Kinova::Api::Base::ControllerType ControllerHandle::type() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ControllerHandle.type)
+  return static_cast< ::Kinova::Api::Base::ControllerType >(type_);
+}
+inline void ControllerHandle::set_type(::Kinova::Api::Base::ControllerType value) {
+  
+  type_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.ControllerHandle.type)
+}
+
+// uint32 controller_identifier = 2;
+inline void ControllerHandle::clear_controller_identifier() {
+  controller_identifier_ = 0u;
+}
+inline ::google::protobuf::uint32 ControllerHandle::controller_identifier() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ControllerHandle.controller_identifier)
+  return controller_identifier_;
+}
+inline void ControllerHandle::set_controller_identifier(::google::protobuf::uint32 value) {
+  
+  controller_identifier_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.ControllerHandle.controller_identifier)
+}
+
+// -------------------------------------------------------------------
+
+// ControllerElementHandle
+
+// .Kinova.Api.Base.ControllerHandle controller_handle = 1;
+inline bool ControllerElementHandle::has_controller_handle() const {
+  return this != internal_default_instance() && controller_handle_ != NULL;
+}
+inline void ControllerElementHandle::clear_controller_handle() {
+  if (GetArenaNoVirtual() == NULL && controller_handle_ != NULL) {
+    delete controller_handle_;
+  }
+  controller_handle_ = NULL;
+}
+inline const ::Kinova::Api::Base::ControllerHandle& ControllerElementHandle::controller_handle() const {
+  const ::Kinova::Api::Base::ControllerHandle* p = controller_handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ControllerElementHandle.controller_handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::ControllerHandle*>(
+      &::Kinova::Api::Base::_ControllerHandle_default_instance_);
+}
+inline ::Kinova::Api::Base::ControllerHandle* ControllerElementHandle::release_controller_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ControllerElementHandle.controller_handle)
+  
+  ::Kinova::Api::Base::ControllerHandle* temp = controller_handle_;
+  controller_handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::ControllerHandle* ControllerElementHandle::mutable_controller_handle() {
+  
+  if (controller_handle_ == NULL) {
+    controller_handle_ = new ::Kinova::Api::Base::ControllerHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ControllerElementHandle.controller_handle)
+  return controller_handle_;
+}
+inline void ControllerElementHandle::set_allocated_controller_handle(::Kinova::Api::Base::ControllerHandle* controller_handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete controller_handle_;
+  }
+  if (controller_handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      controller_handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, controller_handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  controller_handle_ = controller_handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.ControllerElementHandle.controller_handle)
+}
+
+// uint32 button = 2;
+inline bool ControllerElementHandle::has_button() const {
+  return identifier_case() == kButton;
+}
+inline void ControllerElementHandle::set_has_button() {
+  _oneof_case_[0] = kButton;
+}
+inline void ControllerElementHandle::clear_button() {
+  if (has_button()) {
+    identifier_.button_ = 0u;
+    clear_has_identifier();
+  }
+}
+inline ::google::protobuf::uint32 ControllerElementHandle::button() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ControllerElementHandle.button)
+  if (has_button()) {
+    return identifier_.button_;
+  }
+  return 0u;
+}
+inline void ControllerElementHandle::set_button(::google::protobuf::uint32 value) {
+  if (!has_button()) {
+    clear_identifier();
+    set_has_button();
+  }
+  identifier_.button_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.ControllerElementHandle.button)
+}
+
+// uint32 axis = 3;
+inline bool ControllerElementHandle::has_axis() const {
+  return identifier_case() == kAxis;
+}
+inline void ControllerElementHandle::set_has_axis() {
+  _oneof_case_[0] = kAxis;
+}
+inline void ControllerElementHandle::clear_axis() {
+  if (has_axis()) {
+    identifier_.axis_ = 0u;
+    clear_has_identifier();
+  }
+}
+inline ::google::protobuf::uint32 ControllerElementHandle::axis() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ControllerElementHandle.axis)
+  if (has_axis()) {
+    return identifier_.axis_;
+  }
+  return 0u;
+}
+inline void ControllerElementHandle::set_axis(::google::protobuf::uint32 value) {
+  if (!has_axis()) {
+    clear_identifier();
+    set_has_axis();
+  }
+  identifier_.axis_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.ControllerElementHandle.axis)
+}
+
+inline bool ControllerElementHandle::has_identifier() const {
+  return identifier_case() != IDENTIFIER_NOT_SET;
+}
+inline void ControllerElementHandle::clear_has_identifier() {
+  _oneof_case_[0] = IDENTIFIER_NOT_SET;
+}
+inline ControllerElementHandle::IdentifierCase ControllerElementHandle::identifier_case() const {
+  return ControllerElementHandle::IdentifierCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// ControllerNotification
+
+// .Kinova.Api.Base.ControllerState controller_state = 1;
+inline bool ControllerNotification::has_controller_state() const {
+  return state_case() == kControllerState;
+}
+inline void ControllerNotification::set_has_controller_state() {
+  _oneof_case_[0] = kControllerState;
+}
+inline void ControllerNotification::clear_controller_state() {
+  if (has_controller_state()) {
+    delete state_.controller_state_;
+    clear_has_state();
+  }
+}
+inline ::Kinova::Api::Base::ControllerState* ControllerNotification::release_controller_state() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ControllerNotification.controller_state)
+  if (has_controller_state()) {
+    clear_has_state();
+      ::Kinova::Api::Base::ControllerState* temp = state_.controller_state_;
+    state_.controller_state_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline const ::Kinova::Api::Base::ControllerState& ControllerNotification::controller_state() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ControllerNotification.controller_state)
+  return has_controller_state()
+      ? *state_.controller_state_
+      : *reinterpret_cast< ::Kinova::Api::Base::ControllerState*>(&::Kinova::Api::Base::_ControllerState_default_instance_);
+}
+inline ::Kinova::Api::Base::ControllerState* ControllerNotification::mutable_controller_state() {
+  if (!has_controller_state()) {
+    clear_state();
+    set_has_controller_state();
+    state_.controller_state_ = new ::Kinova::Api::Base::ControllerState;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ControllerNotification.controller_state)
+  return state_.controller_state_;
+}
+
+// .Kinova.Api.Base.ControllerElementState controller_element = 2;
+inline bool ControllerNotification::has_controller_element() const {
+  return state_case() == kControllerElement;
+}
+inline void ControllerNotification::set_has_controller_element() {
+  _oneof_case_[0] = kControllerElement;
+}
+inline void ControllerNotification::clear_controller_element() {
+  if (has_controller_element()) {
+    delete state_.controller_element_;
+    clear_has_state();
+  }
+}
+inline ::Kinova::Api::Base::ControllerElementState* ControllerNotification::release_controller_element() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ControllerNotification.controller_element)
+  if (has_controller_element()) {
+    clear_has_state();
+      ::Kinova::Api::Base::ControllerElementState* temp = state_.controller_element_;
+    state_.controller_element_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline const ::Kinova::Api::Base::ControllerElementState& ControllerNotification::controller_element() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ControllerNotification.controller_element)
+  return has_controller_element()
+      ? *state_.controller_element_
+      : *reinterpret_cast< ::Kinova::Api::Base::ControllerElementState*>(&::Kinova::Api::Base::_ControllerElementState_default_instance_);
+}
+inline ::Kinova::Api::Base::ControllerElementState* ControllerNotification::mutable_controller_element() {
+  if (!has_controller_element()) {
+    clear_state();
+    set_has_controller_element();
+    state_.controller_element_ = new ::Kinova::Api::Base::ControllerElementState;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ControllerNotification.controller_element)
+  return state_.controller_element_;
+}
+
+// .Kinova.Api.Common.Timestamp timestamp = 3;
+inline bool ControllerNotification::has_timestamp() const {
+  return this != internal_default_instance() && timestamp_ != NULL;
+}
+inline const ::Kinova::Api::Common::Timestamp& ControllerNotification::timestamp() const {
+  const ::Kinova::Api::Common::Timestamp* p = timestamp_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ControllerNotification.timestamp)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::Timestamp*>(
+      &::Kinova::Api::Common::_Timestamp_default_instance_);
+}
+inline ::Kinova::Api::Common::Timestamp* ControllerNotification::release_timestamp() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ControllerNotification.timestamp)
+  
+  ::Kinova::Api::Common::Timestamp* temp = timestamp_;
+  timestamp_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::Timestamp* ControllerNotification::mutable_timestamp() {
+  
+  if (timestamp_ == NULL) {
+    timestamp_ = new ::Kinova::Api::Common::Timestamp;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ControllerNotification.timestamp)
+  return timestamp_;
+}
+inline void ControllerNotification::set_allocated_timestamp(::Kinova::Api::Common::Timestamp* timestamp) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(timestamp_);
+  }
+  if (timestamp) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      timestamp = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, timestamp, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  timestamp_ = timestamp;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.ControllerNotification.timestamp)
+}
+
+// .Kinova.Api.Common.UserProfileHandle user_handle = 4;
+inline bool ControllerNotification::has_user_handle() const {
+  return this != internal_default_instance() && user_handle_ != NULL;
+}
+inline const ::Kinova::Api::Common::UserProfileHandle& ControllerNotification::user_handle() const {
+  const ::Kinova::Api::Common::UserProfileHandle* p = user_handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ControllerNotification.user_handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::UserProfileHandle*>(
+      &::Kinova::Api::Common::_UserProfileHandle_default_instance_);
+}
+inline ::Kinova::Api::Common::UserProfileHandle* ControllerNotification::release_user_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ControllerNotification.user_handle)
+  
+  ::Kinova::Api::Common::UserProfileHandle* temp = user_handle_;
+  user_handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::UserProfileHandle* ControllerNotification::mutable_user_handle() {
+  
+  if (user_handle_ == NULL) {
+    user_handle_ = new ::Kinova::Api::Common::UserProfileHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ControllerNotification.user_handle)
+  return user_handle_;
+}
+inline void ControllerNotification::set_allocated_user_handle(::Kinova::Api::Common::UserProfileHandle* user_handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(user_handle_);
+  }
+  if (user_handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      user_handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, user_handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  user_handle_ = user_handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.ControllerNotification.user_handle)
+}
+
+// .Kinova.Api.Common.Connection connection = 5;
+inline bool ControllerNotification::has_connection() const {
+  return this != internal_default_instance() && connection_ != NULL;
+}
+inline const ::Kinova::Api::Common::Connection& ControllerNotification::connection() const {
+  const ::Kinova::Api::Common::Connection* p = connection_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ControllerNotification.connection)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::Connection*>(
+      &::Kinova::Api::Common::_Connection_default_instance_);
+}
+inline ::Kinova::Api::Common::Connection* ControllerNotification::release_connection() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ControllerNotification.connection)
+  
+  ::Kinova::Api::Common::Connection* temp = connection_;
+  connection_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::Connection* ControllerNotification::mutable_connection() {
+  
+  if (connection_ == NULL) {
+    connection_ = new ::Kinova::Api::Common::Connection;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ControllerNotification.connection)
+  return connection_;
+}
+inline void ControllerNotification::set_allocated_connection(::Kinova::Api::Common::Connection* connection) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(connection_);
+  }
+  if (connection) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      connection = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, connection, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  connection_ = connection;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.ControllerNotification.connection)
+}
+
+inline bool ControllerNotification::has_state() const {
+  return state_case() != STATE_NOT_SET;
+}
+inline void ControllerNotification::clear_has_state() {
+  _oneof_case_[0] = STATE_NOT_SET;
+}
+inline ControllerNotification::StateCase ControllerNotification::state_case() const {
+  return ControllerNotification::StateCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// ControllerList
+
+// repeated .Kinova.Api.Base.ControllerHandle handles = 1;
+inline int ControllerList::handles_size() const {
+  return handles_.size();
+}
+inline void ControllerList::clear_handles() {
+  handles_.Clear();
+}
+inline const ::Kinova::Api::Base::ControllerHandle& ControllerList::handles(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ControllerList.handles)
+  return handles_.Get(index);
+}
+inline ::Kinova::Api::Base::ControllerHandle* ControllerList::mutable_handles(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ControllerList.handles)
+  return handles_.Mutable(index);
+}
+inline ::Kinova::Api::Base::ControllerHandle* ControllerList::add_handles() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.Base.ControllerList.handles)
+  return handles_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::ControllerHandle >*
+ControllerList::mutable_handles() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.Base.ControllerList.handles)
+  return &handles_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::ControllerHandle >&
+ControllerList::handles() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.Base.ControllerList.handles)
+  return handles_;
+}
+
+// -------------------------------------------------------------------
+
+// ControllerState
+
+// .Kinova.Api.Base.ControllerHandle handle = 1;
+inline bool ControllerState::has_handle() const {
+  return this != internal_default_instance() && handle_ != NULL;
+}
+inline void ControllerState::clear_handle() {
+  if (GetArenaNoVirtual() == NULL && handle_ != NULL) {
+    delete handle_;
+  }
+  handle_ = NULL;
+}
+inline const ::Kinova::Api::Base::ControllerHandle& ControllerState::handle() const {
+  const ::Kinova::Api::Base::ControllerHandle* p = handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ControllerState.handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::ControllerHandle*>(
+      &::Kinova::Api::Base::_ControllerHandle_default_instance_);
+}
+inline ::Kinova::Api::Base::ControllerHandle* ControllerState::release_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ControllerState.handle)
+  
+  ::Kinova::Api::Base::ControllerHandle* temp = handle_;
+  handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::ControllerHandle* ControllerState::mutable_handle() {
+  
+  if (handle_ == NULL) {
+    handle_ = new ::Kinova::Api::Base::ControllerHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ControllerState.handle)
+  return handle_;
+}
+inline void ControllerState::set_allocated_handle(::Kinova::Api::Base::ControllerHandle* handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete handle_;
+  }
+  if (handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  handle_ = handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.ControllerState.handle)
+}
+
+// .Kinova.Api.Base.ControllerEventType event_type = 2;
+inline void ControllerState::clear_event_type() {
+  event_type_ = 0;
+}
+inline ::Kinova::Api::Base::ControllerEventType ControllerState::event_type() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ControllerState.event_type)
+  return static_cast< ::Kinova::Api::Base::ControllerEventType >(event_type_);
+}
+inline void ControllerState::set_event_type(::Kinova::Api::Base::ControllerEventType value) {
+  
+  event_type_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.ControllerState.event_type)
+}
+
+// -------------------------------------------------------------------
+
+// ControllerElementState
+
+// .Kinova.Api.Base.ControllerElementHandle handle = 1;
+inline bool ControllerElementState::has_handle() const {
+  return this != internal_default_instance() && handle_ != NULL;
+}
+inline void ControllerElementState::clear_handle() {
+  if (GetArenaNoVirtual() == NULL && handle_ != NULL) {
+    delete handle_;
+  }
+  handle_ = NULL;
+}
+inline const ::Kinova::Api::Base::ControllerElementHandle& ControllerElementState::handle() const {
+  const ::Kinova::Api::Base::ControllerElementHandle* p = handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ControllerElementState.handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::ControllerElementHandle*>(
+      &::Kinova::Api::Base::_ControllerElementHandle_default_instance_);
+}
+inline ::Kinova::Api::Base::ControllerElementHandle* ControllerElementState::release_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ControllerElementState.handle)
+  
+  ::Kinova::Api::Base::ControllerElementHandle* temp = handle_;
+  handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::ControllerElementHandle* ControllerElementState::mutable_handle() {
+  
+  if (handle_ == NULL) {
+    handle_ = new ::Kinova::Api::Base::ControllerElementHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ControllerElementState.handle)
+  return handle_;
+}
+inline void ControllerElementState::set_allocated_handle(::Kinova::Api::Base::ControllerElementHandle* handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete handle_;
+  }
+  if (handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  handle_ = handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.ControllerElementState.handle)
+}
+
+// .Kinova.Api.Base.ControllerElementEventType event_type = 2;
+inline void ControllerElementState::clear_event_type() {
+  event_type_ = 0;
+}
+inline ::Kinova::Api::Base::ControllerElementEventType ControllerElementState::event_type() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ControllerElementState.event_type)
+  return static_cast< ::Kinova::Api::Base::ControllerElementEventType >(event_type_);
+}
+inline void ControllerElementState::set_event_type(::Kinova::Api::Base::ControllerElementEventType value) {
+  
+  event_type_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.ControllerElementState.event_type)
+}
+
+// float axis_value = 3;
+inline void ControllerElementState::clear_axis_value() {
+  axis_value_ = 0;
+}
+inline float ControllerElementState::axis_value() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ControllerElementState.axis_value)
+  return axis_value_;
+}
+inline void ControllerElementState::set_axis_value(float value) {
+  
+  axis_value_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.ControllerElementState.axis_value)
+}
+
+// -------------------------------------------------------------------
+
+// ActionNotification
+
+// .Kinova.Api.Base.ActionEvent action_event = 1;
+inline void ActionNotification::clear_action_event() {
+  action_event_ = 0;
+}
+inline ::Kinova::Api::Base::ActionEvent ActionNotification::action_event() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ActionNotification.action_event)
+  return static_cast< ::Kinova::Api::Base::ActionEvent >(action_event_);
+}
+inline void ActionNotification::set_action_event(::Kinova::Api::Base::ActionEvent value) {
+  
+  action_event_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.ActionNotification.action_event)
+}
+
+// .Kinova.Api.Base.ActionHandle handle = 2;
+inline bool ActionNotification::has_handle() const {
+  return this != internal_default_instance() && handle_ != NULL;
+}
+inline void ActionNotification::clear_handle() {
+  if (GetArenaNoVirtual() == NULL && handle_ != NULL) {
+    delete handle_;
+  }
+  handle_ = NULL;
+}
+inline const ::Kinova::Api::Base::ActionHandle& ActionNotification::handle() const {
+  const ::Kinova::Api::Base::ActionHandle* p = handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ActionNotification.handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::ActionHandle*>(
+      &::Kinova::Api::Base::_ActionHandle_default_instance_);
+}
+inline ::Kinova::Api::Base::ActionHandle* ActionNotification::release_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ActionNotification.handle)
+  
+  ::Kinova::Api::Base::ActionHandle* temp = handle_;
+  handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::ActionHandle* ActionNotification::mutable_handle() {
+  
+  if (handle_ == NULL) {
+    handle_ = new ::Kinova::Api::Base::ActionHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ActionNotification.handle)
+  return handle_;
+}
+inline void ActionNotification::set_allocated_handle(::Kinova::Api::Base::ActionHandle* handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete handle_;
+  }
+  if (handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  handle_ = handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.ActionNotification.handle)
+}
+
+// .Kinova.Api.Common.Timestamp timestamp = 3;
+inline bool ActionNotification::has_timestamp() const {
+  return this != internal_default_instance() && timestamp_ != NULL;
+}
+inline const ::Kinova::Api::Common::Timestamp& ActionNotification::timestamp() const {
+  const ::Kinova::Api::Common::Timestamp* p = timestamp_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ActionNotification.timestamp)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::Timestamp*>(
+      &::Kinova::Api::Common::_Timestamp_default_instance_);
+}
+inline ::Kinova::Api::Common::Timestamp* ActionNotification::release_timestamp() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ActionNotification.timestamp)
+  
+  ::Kinova::Api::Common::Timestamp* temp = timestamp_;
+  timestamp_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::Timestamp* ActionNotification::mutable_timestamp() {
+  
+  if (timestamp_ == NULL) {
+    timestamp_ = new ::Kinova::Api::Common::Timestamp;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ActionNotification.timestamp)
+  return timestamp_;
+}
+inline void ActionNotification::set_allocated_timestamp(::Kinova::Api::Common::Timestamp* timestamp) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(timestamp_);
+  }
+  if (timestamp) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      timestamp = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, timestamp, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  timestamp_ = timestamp;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.ActionNotification.timestamp)
+}
+
+// .Kinova.Api.Common.UserProfileHandle user_handle = 4;
+inline bool ActionNotification::has_user_handle() const {
+  return this != internal_default_instance() && user_handle_ != NULL;
+}
+inline const ::Kinova::Api::Common::UserProfileHandle& ActionNotification::user_handle() const {
+  const ::Kinova::Api::Common::UserProfileHandle* p = user_handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ActionNotification.user_handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::UserProfileHandle*>(
+      &::Kinova::Api::Common::_UserProfileHandle_default_instance_);
+}
+inline ::Kinova::Api::Common::UserProfileHandle* ActionNotification::release_user_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ActionNotification.user_handle)
+  
+  ::Kinova::Api::Common::UserProfileHandle* temp = user_handle_;
+  user_handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::UserProfileHandle* ActionNotification::mutable_user_handle() {
+  
+  if (user_handle_ == NULL) {
+    user_handle_ = new ::Kinova::Api::Common::UserProfileHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ActionNotification.user_handle)
+  return user_handle_;
+}
+inline void ActionNotification::set_allocated_user_handle(::Kinova::Api::Common::UserProfileHandle* user_handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(user_handle_);
+  }
+  if (user_handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      user_handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, user_handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  user_handle_ = user_handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.ActionNotification.user_handle)
+}
+
+// .Kinova.Api.SubErrorCodes abort_details = 5;
+inline void ActionNotification::clear_abort_details() {
+  abort_details_ = 0;
+}
+inline ::Kinova::Api::SubErrorCodes ActionNotification::abort_details() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ActionNotification.abort_details)
+  return static_cast< ::Kinova::Api::SubErrorCodes >(abort_details_);
+}
+inline void ActionNotification::set_abort_details(::Kinova::Api::SubErrorCodes value) {
+  
+  abort_details_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.ActionNotification.abort_details)
+}
+
+// .Kinova.Api.Common.Connection connection = 6;
+inline bool ActionNotification::has_connection() const {
+  return this != internal_default_instance() && connection_ != NULL;
+}
+inline const ::Kinova::Api::Common::Connection& ActionNotification::connection() const {
+  const ::Kinova::Api::Common::Connection* p = connection_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ActionNotification.connection)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::Connection*>(
+      &::Kinova::Api::Common::_Connection_default_instance_);
+}
+inline ::Kinova::Api::Common::Connection* ActionNotification::release_connection() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ActionNotification.connection)
+  
+  ::Kinova::Api::Common::Connection* temp = connection_;
+  connection_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::Connection* ActionNotification::mutable_connection() {
+  
+  if (connection_ == NULL) {
+    connection_ = new ::Kinova::Api::Common::Connection;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ActionNotification.connection)
+  return connection_;
+}
+inline void ActionNotification::set_allocated_connection(::Kinova::Api::Common::Connection* connection) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(connection_);
+  }
+  if (connection) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      connection = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, connection, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  connection_ = connection;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.ActionNotification.connection)
+}
+
+// repeated .Kinova.Api.Base.TrajectoryInfo trajectory_info = 7;
+inline int ActionNotification::trajectory_info_size() const {
+  return trajectory_info_.size();
+}
+inline void ActionNotification::clear_trajectory_info() {
+  trajectory_info_.Clear();
+}
+inline const ::Kinova::Api::Base::TrajectoryInfo& ActionNotification::trajectory_info(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ActionNotification.trajectory_info)
+  return trajectory_info_.Get(index);
+}
+inline ::Kinova::Api::Base::TrajectoryInfo* ActionNotification::mutable_trajectory_info(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ActionNotification.trajectory_info)
+  return trajectory_info_.Mutable(index);
+}
+inline ::Kinova::Api::Base::TrajectoryInfo* ActionNotification::add_trajectory_info() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.Base.ActionNotification.trajectory_info)
+  return trajectory_info_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::TrajectoryInfo >*
+ActionNotification::mutable_trajectory_info() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.Base.ActionNotification.trajectory_info)
+  return &trajectory_info_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::TrajectoryInfo >&
+ActionNotification::trajectory_info() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.Base.ActionNotification.trajectory_info)
+  return trajectory_info_;
+}
+
+// -------------------------------------------------------------------
+
+// TrajectoryInfo
+
+// .Kinova.Api.Base.TrajectoryInfoType trajectory_info_type = 1;
+inline void TrajectoryInfo::clear_trajectory_info_type() {
+  trajectory_info_type_ = 0;
+}
+inline ::Kinova::Api::Base::TrajectoryInfoType TrajectoryInfo::trajectory_info_type() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.TrajectoryInfo.trajectory_info_type)
+  return static_cast< ::Kinova::Api::Base::TrajectoryInfoType >(trajectory_info_type_);
+}
+inline void TrajectoryInfo::set_trajectory_info_type(::Kinova::Api::Base::TrajectoryInfoType value) {
+  
+  trajectory_info_type_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.TrajectoryInfo.trajectory_info_type)
+}
+
+// uint32 waypoint_index = 2;
+inline void TrajectoryInfo::clear_waypoint_index() {
+  waypoint_index_ = 0u;
+}
+inline ::google::protobuf::uint32 TrajectoryInfo::waypoint_index() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.TrajectoryInfo.waypoint_index)
+  return waypoint_index_;
+}
+inline void TrajectoryInfo::set_waypoint_index(::google::protobuf::uint32 value) {
+  
+  waypoint_index_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.TrajectoryInfo.waypoint_index)
+}
+
+// uint32 joint_index = 3;
+inline void TrajectoryInfo::clear_joint_index() {
+  joint_index_ = 0u;
+}
+inline ::google::protobuf::uint32 TrajectoryInfo::joint_index() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.TrajectoryInfo.joint_index)
+  return joint_index_;
+}
+inline void TrajectoryInfo::set_joint_index(::google::protobuf::uint32 value) {
+  
+  joint_index_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.TrajectoryInfo.joint_index)
+}
+
+// -------------------------------------------------------------------
+
+// RobotEventNotification
+
+// .Kinova.Api.Base.RobotEvent event = 1;
+inline void RobotEventNotification::clear_event() {
+  event_ = 0;
+}
+inline ::Kinova::Api::Base::RobotEvent RobotEventNotification::event() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.RobotEventNotification.event)
+  return static_cast< ::Kinova::Api::Base::RobotEvent >(event_);
+}
+inline void RobotEventNotification::set_event(::Kinova::Api::Base::RobotEvent value) {
+  
+  event_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.RobotEventNotification.event)
+}
+
+// .Kinova.Api.Common.DeviceHandle handle = 2;
+inline bool RobotEventNotification::has_handle() const {
+  return this != internal_default_instance() && handle_ != NULL;
+}
+inline const ::Kinova::Api::Common::DeviceHandle& RobotEventNotification::handle() const {
+  const ::Kinova::Api::Common::DeviceHandle* p = handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.RobotEventNotification.handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::DeviceHandle*>(
+      &::Kinova::Api::Common::_DeviceHandle_default_instance_);
+}
+inline ::Kinova::Api::Common::DeviceHandle* RobotEventNotification::release_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.RobotEventNotification.handle)
+  
+  ::Kinova::Api::Common::DeviceHandle* temp = handle_;
+  handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::DeviceHandle* RobotEventNotification::mutable_handle() {
+  
+  if (handle_ == NULL) {
+    handle_ = new ::Kinova::Api::Common::DeviceHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.RobotEventNotification.handle)
+  return handle_;
+}
+inline void RobotEventNotification::set_allocated_handle(::Kinova::Api::Common::DeviceHandle* handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(handle_);
+  }
+  if (handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  handle_ = handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.RobotEventNotification.handle)
+}
+
+// .Kinova.Api.Common.Timestamp timestamp = 3;
+inline bool RobotEventNotification::has_timestamp() const {
+  return this != internal_default_instance() && timestamp_ != NULL;
+}
+inline const ::Kinova::Api::Common::Timestamp& RobotEventNotification::timestamp() const {
+  const ::Kinova::Api::Common::Timestamp* p = timestamp_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.RobotEventNotification.timestamp)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::Timestamp*>(
+      &::Kinova::Api::Common::_Timestamp_default_instance_);
+}
+inline ::Kinova::Api::Common::Timestamp* RobotEventNotification::release_timestamp() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.RobotEventNotification.timestamp)
+  
+  ::Kinova::Api::Common::Timestamp* temp = timestamp_;
+  timestamp_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::Timestamp* RobotEventNotification::mutable_timestamp() {
+  
+  if (timestamp_ == NULL) {
+    timestamp_ = new ::Kinova::Api::Common::Timestamp;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.RobotEventNotification.timestamp)
+  return timestamp_;
+}
+inline void RobotEventNotification::set_allocated_timestamp(::Kinova::Api::Common::Timestamp* timestamp) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(timestamp_);
+  }
+  if (timestamp) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      timestamp = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, timestamp, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  timestamp_ = timestamp;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.RobotEventNotification.timestamp)
+}
+
+// .Kinova.Api.Common.UserProfileHandle user_handle = 4;
+inline bool RobotEventNotification::has_user_handle() const {
+  return this != internal_default_instance() && user_handle_ != NULL;
+}
+inline const ::Kinova::Api::Common::UserProfileHandle& RobotEventNotification::user_handle() const {
+  const ::Kinova::Api::Common::UserProfileHandle* p = user_handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.RobotEventNotification.user_handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::UserProfileHandle*>(
+      &::Kinova::Api::Common::_UserProfileHandle_default_instance_);
+}
+inline ::Kinova::Api::Common::UserProfileHandle* RobotEventNotification::release_user_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.RobotEventNotification.user_handle)
+  
+  ::Kinova::Api::Common::UserProfileHandle* temp = user_handle_;
+  user_handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::UserProfileHandle* RobotEventNotification::mutable_user_handle() {
+  
+  if (user_handle_ == NULL) {
+    user_handle_ = new ::Kinova::Api::Common::UserProfileHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.RobotEventNotification.user_handle)
+  return user_handle_;
+}
+inline void RobotEventNotification::set_allocated_user_handle(::Kinova::Api::Common::UserProfileHandle* user_handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(user_handle_);
+  }
+  if (user_handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      user_handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, user_handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  user_handle_ = user_handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.RobotEventNotification.user_handle)
+}
+
+// .Kinova.Api.Common.Connection connection = 6;
+inline bool RobotEventNotification::has_connection() const {
+  return this != internal_default_instance() && connection_ != NULL;
+}
+inline const ::Kinova::Api::Common::Connection& RobotEventNotification::connection() const {
+  const ::Kinova::Api::Common::Connection* p = connection_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.RobotEventNotification.connection)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::Connection*>(
+      &::Kinova::Api::Common::_Connection_default_instance_);
+}
+inline ::Kinova::Api::Common::Connection* RobotEventNotification::release_connection() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.RobotEventNotification.connection)
+  
+  ::Kinova::Api::Common::Connection* temp = connection_;
+  connection_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::Connection* RobotEventNotification::mutable_connection() {
+  
+  if (connection_ == NULL) {
+    connection_ = new ::Kinova::Api::Common::Connection;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.RobotEventNotification.connection)
+  return connection_;
+}
+inline void RobotEventNotification::set_allocated_connection(::Kinova::Api::Common::Connection* connection) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(connection_);
+  }
+  if (connection) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      connection = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, connection, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  connection_ = connection;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.RobotEventNotification.connection)
+}
+
+// -------------------------------------------------------------------
+
+// FactoryNotification
+
+// .Kinova.Api.Base.FactoryEvent event = 1;
+inline void FactoryNotification::clear_event() {
+  event_ = 0;
+}
+inline ::Kinova::Api::Base::FactoryEvent FactoryNotification::event() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.FactoryNotification.event)
+  return static_cast< ::Kinova::Api::Base::FactoryEvent >(event_);
+}
+inline void FactoryNotification::set_event(::Kinova::Api::Base::FactoryEvent value) {
+  
+  event_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.FactoryNotification.event)
+}
+
+// .Kinova.Api.Common.Timestamp timestamp = 2;
+inline bool FactoryNotification::has_timestamp() const {
+  return this != internal_default_instance() && timestamp_ != NULL;
+}
+inline const ::Kinova::Api::Common::Timestamp& FactoryNotification::timestamp() const {
+  const ::Kinova::Api::Common::Timestamp* p = timestamp_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.FactoryNotification.timestamp)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::Timestamp*>(
+      &::Kinova::Api::Common::_Timestamp_default_instance_);
+}
+inline ::Kinova::Api::Common::Timestamp* FactoryNotification::release_timestamp() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.FactoryNotification.timestamp)
+  
+  ::Kinova::Api::Common::Timestamp* temp = timestamp_;
+  timestamp_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::Timestamp* FactoryNotification::mutable_timestamp() {
+  
+  if (timestamp_ == NULL) {
+    timestamp_ = new ::Kinova::Api::Common::Timestamp;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.FactoryNotification.timestamp)
+  return timestamp_;
+}
+inline void FactoryNotification::set_allocated_timestamp(::Kinova::Api::Common::Timestamp* timestamp) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(timestamp_);
+  }
+  if (timestamp) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      timestamp = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, timestamp, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  timestamp_ = timestamp;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.FactoryNotification.timestamp)
+}
+
+// .Kinova.Api.Common.UserProfileHandle user_handle = 3;
+inline bool FactoryNotification::has_user_handle() const {
+  return this != internal_default_instance() && user_handle_ != NULL;
+}
+inline const ::Kinova::Api::Common::UserProfileHandle& FactoryNotification::user_handle() const {
+  const ::Kinova::Api::Common::UserProfileHandle* p = user_handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.FactoryNotification.user_handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::UserProfileHandle*>(
+      &::Kinova::Api::Common::_UserProfileHandle_default_instance_);
+}
+inline ::Kinova::Api::Common::UserProfileHandle* FactoryNotification::release_user_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.FactoryNotification.user_handle)
+  
+  ::Kinova::Api::Common::UserProfileHandle* temp = user_handle_;
+  user_handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::UserProfileHandle* FactoryNotification::mutable_user_handle() {
+  
+  if (user_handle_ == NULL) {
+    user_handle_ = new ::Kinova::Api::Common::UserProfileHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.FactoryNotification.user_handle)
+  return user_handle_;
+}
+inline void FactoryNotification::set_allocated_user_handle(::Kinova::Api::Common::UserProfileHandle* user_handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(user_handle_);
+  }
+  if (user_handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      user_handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, user_handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  user_handle_ = user_handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.FactoryNotification.user_handle)
+}
+
+// .Kinova.Api.Common.Connection connection = 4;
+inline bool FactoryNotification::has_connection() const {
+  return this != internal_default_instance() && connection_ != NULL;
+}
+inline const ::Kinova::Api::Common::Connection& FactoryNotification::connection() const {
+  const ::Kinova::Api::Common::Connection* p = connection_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.FactoryNotification.connection)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::Connection*>(
+      &::Kinova::Api::Common::_Connection_default_instance_);
+}
+inline ::Kinova::Api::Common::Connection* FactoryNotification::release_connection() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.FactoryNotification.connection)
+  
+  ::Kinova::Api::Common::Connection* temp = connection_;
+  connection_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::Connection* FactoryNotification::mutable_connection() {
+  
+  if (connection_ == NULL) {
+    connection_ = new ::Kinova::Api::Common::Connection;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.FactoryNotification.connection)
+  return connection_;
+}
+inline void FactoryNotification::set_allocated_connection(::Kinova::Api::Common::Connection* connection) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(connection_);
+  }
+  if (connection) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      connection = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, connection, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  connection_ = connection;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.FactoryNotification.connection)
+}
+
+// -------------------------------------------------------------------
+
+// NetworkNotification
+
+// .Kinova.Api.Base.NetworkEvent event = 1;
+inline void NetworkNotification::clear_event() {
+  event_ = 0;
+}
+inline ::Kinova::Api::Base::NetworkEvent NetworkNotification::event() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.NetworkNotification.event)
+  return static_cast< ::Kinova::Api::Base::NetworkEvent >(event_);
+}
+inline void NetworkNotification::set_event(::Kinova::Api::Base::NetworkEvent value) {
+  
+  event_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.NetworkNotification.event)
+}
+
+// .Kinova.Api.Common.Timestamp timestamp = 2;
+inline bool NetworkNotification::has_timestamp() const {
+  return this != internal_default_instance() && timestamp_ != NULL;
+}
+inline const ::Kinova::Api::Common::Timestamp& NetworkNotification::timestamp() const {
+  const ::Kinova::Api::Common::Timestamp* p = timestamp_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.NetworkNotification.timestamp)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::Timestamp*>(
+      &::Kinova::Api::Common::_Timestamp_default_instance_);
+}
+inline ::Kinova::Api::Common::Timestamp* NetworkNotification::release_timestamp() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.NetworkNotification.timestamp)
+  
+  ::Kinova::Api::Common::Timestamp* temp = timestamp_;
+  timestamp_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::Timestamp* NetworkNotification::mutable_timestamp() {
+  
+  if (timestamp_ == NULL) {
+    timestamp_ = new ::Kinova::Api::Common::Timestamp;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.NetworkNotification.timestamp)
+  return timestamp_;
+}
+inline void NetworkNotification::set_allocated_timestamp(::Kinova::Api::Common::Timestamp* timestamp) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(timestamp_);
+  }
+  if (timestamp) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      timestamp = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, timestamp, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  timestamp_ = timestamp;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.NetworkNotification.timestamp)
+}
+
+// .Kinova.Api.Common.UserProfileHandle user_handle = 3;
+inline bool NetworkNotification::has_user_handle() const {
+  return this != internal_default_instance() && user_handle_ != NULL;
+}
+inline const ::Kinova::Api::Common::UserProfileHandle& NetworkNotification::user_handle() const {
+  const ::Kinova::Api::Common::UserProfileHandle* p = user_handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.NetworkNotification.user_handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::UserProfileHandle*>(
+      &::Kinova::Api::Common::_UserProfileHandle_default_instance_);
+}
+inline ::Kinova::Api::Common::UserProfileHandle* NetworkNotification::release_user_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.NetworkNotification.user_handle)
+  
+  ::Kinova::Api::Common::UserProfileHandle* temp = user_handle_;
+  user_handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::UserProfileHandle* NetworkNotification::mutable_user_handle() {
+  
+  if (user_handle_ == NULL) {
+    user_handle_ = new ::Kinova::Api::Common::UserProfileHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.NetworkNotification.user_handle)
+  return user_handle_;
+}
+inline void NetworkNotification::set_allocated_user_handle(::Kinova::Api::Common::UserProfileHandle* user_handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(user_handle_);
+  }
+  if (user_handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      user_handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, user_handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  user_handle_ = user_handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.NetworkNotification.user_handle)
+}
+
+// .Kinova.Api.Common.Connection connection = 4;
+inline bool NetworkNotification::has_connection() const {
+  return this != internal_default_instance() && connection_ != NULL;
+}
+inline const ::Kinova::Api::Common::Connection& NetworkNotification::connection() const {
+  const ::Kinova::Api::Common::Connection* p = connection_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.NetworkNotification.connection)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::Connection*>(
+      &::Kinova::Api::Common::_Connection_default_instance_);
+}
+inline ::Kinova::Api::Common::Connection* NetworkNotification::release_connection() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.NetworkNotification.connection)
+  
+  ::Kinova::Api::Common::Connection* temp = connection_;
+  connection_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::Connection* NetworkNotification::mutable_connection() {
+  
+  if (connection_ == NULL) {
+    connection_ = new ::Kinova::Api::Common::Connection;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.NetworkNotification.connection)
+  return connection_;
+}
+inline void NetworkNotification::set_allocated_connection(::Kinova::Api::Common::Connection* connection) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(connection_);
+  }
+  if (connection) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      connection = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, connection, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  connection_ = connection;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.NetworkNotification.connection)
+}
+
+// -------------------------------------------------------------------
+
+// ConfigurationChangeNotificationList
+
+// repeated .Kinova.Api.Base.ConfigurationChangeNotification notifications = 1;
+inline int ConfigurationChangeNotificationList::notifications_size() const {
+  return notifications_.size();
+}
+inline void ConfigurationChangeNotificationList::clear_notifications() {
+  notifications_.Clear();
+}
+inline const ::Kinova::Api::Base::ConfigurationChangeNotification& ConfigurationChangeNotificationList::notifications(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ConfigurationChangeNotificationList.notifications)
+  return notifications_.Get(index);
+}
+inline ::Kinova::Api::Base::ConfigurationChangeNotification* ConfigurationChangeNotificationList::mutable_notifications(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ConfigurationChangeNotificationList.notifications)
+  return notifications_.Mutable(index);
+}
+inline ::Kinova::Api::Base::ConfigurationChangeNotification* ConfigurationChangeNotificationList::add_notifications() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.Base.ConfigurationChangeNotificationList.notifications)
+  return notifications_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::ConfigurationChangeNotification >*
+ConfigurationChangeNotificationList::mutable_notifications() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.Base.ConfigurationChangeNotificationList.notifications)
+  return &notifications_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::ConfigurationChangeNotification >&
+ConfigurationChangeNotificationList::notifications() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.Base.ConfigurationChangeNotificationList.notifications)
+  return notifications_;
+}
+
+// -------------------------------------------------------------------
+
+// MappingInfoNotificationList
+
+// repeated .Kinova.Api.Base.MappingInfoNotification notifications = 1;
+inline int MappingInfoNotificationList::notifications_size() const {
+  return notifications_.size();
+}
+inline void MappingInfoNotificationList::clear_notifications() {
+  notifications_.Clear();
+}
+inline const ::Kinova::Api::Base::MappingInfoNotification& MappingInfoNotificationList::notifications(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.MappingInfoNotificationList.notifications)
+  return notifications_.Get(index);
+}
+inline ::Kinova::Api::Base::MappingInfoNotification* MappingInfoNotificationList::mutable_notifications(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.MappingInfoNotificationList.notifications)
+  return notifications_.Mutable(index);
+}
+inline ::Kinova::Api::Base::MappingInfoNotification* MappingInfoNotificationList::add_notifications() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.Base.MappingInfoNotificationList.notifications)
+  return notifications_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::MappingInfoNotification >*
+MappingInfoNotificationList::mutable_notifications() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.Base.MappingInfoNotificationList.notifications)
+  return &notifications_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::MappingInfoNotification >&
+MappingInfoNotificationList::notifications() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.Base.MappingInfoNotificationList.notifications)
+  return notifications_;
+}
+
+// -------------------------------------------------------------------
+
+// OperatingModeNotificationList
+
+// repeated .Kinova.Api.Base.OperatingModeNotification notifications = 1;
+inline int OperatingModeNotificationList::notifications_size() const {
+  return notifications_.size();
+}
+inline void OperatingModeNotificationList::clear_notifications() {
+  notifications_.Clear();
+}
+inline const ::Kinova::Api::Base::OperatingModeNotification& OperatingModeNotificationList::notifications(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.OperatingModeNotificationList.notifications)
+  return notifications_.Get(index);
+}
+inline ::Kinova::Api::Base::OperatingModeNotification* OperatingModeNotificationList::mutable_notifications(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.OperatingModeNotificationList.notifications)
+  return notifications_.Mutable(index);
+}
+inline ::Kinova::Api::Base::OperatingModeNotification* OperatingModeNotificationList::add_notifications() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.Base.OperatingModeNotificationList.notifications)
+  return notifications_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::OperatingModeNotification >*
+OperatingModeNotificationList::mutable_notifications() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.Base.OperatingModeNotificationList.notifications)
+  return &notifications_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::OperatingModeNotification >&
+OperatingModeNotificationList::notifications() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.Base.OperatingModeNotificationList.notifications)
+  return notifications_;
+}
+
+// -------------------------------------------------------------------
+
+// ServoingModeNotificationList
+
+// repeated .Kinova.Api.Base.ServoingModeNotification notifications = 1;
+inline int ServoingModeNotificationList::notifications_size() const {
+  return notifications_.size();
+}
+inline void ServoingModeNotificationList::clear_notifications() {
+  notifications_.Clear();
+}
+inline const ::Kinova::Api::Base::ServoingModeNotification& ServoingModeNotificationList::notifications(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ServoingModeNotificationList.notifications)
+  return notifications_.Get(index);
+}
+inline ::Kinova::Api::Base::ServoingModeNotification* ServoingModeNotificationList::mutable_notifications(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ServoingModeNotificationList.notifications)
+  return notifications_.Mutable(index);
+}
+inline ::Kinova::Api::Base::ServoingModeNotification* ServoingModeNotificationList::add_notifications() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.Base.ServoingModeNotificationList.notifications)
+  return notifications_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::ServoingModeNotification >*
+ServoingModeNotificationList::mutable_notifications() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.Base.ServoingModeNotificationList.notifications)
+  return &notifications_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::ServoingModeNotification >&
+ServoingModeNotificationList::notifications() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.Base.ServoingModeNotificationList.notifications)
+  return notifications_;
+}
+
+// -------------------------------------------------------------------
+
+// SequenceInfoNotificationList
+
+// repeated .Kinova.Api.Base.SequenceInfoNotification notifications = 1;
+inline int SequenceInfoNotificationList::notifications_size() const {
+  return notifications_.size();
+}
+inline void SequenceInfoNotificationList::clear_notifications() {
+  notifications_.Clear();
+}
+inline const ::Kinova::Api::Base::SequenceInfoNotification& SequenceInfoNotificationList::notifications(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.SequenceInfoNotificationList.notifications)
+  return notifications_.Get(index);
+}
+inline ::Kinova::Api::Base::SequenceInfoNotification* SequenceInfoNotificationList::mutable_notifications(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.SequenceInfoNotificationList.notifications)
+  return notifications_.Mutable(index);
+}
+inline ::Kinova::Api::Base::SequenceInfoNotification* SequenceInfoNotificationList::add_notifications() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.Base.SequenceInfoNotificationList.notifications)
+  return notifications_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::SequenceInfoNotification >*
+SequenceInfoNotificationList::mutable_notifications() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.Base.SequenceInfoNotificationList.notifications)
+  return &notifications_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::SequenceInfoNotification >&
+SequenceInfoNotificationList::notifications() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.Base.SequenceInfoNotificationList.notifications)
+  return notifications_;
+}
+
+// -------------------------------------------------------------------
+
+// ProtectionZoneNotificationList
+
+// repeated .Kinova.Api.Base.ProtectionZoneNotification notifications = 1;
+inline int ProtectionZoneNotificationList::notifications_size() const {
+  return notifications_.size();
+}
+inline void ProtectionZoneNotificationList::clear_notifications() {
+  notifications_.Clear();
+}
+inline const ::Kinova::Api::Base::ProtectionZoneNotification& ProtectionZoneNotificationList::notifications(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ProtectionZoneNotificationList.notifications)
+  return notifications_.Get(index);
+}
+inline ::Kinova::Api::Base::ProtectionZoneNotification* ProtectionZoneNotificationList::mutable_notifications(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ProtectionZoneNotificationList.notifications)
+  return notifications_.Mutable(index);
+}
+inline ::Kinova::Api::Base::ProtectionZoneNotification* ProtectionZoneNotificationList::add_notifications() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.Base.ProtectionZoneNotificationList.notifications)
+  return notifications_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::ProtectionZoneNotification >*
+ProtectionZoneNotificationList::mutable_notifications() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.Base.ProtectionZoneNotificationList.notifications)
+  return &notifications_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::ProtectionZoneNotification >&
+ProtectionZoneNotificationList::notifications() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.Base.ProtectionZoneNotificationList.notifications)
+  return notifications_;
+}
+
+// -------------------------------------------------------------------
+
+// UserNotificationList
+
+// repeated .Kinova.Api.Base.UserNotification notifications = 1;
+inline int UserNotificationList::notifications_size() const {
+  return notifications_.size();
+}
+inline void UserNotificationList::clear_notifications() {
+  notifications_.Clear();
+}
+inline const ::Kinova::Api::Base::UserNotification& UserNotificationList::notifications(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.UserNotificationList.notifications)
+  return notifications_.Get(index);
+}
+inline ::Kinova::Api::Base::UserNotification* UserNotificationList::mutable_notifications(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.UserNotificationList.notifications)
+  return notifications_.Mutable(index);
+}
+inline ::Kinova::Api::Base::UserNotification* UserNotificationList::add_notifications() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.Base.UserNotificationList.notifications)
+  return notifications_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::UserNotification >*
+UserNotificationList::mutable_notifications() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.Base.UserNotificationList.notifications)
+  return &notifications_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::UserNotification >&
+UserNotificationList::notifications() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.Base.UserNotificationList.notifications)
+  return notifications_;
+}
+
+// -------------------------------------------------------------------
+
+// SafetyNotificationList
+
+// repeated .Kinova.Api.Common.SafetyNotification notifications = 1;
+inline int SafetyNotificationList::notifications_size() const {
+  return notifications_.size();
+}
+inline const ::Kinova::Api::Common::SafetyNotification& SafetyNotificationList::notifications(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.SafetyNotificationList.notifications)
+  return notifications_.Get(index);
+}
+inline ::Kinova::Api::Common::SafetyNotification* SafetyNotificationList::mutable_notifications(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.SafetyNotificationList.notifications)
+  return notifications_.Mutable(index);
+}
+inline ::Kinova::Api::Common::SafetyNotification* SafetyNotificationList::add_notifications() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.Base.SafetyNotificationList.notifications)
+  return notifications_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Common::SafetyNotification >*
+SafetyNotificationList::mutable_notifications() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.Base.SafetyNotificationList.notifications)
+  return &notifications_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Common::SafetyNotification >&
+SafetyNotificationList::notifications() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.Base.SafetyNotificationList.notifications)
+  return notifications_;
+}
+
+// -------------------------------------------------------------------
+
+// ControllerNotificationList
+
+// repeated .Kinova.Api.Base.ControllerNotification notifications = 1;
+inline int ControllerNotificationList::notifications_size() const {
+  return notifications_.size();
+}
+inline void ControllerNotificationList::clear_notifications() {
+  notifications_.Clear();
+}
+inline const ::Kinova::Api::Base::ControllerNotification& ControllerNotificationList::notifications(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ControllerNotificationList.notifications)
+  return notifications_.Get(index);
+}
+inline ::Kinova::Api::Base::ControllerNotification* ControllerNotificationList::mutable_notifications(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ControllerNotificationList.notifications)
+  return notifications_.Mutable(index);
+}
+inline ::Kinova::Api::Base::ControllerNotification* ControllerNotificationList::add_notifications() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.Base.ControllerNotificationList.notifications)
+  return notifications_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::ControllerNotification >*
+ControllerNotificationList::mutable_notifications() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.Base.ControllerNotificationList.notifications)
+  return &notifications_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::ControllerNotification >&
+ControllerNotificationList::notifications() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.Base.ControllerNotificationList.notifications)
+  return notifications_;
+}
+
+// -------------------------------------------------------------------
+
+// ActionNotificationList
+
+// repeated .Kinova.Api.Base.ActionNotification notifications = 1;
+inline int ActionNotificationList::notifications_size() const {
+  return notifications_.size();
+}
+inline void ActionNotificationList::clear_notifications() {
+  notifications_.Clear();
+}
+inline const ::Kinova::Api::Base::ActionNotification& ActionNotificationList::notifications(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ActionNotificationList.notifications)
+  return notifications_.Get(index);
+}
+inline ::Kinova::Api::Base::ActionNotification* ActionNotificationList::mutable_notifications(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ActionNotificationList.notifications)
+  return notifications_.Mutable(index);
+}
+inline ::Kinova::Api::Base::ActionNotification* ActionNotificationList::add_notifications() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.Base.ActionNotificationList.notifications)
+  return notifications_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::ActionNotification >*
+ActionNotificationList::mutable_notifications() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.Base.ActionNotificationList.notifications)
+  return &notifications_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::ActionNotification >&
+ActionNotificationList::notifications() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.Base.ActionNotificationList.notifications)
+  return notifications_;
+}
+
+// -------------------------------------------------------------------
+
+// RobotEventNotificationList
+
+// repeated .Kinova.Api.Base.RobotEventNotification notifications = 1;
+inline int RobotEventNotificationList::notifications_size() const {
+  return notifications_.size();
+}
+inline void RobotEventNotificationList::clear_notifications() {
+  notifications_.Clear();
+}
+inline const ::Kinova::Api::Base::RobotEventNotification& RobotEventNotificationList::notifications(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.RobotEventNotificationList.notifications)
+  return notifications_.Get(index);
+}
+inline ::Kinova::Api::Base::RobotEventNotification* RobotEventNotificationList::mutable_notifications(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.RobotEventNotificationList.notifications)
+  return notifications_.Mutable(index);
+}
+inline ::Kinova::Api::Base::RobotEventNotification* RobotEventNotificationList::add_notifications() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.Base.RobotEventNotificationList.notifications)
+  return notifications_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::RobotEventNotification >*
+RobotEventNotificationList::mutable_notifications() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.Base.RobotEventNotificationList.notifications)
+  return &notifications_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::RobotEventNotification >&
+RobotEventNotificationList::notifications() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.Base.RobotEventNotificationList.notifications)
+  return notifications_;
+}
+
+// -------------------------------------------------------------------
+
+// NetworkNotificationList
+
+// repeated .Kinova.Api.Base.NetworkNotification notifications = 1;
+inline int NetworkNotificationList::notifications_size() const {
+  return notifications_.size();
+}
+inline void NetworkNotificationList::clear_notifications() {
+  notifications_.Clear();
+}
+inline const ::Kinova::Api::Base::NetworkNotification& NetworkNotificationList::notifications(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.NetworkNotificationList.notifications)
+  return notifications_.Get(index);
+}
+inline ::Kinova::Api::Base::NetworkNotification* NetworkNotificationList::mutable_notifications(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.NetworkNotificationList.notifications)
+  return notifications_.Mutable(index);
+}
+inline ::Kinova::Api::Base::NetworkNotification* NetworkNotificationList::add_notifications() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.Base.NetworkNotificationList.notifications)
+  return notifications_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::NetworkNotification >*
+NetworkNotificationList::mutable_notifications() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.Base.NetworkNotificationList.notifications)
+  return &notifications_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::NetworkNotification >&
+NetworkNotificationList::notifications() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.Base.NetworkNotificationList.notifications)
+  return notifications_;
+}
+
+// -------------------------------------------------------------------
+
+// MappingHandle
+
+// uint32 identifier = 1;
+inline void MappingHandle::clear_identifier() {
+  identifier_ = 0u;
+}
+inline ::google::protobuf::uint32 MappingHandle::identifier() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.MappingHandle.identifier)
+  return identifier_;
+}
+inline void MappingHandle::set_identifier(::google::protobuf::uint32 value) {
+  
+  identifier_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.MappingHandle.identifier)
+}
+
+// fixed32 permission = 2;
+inline void MappingHandle::clear_permission() {
+  permission_ = 0u;
+}
+inline ::google::protobuf::uint32 MappingHandle::permission() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.MappingHandle.permission)
+  return permission_;
+}
+inline void MappingHandle::set_permission(::google::protobuf::uint32 value) {
+  
+  permission_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.MappingHandle.permission)
+}
+
+// -------------------------------------------------------------------
+
+// ControllerEvent
+
+// .Kinova.Api.Base.ControllerInputType input_type = 1;
+inline void ControllerEvent::clear_input_type() {
+  input_type_ = 0;
+}
+inline ::Kinova::Api::Base::ControllerInputType ControllerEvent::input_type() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ControllerEvent.input_type)
+  return static_cast< ::Kinova::Api::Base::ControllerInputType >(input_type_);
+}
+inline void ControllerEvent::set_input_type(::Kinova::Api::Base::ControllerInputType value) {
+  
+  input_type_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.ControllerEvent.input_type)
+}
+
+// .Kinova.Api.Base.ControllerBehavior behavior = 2;
+inline void ControllerEvent::clear_behavior() {
+  behavior_ = 0;
+}
+inline ::Kinova::Api::Base::ControllerBehavior ControllerEvent::behavior() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ControllerEvent.behavior)
+  return static_cast< ::Kinova::Api::Base::ControllerBehavior >(behavior_);
+}
+inline void ControllerEvent::set_behavior(::Kinova::Api::Base::ControllerBehavior value) {
+  
+  behavior_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.ControllerEvent.behavior)
+}
+
+// uint32 input_identifier = 3;
+inline void ControllerEvent::clear_input_identifier() {
+  input_identifier_ = 0u;
+}
+inline ::google::protobuf::uint32 ControllerEvent::input_identifier() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ControllerEvent.input_identifier)
+  return input_identifier_;
+}
+inline void ControllerEvent::set_input_identifier(::google::protobuf::uint32 value) {
+  
+  input_identifier_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.ControllerEvent.input_identifier)
+}
+
+// -------------------------------------------------------------------
+
+// GpioEvent
+
+// .Kinova.Api.Base.ControllerInputType input_type = 1;
+inline void GpioEvent::clear_input_type() {
+  input_type_ = 0;
+}
+inline ::Kinova::Api::Base::ControllerInputType GpioEvent::input_type() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.GpioEvent.input_type)
+  return static_cast< ::Kinova::Api::Base::ControllerInputType >(input_type_);
+}
+inline void GpioEvent::set_input_type(::Kinova::Api::Base::ControllerInputType value) {
+  
+  input_type_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.GpioEvent.input_type)
+}
+
+// .Kinova.Api.Base.GpioBehavior behavior = 2;
+inline void GpioEvent::clear_behavior() {
+  behavior_ = 0;
+}
+inline ::Kinova::Api::Base::GpioBehavior GpioEvent::behavior() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.GpioEvent.behavior)
+  return static_cast< ::Kinova::Api::Base::GpioBehavior >(behavior_);
+}
+inline void GpioEvent::set_behavior(::Kinova::Api::Base::GpioBehavior value) {
+  
+  behavior_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.GpioEvent.behavior)
+}
+
+// uint32 input_identifier = 3;
+inline void GpioEvent::clear_input_identifier() {
+  input_identifier_ = 0u;
+}
+inline ::google::protobuf::uint32 GpioEvent::input_identifier() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.GpioEvent.input_identifier)
+  return input_identifier_;
+}
+inline void GpioEvent::set_input_identifier(::google::protobuf::uint32 value) {
+  
+  input_identifier_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.GpioEvent.input_identifier)
+}
+
+// -------------------------------------------------------------------
+
+// MapEvent
+
+// .Kinova.Api.Base.GpioEvent gpio_event = 2;
+inline bool MapEvent::has_gpio_event() const {
+  return events_case() == kGpioEvent;
+}
+inline void MapEvent::set_has_gpio_event() {
+  _oneof_case_[0] = kGpioEvent;
+}
+inline void MapEvent::clear_gpio_event() {
+  if (has_gpio_event()) {
+    delete events_.gpio_event_;
+    clear_has_events();
+  }
+}
+inline ::Kinova::Api::Base::GpioEvent* MapEvent::release_gpio_event() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.MapEvent.gpio_event)
+  if (has_gpio_event()) {
+    clear_has_events();
+      ::Kinova::Api::Base::GpioEvent* temp = events_.gpio_event_;
+    events_.gpio_event_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline const ::Kinova::Api::Base::GpioEvent& MapEvent::gpio_event() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.MapEvent.gpio_event)
+  return has_gpio_event()
+      ? *events_.gpio_event_
+      : *reinterpret_cast< ::Kinova::Api::Base::GpioEvent*>(&::Kinova::Api::Base::_GpioEvent_default_instance_);
+}
+inline ::Kinova::Api::Base::GpioEvent* MapEvent::mutable_gpio_event() {
+  if (!has_gpio_event()) {
+    clear_events();
+    set_has_gpio_event();
+    events_.gpio_event_ = new ::Kinova::Api::Base::GpioEvent;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.MapEvent.gpio_event)
+  return events_.gpio_event_;
+}
+
+// .Kinova.Api.Base.ControllerEvent controller_event = 3;
+inline bool MapEvent::has_controller_event() const {
+  return events_case() == kControllerEvent;
+}
+inline void MapEvent::set_has_controller_event() {
+  _oneof_case_[0] = kControllerEvent;
+}
+inline void MapEvent::clear_controller_event() {
+  if (has_controller_event()) {
+    delete events_.controller_event_;
+    clear_has_events();
+  }
+}
+inline ::Kinova::Api::Base::ControllerEvent* MapEvent::release_controller_event() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.MapEvent.controller_event)
+  if (has_controller_event()) {
+    clear_has_events();
+      ::Kinova::Api::Base::ControllerEvent* temp = events_.controller_event_;
+    events_.controller_event_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline const ::Kinova::Api::Base::ControllerEvent& MapEvent::controller_event() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.MapEvent.controller_event)
+  return has_controller_event()
+      ? *events_.controller_event_
+      : *reinterpret_cast< ::Kinova::Api::Base::ControllerEvent*>(&::Kinova::Api::Base::_ControllerEvent_default_instance_);
+}
+inline ::Kinova::Api::Base::ControllerEvent* MapEvent::mutable_controller_event() {
+  if (!has_controller_event()) {
+    clear_events();
+    set_has_controller_event();
+    events_.controller_event_ = new ::Kinova::Api::Base::ControllerEvent;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.MapEvent.controller_event)
+  return events_.controller_event_;
+}
+
+// string name = 4;
+inline void MapEvent::clear_name() {
+  name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& MapEvent::name() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.MapEvent.name)
+  return name_.GetNoArena();
+}
+inline void MapEvent::set_name(const ::std::string& value) {
+  
+  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.MapEvent.name)
+}
+#if LANG_CXX11
+inline void MapEvent::set_name(::std::string&& value) {
+  
+  name_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:Kinova.Api.Base.MapEvent.name)
+}
+#endif
+inline void MapEvent::set_name(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:Kinova.Api.Base.MapEvent.name)
+}
+inline void MapEvent::set_name(const char* value, size_t size) {
+  
+  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:Kinova.Api.Base.MapEvent.name)
+}
+inline ::std::string* MapEvent::mutable_name() {
+  
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.MapEvent.name)
+  return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* MapEvent::release_name() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.MapEvent.name)
+  
+  return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void MapEvent::set_allocated_name(::std::string* name) {
+  if (name != NULL) {
+    
+  } else {
+    
+  }
+  name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.MapEvent.name)
+}
+
+inline bool MapEvent::has_events() const {
+  return events_case() != EVENTS_NOT_SET;
+}
+inline void MapEvent::clear_has_events() {
+  _oneof_case_[0] = EVENTS_NOT_SET;
+}
+inline MapEvent::EventsCase MapEvent::events_case() const {
+  return MapEvent::EventsCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// MapElement
+
+// .Kinova.Api.Base.MapEvent event = 1;
+inline bool MapElement::has_event() const {
+  return this != internal_default_instance() && event_ != NULL;
+}
+inline void MapElement::clear_event() {
+  if (GetArenaNoVirtual() == NULL && event_ != NULL) {
+    delete event_;
+  }
+  event_ = NULL;
+}
+inline const ::Kinova::Api::Base::MapEvent& MapElement::event() const {
+  const ::Kinova::Api::Base::MapEvent* p = event_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.MapElement.event)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::MapEvent*>(
+      &::Kinova::Api::Base::_MapEvent_default_instance_);
+}
+inline ::Kinova::Api::Base::MapEvent* MapElement::release_event() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.MapElement.event)
+  
+  ::Kinova::Api::Base::MapEvent* temp = event_;
+  event_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::MapEvent* MapElement::mutable_event() {
+  
+  if (event_ == NULL) {
+    event_ = new ::Kinova::Api::Base::MapEvent;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.MapElement.event)
+  return event_;
+}
+inline void MapElement::set_allocated_event(::Kinova::Api::Base::MapEvent* event) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete event_;
+  }
+  if (event) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      event = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, event, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  event_ = event;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.MapElement.event)
+}
+
+// .Kinova.Api.Base.Action action = 2;
+inline bool MapElement::has_action() const {
+  return this != internal_default_instance() && action_ != NULL;
+}
+inline void MapElement::clear_action() {
+  if (GetArenaNoVirtual() == NULL && action_ != NULL) {
+    delete action_;
+  }
+  action_ = NULL;
+}
+inline const ::Kinova::Api::Base::Action& MapElement::action() const {
+  const ::Kinova::Api::Base::Action* p = action_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.MapElement.action)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::Action*>(
+      &::Kinova::Api::Base::_Action_default_instance_);
+}
+inline ::Kinova::Api::Base::Action* MapElement::release_action() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.MapElement.action)
+  
+  ::Kinova::Api::Base::Action* temp = action_;
+  action_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::Action* MapElement::mutable_action() {
+  
+  if (action_ == NULL) {
+    action_ = new ::Kinova::Api::Base::Action;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.MapElement.action)
+  return action_;
+}
+inline void MapElement::set_allocated_action(::Kinova::Api::Base::Action* action) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete action_;
+  }
+  if (action) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      action = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, action, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  action_ = action;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.MapElement.action)
+}
+
+// string name = 3;
+inline void MapElement::clear_name() {
+  name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& MapElement::name() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.MapElement.name)
+  return name_.GetNoArena();
+}
+inline void MapElement::set_name(const ::std::string& value) {
+  
+  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.MapElement.name)
+}
+#if LANG_CXX11
+inline void MapElement::set_name(::std::string&& value) {
+  
+  name_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:Kinova.Api.Base.MapElement.name)
+}
+#endif
+inline void MapElement::set_name(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:Kinova.Api.Base.MapElement.name)
+}
+inline void MapElement::set_name(const char* value, size_t size) {
+  
+  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:Kinova.Api.Base.MapElement.name)
+}
+inline ::std::string* MapElement::mutable_name() {
+  
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.MapElement.name)
+  return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* MapElement::release_name() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.MapElement.name)
+  
+  return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void MapElement::set_allocated_name(::std::string* name) {
+  if (name != NULL) {
+    
+  } else {
+    
+  }
+  name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.MapElement.name)
+}
+
+// -------------------------------------------------------------------
+
+// ActivateMapHandle
+
+// .Kinova.Api.Base.MappingHandle mapping_handle = 1;
+inline bool ActivateMapHandle::has_mapping_handle() const {
+  return this != internal_default_instance() && mapping_handle_ != NULL;
+}
+inline void ActivateMapHandle::clear_mapping_handle() {
+  if (GetArenaNoVirtual() == NULL && mapping_handle_ != NULL) {
+    delete mapping_handle_;
+  }
+  mapping_handle_ = NULL;
+}
+inline const ::Kinova::Api::Base::MappingHandle& ActivateMapHandle::mapping_handle() const {
+  const ::Kinova::Api::Base::MappingHandle* p = mapping_handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ActivateMapHandle.mapping_handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::MappingHandle*>(
+      &::Kinova::Api::Base::_MappingHandle_default_instance_);
+}
+inline ::Kinova::Api::Base::MappingHandle* ActivateMapHandle::release_mapping_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ActivateMapHandle.mapping_handle)
+  
+  ::Kinova::Api::Base::MappingHandle* temp = mapping_handle_;
+  mapping_handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::MappingHandle* ActivateMapHandle::mutable_mapping_handle() {
+  
+  if (mapping_handle_ == NULL) {
+    mapping_handle_ = new ::Kinova::Api::Base::MappingHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ActivateMapHandle.mapping_handle)
+  return mapping_handle_;
+}
+inline void ActivateMapHandle::set_allocated_mapping_handle(::Kinova::Api::Base::MappingHandle* mapping_handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete mapping_handle_;
+  }
+  if (mapping_handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      mapping_handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, mapping_handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  mapping_handle_ = mapping_handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.ActivateMapHandle.mapping_handle)
+}
+
+// .Kinova.Api.Base.MapGroupHandle map_group_handle = 2;
+inline bool ActivateMapHandle::has_map_group_handle() const {
+  return this != internal_default_instance() && map_group_handle_ != NULL;
+}
+inline void ActivateMapHandle::clear_map_group_handle() {
+  if (GetArenaNoVirtual() == NULL && map_group_handle_ != NULL) {
+    delete map_group_handle_;
+  }
+  map_group_handle_ = NULL;
+}
+inline const ::Kinova::Api::Base::MapGroupHandle& ActivateMapHandle::map_group_handle() const {
+  const ::Kinova::Api::Base::MapGroupHandle* p = map_group_handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ActivateMapHandle.map_group_handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::MapGroupHandle*>(
+      &::Kinova::Api::Base::_MapGroupHandle_default_instance_);
+}
+inline ::Kinova::Api::Base::MapGroupHandle* ActivateMapHandle::release_map_group_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ActivateMapHandle.map_group_handle)
+  
+  ::Kinova::Api::Base::MapGroupHandle* temp = map_group_handle_;
+  map_group_handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::MapGroupHandle* ActivateMapHandle::mutable_map_group_handle() {
+  
+  if (map_group_handle_ == NULL) {
+    map_group_handle_ = new ::Kinova::Api::Base::MapGroupHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ActivateMapHandle.map_group_handle)
+  return map_group_handle_;
+}
+inline void ActivateMapHandle::set_allocated_map_group_handle(::Kinova::Api::Base::MapGroupHandle* map_group_handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete map_group_handle_;
+  }
+  if (map_group_handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      map_group_handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, map_group_handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  map_group_handle_ = map_group_handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.ActivateMapHandle.map_group_handle)
+}
+
+// .Kinova.Api.Base.MapHandle map_handle = 3;
+inline bool ActivateMapHandle::has_map_handle() const {
+  return this != internal_default_instance() && map_handle_ != NULL;
+}
+inline void ActivateMapHandle::clear_map_handle() {
+  if (GetArenaNoVirtual() == NULL && map_handle_ != NULL) {
+    delete map_handle_;
+  }
+  map_handle_ = NULL;
+}
+inline const ::Kinova::Api::Base::MapHandle& ActivateMapHandle::map_handle() const {
+  const ::Kinova::Api::Base::MapHandle* p = map_handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ActivateMapHandle.map_handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::MapHandle*>(
+      &::Kinova::Api::Base::_MapHandle_default_instance_);
+}
+inline ::Kinova::Api::Base::MapHandle* ActivateMapHandle::release_map_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ActivateMapHandle.map_handle)
+  
+  ::Kinova::Api::Base::MapHandle* temp = map_handle_;
+  map_handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::MapHandle* ActivateMapHandle::mutable_map_handle() {
+  
+  if (map_handle_ == NULL) {
+    map_handle_ = new ::Kinova::Api::Base::MapHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ActivateMapHandle.map_handle)
+  return map_handle_;
+}
+inline void ActivateMapHandle::set_allocated_map_handle(::Kinova::Api::Base::MapHandle* map_handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete map_handle_;
+  }
+  if (map_handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      map_handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, map_handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  map_handle_ = map_handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.ActivateMapHandle.map_handle)
+}
+
+// -------------------------------------------------------------------
+
+// Map
+
+// .Kinova.Api.Base.MapHandle handle = 1;
+inline bool Map::has_handle() const {
+  return this != internal_default_instance() && handle_ != NULL;
+}
+inline void Map::clear_handle() {
+  if (GetArenaNoVirtual() == NULL && handle_ != NULL) {
+    delete handle_;
+  }
+  handle_ = NULL;
+}
+inline const ::Kinova::Api::Base::MapHandle& Map::handle() const {
+  const ::Kinova::Api::Base::MapHandle* p = handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Map.handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::MapHandle*>(
+      &::Kinova::Api::Base::_MapHandle_default_instance_);
+}
+inline ::Kinova::Api::Base::MapHandle* Map::release_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.Map.handle)
+  
+  ::Kinova::Api::Base::MapHandle* temp = handle_;
+  handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::MapHandle* Map::mutable_handle() {
+  
+  if (handle_ == NULL) {
+    handle_ = new ::Kinova::Api::Base::MapHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.Map.handle)
+  return handle_;
+}
+inline void Map::set_allocated_handle(::Kinova::Api::Base::MapHandle* handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete handle_;
+  }
+  if (handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  handle_ = handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.Map.handle)
+}
+
+// string name = 2;
+inline void Map::clear_name() {
+  name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& Map::name() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Map.name)
+  return name_.GetNoArena();
+}
+inline void Map::set_name(const ::std::string& value) {
+  
+  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.Map.name)
+}
+#if LANG_CXX11
+inline void Map::set_name(::std::string&& value) {
+  
+  name_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:Kinova.Api.Base.Map.name)
+}
+#endif
+inline void Map::set_name(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:Kinova.Api.Base.Map.name)
+}
+inline void Map::set_name(const char* value, size_t size) {
+  
+  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:Kinova.Api.Base.Map.name)
+}
+inline ::std::string* Map::mutable_name() {
+  
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.Map.name)
+  return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* Map::release_name() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.Map.name)
+  
+  return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void Map::set_allocated_name(::std::string* name) {
+  if (name != NULL) {
+    
+  } else {
+    
+  }
+  name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.Map.name)
+}
+
+// repeated .Kinova.Api.Base.MapElement elements = 3;
+inline int Map::elements_size() const {
+  return elements_.size();
+}
+inline void Map::clear_elements() {
+  elements_.Clear();
+}
+inline const ::Kinova::Api::Base::MapElement& Map::elements(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Map.elements)
+  return elements_.Get(index);
+}
+inline ::Kinova::Api::Base::MapElement* Map::mutable_elements(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.Map.elements)
+  return elements_.Mutable(index);
+}
+inline ::Kinova::Api::Base::MapElement* Map::add_elements() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.Base.Map.elements)
+  return elements_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::MapElement >*
+Map::mutable_elements() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.Base.Map.elements)
+  return &elements_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::MapElement >&
+Map::elements() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.Base.Map.elements)
+  return elements_;
+}
+
+// -------------------------------------------------------------------
+
+// MapHandle
+
+// uint32 identifier = 1;
+inline void MapHandle::clear_identifier() {
+  identifier_ = 0u;
+}
+inline ::google::protobuf::uint32 MapHandle::identifier() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.MapHandle.identifier)
+  return identifier_;
+}
+inline void MapHandle::set_identifier(::google::protobuf::uint32 value) {
+  
+  identifier_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.MapHandle.identifier)
+}
+
+// fixed32 permission = 2;
+inline void MapHandle::clear_permission() {
+  permission_ = 0u;
+}
+inline ::google::protobuf::uint32 MapHandle::permission() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.MapHandle.permission)
+  return permission_;
+}
+inline void MapHandle::set_permission(::google::protobuf::uint32 value) {
+  
+  permission_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.MapHandle.permission)
+}
+
+// -------------------------------------------------------------------
+
+// MapList
+
+// repeated .Kinova.Api.Base.Map map_list = 1;
+inline int MapList::map_list_size() const {
+  return map_list_.size();
+}
+inline void MapList::clear_map_list() {
+  map_list_.Clear();
+}
+inline const ::Kinova::Api::Base::Map& MapList::map_list(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.MapList.map_list)
+  return map_list_.Get(index);
+}
+inline ::Kinova::Api::Base::Map* MapList::mutable_map_list(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.MapList.map_list)
+  return map_list_.Mutable(index);
+}
+inline ::Kinova::Api::Base::Map* MapList::add_map_list() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.Base.MapList.map_list)
+  return map_list_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::Map >*
+MapList::mutable_map_list() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.Base.MapList.map_list)
+  return &map_list_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::Map >&
+MapList::map_list() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.Base.MapList.map_list)
+  return map_list_;
+}
+
+// -------------------------------------------------------------------
+
+// MapGroupHandle
+
+// uint32 identifier = 1;
+inline void MapGroupHandle::clear_identifier() {
+  identifier_ = 0u;
+}
+inline ::google::protobuf::uint32 MapGroupHandle::identifier() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.MapGroupHandle.identifier)
+  return identifier_;
+}
+inline void MapGroupHandle::set_identifier(::google::protobuf::uint32 value) {
+  
+  identifier_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.MapGroupHandle.identifier)
+}
+
+// fixed32 permission = 2;
+inline void MapGroupHandle::clear_permission() {
+  permission_ = 0u;
+}
+inline ::google::protobuf::uint32 MapGroupHandle::permission() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.MapGroupHandle.permission)
+  return permission_;
+}
+inline void MapGroupHandle::set_permission(::google::protobuf::uint32 value) {
+  
+  permission_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.MapGroupHandle.permission)
+}
+
+// -------------------------------------------------------------------
+
+// MapGroup
+
+// .Kinova.Api.Base.MapGroupHandle group_handle = 1;
+inline bool MapGroup::has_group_handle() const {
+  return this != internal_default_instance() && group_handle_ != NULL;
+}
+inline void MapGroup::clear_group_handle() {
+  if (GetArenaNoVirtual() == NULL && group_handle_ != NULL) {
+    delete group_handle_;
+  }
+  group_handle_ = NULL;
+}
+inline const ::Kinova::Api::Base::MapGroupHandle& MapGroup::group_handle() const {
+  const ::Kinova::Api::Base::MapGroupHandle* p = group_handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.MapGroup.group_handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::MapGroupHandle*>(
+      &::Kinova::Api::Base::_MapGroupHandle_default_instance_);
+}
+inline ::Kinova::Api::Base::MapGroupHandle* MapGroup::release_group_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.MapGroup.group_handle)
+  
+  ::Kinova::Api::Base::MapGroupHandle* temp = group_handle_;
+  group_handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::MapGroupHandle* MapGroup::mutable_group_handle() {
+  
+  if (group_handle_ == NULL) {
+    group_handle_ = new ::Kinova::Api::Base::MapGroupHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.MapGroup.group_handle)
+  return group_handle_;
+}
+inline void MapGroup::set_allocated_group_handle(::Kinova::Api::Base::MapGroupHandle* group_handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete group_handle_;
+  }
+  if (group_handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      group_handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, group_handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  group_handle_ = group_handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.MapGroup.group_handle)
+}
+
+// string name = 2;
+inline void MapGroup::clear_name() {
+  name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& MapGroup::name() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.MapGroup.name)
+  return name_.GetNoArena();
+}
+inline void MapGroup::set_name(const ::std::string& value) {
+  
+  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.MapGroup.name)
+}
+#if LANG_CXX11
+inline void MapGroup::set_name(::std::string&& value) {
+  
+  name_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:Kinova.Api.Base.MapGroup.name)
+}
+#endif
+inline void MapGroup::set_name(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:Kinova.Api.Base.MapGroup.name)
+}
+inline void MapGroup::set_name(const char* value, size_t size) {
+  
+  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:Kinova.Api.Base.MapGroup.name)
+}
+inline ::std::string* MapGroup::mutable_name() {
+  
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.MapGroup.name)
+  return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* MapGroup::release_name() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.MapGroup.name)
+  
+  return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void MapGroup::set_allocated_name(::std::string* name) {
+  if (name != NULL) {
+    
+  } else {
+    
+  }
+  name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.MapGroup.name)
+}
+
+// .Kinova.Api.Base.MappingHandle related_mapping_handle = 3;
+inline bool MapGroup::has_related_mapping_handle() const {
+  return this != internal_default_instance() && related_mapping_handle_ != NULL;
+}
+inline void MapGroup::clear_related_mapping_handle() {
+  if (GetArenaNoVirtual() == NULL && related_mapping_handle_ != NULL) {
+    delete related_mapping_handle_;
+  }
+  related_mapping_handle_ = NULL;
+}
+inline const ::Kinova::Api::Base::MappingHandle& MapGroup::related_mapping_handle() const {
+  const ::Kinova::Api::Base::MappingHandle* p = related_mapping_handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.MapGroup.related_mapping_handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::MappingHandle*>(
+      &::Kinova::Api::Base::_MappingHandle_default_instance_);
+}
+inline ::Kinova::Api::Base::MappingHandle* MapGroup::release_related_mapping_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.MapGroup.related_mapping_handle)
+  
+  ::Kinova::Api::Base::MappingHandle* temp = related_mapping_handle_;
+  related_mapping_handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::MappingHandle* MapGroup::mutable_related_mapping_handle() {
+  
+  if (related_mapping_handle_ == NULL) {
+    related_mapping_handle_ = new ::Kinova::Api::Base::MappingHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.MapGroup.related_mapping_handle)
+  return related_mapping_handle_;
+}
+inline void MapGroup::set_allocated_related_mapping_handle(::Kinova::Api::Base::MappingHandle* related_mapping_handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete related_mapping_handle_;
+  }
+  if (related_mapping_handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      related_mapping_handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, related_mapping_handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  related_mapping_handle_ = related_mapping_handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.MapGroup.related_mapping_handle)
+}
+
+// .Kinova.Api.Base.MapGroupHandle parent_group_handle = 4;
+inline bool MapGroup::has_parent_group_handle() const {
+  return this != internal_default_instance() && parent_group_handle_ != NULL;
+}
+inline void MapGroup::clear_parent_group_handle() {
+  if (GetArenaNoVirtual() == NULL && parent_group_handle_ != NULL) {
+    delete parent_group_handle_;
+  }
+  parent_group_handle_ = NULL;
+}
+inline const ::Kinova::Api::Base::MapGroupHandle& MapGroup::parent_group_handle() const {
+  const ::Kinova::Api::Base::MapGroupHandle* p = parent_group_handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.MapGroup.parent_group_handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::MapGroupHandle*>(
+      &::Kinova::Api::Base::_MapGroupHandle_default_instance_);
+}
+inline ::Kinova::Api::Base::MapGroupHandle* MapGroup::release_parent_group_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.MapGroup.parent_group_handle)
+  
+  ::Kinova::Api::Base::MapGroupHandle* temp = parent_group_handle_;
+  parent_group_handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::MapGroupHandle* MapGroup::mutable_parent_group_handle() {
+  
+  if (parent_group_handle_ == NULL) {
+    parent_group_handle_ = new ::Kinova::Api::Base::MapGroupHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.MapGroup.parent_group_handle)
+  return parent_group_handle_;
+}
+inline void MapGroup::set_allocated_parent_group_handle(::Kinova::Api::Base::MapGroupHandle* parent_group_handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete parent_group_handle_;
+  }
+  if (parent_group_handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      parent_group_handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, parent_group_handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  parent_group_handle_ = parent_group_handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.MapGroup.parent_group_handle)
+}
+
+// repeated .Kinova.Api.Base.MapGroupHandle children_map_group_handles = 5;
+inline int MapGroup::children_map_group_handles_size() const {
+  return children_map_group_handles_.size();
+}
+inline void MapGroup::clear_children_map_group_handles() {
+  children_map_group_handles_.Clear();
+}
+inline const ::Kinova::Api::Base::MapGroupHandle& MapGroup::children_map_group_handles(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.MapGroup.children_map_group_handles)
+  return children_map_group_handles_.Get(index);
+}
+inline ::Kinova::Api::Base::MapGroupHandle* MapGroup::mutable_children_map_group_handles(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.MapGroup.children_map_group_handles)
+  return children_map_group_handles_.Mutable(index);
+}
+inline ::Kinova::Api::Base::MapGroupHandle* MapGroup::add_children_map_group_handles() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.Base.MapGroup.children_map_group_handles)
+  return children_map_group_handles_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::MapGroupHandle >*
+MapGroup::mutable_children_map_group_handles() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.Base.MapGroup.children_map_group_handles)
+  return &children_map_group_handles_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::MapGroupHandle >&
+MapGroup::children_map_group_handles() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.Base.MapGroup.children_map_group_handles)
+  return children_map_group_handles_;
+}
+
+// repeated .Kinova.Api.Base.MapHandle map_handles = 6;
+inline int MapGroup::map_handles_size() const {
+  return map_handles_.size();
+}
+inline void MapGroup::clear_map_handles() {
+  map_handles_.Clear();
+}
+inline const ::Kinova::Api::Base::MapHandle& MapGroup::map_handles(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.MapGroup.map_handles)
+  return map_handles_.Get(index);
+}
+inline ::Kinova::Api::Base::MapHandle* MapGroup::mutable_map_handles(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.MapGroup.map_handles)
+  return map_handles_.Mutable(index);
+}
+inline ::Kinova::Api::Base::MapHandle* MapGroup::add_map_handles() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.Base.MapGroup.map_handles)
+  return map_handles_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::MapHandle >*
+MapGroup::mutable_map_handles() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.Base.MapGroup.map_handles)
+  return &map_handles_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::MapHandle >&
+MapGroup::map_handles() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.Base.MapGroup.map_handles)
+  return map_handles_;
+}
+
+// string application_data = 7;
+inline void MapGroup::clear_application_data() {
+  application_data_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& MapGroup::application_data() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.MapGroup.application_data)
+  return application_data_.GetNoArena();
+}
+inline void MapGroup::set_application_data(const ::std::string& value) {
+  
+  application_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.MapGroup.application_data)
+}
+#if LANG_CXX11
+inline void MapGroup::set_application_data(::std::string&& value) {
+  
+  application_data_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:Kinova.Api.Base.MapGroup.application_data)
+}
+#endif
+inline void MapGroup::set_application_data(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  application_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:Kinova.Api.Base.MapGroup.application_data)
+}
+inline void MapGroup::set_application_data(const char* value, size_t size) {
+  
+  application_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:Kinova.Api.Base.MapGroup.application_data)
+}
+inline ::std::string* MapGroup::mutable_application_data() {
+  
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.MapGroup.application_data)
+  return application_data_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* MapGroup::release_application_data() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.MapGroup.application_data)
+  
+  return application_data_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void MapGroup::set_allocated_application_data(::std::string* application_data) {
+  if (application_data != NULL) {
+    
+  } else {
+    
+  }
+  application_data_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), application_data);
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.MapGroup.application_data)
+}
+
+// -------------------------------------------------------------------
+
+// MapGroupList
+
+// repeated .Kinova.Api.Base.MapGroup map_groups = 1;
+inline int MapGroupList::map_groups_size() const {
+  return map_groups_.size();
+}
+inline void MapGroupList::clear_map_groups() {
+  map_groups_.Clear();
+}
+inline const ::Kinova::Api::Base::MapGroup& MapGroupList::map_groups(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.MapGroupList.map_groups)
+  return map_groups_.Get(index);
+}
+inline ::Kinova::Api::Base::MapGroup* MapGroupList::mutable_map_groups(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.MapGroupList.map_groups)
+  return map_groups_.Mutable(index);
+}
+inline ::Kinova::Api::Base::MapGroup* MapGroupList::add_map_groups() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.Base.MapGroupList.map_groups)
+  return map_groups_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::MapGroup >*
+MapGroupList::mutable_map_groups() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.Base.MapGroupList.map_groups)
+  return &map_groups_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::MapGroup >&
+MapGroupList::map_groups() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.Base.MapGroupList.map_groups)
+  return map_groups_;
+}
+
+// -------------------------------------------------------------------
+
+// Mapping
+
+// .Kinova.Api.Base.MappingHandle handle = 1;
+inline bool Mapping::has_handle() const {
+  return this != internal_default_instance() && handle_ != NULL;
+}
+inline void Mapping::clear_handle() {
+  if (GetArenaNoVirtual() == NULL && handle_ != NULL) {
+    delete handle_;
+  }
+  handle_ = NULL;
+}
+inline const ::Kinova::Api::Base::MappingHandle& Mapping::handle() const {
+  const ::Kinova::Api::Base::MappingHandle* p = handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Mapping.handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::MappingHandle*>(
+      &::Kinova::Api::Base::_MappingHandle_default_instance_);
+}
+inline ::Kinova::Api::Base::MappingHandle* Mapping::release_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.Mapping.handle)
+  
+  ::Kinova::Api::Base::MappingHandle* temp = handle_;
+  handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::MappingHandle* Mapping::mutable_handle() {
+  
+  if (handle_ == NULL) {
+    handle_ = new ::Kinova::Api::Base::MappingHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.Mapping.handle)
+  return handle_;
+}
+inline void Mapping::set_allocated_handle(::Kinova::Api::Base::MappingHandle* handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete handle_;
+  }
+  if (handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  handle_ = handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.Mapping.handle)
+}
+
+// string name = 2;
+inline void Mapping::clear_name() {
+  name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& Mapping::name() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Mapping.name)
+  return name_.GetNoArena();
+}
+inline void Mapping::set_name(const ::std::string& value) {
+  
+  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.Mapping.name)
+}
+#if LANG_CXX11
+inline void Mapping::set_name(::std::string&& value) {
+  
+  name_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:Kinova.Api.Base.Mapping.name)
+}
+#endif
+inline void Mapping::set_name(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:Kinova.Api.Base.Mapping.name)
+}
+inline void Mapping::set_name(const char* value, size_t size) {
+  
+  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:Kinova.Api.Base.Mapping.name)
+}
+inline ::std::string* Mapping::mutable_name() {
+  
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.Mapping.name)
+  return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* Mapping::release_name() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.Mapping.name)
+  
+  return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void Mapping::set_allocated_name(::std::string* name) {
+  if (name != NULL) {
+    
+  } else {
+    
+  }
+  name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.Mapping.name)
+}
+
+// uint32 controller_identifier = 3;
+inline void Mapping::clear_controller_identifier() {
+  controller_identifier_ = 0u;
+}
+inline ::google::protobuf::uint32 Mapping::controller_identifier() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Mapping.controller_identifier)
+  return controller_identifier_;
+}
+inline void Mapping::set_controller_identifier(::google::protobuf::uint32 value) {
+  
+  controller_identifier_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.Mapping.controller_identifier)
+}
+
+// .Kinova.Api.Base.MapGroupHandle active_map_group_handle = 4;
+inline bool Mapping::has_active_map_group_handle() const {
+  return this != internal_default_instance() && active_map_group_handle_ != NULL;
+}
+inline void Mapping::clear_active_map_group_handle() {
+  if (GetArenaNoVirtual() == NULL && active_map_group_handle_ != NULL) {
+    delete active_map_group_handle_;
+  }
+  active_map_group_handle_ = NULL;
+}
+inline const ::Kinova::Api::Base::MapGroupHandle& Mapping::active_map_group_handle() const {
+  const ::Kinova::Api::Base::MapGroupHandle* p = active_map_group_handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Mapping.active_map_group_handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::MapGroupHandle*>(
+      &::Kinova::Api::Base::_MapGroupHandle_default_instance_);
+}
+inline ::Kinova::Api::Base::MapGroupHandle* Mapping::release_active_map_group_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.Mapping.active_map_group_handle)
+  
+  ::Kinova::Api::Base::MapGroupHandle* temp = active_map_group_handle_;
+  active_map_group_handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::MapGroupHandle* Mapping::mutable_active_map_group_handle() {
+  
+  if (active_map_group_handle_ == NULL) {
+    active_map_group_handle_ = new ::Kinova::Api::Base::MapGroupHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.Mapping.active_map_group_handle)
+  return active_map_group_handle_;
+}
+inline void Mapping::set_allocated_active_map_group_handle(::Kinova::Api::Base::MapGroupHandle* active_map_group_handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete active_map_group_handle_;
+  }
+  if (active_map_group_handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      active_map_group_handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, active_map_group_handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  active_map_group_handle_ = active_map_group_handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.Mapping.active_map_group_handle)
+}
+
+// repeated .Kinova.Api.Base.MapGroupHandle map_group_handles = 5;
+inline int Mapping::map_group_handles_size() const {
+  return map_group_handles_.size();
+}
+inline void Mapping::clear_map_group_handles() {
+  map_group_handles_.Clear();
+}
+inline const ::Kinova::Api::Base::MapGroupHandle& Mapping::map_group_handles(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Mapping.map_group_handles)
+  return map_group_handles_.Get(index);
+}
+inline ::Kinova::Api::Base::MapGroupHandle* Mapping::mutable_map_group_handles(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.Mapping.map_group_handles)
+  return map_group_handles_.Mutable(index);
+}
+inline ::Kinova::Api::Base::MapGroupHandle* Mapping::add_map_group_handles() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.Base.Mapping.map_group_handles)
+  return map_group_handles_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::MapGroupHandle >*
+Mapping::mutable_map_group_handles() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.Base.Mapping.map_group_handles)
+  return &map_group_handles_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::MapGroupHandle >&
+Mapping::map_group_handles() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.Base.Mapping.map_group_handles)
+  return map_group_handles_;
+}
+
+// .Kinova.Api.Base.MapHandle active_map_handle = 6;
+inline bool Mapping::has_active_map_handle() const {
+  return this != internal_default_instance() && active_map_handle_ != NULL;
+}
+inline void Mapping::clear_active_map_handle() {
+  if (GetArenaNoVirtual() == NULL && active_map_handle_ != NULL) {
+    delete active_map_handle_;
+  }
+  active_map_handle_ = NULL;
+}
+inline const ::Kinova::Api::Base::MapHandle& Mapping::active_map_handle() const {
+  const ::Kinova::Api::Base::MapHandle* p = active_map_handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Mapping.active_map_handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::MapHandle*>(
+      &::Kinova::Api::Base::_MapHandle_default_instance_);
+}
+inline ::Kinova::Api::Base::MapHandle* Mapping::release_active_map_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.Mapping.active_map_handle)
+  
+  ::Kinova::Api::Base::MapHandle* temp = active_map_handle_;
+  active_map_handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::MapHandle* Mapping::mutable_active_map_handle() {
+  
+  if (active_map_handle_ == NULL) {
+    active_map_handle_ = new ::Kinova::Api::Base::MapHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.Mapping.active_map_handle)
+  return active_map_handle_;
+}
+inline void Mapping::set_allocated_active_map_handle(::Kinova::Api::Base::MapHandle* active_map_handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete active_map_handle_;
+  }
+  if (active_map_handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      active_map_handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, active_map_handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  active_map_handle_ = active_map_handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.Mapping.active_map_handle)
+}
+
+// repeated .Kinova.Api.Base.MapHandle map_handles = 7;
+inline int Mapping::map_handles_size() const {
+  return map_handles_.size();
+}
+inline void Mapping::clear_map_handles() {
+  map_handles_.Clear();
+}
+inline const ::Kinova::Api::Base::MapHandle& Mapping::map_handles(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Mapping.map_handles)
+  return map_handles_.Get(index);
+}
+inline ::Kinova::Api::Base::MapHandle* Mapping::mutable_map_handles(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.Mapping.map_handles)
+  return map_handles_.Mutable(index);
+}
+inline ::Kinova::Api::Base::MapHandle* Mapping::add_map_handles() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.Base.Mapping.map_handles)
+  return map_handles_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::MapHandle >*
+Mapping::mutable_map_handles() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.Base.Mapping.map_handles)
+  return &map_handles_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::MapHandle >&
+Mapping::map_handles() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.Base.Mapping.map_handles)
+  return map_handles_;
+}
+
+// string application_data = 8;
+inline void Mapping::clear_application_data() {
+  application_data_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& Mapping::application_data() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Mapping.application_data)
+  return application_data_.GetNoArena();
+}
+inline void Mapping::set_application_data(const ::std::string& value) {
+  
+  application_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.Mapping.application_data)
+}
+#if LANG_CXX11
+inline void Mapping::set_application_data(::std::string&& value) {
+  
+  application_data_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:Kinova.Api.Base.Mapping.application_data)
+}
+#endif
+inline void Mapping::set_application_data(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  application_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:Kinova.Api.Base.Mapping.application_data)
+}
+inline void Mapping::set_application_data(const char* value, size_t size) {
+  
+  application_data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:Kinova.Api.Base.Mapping.application_data)
+}
+inline ::std::string* Mapping::mutable_application_data() {
+  
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.Mapping.application_data)
+  return application_data_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* Mapping::release_application_data() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.Mapping.application_data)
+  
+  return application_data_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void Mapping::set_allocated_application_data(::std::string* application_data) {
+  if (application_data != NULL) {
+    
+  } else {
+    
+  }
+  application_data_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), application_data);
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.Mapping.application_data)
+}
+
+// -------------------------------------------------------------------
+
+// MappingList
+
+// repeated .Kinova.Api.Base.Mapping mappings = 1;
+inline int MappingList::mappings_size() const {
+  return mappings_.size();
+}
+inline void MappingList::clear_mappings() {
+  mappings_.Clear();
+}
+inline const ::Kinova::Api::Base::Mapping& MappingList::mappings(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.MappingList.mappings)
+  return mappings_.Get(index);
+}
+inline ::Kinova::Api::Base::Mapping* MappingList::mutable_mappings(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.MappingList.mappings)
+  return mappings_.Mutable(index);
+}
+inline ::Kinova::Api::Base::Mapping* MappingList::add_mappings() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.Base.MappingList.mappings)
+  return mappings_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::Mapping >*
+MappingList::mutable_mappings() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.Base.MappingList.mappings)
+  return &mappings_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::Mapping >&
+MappingList::mappings() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.Base.MappingList.mappings)
+  return mappings_;
+}
+
+// -------------------------------------------------------------------
+
+// TransformationMatrix
+
+// .Kinova.Api.Base.TransformationRow r0 = 1;
+inline bool TransformationMatrix::has_r0() const {
+  return this != internal_default_instance() && r0_ != NULL;
+}
+inline void TransformationMatrix::clear_r0() {
+  if (GetArenaNoVirtual() == NULL && r0_ != NULL) {
+    delete r0_;
+  }
+  r0_ = NULL;
+}
+inline const ::Kinova::Api::Base::TransformationRow& TransformationMatrix::r0() const {
+  const ::Kinova::Api::Base::TransformationRow* p = r0_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.TransformationMatrix.r0)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::TransformationRow*>(
+      &::Kinova::Api::Base::_TransformationRow_default_instance_);
+}
+inline ::Kinova::Api::Base::TransformationRow* TransformationMatrix::release_r0() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.TransformationMatrix.r0)
+  
+  ::Kinova::Api::Base::TransformationRow* temp = r0_;
+  r0_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::TransformationRow* TransformationMatrix::mutable_r0() {
+  
+  if (r0_ == NULL) {
+    r0_ = new ::Kinova::Api::Base::TransformationRow;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.TransformationMatrix.r0)
+  return r0_;
+}
+inline void TransformationMatrix::set_allocated_r0(::Kinova::Api::Base::TransformationRow* r0) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete r0_;
+  }
+  if (r0) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      r0 = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, r0, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  r0_ = r0;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.TransformationMatrix.r0)
+}
+
+// .Kinova.Api.Base.TransformationRow r1 = 2;
+inline bool TransformationMatrix::has_r1() const {
+  return this != internal_default_instance() && r1_ != NULL;
+}
+inline void TransformationMatrix::clear_r1() {
+  if (GetArenaNoVirtual() == NULL && r1_ != NULL) {
+    delete r1_;
+  }
+  r1_ = NULL;
+}
+inline const ::Kinova::Api::Base::TransformationRow& TransformationMatrix::r1() const {
+  const ::Kinova::Api::Base::TransformationRow* p = r1_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.TransformationMatrix.r1)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::TransformationRow*>(
+      &::Kinova::Api::Base::_TransformationRow_default_instance_);
+}
+inline ::Kinova::Api::Base::TransformationRow* TransformationMatrix::release_r1() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.TransformationMatrix.r1)
+  
+  ::Kinova::Api::Base::TransformationRow* temp = r1_;
+  r1_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::TransformationRow* TransformationMatrix::mutable_r1() {
+  
+  if (r1_ == NULL) {
+    r1_ = new ::Kinova::Api::Base::TransformationRow;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.TransformationMatrix.r1)
+  return r1_;
+}
+inline void TransformationMatrix::set_allocated_r1(::Kinova::Api::Base::TransformationRow* r1) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete r1_;
+  }
+  if (r1) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      r1 = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, r1, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  r1_ = r1;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.TransformationMatrix.r1)
+}
+
+// .Kinova.Api.Base.TransformationRow r2 = 3;
+inline bool TransformationMatrix::has_r2() const {
+  return this != internal_default_instance() && r2_ != NULL;
+}
+inline void TransformationMatrix::clear_r2() {
+  if (GetArenaNoVirtual() == NULL && r2_ != NULL) {
+    delete r2_;
+  }
+  r2_ = NULL;
+}
+inline const ::Kinova::Api::Base::TransformationRow& TransformationMatrix::r2() const {
+  const ::Kinova::Api::Base::TransformationRow* p = r2_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.TransformationMatrix.r2)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::TransformationRow*>(
+      &::Kinova::Api::Base::_TransformationRow_default_instance_);
+}
+inline ::Kinova::Api::Base::TransformationRow* TransformationMatrix::release_r2() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.TransformationMatrix.r2)
+  
+  ::Kinova::Api::Base::TransformationRow* temp = r2_;
+  r2_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::TransformationRow* TransformationMatrix::mutable_r2() {
+  
+  if (r2_ == NULL) {
+    r2_ = new ::Kinova::Api::Base::TransformationRow;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.TransformationMatrix.r2)
+  return r2_;
+}
+inline void TransformationMatrix::set_allocated_r2(::Kinova::Api::Base::TransformationRow* r2) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete r2_;
+  }
+  if (r2) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      r2 = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, r2, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  r2_ = r2;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.TransformationMatrix.r2)
+}
+
+// .Kinova.Api.Base.TransformationRow r3 = 4;
+inline bool TransformationMatrix::has_r3() const {
+  return this != internal_default_instance() && r3_ != NULL;
+}
+inline void TransformationMatrix::clear_r3() {
+  if (GetArenaNoVirtual() == NULL && r3_ != NULL) {
+    delete r3_;
+  }
+  r3_ = NULL;
+}
+inline const ::Kinova::Api::Base::TransformationRow& TransformationMatrix::r3() const {
+  const ::Kinova::Api::Base::TransformationRow* p = r3_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.TransformationMatrix.r3)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::TransformationRow*>(
+      &::Kinova::Api::Base::_TransformationRow_default_instance_);
+}
+inline ::Kinova::Api::Base::TransformationRow* TransformationMatrix::release_r3() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.TransformationMatrix.r3)
+  
+  ::Kinova::Api::Base::TransformationRow* temp = r3_;
+  r3_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::TransformationRow* TransformationMatrix::mutable_r3() {
+  
+  if (r3_ == NULL) {
+    r3_ = new ::Kinova::Api::Base::TransformationRow;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.TransformationMatrix.r3)
+  return r3_;
+}
+inline void TransformationMatrix::set_allocated_r3(::Kinova::Api::Base::TransformationRow* r3) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete r3_;
+  }
+  if (r3) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      r3 = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, r3, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  r3_ = r3;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.TransformationMatrix.r3)
+}
+
+// -------------------------------------------------------------------
+
+// TransformationRow
+
+// float c0 = 1;
+inline void TransformationRow::clear_c0() {
+  c0_ = 0;
+}
+inline float TransformationRow::c0() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.TransformationRow.c0)
+  return c0_;
+}
+inline void TransformationRow::set_c0(float value) {
+  
+  c0_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.TransformationRow.c0)
+}
+
+// float c1 = 2;
+inline void TransformationRow::clear_c1() {
+  c1_ = 0;
+}
+inline float TransformationRow::c1() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.TransformationRow.c1)
+  return c1_;
+}
+inline void TransformationRow::set_c1(float value) {
+  
+  c1_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.TransformationRow.c1)
+}
+
+// float c2 = 3;
+inline void TransformationRow::clear_c2() {
+  c2_ = 0;
+}
+inline float TransformationRow::c2() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.TransformationRow.c2)
+  return c2_;
+}
+inline void TransformationRow::set_c2(float value) {
+  
+  c2_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.TransformationRow.c2)
+}
+
+// float c3 = 4;
+inline void TransformationRow::clear_c3() {
+  c3_ = 0;
+}
+inline float TransformationRow::c3() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.TransformationRow.c3)
+  return c3_;
+}
+inline void TransformationRow::set_c3(float value) {
+  
+  c3_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.TransformationRow.c3)
+}
+
+// -------------------------------------------------------------------
+
+// Pose
+
+// float x = 1;
+inline void Pose::clear_x() {
+  x_ = 0;
+}
+inline float Pose::x() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Pose.x)
+  return x_;
+}
+inline void Pose::set_x(float value) {
+  
+  x_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.Pose.x)
+}
+
+// float y = 2;
+inline void Pose::clear_y() {
+  y_ = 0;
+}
+inline float Pose::y() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Pose.y)
+  return y_;
+}
+inline void Pose::set_y(float value) {
+  
+  y_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.Pose.y)
+}
+
+// float z = 3;
+inline void Pose::clear_z() {
+  z_ = 0;
+}
+inline float Pose::z() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Pose.z)
+  return z_;
+}
+inline void Pose::set_z(float value) {
+  
+  z_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.Pose.z)
+}
+
+// float theta_x = 4;
+inline void Pose::clear_theta_x() {
+  theta_x_ = 0;
+}
+inline float Pose::theta_x() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Pose.theta_x)
+  return theta_x_;
+}
+inline void Pose::set_theta_x(float value) {
+  
+  theta_x_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.Pose.theta_x)
+}
+
+// float theta_y = 5;
+inline void Pose::clear_theta_y() {
+  theta_y_ = 0;
+}
+inline float Pose::theta_y() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Pose.theta_y)
+  return theta_y_;
+}
+inline void Pose::set_theta_y(float value) {
+  
+  theta_y_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.Pose.theta_y)
+}
+
+// float theta_z = 6;
+inline void Pose::clear_theta_z() {
+  theta_z_ = 0;
+}
+inline float Pose::theta_z() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Pose.theta_z)
+  return theta_z_;
+}
+inline void Pose::set_theta_z(float value) {
+  
+  theta_z_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.Pose.theta_z)
+}
+
+// -------------------------------------------------------------------
+
+// Position
+
+// float x = 1;
+inline void Position::clear_x() {
+  x_ = 0;
+}
+inline float Position::x() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Position.x)
+  return x_;
+}
+inline void Position::set_x(float value) {
+  
+  x_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.Position.x)
+}
+
+// float y = 2;
+inline void Position::clear_y() {
+  y_ = 0;
+}
+inline float Position::y() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Position.y)
+  return y_;
+}
+inline void Position::set_y(float value) {
+  
+  y_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.Position.y)
+}
+
+// float z = 3;
+inline void Position::clear_z() {
+  z_ = 0;
+}
+inline float Position::z() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Position.z)
+  return z_;
+}
+inline void Position::set_z(float value) {
+  
+  z_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.Position.z)
+}
+
+// -------------------------------------------------------------------
+
+// Orientation
+
+// float theta_x = 1;
+inline void Orientation::clear_theta_x() {
+  theta_x_ = 0;
+}
+inline float Orientation::theta_x() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Orientation.theta_x)
+  return theta_x_;
+}
+inline void Orientation::set_theta_x(float value) {
+  
+  theta_x_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.Orientation.theta_x)
+}
+
+// float theta_y = 2;
+inline void Orientation::clear_theta_y() {
+  theta_y_ = 0;
+}
+inline float Orientation::theta_y() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Orientation.theta_y)
+  return theta_y_;
+}
+inline void Orientation::set_theta_y(float value) {
+  
+  theta_y_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.Orientation.theta_y)
+}
+
+// float theta_z = 3;
+inline void Orientation::clear_theta_z() {
+  theta_z_ = 0;
+}
+inline float Orientation::theta_z() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Orientation.theta_z)
+  return theta_z_;
+}
+inline void Orientation::set_theta_z(float value) {
+  
+  theta_z_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.Orientation.theta_z)
+}
+
+// -------------------------------------------------------------------
+
+// CartesianSpeed
+
+// float translation = 1;
+inline void CartesianSpeed::clear_translation() {
+  translation_ = 0;
+}
+inline float CartesianSpeed::translation() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.CartesianSpeed.translation)
+  return translation_;
+}
+inline void CartesianSpeed::set_translation(float value) {
+  
+  translation_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.CartesianSpeed.translation)
+}
+
+// float orientation = 2;
+inline void CartesianSpeed::clear_orientation() {
+  orientation_ = 0;
+}
+inline float CartesianSpeed::orientation() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.CartesianSpeed.orientation)
+  return orientation_;
+}
+inline void CartesianSpeed::set_orientation(float value) {
+  
+  orientation_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.CartesianSpeed.orientation)
+}
+
+// -------------------------------------------------------------------
+
+// CartesianTrajectoryConstraint
+
+// .Kinova.Api.Base.CartesianSpeed speed = 1;
+inline bool CartesianTrajectoryConstraint::has_speed() const {
+  return type_case() == kSpeed;
+}
+inline void CartesianTrajectoryConstraint::set_has_speed() {
+  _oneof_case_[0] = kSpeed;
+}
+inline void CartesianTrajectoryConstraint::clear_speed() {
+  if (has_speed()) {
+    delete type_.speed_;
+    clear_has_type();
+  }
+}
+inline ::Kinova::Api::Base::CartesianSpeed* CartesianTrajectoryConstraint::release_speed() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.CartesianTrajectoryConstraint.speed)
+  if (has_speed()) {
+    clear_has_type();
+      ::Kinova::Api::Base::CartesianSpeed* temp = type_.speed_;
+    type_.speed_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline const ::Kinova::Api::Base::CartesianSpeed& CartesianTrajectoryConstraint::speed() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.CartesianTrajectoryConstraint.speed)
+  return has_speed()
+      ? *type_.speed_
+      : *reinterpret_cast< ::Kinova::Api::Base::CartesianSpeed*>(&::Kinova::Api::Base::_CartesianSpeed_default_instance_);
+}
+inline ::Kinova::Api::Base::CartesianSpeed* CartesianTrajectoryConstraint::mutable_speed() {
+  if (!has_speed()) {
+    clear_type();
+    set_has_speed();
+    type_.speed_ = new ::Kinova::Api::Base::CartesianSpeed;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.CartesianTrajectoryConstraint.speed)
+  return type_.speed_;
+}
+
+// float duration = 2;
+inline bool CartesianTrajectoryConstraint::has_duration() const {
+  return type_case() == kDuration;
+}
+inline void CartesianTrajectoryConstraint::set_has_duration() {
+  _oneof_case_[0] = kDuration;
+}
+inline void CartesianTrajectoryConstraint::clear_duration() {
+  if (has_duration()) {
+    type_.duration_ = 0;
+    clear_has_type();
+  }
+}
+inline float CartesianTrajectoryConstraint::duration() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.CartesianTrajectoryConstraint.duration)
+  if (has_duration()) {
+    return type_.duration_;
+  }
+  return 0;
+}
+inline void CartesianTrajectoryConstraint::set_duration(float value) {
+  if (!has_duration()) {
+    clear_type();
+    set_has_duration();
+  }
+  type_.duration_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.CartesianTrajectoryConstraint.duration)
+}
+
+inline bool CartesianTrajectoryConstraint::has_type() const {
+  return type_case() != TYPE_NOT_SET;
+}
+inline void CartesianTrajectoryConstraint::clear_has_type() {
+  _oneof_case_[0] = TYPE_NOT_SET;
+}
+inline CartesianTrajectoryConstraint::TypeCase CartesianTrajectoryConstraint::type_case() const {
+  return CartesianTrajectoryConstraint::TypeCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// JointTrajectoryConstraint
+
+// .Kinova.Api.Base.JointTrajectoryConstraintType type = 1;
+inline void JointTrajectoryConstraint::clear_type() {
+  type_ = 0;
+}
+inline ::Kinova::Api::Base::JointTrajectoryConstraintType JointTrajectoryConstraint::type() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.JointTrajectoryConstraint.type)
+  return static_cast< ::Kinova::Api::Base::JointTrajectoryConstraintType >(type_);
+}
+inline void JointTrajectoryConstraint::set_type(::Kinova::Api::Base::JointTrajectoryConstraintType value) {
+  
+  type_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.JointTrajectoryConstraint.type)
+}
+
+// float value = 2;
+inline void JointTrajectoryConstraint::clear_value() {
+  value_ = 0;
+}
+inline float JointTrajectoryConstraint::value() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.JointTrajectoryConstraint.value)
+  return value_;
+}
+inline void JointTrajectoryConstraint::set_value(float value) {
+  
+  value_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.JointTrajectoryConstraint.value)
+}
+
+// -------------------------------------------------------------------
+
+// Wrench
+
+// float force_x = 1;
+inline void Wrench::clear_force_x() {
+  force_x_ = 0;
+}
+inline float Wrench::force_x() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Wrench.force_x)
+  return force_x_;
+}
+inline void Wrench::set_force_x(float value) {
+  
+  force_x_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.Wrench.force_x)
+}
+
+// float force_y = 2;
+inline void Wrench::clear_force_y() {
+  force_y_ = 0;
+}
+inline float Wrench::force_y() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Wrench.force_y)
+  return force_y_;
+}
+inline void Wrench::set_force_y(float value) {
+  
+  force_y_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.Wrench.force_y)
+}
+
+// float force_z = 3;
+inline void Wrench::clear_force_z() {
+  force_z_ = 0;
+}
+inline float Wrench::force_z() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Wrench.force_z)
+  return force_z_;
+}
+inline void Wrench::set_force_z(float value) {
+  
+  force_z_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.Wrench.force_z)
+}
+
+// float torque_x = 4;
+inline void Wrench::clear_torque_x() {
+  torque_x_ = 0;
+}
+inline float Wrench::torque_x() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Wrench.torque_x)
+  return torque_x_;
+}
+inline void Wrench::set_torque_x(float value) {
+  
+  torque_x_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.Wrench.torque_x)
+}
+
+// float torque_y = 5;
+inline void Wrench::clear_torque_y() {
+  torque_y_ = 0;
+}
+inline float Wrench::torque_y() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Wrench.torque_y)
+  return torque_y_;
+}
+inline void Wrench::set_torque_y(float value) {
+  
+  torque_y_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.Wrench.torque_y)
+}
+
+// float torque_z = 6;
+inline void Wrench::clear_torque_z() {
+  torque_z_ = 0;
+}
+inline float Wrench::torque_z() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Wrench.torque_z)
+  return torque_z_;
+}
+inline void Wrench::set_torque_z(float value) {
+  
+  torque_z_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.Wrench.torque_z)
+}
+
+// -------------------------------------------------------------------
+
+// Twist
+
+// float linear_x = 1;
+inline void Twist::clear_linear_x() {
+  linear_x_ = 0;
+}
+inline float Twist::linear_x() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Twist.linear_x)
+  return linear_x_;
+}
+inline void Twist::set_linear_x(float value) {
+  
+  linear_x_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.Twist.linear_x)
+}
+
+// float linear_y = 2;
+inline void Twist::clear_linear_y() {
+  linear_y_ = 0;
+}
+inline float Twist::linear_y() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Twist.linear_y)
+  return linear_y_;
+}
+inline void Twist::set_linear_y(float value) {
+  
+  linear_y_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.Twist.linear_y)
+}
+
+// float linear_z = 3;
+inline void Twist::clear_linear_z() {
+  linear_z_ = 0;
+}
+inline float Twist::linear_z() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Twist.linear_z)
+  return linear_z_;
+}
+inline void Twist::set_linear_z(float value) {
+  
+  linear_z_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.Twist.linear_z)
+}
+
+// float angular_x = 4;
+inline void Twist::clear_angular_x() {
+  angular_x_ = 0;
+}
+inline float Twist::angular_x() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Twist.angular_x)
+  return angular_x_;
+}
+inline void Twist::set_angular_x(float value) {
+  
+  angular_x_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.Twist.angular_x)
+}
+
+// float angular_y = 5;
+inline void Twist::clear_angular_y() {
+  angular_y_ = 0;
+}
+inline float Twist::angular_y() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Twist.angular_y)
+  return angular_y_;
+}
+inline void Twist::set_angular_y(float value) {
+  
+  angular_y_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.Twist.angular_y)
+}
+
+// float angular_z = 6;
+inline void Twist::clear_angular_z() {
+  angular_z_ = 0;
+}
+inline float Twist::angular_z() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Twist.angular_z)
+  return angular_z_;
+}
+inline void Twist::set_angular_z(float value) {
+  
+  angular_z_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.Twist.angular_z)
+}
+
+// -------------------------------------------------------------------
+
+// Admittance
+
+// .Kinova.Api.Base.AdmittanceMode admittance_mode = 1;
+inline void Admittance::clear_admittance_mode() {
+  admittance_mode_ = 0;
+}
+inline ::Kinova::Api::Base::AdmittanceMode Admittance::admittance_mode() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Admittance.admittance_mode)
+  return static_cast< ::Kinova::Api::Base::AdmittanceMode >(admittance_mode_);
+}
+inline void Admittance::set_admittance_mode(::Kinova::Api::Base::AdmittanceMode value) {
+  
+  admittance_mode_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.Admittance.admittance_mode)
+}
+
+// -------------------------------------------------------------------
+
+// ConstrainedPose
+
+// .Kinova.Api.Base.Pose target_pose = 1;
+inline bool ConstrainedPose::has_target_pose() const {
+  return this != internal_default_instance() && target_pose_ != NULL;
+}
+inline void ConstrainedPose::clear_target_pose() {
+  if (GetArenaNoVirtual() == NULL && target_pose_ != NULL) {
+    delete target_pose_;
+  }
+  target_pose_ = NULL;
+}
+inline const ::Kinova::Api::Base::Pose& ConstrainedPose::target_pose() const {
+  const ::Kinova::Api::Base::Pose* p = target_pose_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ConstrainedPose.target_pose)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::Pose*>(
+      &::Kinova::Api::Base::_Pose_default_instance_);
+}
+inline ::Kinova::Api::Base::Pose* ConstrainedPose::release_target_pose() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ConstrainedPose.target_pose)
+  
+  ::Kinova::Api::Base::Pose* temp = target_pose_;
+  target_pose_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::Pose* ConstrainedPose::mutable_target_pose() {
+  
+  if (target_pose_ == NULL) {
+    target_pose_ = new ::Kinova::Api::Base::Pose;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ConstrainedPose.target_pose)
+  return target_pose_;
+}
+inline void ConstrainedPose::set_allocated_target_pose(::Kinova::Api::Base::Pose* target_pose) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete target_pose_;
+  }
+  if (target_pose) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      target_pose = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, target_pose, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  target_pose_ = target_pose;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.ConstrainedPose.target_pose)
+}
+
+// .Kinova.Api.Base.CartesianTrajectoryConstraint constraint = 2;
+inline bool ConstrainedPose::has_constraint() const {
+  return this != internal_default_instance() && constraint_ != NULL;
+}
+inline void ConstrainedPose::clear_constraint() {
+  if (GetArenaNoVirtual() == NULL && constraint_ != NULL) {
+    delete constraint_;
+  }
+  constraint_ = NULL;
+}
+inline const ::Kinova::Api::Base::CartesianTrajectoryConstraint& ConstrainedPose::constraint() const {
+  const ::Kinova::Api::Base::CartesianTrajectoryConstraint* p = constraint_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ConstrainedPose.constraint)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::CartesianTrajectoryConstraint*>(
+      &::Kinova::Api::Base::_CartesianTrajectoryConstraint_default_instance_);
+}
+inline ::Kinova::Api::Base::CartesianTrajectoryConstraint* ConstrainedPose::release_constraint() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ConstrainedPose.constraint)
+  
+  ::Kinova::Api::Base::CartesianTrajectoryConstraint* temp = constraint_;
+  constraint_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::CartesianTrajectoryConstraint* ConstrainedPose::mutable_constraint() {
+  
+  if (constraint_ == NULL) {
+    constraint_ = new ::Kinova::Api::Base::CartesianTrajectoryConstraint;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ConstrainedPose.constraint)
+  return constraint_;
+}
+inline void ConstrainedPose::set_allocated_constraint(::Kinova::Api::Base::CartesianTrajectoryConstraint* constraint) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete constraint_;
+  }
+  if (constraint) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      constraint = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, constraint, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  constraint_ = constraint;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.ConstrainedPose.constraint)
+}
+
+// -------------------------------------------------------------------
+
+// ConstrainedPosition
+
+// .Kinova.Api.Base.Position target_position = 1;
+inline bool ConstrainedPosition::has_target_position() const {
+  return this != internal_default_instance() && target_position_ != NULL;
+}
+inline void ConstrainedPosition::clear_target_position() {
+  if (GetArenaNoVirtual() == NULL && target_position_ != NULL) {
+    delete target_position_;
+  }
+  target_position_ = NULL;
+}
+inline const ::Kinova::Api::Base::Position& ConstrainedPosition::target_position() const {
+  const ::Kinova::Api::Base::Position* p = target_position_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ConstrainedPosition.target_position)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::Position*>(
+      &::Kinova::Api::Base::_Position_default_instance_);
+}
+inline ::Kinova::Api::Base::Position* ConstrainedPosition::release_target_position() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ConstrainedPosition.target_position)
+  
+  ::Kinova::Api::Base::Position* temp = target_position_;
+  target_position_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::Position* ConstrainedPosition::mutable_target_position() {
+  
+  if (target_position_ == NULL) {
+    target_position_ = new ::Kinova::Api::Base::Position;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ConstrainedPosition.target_position)
+  return target_position_;
+}
+inline void ConstrainedPosition::set_allocated_target_position(::Kinova::Api::Base::Position* target_position) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete target_position_;
+  }
+  if (target_position) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      target_position = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, target_position, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  target_position_ = target_position;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.ConstrainedPosition.target_position)
+}
+
+// .Kinova.Api.Base.CartesianTrajectoryConstraint constraint = 2;
+inline bool ConstrainedPosition::has_constraint() const {
+  return this != internal_default_instance() && constraint_ != NULL;
+}
+inline void ConstrainedPosition::clear_constraint() {
+  if (GetArenaNoVirtual() == NULL && constraint_ != NULL) {
+    delete constraint_;
+  }
+  constraint_ = NULL;
+}
+inline const ::Kinova::Api::Base::CartesianTrajectoryConstraint& ConstrainedPosition::constraint() const {
+  const ::Kinova::Api::Base::CartesianTrajectoryConstraint* p = constraint_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ConstrainedPosition.constraint)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::CartesianTrajectoryConstraint*>(
+      &::Kinova::Api::Base::_CartesianTrajectoryConstraint_default_instance_);
+}
+inline ::Kinova::Api::Base::CartesianTrajectoryConstraint* ConstrainedPosition::release_constraint() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ConstrainedPosition.constraint)
+  
+  ::Kinova::Api::Base::CartesianTrajectoryConstraint* temp = constraint_;
+  constraint_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::CartesianTrajectoryConstraint* ConstrainedPosition::mutable_constraint() {
+  
+  if (constraint_ == NULL) {
+    constraint_ = new ::Kinova::Api::Base::CartesianTrajectoryConstraint;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ConstrainedPosition.constraint)
+  return constraint_;
+}
+inline void ConstrainedPosition::set_allocated_constraint(::Kinova::Api::Base::CartesianTrajectoryConstraint* constraint) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete constraint_;
+  }
+  if (constraint) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      constraint = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, constraint, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  constraint_ = constraint;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.ConstrainedPosition.constraint)
+}
+
+// -------------------------------------------------------------------
+
+// ConstrainedOrientation
+
+// .Kinova.Api.Base.Orientation target_orientation = 1;
+inline bool ConstrainedOrientation::has_target_orientation() const {
+  return this != internal_default_instance() && target_orientation_ != NULL;
+}
+inline void ConstrainedOrientation::clear_target_orientation() {
+  if (GetArenaNoVirtual() == NULL && target_orientation_ != NULL) {
+    delete target_orientation_;
+  }
+  target_orientation_ = NULL;
+}
+inline const ::Kinova::Api::Base::Orientation& ConstrainedOrientation::target_orientation() const {
+  const ::Kinova::Api::Base::Orientation* p = target_orientation_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ConstrainedOrientation.target_orientation)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::Orientation*>(
+      &::Kinova::Api::Base::_Orientation_default_instance_);
+}
+inline ::Kinova::Api::Base::Orientation* ConstrainedOrientation::release_target_orientation() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ConstrainedOrientation.target_orientation)
+  
+  ::Kinova::Api::Base::Orientation* temp = target_orientation_;
+  target_orientation_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::Orientation* ConstrainedOrientation::mutable_target_orientation() {
+  
+  if (target_orientation_ == NULL) {
+    target_orientation_ = new ::Kinova::Api::Base::Orientation;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ConstrainedOrientation.target_orientation)
+  return target_orientation_;
+}
+inline void ConstrainedOrientation::set_allocated_target_orientation(::Kinova::Api::Base::Orientation* target_orientation) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete target_orientation_;
+  }
+  if (target_orientation) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      target_orientation = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, target_orientation, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  target_orientation_ = target_orientation;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.ConstrainedOrientation.target_orientation)
+}
+
+// .Kinova.Api.Base.CartesianTrajectoryConstraint constraint = 2;
+inline bool ConstrainedOrientation::has_constraint() const {
+  return this != internal_default_instance() && constraint_ != NULL;
+}
+inline void ConstrainedOrientation::clear_constraint() {
+  if (GetArenaNoVirtual() == NULL && constraint_ != NULL) {
+    delete constraint_;
+  }
+  constraint_ = NULL;
+}
+inline const ::Kinova::Api::Base::CartesianTrajectoryConstraint& ConstrainedOrientation::constraint() const {
+  const ::Kinova::Api::Base::CartesianTrajectoryConstraint* p = constraint_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ConstrainedOrientation.constraint)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::CartesianTrajectoryConstraint*>(
+      &::Kinova::Api::Base::_CartesianTrajectoryConstraint_default_instance_);
+}
+inline ::Kinova::Api::Base::CartesianTrajectoryConstraint* ConstrainedOrientation::release_constraint() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ConstrainedOrientation.constraint)
+  
+  ::Kinova::Api::Base::CartesianTrajectoryConstraint* temp = constraint_;
+  constraint_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::CartesianTrajectoryConstraint* ConstrainedOrientation::mutable_constraint() {
+  
+  if (constraint_ == NULL) {
+    constraint_ = new ::Kinova::Api::Base::CartesianTrajectoryConstraint;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ConstrainedOrientation.constraint)
+  return constraint_;
+}
+inline void ConstrainedOrientation::set_allocated_constraint(::Kinova::Api::Base::CartesianTrajectoryConstraint* constraint) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete constraint_;
+  }
+  if (constraint) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      constraint = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, constraint, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  constraint_ = constraint;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.ConstrainedOrientation.constraint)
+}
+
+// -------------------------------------------------------------------
+
+// WrenchCommand
+
+// .Kinova.Api.Common.CartesianReferenceFrame reference_frame = 1;
+inline void WrenchCommand::clear_reference_frame() {
+  reference_frame_ = 0;
+}
+inline ::Kinova::Api::Common::CartesianReferenceFrame WrenchCommand::reference_frame() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.WrenchCommand.reference_frame)
+  return static_cast< ::Kinova::Api::Common::CartesianReferenceFrame >(reference_frame_);
+}
+inline void WrenchCommand::set_reference_frame(::Kinova::Api::Common::CartesianReferenceFrame value) {
+  
+  reference_frame_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.WrenchCommand.reference_frame)
+}
+
+// .Kinova.Api.Base.WrenchMode mode = 2;
+inline void WrenchCommand::clear_mode() {
+  mode_ = 0;
+}
+inline ::Kinova::Api::Base::WrenchMode WrenchCommand::mode() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.WrenchCommand.mode)
+  return static_cast< ::Kinova::Api::Base::WrenchMode >(mode_);
+}
+inline void WrenchCommand::set_mode(::Kinova::Api::Base::WrenchMode value) {
+  
+  mode_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.WrenchCommand.mode)
+}
+
+// .Kinova.Api.Base.Wrench wrench = 3;
+inline bool WrenchCommand::has_wrench() const {
+  return this != internal_default_instance() && wrench_ != NULL;
+}
+inline void WrenchCommand::clear_wrench() {
+  if (GetArenaNoVirtual() == NULL && wrench_ != NULL) {
+    delete wrench_;
+  }
+  wrench_ = NULL;
+}
+inline const ::Kinova::Api::Base::Wrench& WrenchCommand::wrench() const {
+  const ::Kinova::Api::Base::Wrench* p = wrench_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.WrenchCommand.wrench)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::Wrench*>(
+      &::Kinova::Api::Base::_Wrench_default_instance_);
+}
+inline ::Kinova::Api::Base::Wrench* WrenchCommand::release_wrench() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.WrenchCommand.wrench)
+  
+  ::Kinova::Api::Base::Wrench* temp = wrench_;
+  wrench_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::Wrench* WrenchCommand::mutable_wrench() {
+  
+  if (wrench_ == NULL) {
+    wrench_ = new ::Kinova::Api::Base::Wrench;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.WrenchCommand.wrench)
+  return wrench_;
+}
+inline void WrenchCommand::set_allocated_wrench(::Kinova::Api::Base::Wrench* wrench) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete wrench_;
+  }
+  if (wrench) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      wrench = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, wrench, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  wrench_ = wrench;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.WrenchCommand.wrench)
+}
+
+// uint32 duration = 4;
+inline void WrenchCommand::clear_duration() {
+  duration_ = 0u;
+}
+inline ::google::protobuf::uint32 WrenchCommand::duration() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.WrenchCommand.duration)
+  return duration_;
+}
+inline void WrenchCommand::set_duration(::google::protobuf::uint32 value) {
+  
+  duration_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.WrenchCommand.duration)
+}
+
+// -------------------------------------------------------------------
+
+// TwistCommand
+
+// .Kinova.Api.Common.CartesianReferenceFrame reference_frame = 1;
+inline void TwistCommand::clear_reference_frame() {
+  reference_frame_ = 0;
+}
+inline ::Kinova::Api::Common::CartesianReferenceFrame TwistCommand::reference_frame() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.TwistCommand.reference_frame)
+  return static_cast< ::Kinova::Api::Common::CartesianReferenceFrame >(reference_frame_);
+}
+inline void TwistCommand::set_reference_frame(::Kinova::Api::Common::CartesianReferenceFrame value) {
+  
+  reference_frame_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.TwistCommand.reference_frame)
+}
+
+// .Kinova.Api.Base.Twist twist = 2;
+inline bool TwistCommand::has_twist() const {
+  return this != internal_default_instance() && twist_ != NULL;
+}
+inline void TwistCommand::clear_twist() {
+  if (GetArenaNoVirtual() == NULL && twist_ != NULL) {
+    delete twist_;
+  }
+  twist_ = NULL;
+}
+inline const ::Kinova::Api::Base::Twist& TwistCommand::twist() const {
+  const ::Kinova::Api::Base::Twist* p = twist_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.TwistCommand.twist)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::Twist*>(
+      &::Kinova::Api::Base::_Twist_default_instance_);
+}
+inline ::Kinova::Api::Base::Twist* TwistCommand::release_twist() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.TwistCommand.twist)
+  
+  ::Kinova::Api::Base::Twist* temp = twist_;
+  twist_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::Twist* TwistCommand::mutable_twist() {
+  
+  if (twist_ == NULL) {
+    twist_ = new ::Kinova::Api::Base::Twist;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.TwistCommand.twist)
+  return twist_;
+}
+inline void TwistCommand::set_allocated_twist(::Kinova::Api::Base::Twist* twist) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete twist_;
+  }
+  if (twist) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      twist = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, twist, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  twist_ = twist;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.TwistCommand.twist)
+}
+
+// -------------------------------------------------------------------
+
+// ConstrainedJointAngles
+
+// .Kinova.Api.Base.JointAngles joint_angles = 1;
+inline bool ConstrainedJointAngles::has_joint_angles() const {
+  return this != internal_default_instance() && joint_angles_ != NULL;
+}
+inline void ConstrainedJointAngles::clear_joint_angles() {
+  if (GetArenaNoVirtual() == NULL && joint_angles_ != NULL) {
+    delete joint_angles_;
+  }
+  joint_angles_ = NULL;
+}
+inline const ::Kinova::Api::Base::JointAngles& ConstrainedJointAngles::joint_angles() const {
+  const ::Kinova::Api::Base::JointAngles* p = joint_angles_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ConstrainedJointAngles.joint_angles)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::JointAngles*>(
+      &::Kinova::Api::Base::_JointAngles_default_instance_);
+}
+inline ::Kinova::Api::Base::JointAngles* ConstrainedJointAngles::release_joint_angles() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ConstrainedJointAngles.joint_angles)
+  
+  ::Kinova::Api::Base::JointAngles* temp = joint_angles_;
+  joint_angles_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::JointAngles* ConstrainedJointAngles::mutable_joint_angles() {
+  
+  if (joint_angles_ == NULL) {
+    joint_angles_ = new ::Kinova::Api::Base::JointAngles;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ConstrainedJointAngles.joint_angles)
+  return joint_angles_;
+}
+inline void ConstrainedJointAngles::set_allocated_joint_angles(::Kinova::Api::Base::JointAngles* joint_angles) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete joint_angles_;
+  }
+  if (joint_angles) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      joint_angles = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, joint_angles, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  joint_angles_ = joint_angles;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.ConstrainedJointAngles.joint_angles)
+}
+
+// .Kinova.Api.Base.JointTrajectoryConstraint constraint = 2;
+inline bool ConstrainedJointAngles::has_constraint() const {
+  return this != internal_default_instance() && constraint_ != NULL;
+}
+inline void ConstrainedJointAngles::clear_constraint() {
+  if (GetArenaNoVirtual() == NULL && constraint_ != NULL) {
+    delete constraint_;
+  }
+  constraint_ = NULL;
+}
+inline const ::Kinova::Api::Base::JointTrajectoryConstraint& ConstrainedJointAngles::constraint() const {
+  const ::Kinova::Api::Base::JointTrajectoryConstraint* p = constraint_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ConstrainedJointAngles.constraint)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::JointTrajectoryConstraint*>(
+      &::Kinova::Api::Base::_JointTrajectoryConstraint_default_instance_);
+}
+inline ::Kinova::Api::Base::JointTrajectoryConstraint* ConstrainedJointAngles::release_constraint() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ConstrainedJointAngles.constraint)
+  
+  ::Kinova::Api::Base::JointTrajectoryConstraint* temp = constraint_;
+  constraint_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::JointTrajectoryConstraint* ConstrainedJointAngles::mutable_constraint() {
+  
+  if (constraint_ == NULL) {
+    constraint_ = new ::Kinova::Api::Base::JointTrajectoryConstraint;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ConstrainedJointAngles.constraint)
+  return constraint_;
+}
+inline void ConstrainedJointAngles::set_allocated_constraint(::Kinova::Api::Base::JointTrajectoryConstraint* constraint) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete constraint_;
+  }
+  if (constraint) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      constraint = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, constraint, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  constraint_ = constraint;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.ConstrainedJointAngles.constraint)
+}
+
+// -------------------------------------------------------------------
+
+// ConstrainedJointAngle
+
+// uint32 joint_identifier = 1;
+inline void ConstrainedJointAngle::clear_joint_identifier() {
+  joint_identifier_ = 0u;
+}
+inline ::google::protobuf::uint32 ConstrainedJointAngle::joint_identifier() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ConstrainedJointAngle.joint_identifier)
+  return joint_identifier_;
+}
+inline void ConstrainedJointAngle::set_joint_identifier(::google::protobuf::uint32 value) {
+  
+  joint_identifier_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.ConstrainedJointAngle.joint_identifier)
+}
+
+// float value = 2;
+inline void ConstrainedJointAngle::clear_value() {
+  value_ = 0;
+}
+inline float ConstrainedJointAngle::value() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ConstrainedJointAngle.value)
+  return value_;
+}
+inline void ConstrainedJointAngle::set_value(float value) {
+  
+  value_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.ConstrainedJointAngle.value)
+}
+
+// .Kinova.Api.Base.JointTrajectoryConstraint constraint = 3;
+inline bool ConstrainedJointAngle::has_constraint() const {
+  return this != internal_default_instance() && constraint_ != NULL;
+}
+inline void ConstrainedJointAngle::clear_constraint() {
+  if (GetArenaNoVirtual() == NULL && constraint_ != NULL) {
+    delete constraint_;
+  }
+  constraint_ = NULL;
+}
+inline const ::Kinova::Api::Base::JointTrajectoryConstraint& ConstrainedJointAngle::constraint() const {
+  const ::Kinova::Api::Base::JointTrajectoryConstraint* p = constraint_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ConstrainedJointAngle.constraint)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::JointTrajectoryConstraint*>(
+      &::Kinova::Api::Base::_JointTrajectoryConstraint_default_instance_);
+}
+inline ::Kinova::Api::Base::JointTrajectoryConstraint* ConstrainedJointAngle::release_constraint() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ConstrainedJointAngle.constraint)
+  
+  ::Kinova::Api::Base::JointTrajectoryConstraint* temp = constraint_;
+  constraint_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::JointTrajectoryConstraint* ConstrainedJointAngle::mutable_constraint() {
+  
+  if (constraint_ == NULL) {
+    constraint_ = new ::Kinova::Api::Base::JointTrajectoryConstraint;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ConstrainedJointAngle.constraint)
+  return constraint_;
+}
+inline void ConstrainedJointAngle::set_allocated_constraint(::Kinova::Api::Base::JointTrajectoryConstraint* constraint) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete constraint_;
+  }
+  if (constraint) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      constraint = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, constraint, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  constraint_ = constraint;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.ConstrainedJointAngle.constraint)
+}
+
+// -------------------------------------------------------------------
+
+// JointAngles
+
+// repeated .Kinova.Api.Base.JointAngle joint_angles = 1;
+inline int JointAngles::joint_angles_size() const {
+  return joint_angles_.size();
+}
+inline void JointAngles::clear_joint_angles() {
+  joint_angles_.Clear();
+}
+inline const ::Kinova::Api::Base::JointAngle& JointAngles::joint_angles(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.JointAngles.joint_angles)
+  return joint_angles_.Get(index);
+}
+inline ::Kinova::Api::Base::JointAngle* JointAngles::mutable_joint_angles(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.JointAngles.joint_angles)
+  return joint_angles_.Mutable(index);
+}
+inline ::Kinova::Api::Base::JointAngle* JointAngles::add_joint_angles() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.Base.JointAngles.joint_angles)
+  return joint_angles_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::JointAngle >*
+JointAngles::mutable_joint_angles() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.Base.JointAngles.joint_angles)
+  return &joint_angles_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::JointAngle >&
+JointAngles::joint_angles() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.Base.JointAngles.joint_angles)
+  return joint_angles_;
+}
+
+// -------------------------------------------------------------------
+
+// JointAngle
+
+// uint32 joint_identifier = 1;
+inline void JointAngle::clear_joint_identifier() {
+  joint_identifier_ = 0u;
+}
+inline ::google::protobuf::uint32 JointAngle::joint_identifier() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.JointAngle.joint_identifier)
+  return joint_identifier_;
+}
+inline void JointAngle::set_joint_identifier(::google::protobuf::uint32 value) {
+  
+  joint_identifier_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.JointAngle.joint_identifier)
+}
+
+// float value = 2;
+inline void JointAngle::clear_value() {
+  value_ = 0;
+}
+inline float JointAngle::value() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.JointAngle.value)
+  return value_;
+}
+inline void JointAngle::set_value(float value) {
+  
+  value_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.JointAngle.value)
+}
+
+// -------------------------------------------------------------------
+
+// JointSpeeds
+
+// repeated .Kinova.Api.Base.JointSpeed joint_speeds = 1;
+inline int JointSpeeds::joint_speeds_size() const {
+  return joint_speeds_.size();
+}
+inline void JointSpeeds::clear_joint_speeds() {
+  joint_speeds_.Clear();
+}
+inline const ::Kinova::Api::Base::JointSpeed& JointSpeeds::joint_speeds(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.JointSpeeds.joint_speeds)
+  return joint_speeds_.Get(index);
+}
+inline ::Kinova::Api::Base::JointSpeed* JointSpeeds::mutable_joint_speeds(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.JointSpeeds.joint_speeds)
+  return joint_speeds_.Mutable(index);
+}
+inline ::Kinova::Api::Base::JointSpeed* JointSpeeds::add_joint_speeds() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.Base.JointSpeeds.joint_speeds)
+  return joint_speeds_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::JointSpeed >*
+JointSpeeds::mutable_joint_speeds() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.Base.JointSpeeds.joint_speeds)
+  return &joint_speeds_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::JointSpeed >&
+JointSpeeds::joint_speeds() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.Base.JointSpeeds.joint_speeds)
+  return joint_speeds_;
+}
+
+// -------------------------------------------------------------------
+
+// JointSpeed
+
+// uint32 joint_identifier = 1;
+inline void JointSpeed::clear_joint_identifier() {
+  joint_identifier_ = 0u;
+}
+inline ::google::protobuf::uint32 JointSpeed::joint_identifier() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.JointSpeed.joint_identifier)
+  return joint_identifier_;
+}
+inline void JointSpeed::set_joint_identifier(::google::protobuf::uint32 value) {
+  
+  joint_identifier_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.JointSpeed.joint_identifier)
+}
+
+// float value = 2;
+inline void JointSpeed::clear_value() {
+  value_ = 0;
+}
+inline float JointSpeed::value() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.JointSpeed.value)
+  return value_;
+}
+inline void JointSpeed::set_value(float value) {
+  
+  value_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.JointSpeed.value)
+}
+
+// -------------------------------------------------------------------
+
+// GripperCommand
+
+// .Kinova.Api.Base.GripperMode mode = 1;
+inline void GripperCommand::clear_mode() {
+  mode_ = 0;
+}
+inline ::Kinova::Api::Base::GripperMode GripperCommand::mode() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.GripperCommand.mode)
+  return static_cast< ::Kinova::Api::Base::GripperMode >(mode_);
+}
+inline void GripperCommand::set_mode(::Kinova::Api::Base::GripperMode value) {
+  
+  mode_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.GripperCommand.mode)
+}
+
+// .Kinova.Api.Base.Gripper gripper = 2;
+inline bool GripperCommand::has_gripper() const {
+  return this != internal_default_instance() && gripper_ != NULL;
+}
+inline void GripperCommand::clear_gripper() {
+  if (GetArenaNoVirtual() == NULL && gripper_ != NULL) {
+    delete gripper_;
+  }
+  gripper_ = NULL;
+}
+inline const ::Kinova::Api::Base::Gripper& GripperCommand::gripper() const {
+  const ::Kinova::Api::Base::Gripper* p = gripper_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.GripperCommand.gripper)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::Gripper*>(
+      &::Kinova::Api::Base::_Gripper_default_instance_);
+}
+inline ::Kinova::Api::Base::Gripper* GripperCommand::release_gripper() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.GripperCommand.gripper)
+  
+  ::Kinova::Api::Base::Gripper* temp = gripper_;
+  gripper_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::Gripper* GripperCommand::mutable_gripper() {
+  
+  if (gripper_ == NULL) {
+    gripper_ = new ::Kinova::Api::Base::Gripper;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.GripperCommand.gripper)
+  return gripper_;
+}
+inline void GripperCommand::set_allocated_gripper(::Kinova::Api::Base::Gripper* gripper) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete gripper_;
+  }
+  if (gripper) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      gripper = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, gripper, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  gripper_ = gripper;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.GripperCommand.gripper)
+}
+
+// uint32 duration = 3;
+inline void GripperCommand::clear_duration() {
+  duration_ = 0u;
+}
+inline ::google::protobuf::uint32 GripperCommand::duration() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.GripperCommand.duration)
+  return duration_;
+}
+inline void GripperCommand::set_duration(::google::protobuf::uint32 value) {
+  
+  duration_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.GripperCommand.duration)
+}
+
+// -------------------------------------------------------------------
+
+// GripperRequest
+
+// .Kinova.Api.Base.GripperMode mode = 1;
+inline void GripperRequest::clear_mode() {
+  mode_ = 0;
+}
+inline ::Kinova::Api::Base::GripperMode GripperRequest::mode() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.GripperRequest.mode)
+  return static_cast< ::Kinova::Api::Base::GripperMode >(mode_);
+}
+inline void GripperRequest::set_mode(::Kinova::Api::Base::GripperMode value) {
+  
+  mode_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.GripperRequest.mode)
+}
+
+// -------------------------------------------------------------------
+
+// Gripper
+
+// repeated .Kinova.Api.Base.Finger finger = 1;
+inline int Gripper::finger_size() const {
+  return finger_.size();
+}
+inline void Gripper::clear_finger() {
+  finger_.Clear();
+}
+inline const ::Kinova::Api::Base::Finger& Gripper::finger(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Gripper.finger)
+  return finger_.Get(index);
+}
+inline ::Kinova::Api::Base::Finger* Gripper::mutable_finger(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.Gripper.finger)
+  return finger_.Mutable(index);
+}
+inline ::Kinova::Api::Base::Finger* Gripper::add_finger() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.Base.Gripper.finger)
+  return finger_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::Finger >*
+Gripper::mutable_finger() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.Base.Gripper.finger)
+  return &finger_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::Finger >&
+Gripper::finger() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.Base.Gripper.finger)
+  return finger_;
+}
+
+// -------------------------------------------------------------------
+
+// Finger
+
+// uint32 finger_identifier = 1;
+inline void Finger::clear_finger_identifier() {
+  finger_identifier_ = 0u;
+}
+inline ::google::protobuf::uint32 Finger::finger_identifier() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Finger.finger_identifier)
+  return finger_identifier_;
+}
+inline void Finger::set_finger_identifier(::google::protobuf::uint32 value) {
+  
+  finger_identifier_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.Finger.finger_identifier)
+}
+
+// float value = 2;
+inline void Finger::clear_value() {
+  value_ = 0;
+}
+inline float Finger::value() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Finger.value)
+  return value_;
+}
+inline void Finger::set_value(float value) {
+  
+  value_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.Finger.value)
+}
+
+// -------------------------------------------------------------------
+
+// GpioCommand
+
+// uint32 port_identifier = 1;
+inline void GpioCommand::clear_port_identifier() {
+  port_identifier_ = 0u;
+}
+inline ::google::protobuf::uint32 GpioCommand::port_identifier() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.GpioCommand.port_identifier)
+  return port_identifier_;
+}
+inline void GpioCommand::set_port_identifier(::google::protobuf::uint32 value) {
+  
+  port_identifier_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.GpioCommand.port_identifier)
+}
+
+// uint32 pin_identifier = 2;
+inline void GpioCommand::clear_pin_identifier() {
+  pin_identifier_ = 0u;
+}
+inline ::google::protobuf::uint32 GpioCommand::pin_identifier() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.GpioCommand.pin_identifier)
+  return pin_identifier_;
+}
+inline void GpioCommand::set_pin_identifier(::google::protobuf::uint32 value) {
+  
+  pin_identifier_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.GpioCommand.pin_identifier)
+}
+
+// .Kinova.Api.Base.GpioAction action = 3;
+inline void GpioCommand::clear_action() {
+  action_ = 0;
+}
+inline ::Kinova::Api::Base::GpioAction GpioCommand::action() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.GpioCommand.action)
+  return static_cast< ::Kinova::Api::Base::GpioAction >(action_);
+}
+inline void GpioCommand::set_action(::Kinova::Api::Base::GpioAction value) {
+  
+  action_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.GpioCommand.action)
+}
+
+// uint32 period = 4;
+inline void GpioCommand::clear_period() {
+  period_ = 0u;
+}
+inline ::google::protobuf::uint32 GpioCommand::period() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.GpioCommand.period)
+  return period_;
+}
+inline void GpioCommand::set_period(::google::protobuf::uint32 value) {
+  
+  period_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.GpioCommand.period)
+}
+
+// -------------------------------------------------------------------
+
+// ControllerConfigurationMode
+
+// bool enable = 1;
+inline void ControllerConfigurationMode::clear_enable() {
+  enable_ = false;
+}
+inline bool ControllerConfigurationMode::enable() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ControllerConfigurationMode.enable)
+  return enable_;
+}
+inline void ControllerConfigurationMode::set_enable(bool value) {
+  
+  enable_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.ControllerConfigurationMode.enable)
+}
+
+// -------------------------------------------------------------------
+
+// ControllerConfiguration
+
+// .Kinova.Api.Base.ControllerHandle handle = 1;
+inline bool ControllerConfiguration::has_handle() const {
+  return this != internal_default_instance() && handle_ != NULL;
+}
+inline void ControllerConfiguration::clear_handle() {
+  if (GetArenaNoVirtual() == NULL && handle_ != NULL) {
+    delete handle_;
+  }
+  handle_ = NULL;
+}
+inline const ::Kinova::Api::Base::ControllerHandle& ControllerConfiguration::handle() const {
+  const ::Kinova::Api::Base::ControllerHandle* p = handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ControllerConfiguration.handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::ControllerHandle*>(
+      &::Kinova::Api::Base::_ControllerHandle_default_instance_);
+}
+inline ::Kinova::Api::Base::ControllerHandle* ControllerConfiguration::release_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ControllerConfiguration.handle)
+  
+  ::Kinova::Api::Base::ControllerHandle* temp = handle_;
+  handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::ControllerHandle* ControllerConfiguration::mutable_handle() {
+  
+  if (handle_ == NULL) {
+    handle_ = new ::Kinova::Api::Base::ControllerHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ControllerConfiguration.handle)
+  return handle_;
+}
+inline void ControllerConfiguration::set_allocated_handle(::Kinova::Api::Base::ControllerHandle* handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete handle_;
+  }
+  if (handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  handle_ = handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.ControllerConfiguration.handle)
+}
+
+// string name = 2;
+inline void ControllerConfiguration::clear_name() {
+  name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& ControllerConfiguration::name() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ControllerConfiguration.name)
+  return name_.GetNoArena();
+}
+inline void ControllerConfiguration::set_name(const ::std::string& value) {
+  
+  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.ControllerConfiguration.name)
+}
+#if LANG_CXX11
+inline void ControllerConfiguration::set_name(::std::string&& value) {
+  
+  name_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:Kinova.Api.Base.ControllerConfiguration.name)
+}
+#endif
+inline void ControllerConfiguration::set_name(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:Kinova.Api.Base.ControllerConfiguration.name)
+}
+inline void ControllerConfiguration::set_name(const char* value, size_t size) {
+  
+  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:Kinova.Api.Base.ControllerConfiguration.name)
+}
+inline ::std::string* ControllerConfiguration::mutable_name() {
+  
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ControllerConfiguration.name)
+  return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* ControllerConfiguration::release_name() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ControllerConfiguration.name)
+  
+  return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void ControllerConfiguration::set_allocated_name(::std::string* name) {
+  if (name != NULL) {
+    
+  } else {
+    
+  }
+  name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.ControllerConfiguration.name)
+}
+
+// .Kinova.Api.Base.MappingHandle active_mapping_handle = 3;
+inline bool ControllerConfiguration::has_active_mapping_handle() const {
+  return this != internal_default_instance() && active_mapping_handle_ != NULL;
+}
+inline void ControllerConfiguration::clear_active_mapping_handle() {
+  if (GetArenaNoVirtual() == NULL && active_mapping_handle_ != NULL) {
+    delete active_mapping_handle_;
+  }
+  active_mapping_handle_ = NULL;
+}
+inline const ::Kinova::Api::Base::MappingHandle& ControllerConfiguration::active_mapping_handle() const {
+  const ::Kinova::Api::Base::MappingHandle* p = active_mapping_handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ControllerConfiguration.active_mapping_handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::MappingHandle*>(
+      &::Kinova::Api::Base::_MappingHandle_default_instance_);
+}
+inline ::Kinova::Api::Base::MappingHandle* ControllerConfiguration::release_active_mapping_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ControllerConfiguration.active_mapping_handle)
+  
+  ::Kinova::Api::Base::MappingHandle* temp = active_mapping_handle_;
+  active_mapping_handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::MappingHandle* ControllerConfiguration::mutable_active_mapping_handle() {
+  
+  if (active_mapping_handle_ == NULL) {
+    active_mapping_handle_ = new ::Kinova::Api::Base::MappingHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ControllerConfiguration.active_mapping_handle)
+  return active_mapping_handle_;
+}
+inline void ControllerConfiguration::set_allocated_active_mapping_handle(::Kinova::Api::Base::MappingHandle* active_mapping_handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete active_mapping_handle_;
+  }
+  if (active_mapping_handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      active_mapping_handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, active_mapping_handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  active_mapping_handle_ = active_mapping_handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.ControllerConfiguration.active_mapping_handle)
+}
+
+// string analog_input_identifier_enum = 4;
+inline void ControllerConfiguration::clear_analog_input_identifier_enum() {
+  analog_input_identifier_enum_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& ControllerConfiguration::analog_input_identifier_enum() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ControllerConfiguration.analog_input_identifier_enum)
+  return analog_input_identifier_enum_.GetNoArena();
+}
+inline void ControllerConfiguration::set_analog_input_identifier_enum(const ::std::string& value) {
+  
+  analog_input_identifier_enum_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.ControllerConfiguration.analog_input_identifier_enum)
+}
+#if LANG_CXX11
+inline void ControllerConfiguration::set_analog_input_identifier_enum(::std::string&& value) {
+  
+  analog_input_identifier_enum_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:Kinova.Api.Base.ControllerConfiguration.analog_input_identifier_enum)
+}
+#endif
+inline void ControllerConfiguration::set_analog_input_identifier_enum(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  analog_input_identifier_enum_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:Kinova.Api.Base.ControllerConfiguration.analog_input_identifier_enum)
+}
+inline void ControllerConfiguration::set_analog_input_identifier_enum(const char* value, size_t size) {
+  
+  analog_input_identifier_enum_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:Kinova.Api.Base.ControllerConfiguration.analog_input_identifier_enum)
+}
+inline ::std::string* ControllerConfiguration::mutable_analog_input_identifier_enum() {
+  
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ControllerConfiguration.analog_input_identifier_enum)
+  return analog_input_identifier_enum_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* ControllerConfiguration::release_analog_input_identifier_enum() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ControllerConfiguration.analog_input_identifier_enum)
+  
+  return analog_input_identifier_enum_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void ControllerConfiguration::set_allocated_analog_input_identifier_enum(::std::string* analog_input_identifier_enum) {
+  if (analog_input_identifier_enum != NULL) {
+    
+  } else {
+    
+  }
+  analog_input_identifier_enum_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), analog_input_identifier_enum);
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.ControllerConfiguration.analog_input_identifier_enum)
+}
+
+// string digital_input_identifier_enum = 5;
+inline void ControllerConfiguration::clear_digital_input_identifier_enum() {
+  digital_input_identifier_enum_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& ControllerConfiguration::digital_input_identifier_enum() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ControllerConfiguration.digital_input_identifier_enum)
+  return digital_input_identifier_enum_.GetNoArena();
+}
+inline void ControllerConfiguration::set_digital_input_identifier_enum(const ::std::string& value) {
+  
+  digital_input_identifier_enum_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.ControllerConfiguration.digital_input_identifier_enum)
+}
+#if LANG_CXX11
+inline void ControllerConfiguration::set_digital_input_identifier_enum(::std::string&& value) {
+  
+  digital_input_identifier_enum_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:Kinova.Api.Base.ControllerConfiguration.digital_input_identifier_enum)
+}
+#endif
+inline void ControllerConfiguration::set_digital_input_identifier_enum(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  digital_input_identifier_enum_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:Kinova.Api.Base.ControllerConfiguration.digital_input_identifier_enum)
+}
+inline void ControllerConfiguration::set_digital_input_identifier_enum(const char* value, size_t size) {
+  
+  digital_input_identifier_enum_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:Kinova.Api.Base.ControllerConfiguration.digital_input_identifier_enum)
+}
+inline ::std::string* ControllerConfiguration::mutable_digital_input_identifier_enum() {
+  
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ControllerConfiguration.digital_input_identifier_enum)
+  return digital_input_identifier_enum_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* ControllerConfiguration::release_digital_input_identifier_enum() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ControllerConfiguration.digital_input_identifier_enum)
+  
+  return digital_input_identifier_enum_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void ControllerConfiguration::set_allocated_digital_input_identifier_enum(::std::string* digital_input_identifier_enum) {
+  if (digital_input_identifier_enum != NULL) {
+    
+  } else {
+    
+  }
+  digital_input_identifier_enum_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), digital_input_identifier_enum);
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.ControllerConfiguration.digital_input_identifier_enum)
+}
+
+// -------------------------------------------------------------------
+
+// ControllerConfigurationList
+
+// repeated .Kinova.Api.Base.ControllerConfiguration controller_configurations = 1;
+inline int ControllerConfigurationList::controller_configurations_size() const {
+  return controller_configurations_.size();
+}
+inline void ControllerConfigurationList::clear_controller_configurations() {
+  controller_configurations_.Clear();
+}
+inline const ::Kinova::Api::Base::ControllerConfiguration& ControllerConfigurationList::controller_configurations(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ControllerConfigurationList.controller_configurations)
+  return controller_configurations_.Get(index);
+}
+inline ::Kinova::Api::Base::ControllerConfiguration* ControllerConfigurationList::mutable_controller_configurations(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ControllerConfigurationList.controller_configurations)
+  return controller_configurations_.Mutable(index);
+}
+inline ::Kinova::Api::Base::ControllerConfiguration* ControllerConfigurationList::add_controller_configurations() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.Base.ControllerConfigurationList.controller_configurations)
+  return controller_configurations_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::ControllerConfiguration >*
+ControllerConfigurationList::mutable_controller_configurations() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.Base.ControllerConfigurationList.controller_configurations)
+  return &controller_configurations_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::ControllerConfiguration >&
+ControllerConfigurationList::controller_configurations() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.Base.ControllerConfigurationList.controller_configurations)
+  return controller_configurations_;
+}
+
+// -------------------------------------------------------------------
+
+// ActuatorInformation
+
+// uint32 count = 1;
+inline void ActuatorInformation::clear_count() {
+  count_ = 0u;
+}
+inline ::google::protobuf::uint32 ActuatorInformation::count() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ActuatorInformation.count)
+  return count_;
+}
+inline void ActuatorInformation::set_count(::google::protobuf::uint32 value) {
+  
+  count_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.ActuatorInformation.count)
+}
+
+// -------------------------------------------------------------------
+
+// ArmStateInformation
+
+// .Kinova.Api.Common.ArmState active_state = 1;
+inline void ArmStateInformation::clear_active_state() {
+  active_state_ = 0;
+}
+inline ::Kinova::Api::Common::ArmState ArmStateInformation::active_state() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ArmStateInformation.active_state)
+  return static_cast< ::Kinova::Api::Common::ArmState >(active_state_);
+}
+inline void ArmStateInformation::set_active_state(::Kinova::Api::Common::ArmState value) {
+  
+  active_state_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.ArmStateInformation.active_state)
+}
+
+// .Kinova.Api.Common.Connection connection = 2;
+inline bool ArmStateInformation::has_connection() const {
+  return this != internal_default_instance() && connection_ != NULL;
+}
+inline const ::Kinova::Api::Common::Connection& ArmStateInformation::connection() const {
+  const ::Kinova::Api::Common::Connection* p = connection_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ArmStateInformation.connection)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::Connection*>(
+      &::Kinova::Api::Common::_Connection_default_instance_);
+}
+inline ::Kinova::Api::Common::Connection* ArmStateInformation::release_connection() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ArmStateInformation.connection)
+  
+  ::Kinova::Api::Common::Connection* temp = connection_;
+  connection_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::Connection* ArmStateInformation::mutable_connection() {
+  
+  if (connection_ == NULL) {
+    connection_ = new ::Kinova::Api::Common::Connection;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ArmStateInformation.connection)
+  return connection_;
+}
+inline void ArmStateInformation::set_allocated_connection(::Kinova::Api::Common::Connection* connection) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(connection_);
+  }
+  if (connection) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      connection = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, connection, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  connection_ = connection;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.ArmStateInformation.connection)
+}
+
+// -------------------------------------------------------------------
+
+// ArmStateNotification
+
+// .Kinova.Api.Common.ArmState active_state = 1;
+inline void ArmStateNotification::clear_active_state() {
+  active_state_ = 0;
+}
+inline ::Kinova::Api::Common::ArmState ArmStateNotification::active_state() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ArmStateNotification.active_state)
+  return static_cast< ::Kinova::Api::Common::ArmState >(active_state_);
+}
+inline void ArmStateNotification::set_active_state(::Kinova::Api::Common::ArmState value) {
+  
+  active_state_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.ArmStateNotification.active_state)
+}
+
+// .Kinova.Api.Common.Timestamp timestamp = 2;
+inline bool ArmStateNotification::has_timestamp() const {
+  return this != internal_default_instance() && timestamp_ != NULL;
+}
+inline const ::Kinova::Api::Common::Timestamp& ArmStateNotification::timestamp() const {
+  const ::Kinova::Api::Common::Timestamp* p = timestamp_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ArmStateNotification.timestamp)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::Timestamp*>(
+      &::Kinova::Api::Common::_Timestamp_default_instance_);
+}
+inline ::Kinova::Api::Common::Timestamp* ArmStateNotification::release_timestamp() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ArmStateNotification.timestamp)
+  
+  ::Kinova::Api::Common::Timestamp* temp = timestamp_;
+  timestamp_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::Timestamp* ArmStateNotification::mutable_timestamp() {
+  
+  if (timestamp_ == NULL) {
+    timestamp_ = new ::Kinova::Api::Common::Timestamp;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ArmStateNotification.timestamp)
+  return timestamp_;
+}
+inline void ArmStateNotification::set_allocated_timestamp(::Kinova::Api::Common::Timestamp* timestamp) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(timestamp_);
+  }
+  if (timestamp) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      timestamp = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, timestamp, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  timestamp_ = timestamp;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.ArmStateNotification.timestamp)
+}
+
+// .Kinova.Api.Common.Connection connection = 3;
+inline bool ArmStateNotification::has_connection() const {
+  return this != internal_default_instance() && connection_ != NULL;
+}
+inline const ::Kinova::Api::Common::Connection& ArmStateNotification::connection() const {
+  const ::Kinova::Api::Common::Connection* p = connection_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.ArmStateNotification.connection)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::Connection*>(
+      &::Kinova::Api::Common::_Connection_default_instance_);
+}
+inline ::Kinova::Api::Common::Connection* ArmStateNotification::release_connection() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.ArmStateNotification.connection)
+  
+  ::Kinova::Api::Common::Connection* temp = connection_;
+  connection_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::Connection* ArmStateNotification::mutable_connection() {
+  
+  if (connection_ == NULL) {
+    connection_ = new ::Kinova::Api::Common::Connection;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.ArmStateNotification.connection)
+  return connection_;
+}
+inline void ArmStateNotification::set_allocated_connection(::Kinova::Api::Common::Connection* connection) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(connection_);
+  }
+  if (connection) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      connection = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, connection, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  connection_ = connection;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.ArmStateNotification.connection)
+}
+
+// -------------------------------------------------------------------
+
+// CapSenseConfig
+
+// uint32 identifier = 1;
+inline void CapSenseConfig::clear_identifier() {
+  identifier_ = 0u;
+}
+inline ::google::protobuf::uint32 CapSenseConfig::identifier() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.CapSenseConfig.identifier)
+  return identifier_;
+}
+inline void CapSenseConfig::set_identifier(::google::protobuf::uint32 value) {
+  
+  identifier_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.CapSenseConfig.identifier)
+}
+
+// .Kinova.Api.Base.CapSenseMode mode = 2;
+inline void CapSenseConfig::clear_mode() {
+  mode_ = 0;
+}
+inline ::Kinova::Api::Base::CapSenseMode CapSenseConfig::mode() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.CapSenseConfig.mode)
+  return static_cast< ::Kinova::Api::Base::CapSenseMode >(mode_);
+}
+inline void CapSenseConfig::set_mode(::Kinova::Api::Base::CapSenseMode value) {
+  
+  mode_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.CapSenseConfig.mode)
+}
+
+// float threshold_a = 3;
+inline void CapSenseConfig::clear_threshold_a() {
+  threshold_a_ = 0;
+}
+inline float CapSenseConfig::threshold_a() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.CapSenseConfig.threshold_a)
+  return threshold_a_;
+}
+inline void CapSenseConfig::set_threshold_a(float value) {
+  
+  threshold_a_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.CapSenseConfig.threshold_a)
+}
+
+// float threshold_b = 4;
+inline void CapSenseConfig::clear_threshold_b() {
+  threshold_b_ = 0;
+}
+inline float CapSenseConfig::threshold_b() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.CapSenseConfig.threshold_b)
+  return threshold_b_;
+}
+inline void CapSenseConfig::set_threshold_b(float value) {
+  
+  threshold_b_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.CapSenseConfig.threshold_b)
+}
+
+// float sensitivity_a = 5;
+inline void CapSenseConfig::clear_sensitivity_a() {
+  sensitivity_a_ = 0;
+}
+inline float CapSenseConfig::sensitivity_a() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.CapSenseConfig.sensitivity_a)
+  return sensitivity_a_;
+}
+inline void CapSenseConfig::set_sensitivity_a(float value) {
+  
+  sensitivity_a_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.CapSenseConfig.sensitivity_a)
+}
+
+// float sensitivity_b = 6;
+inline void CapSenseConfig::clear_sensitivity_b() {
+  sensitivity_b_ = 0;
+}
+inline float CapSenseConfig::sensitivity_b() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.CapSenseConfig.sensitivity_b)
+  return sensitivity_b_;
+}
+inline void CapSenseConfig::set_sensitivity_b(float value) {
+  
+  sensitivity_b_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.CapSenseConfig.sensitivity_b)
+}
+
+// -------------------------------------------------------------------
+
+// BridgeList
+
+// repeated .Kinova.Api.Base.BridgeConfig bridgeConfig = 1;
+inline int BridgeList::bridgeconfig_size() const {
+  return bridgeconfig_.size();
+}
+inline void BridgeList::clear_bridgeconfig() {
+  bridgeconfig_.Clear();
+}
+inline const ::Kinova::Api::Base::BridgeConfig& BridgeList::bridgeconfig(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.BridgeList.bridgeConfig)
+  return bridgeconfig_.Get(index);
+}
+inline ::Kinova::Api::Base::BridgeConfig* BridgeList::mutable_bridgeconfig(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.BridgeList.bridgeConfig)
+  return bridgeconfig_.Mutable(index);
+}
+inline ::Kinova::Api::Base::BridgeConfig* BridgeList::add_bridgeconfig() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.Base.BridgeList.bridgeConfig)
+  return bridgeconfig_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::BridgeConfig >*
+BridgeList::mutable_bridgeconfig() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.Base.BridgeList.bridgeConfig)
+  return &bridgeconfig_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::BridgeConfig >&
+BridgeList::bridgeconfig() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.Base.BridgeList.bridgeConfig)
+  return bridgeconfig_;
+}
+
+// -------------------------------------------------------------------
+
+// BridgeResult
+
+// .Kinova.Api.Base.BridgeIdentifier bridge_id = 1;
+inline bool BridgeResult::has_bridge_id() const {
+  return this != internal_default_instance() && bridge_id_ != NULL;
+}
+inline void BridgeResult::clear_bridge_id() {
+  if (GetArenaNoVirtual() == NULL && bridge_id_ != NULL) {
+    delete bridge_id_;
+  }
+  bridge_id_ = NULL;
+}
+inline const ::Kinova::Api::Base::BridgeIdentifier& BridgeResult::bridge_id() const {
+  const ::Kinova::Api::Base::BridgeIdentifier* p = bridge_id_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.BridgeResult.bridge_id)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::BridgeIdentifier*>(
+      &::Kinova::Api::Base::_BridgeIdentifier_default_instance_);
+}
+inline ::Kinova::Api::Base::BridgeIdentifier* BridgeResult::release_bridge_id() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.BridgeResult.bridge_id)
+  
+  ::Kinova::Api::Base::BridgeIdentifier* temp = bridge_id_;
+  bridge_id_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::BridgeIdentifier* BridgeResult::mutable_bridge_id() {
+  
+  if (bridge_id_ == NULL) {
+    bridge_id_ = new ::Kinova::Api::Base::BridgeIdentifier;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.BridgeResult.bridge_id)
+  return bridge_id_;
+}
+inline void BridgeResult::set_allocated_bridge_id(::Kinova::Api::Base::BridgeIdentifier* bridge_id) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete bridge_id_;
+  }
+  if (bridge_id) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      bridge_id = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, bridge_id, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  bridge_id_ = bridge_id;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.BridgeResult.bridge_id)
+}
+
+// .Kinova.Api.Base.BridgeStatus status = 2;
+inline void BridgeResult::clear_status() {
+  status_ = 0;
+}
+inline ::Kinova::Api::Base::BridgeStatus BridgeResult::status() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.BridgeResult.status)
+  return static_cast< ::Kinova::Api::Base::BridgeStatus >(status_);
+}
+inline void BridgeResult::set_status(::Kinova::Api::Base::BridgeStatus value) {
+  
+  status_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.BridgeResult.status)
+}
+
+// -------------------------------------------------------------------
+
+// BridgeIdentifier
+
+// uint32 bridge_id = 1;
+inline void BridgeIdentifier::clear_bridge_id() {
+  bridge_id_ = 0u;
+}
+inline ::google::protobuf::uint32 BridgeIdentifier::bridge_id() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.BridgeIdentifier.bridge_id)
+  return bridge_id_;
+}
+inline void BridgeIdentifier::set_bridge_id(::google::protobuf::uint32 value) {
+  
+  bridge_id_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.BridgeIdentifier.bridge_id)
+}
+
+// -------------------------------------------------------------------
+
+// BridgeConfig
+
+// uint32 device_identifier = 1;
+inline void BridgeConfig::clear_device_identifier() {
+  device_identifier_ = 0u;
+}
+inline ::google::protobuf::uint32 BridgeConfig::device_identifier() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.BridgeConfig.device_identifier)
+  return device_identifier_;
+}
+inline void BridgeConfig::set_device_identifier(::google::protobuf::uint32 value) {
+  
+  device_identifier_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.BridgeConfig.device_identifier)
+}
+
+// .Kinova.Api.Base.BridgeType bridgetype = 2;
+inline void BridgeConfig::clear_bridgetype() {
+  bridgetype_ = 0;
+}
+inline ::Kinova::Api::Base::BridgeType BridgeConfig::bridgetype() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.BridgeConfig.bridgetype)
+  return static_cast< ::Kinova::Api::Base::BridgeType >(bridgetype_);
+}
+inline void BridgeConfig::set_bridgetype(::Kinova::Api::Base::BridgeType value) {
+  
+  bridgetype_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.BridgeConfig.bridgetype)
+}
+
+// .Kinova.Api.Base.BridgePortConfig port_config = 3;
+inline bool BridgeConfig::has_port_config() const {
+  return this != internal_default_instance() && port_config_ != NULL;
+}
+inline void BridgeConfig::clear_port_config() {
+  if (GetArenaNoVirtual() == NULL && port_config_ != NULL) {
+    delete port_config_;
+  }
+  port_config_ = NULL;
+}
+inline const ::Kinova::Api::Base::BridgePortConfig& BridgeConfig::port_config() const {
+  const ::Kinova::Api::Base::BridgePortConfig* p = port_config_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.BridgeConfig.port_config)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::BridgePortConfig*>(
+      &::Kinova::Api::Base::_BridgePortConfig_default_instance_);
+}
+inline ::Kinova::Api::Base::BridgePortConfig* BridgeConfig::release_port_config() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.BridgeConfig.port_config)
+  
+  ::Kinova::Api::Base::BridgePortConfig* temp = port_config_;
+  port_config_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::BridgePortConfig* BridgeConfig::mutable_port_config() {
+  
+  if (port_config_ == NULL) {
+    port_config_ = new ::Kinova::Api::Base::BridgePortConfig;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.BridgeConfig.port_config)
+  return port_config_;
+}
+inline void BridgeConfig::set_allocated_port_config(::Kinova::Api::Base::BridgePortConfig* port_config) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete port_config_;
+  }
+  if (port_config) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      port_config = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, port_config, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  port_config_ = port_config;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.BridgeConfig.port_config)
+}
+
+// .Kinova.Api.Base.BridgeIdentifier bridge_id = 4;
+inline bool BridgeConfig::has_bridge_id() const {
+  return this != internal_default_instance() && bridge_id_ != NULL;
+}
+inline void BridgeConfig::clear_bridge_id() {
+  if (GetArenaNoVirtual() == NULL && bridge_id_ != NULL) {
+    delete bridge_id_;
+  }
+  bridge_id_ = NULL;
+}
+inline const ::Kinova::Api::Base::BridgeIdentifier& BridgeConfig::bridge_id() const {
+  const ::Kinova::Api::Base::BridgeIdentifier* p = bridge_id_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.BridgeConfig.bridge_id)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::BridgeIdentifier*>(
+      &::Kinova::Api::Base::_BridgeIdentifier_default_instance_);
+}
+inline ::Kinova::Api::Base::BridgeIdentifier* BridgeConfig::release_bridge_id() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.BridgeConfig.bridge_id)
+  
+  ::Kinova::Api::Base::BridgeIdentifier* temp = bridge_id_;
+  bridge_id_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::BridgeIdentifier* BridgeConfig::mutable_bridge_id() {
+  
+  if (bridge_id_ == NULL) {
+    bridge_id_ = new ::Kinova::Api::Base::BridgeIdentifier;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.BridgeConfig.bridge_id)
+  return bridge_id_;
+}
+inline void BridgeConfig::set_allocated_bridge_id(::Kinova::Api::Base::BridgeIdentifier* bridge_id) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete bridge_id_;
+  }
+  if (bridge_id) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      bridge_id = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, bridge_id, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  bridge_id_ = bridge_id;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.BridgeConfig.bridge_id)
+}
+
+// -------------------------------------------------------------------
+
+// BridgePortConfig
+
+// uint32 target_port = 1;
+inline void BridgePortConfig::clear_target_port() {
+  target_port_ = 0u;
+}
+inline ::google::protobuf::uint32 BridgePortConfig::target_port() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.BridgePortConfig.target_port)
+  return target_port_;
+}
+inline void BridgePortConfig::set_target_port(::google::protobuf::uint32 value) {
+  
+  target_port_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.BridgePortConfig.target_port)
+}
+
+// uint32 out_port = 2;
+inline void BridgePortConfig::clear_out_port() {
+  out_port_ = 0u;
+}
+inline ::google::protobuf::uint32 BridgePortConfig::out_port() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.BridgePortConfig.out_port)
+  return out_port_;
+}
+inline void BridgePortConfig::set_out_port(::google::protobuf::uint32 value) {
+  
+  out_port_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.BridgePortConfig.out_port)
+}
+
+// -------------------------------------------------------------------
+
+// PreComputedJointTrajectory
+
+// .Kinova.Api.Base.TrajectoryContinuityMode mode = 1;
+inline void PreComputedJointTrajectory::clear_mode() {
+  mode_ = 0;
+}
+inline ::Kinova::Api::Base::TrajectoryContinuityMode PreComputedJointTrajectory::mode() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.PreComputedJointTrajectory.mode)
+  return static_cast< ::Kinova::Api::Base::TrajectoryContinuityMode >(mode_);
+}
+inline void PreComputedJointTrajectory::set_mode(::Kinova::Api::Base::TrajectoryContinuityMode value) {
+  
+  mode_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.PreComputedJointTrajectory.mode)
+}
+
+// repeated .Kinova.Api.Base.PreComputedJointTrajectoryElement trajectory_elements = 2;
+inline int PreComputedJointTrajectory::trajectory_elements_size() const {
+  return trajectory_elements_.size();
+}
+inline void PreComputedJointTrajectory::clear_trajectory_elements() {
+  trajectory_elements_.Clear();
+}
+inline const ::Kinova::Api::Base::PreComputedJointTrajectoryElement& PreComputedJointTrajectory::trajectory_elements(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.PreComputedJointTrajectory.trajectory_elements)
+  return trajectory_elements_.Get(index);
+}
+inline ::Kinova::Api::Base::PreComputedJointTrajectoryElement* PreComputedJointTrajectory::mutable_trajectory_elements(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.PreComputedJointTrajectory.trajectory_elements)
+  return trajectory_elements_.Mutable(index);
+}
+inline ::Kinova::Api::Base::PreComputedJointTrajectoryElement* PreComputedJointTrajectory::add_trajectory_elements() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.Base.PreComputedJointTrajectory.trajectory_elements)
+  return trajectory_elements_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::PreComputedJointTrajectoryElement >*
+PreComputedJointTrajectory::mutable_trajectory_elements() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.Base.PreComputedJointTrajectory.trajectory_elements)
+  return &trajectory_elements_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::PreComputedJointTrajectoryElement >&
+PreComputedJointTrajectory::trajectory_elements() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.Base.PreComputedJointTrajectory.trajectory_elements)
+  return trajectory_elements_;
+}
+
+// -------------------------------------------------------------------
+
+// PreComputedJointTrajectoryElement
+
+// repeated float joint_angles = 1;
+inline int PreComputedJointTrajectoryElement::joint_angles_size() const {
+  return joint_angles_.size();
+}
+inline void PreComputedJointTrajectoryElement::clear_joint_angles() {
+  joint_angles_.Clear();
+}
+inline float PreComputedJointTrajectoryElement::joint_angles(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.PreComputedJointTrajectoryElement.joint_angles)
+  return joint_angles_.Get(index);
+}
+inline void PreComputedJointTrajectoryElement::set_joint_angles(int index, float value) {
+  joint_angles_.Set(index, value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.PreComputedJointTrajectoryElement.joint_angles)
+}
+inline void PreComputedJointTrajectoryElement::add_joint_angles(float value) {
+  joint_angles_.Add(value);
+  // @@protoc_insertion_point(field_add:Kinova.Api.Base.PreComputedJointTrajectoryElement.joint_angles)
+}
+inline const ::google::protobuf::RepeatedField< float >&
+PreComputedJointTrajectoryElement::joint_angles() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.Base.PreComputedJointTrajectoryElement.joint_angles)
+  return joint_angles_;
+}
+inline ::google::protobuf::RepeatedField< float >*
+PreComputedJointTrajectoryElement::mutable_joint_angles() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.Base.PreComputedJointTrajectoryElement.joint_angles)
+  return &joint_angles_;
+}
+
+// repeated float joint_speeds = 2;
+inline int PreComputedJointTrajectoryElement::joint_speeds_size() const {
+  return joint_speeds_.size();
+}
+inline void PreComputedJointTrajectoryElement::clear_joint_speeds() {
+  joint_speeds_.Clear();
+}
+inline float PreComputedJointTrajectoryElement::joint_speeds(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.PreComputedJointTrajectoryElement.joint_speeds)
+  return joint_speeds_.Get(index);
+}
+inline void PreComputedJointTrajectoryElement::set_joint_speeds(int index, float value) {
+  joint_speeds_.Set(index, value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.PreComputedJointTrajectoryElement.joint_speeds)
+}
+inline void PreComputedJointTrajectoryElement::add_joint_speeds(float value) {
+  joint_speeds_.Add(value);
+  // @@protoc_insertion_point(field_add:Kinova.Api.Base.PreComputedJointTrajectoryElement.joint_speeds)
+}
+inline const ::google::protobuf::RepeatedField< float >&
+PreComputedJointTrajectoryElement::joint_speeds() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.Base.PreComputedJointTrajectoryElement.joint_speeds)
+  return joint_speeds_;
+}
+inline ::google::protobuf::RepeatedField< float >*
+PreComputedJointTrajectoryElement::mutable_joint_speeds() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.Base.PreComputedJointTrajectoryElement.joint_speeds)
+  return &joint_speeds_;
+}
+
+// repeated float joint_accelerations = 3;
+inline int PreComputedJointTrajectoryElement::joint_accelerations_size() const {
+  return joint_accelerations_.size();
+}
+inline void PreComputedJointTrajectoryElement::clear_joint_accelerations() {
+  joint_accelerations_.Clear();
+}
+inline float PreComputedJointTrajectoryElement::joint_accelerations(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.PreComputedJointTrajectoryElement.joint_accelerations)
+  return joint_accelerations_.Get(index);
+}
+inline void PreComputedJointTrajectoryElement::set_joint_accelerations(int index, float value) {
+  joint_accelerations_.Set(index, value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.PreComputedJointTrajectoryElement.joint_accelerations)
+}
+inline void PreComputedJointTrajectoryElement::add_joint_accelerations(float value) {
+  joint_accelerations_.Add(value);
+  // @@protoc_insertion_point(field_add:Kinova.Api.Base.PreComputedJointTrajectoryElement.joint_accelerations)
+}
+inline const ::google::protobuf::RepeatedField< float >&
+PreComputedJointTrajectoryElement::joint_accelerations() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.Base.PreComputedJointTrajectoryElement.joint_accelerations)
+  return joint_accelerations_;
+}
+inline ::google::protobuf::RepeatedField< float >*
+PreComputedJointTrajectoryElement::mutable_joint_accelerations() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.Base.PreComputedJointTrajectoryElement.joint_accelerations)
+  return &joint_accelerations_;
+}
+
+// float time_from_start = 4;
+inline void PreComputedJointTrajectoryElement::clear_time_from_start() {
+  time_from_start_ = 0;
+}
+inline float PreComputedJointTrajectoryElement::time_from_start() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.PreComputedJointTrajectoryElement.time_from_start)
+  return time_from_start_;
+}
+inline void PreComputedJointTrajectoryElement::set_time_from_start(float value) {
+  
+  time_from_start_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.PreComputedJointTrajectoryElement.time_from_start)
+}
+
+// -------------------------------------------------------------------
+
+// TrajectoryErrorElement
+
+// .Kinova.Api.Base.TrajectoryErrorType error_type = 1;
+inline void TrajectoryErrorElement::clear_error_type() {
+  error_type_ = 0;
+}
+inline ::Kinova::Api::Base::TrajectoryErrorType TrajectoryErrorElement::error_type() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.TrajectoryErrorElement.error_type)
+  return static_cast< ::Kinova::Api::Base::TrajectoryErrorType >(error_type_);
+}
+inline void TrajectoryErrorElement::set_error_type(::Kinova::Api::Base::TrajectoryErrorType value) {
+  
+  error_type_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.TrajectoryErrorElement.error_type)
+}
+
+// float error_value = 3;
+inline void TrajectoryErrorElement::clear_error_value() {
+  error_value_ = 0;
+}
+inline float TrajectoryErrorElement::error_value() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.TrajectoryErrorElement.error_value)
+  return error_value_;
+}
+inline void TrajectoryErrorElement::set_error_value(float value) {
+  
+  error_value_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.TrajectoryErrorElement.error_value)
+}
+
+// float min_value = 4;
+inline void TrajectoryErrorElement::clear_min_value() {
+  min_value_ = 0;
+}
+inline float TrajectoryErrorElement::min_value() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.TrajectoryErrorElement.min_value)
+  return min_value_;
+}
+inline void TrajectoryErrorElement::set_min_value(float value) {
+  
+  min_value_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.TrajectoryErrorElement.min_value)
+}
+
+// float max_value = 5;
+inline void TrajectoryErrorElement::clear_max_value() {
+  max_value_ = 0;
+}
+inline float TrajectoryErrorElement::max_value() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.TrajectoryErrorElement.max_value)
+  return max_value_;
+}
+inline void TrajectoryErrorElement::set_max_value(float value) {
+  
+  max_value_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.TrajectoryErrorElement.max_value)
+}
+
+// uint32 index = 6;
+inline void TrajectoryErrorElement::clear_index() {
+  index_ = 0u;
+}
+inline ::google::protobuf::uint32 TrajectoryErrorElement::index() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.TrajectoryErrorElement.index)
+  return index_;
+}
+inline void TrajectoryErrorElement::set_index(::google::protobuf::uint32 value) {
+  
+  index_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.TrajectoryErrorElement.index)
+}
+
+// string message = 7;
+inline void TrajectoryErrorElement::clear_message() {
+  message_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& TrajectoryErrorElement::message() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.TrajectoryErrorElement.message)
+  return message_.GetNoArena();
+}
+inline void TrajectoryErrorElement::set_message(const ::std::string& value) {
+  
+  message_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.TrajectoryErrorElement.message)
+}
+#if LANG_CXX11
+inline void TrajectoryErrorElement::set_message(::std::string&& value) {
+  
+  message_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:Kinova.Api.Base.TrajectoryErrorElement.message)
+}
+#endif
+inline void TrajectoryErrorElement::set_message(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  message_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:Kinova.Api.Base.TrajectoryErrorElement.message)
+}
+inline void TrajectoryErrorElement::set_message(const char* value, size_t size) {
+  
+  message_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:Kinova.Api.Base.TrajectoryErrorElement.message)
+}
+inline ::std::string* TrajectoryErrorElement::mutable_message() {
+  
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.TrajectoryErrorElement.message)
+  return message_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* TrajectoryErrorElement::release_message() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.TrajectoryErrorElement.message)
+  
+  return message_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void TrajectoryErrorElement::set_allocated_message(::std::string* message) {
+  if (message != NULL) {
+    
+  } else {
+    
+  }
+  message_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), message);
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.TrajectoryErrorElement.message)
+}
+
+// uint32 waypoint_index = 8;
+inline void TrajectoryErrorElement::clear_waypoint_index() {
+  waypoint_index_ = 0u;
+}
+inline ::google::protobuf::uint32 TrajectoryErrorElement::waypoint_index() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.TrajectoryErrorElement.waypoint_index)
+  return waypoint_index_;
+}
+inline void TrajectoryErrorElement::set_waypoint_index(::google::protobuf::uint32 value) {
+  
+  waypoint_index_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.TrajectoryErrorElement.waypoint_index)
+}
+
+// -------------------------------------------------------------------
+
+// TrajectoryErrorReport
+
+// repeated .Kinova.Api.Base.TrajectoryErrorElement trajectory_error_elements = 1;
+inline int TrajectoryErrorReport::trajectory_error_elements_size() const {
+  return trajectory_error_elements_.size();
+}
+inline void TrajectoryErrorReport::clear_trajectory_error_elements() {
+  trajectory_error_elements_.Clear();
+}
+inline const ::Kinova::Api::Base::TrajectoryErrorElement& TrajectoryErrorReport::trajectory_error_elements(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.TrajectoryErrorReport.trajectory_error_elements)
+  return trajectory_error_elements_.Get(index);
+}
+inline ::Kinova::Api::Base::TrajectoryErrorElement* TrajectoryErrorReport::mutable_trajectory_error_elements(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.TrajectoryErrorReport.trajectory_error_elements)
+  return trajectory_error_elements_.Mutable(index);
+}
+inline ::Kinova::Api::Base::TrajectoryErrorElement* TrajectoryErrorReport::add_trajectory_error_elements() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.Base.TrajectoryErrorReport.trajectory_error_elements)
+  return trajectory_error_elements_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::TrajectoryErrorElement >*
+TrajectoryErrorReport::mutable_trajectory_error_elements() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.Base.TrajectoryErrorReport.trajectory_error_elements)
+  return &trajectory_error_elements_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::TrajectoryErrorElement >&
+TrajectoryErrorReport::trajectory_error_elements() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.Base.TrajectoryErrorReport.trajectory_error_elements)
+  return trajectory_error_elements_;
+}
+
+// -------------------------------------------------------------------
+
+// WaypointValidationReport
+
+// .Kinova.Api.Base.TrajectoryErrorReport trajectory_error_report = 1;
+inline bool WaypointValidationReport::has_trajectory_error_report() const {
+  return this != internal_default_instance() && trajectory_error_report_ != NULL;
+}
+inline void WaypointValidationReport::clear_trajectory_error_report() {
+  if (GetArenaNoVirtual() == NULL && trajectory_error_report_ != NULL) {
+    delete trajectory_error_report_;
+  }
+  trajectory_error_report_ = NULL;
+}
+inline const ::Kinova::Api::Base::TrajectoryErrorReport& WaypointValidationReport::trajectory_error_report() const {
+  const ::Kinova::Api::Base::TrajectoryErrorReport* p = trajectory_error_report_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.WaypointValidationReport.trajectory_error_report)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::TrajectoryErrorReport*>(
+      &::Kinova::Api::Base::_TrajectoryErrorReport_default_instance_);
+}
+inline ::Kinova::Api::Base::TrajectoryErrorReport* WaypointValidationReport::release_trajectory_error_report() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.WaypointValidationReport.trajectory_error_report)
+  
+  ::Kinova::Api::Base::TrajectoryErrorReport* temp = trajectory_error_report_;
+  trajectory_error_report_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::TrajectoryErrorReport* WaypointValidationReport::mutable_trajectory_error_report() {
+  
+  if (trajectory_error_report_ == NULL) {
+    trajectory_error_report_ = new ::Kinova::Api::Base::TrajectoryErrorReport;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.WaypointValidationReport.trajectory_error_report)
+  return trajectory_error_report_;
+}
+inline void WaypointValidationReport::set_allocated_trajectory_error_report(::Kinova::Api::Base::TrajectoryErrorReport* trajectory_error_report) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete trajectory_error_report_;
+  }
+  if (trajectory_error_report) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      trajectory_error_report = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, trajectory_error_report, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  trajectory_error_report_ = trajectory_error_report;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.WaypointValidationReport.trajectory_error_report)
+}
+
+// .Kinova.Api.Base.WaypointList optimal_waypoint_list = 2;
+inline bool WaypointValidationReport::has_optimal_waypoint_list() const {
+  return this != internal_default_instance() && optimal_waypoint_list_ != NULL;
+}
+inline void WaypointValidationReport::clear_optimal_waypoint_list() {
+  if (GetArenaNoVirtual() == NULL && optimal_waypoint_list_ != NULL) {
+    delete optimal_waypoint_list_;
+  }
+  optimal_waypoint_list_ = NULL;
+}
+inline const ::Kinova::Api::Base::WaypointList& WaypointValidationReport::optimal_waypoint_list() const {
+  const ::Kinova::Api::Base::WaypointList* p = optimal_waypoint_list_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.WaypointValidationReport.optimal_waypoint_list)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::WaypointList*>(
+      &::Kinova::Api::Base::_WaypointList_default_instance_);
+}
+inline ::Kinova::Api::Base::WaypointList* WaypointValidationReport::release_optimal_waypoint_list() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.WaypointValidationReport.optimal_waypoint_list)
+  
+  ::Kinova::Api::Base::WaypointList* temp = optimal_waypoint_list_;
+  optimal_waypoint_list_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::WaypointList* WaypointValidationReport::mutable_optimal_waypoint_list() {
+  
+  if (optimal_waypoint_list_ == NULL) {
+    optimal_waypoint_list_ = new ::Kinova::Api::Base::WaypointList;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.WaypointValidationReport.optimal_waypoint_list)
+  return optimal_waypoint_list_;
+}
+inline void WaypointValidationReport::set_allocated_optimal_waypoint_list(::Kinova::Api::Base::WaypointList* optimal_waypoint_list) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete optimal_waypoint_list_;
+  }
+  if (optimal_waypoint_list) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      optimal_waypoint_list = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, optimal_waypoint_list, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  optimal_waypoint_list_ = optimal_waypoint_list;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.WaypointValidationReport.optimal_waypoint_list)
+}
+
+// -------------------------------------------------------------------
+
+// Waypoint
+
+// string name = 1;
+inline void Waypoint::clear_name() {
+  name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& Waypoint::name() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Waypoint.name)
+  return name_.GetNoArena();
+}
+inline void Waypoint::set_name(const ::std::string& value) {
+  
+  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.Waypoint.name)
+}
+#if LANG_CXX11
+inline void Waypoint::set_name(::std::string&& value) {
+  
+  name_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:Kinova.Api.Base.Waypoint.name)
+}
+#endif
+inline void Waypoint::set_name(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:Kinova.Api.Base.Waypoint.name)
+}
+inline void Waypoint::set_name(const char* value, size_t size) {
+  
+  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:Kinova.Api.Base.Waypoint.name)
+}
+inline ::std::string* Waypoint::mutable_name() {
+  
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.Waypoint.name)
+  return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* Waypoint::release_name() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.Waypoint.name)
+  
+  return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void Waypoint::set_allocated_name(::std::string* name) {
+  if (name != NULL) {
+    
+  } else {
+    
+  }
+  name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.Waypoint.name)
+}
+
+// .Kinova.Api.Base.AngularWaypoint angular_waypoint = 2;
+inline bool Waypoint::has_angular_waypoint() const {
+  return type_of_waypoint_case() == kAngularWaypoint;
+}
+inline void Waypoint::set_has_angular_waypoint() {
+  _oneof_case_[0] = kAngularWaypoint;
+}
+inline void Waypoint::clear_angular_waypoint() {
+  if (has_angular_waypoint()) {
+    delete type_of_waypoint_.angular_waypoint_;
+    clear_has_type_of_waypoint();
+  }
+}
+inline ::Kinova::Api::Base::AngularWaypoint* Waypoint::release_angular_waypoint() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.Waypoint.angular_waypoint)
+  if (has_angular_waypoint()) {
+    clear_has_type_of_waypoint();
+      ::Kinova::Api::Base::AngularWaypoint* temp = type_of_waypoint_.angular_waypoint_;
+    type_of_waypoint_.angular_waypoint_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline const ::Kinova::Api::Base::AngularWaypoint& Waypoint::angular_waypoint() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Waypoint.angular_waypoint)
+  return has_angular_waypoint()
+      ? *type_of_waypoint_.angular_waypoint_
+      : *reinterpret_cast< ::Kinova::Api::Base::AngularWaypoint*>(&::Kinova::Api::Base::_AngularWaypoint_default_instance_);
+}
+inline ::Kinova::Api::Base::AngularWaypoint* Waypoint::mutable_angular_waypoint() {
+  if (!has_angular_waypoint()) {
+    clear_type_of_waypoint();
+    set_has_angular_waypoint();
+    type_of_waypoint_.angular_waypoint_ = new ::Kinova::Api::Base::AngularWaypoint;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.Waypoint.angular_waypoint)
+  return type_of_waypoint_.angular_waypoint_;
+}
+
+// .Kinova.Api.Base.CartesianWaypoint cartesian_waypoint = 3;
+inline bool Waypoint::has_cartesian_waypoint() const {
+  return type_of_waypoint_case() == kCartesianWaypoint;
+}
+inline void Waypoint::set_has_cartesian_waypoint() {
+  _oneof_case_[0] = kCartesianWaypoint;
+}
+inline void Waypoint::clear_cartesian_waypoint() {
+  if (has_cartesian_waypoint()) {
+    delete type_of_waypoint_.cartesian_waypoint_;
+    clear_has_type_of_waypoint();
+  }
+}
+inline ::Kinova::Api::Base::CartesianWaypoint* Waypoint::release_cartesian_waypoint() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.Waypoint.cartesian_waypoint)
+  if (has_cartesian_waypoint()) {
+    clear_has_type_of_waypoint();
+      ::Kinova::Api::Base::CartesianWaypoint* temp = type_of_waypoint_.cartesian_waypoint_;
+    type_of_waypoint_.cartesian_waypoint_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline const ::Kinova::Api::Base::CartesianWaypoint& Waypoint::cartesian_waypoint() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.Waypoint.cartesian_waypoint)
+  return has_cartesian_waypoint()
+      ? *type_of_waypoint_.cartesian_waypoint_
+      : *reinterpret_cast< ::Kinova::Api::Base::CartesianWaypoint*>(&::Kinova::Api::Base::_CartesianWaypoint_default_instance_);
+}
+inline ::Kinova::Api::Base::CartesianWaypoint* Waypoint::mutable_cartesian_waypoint() {
+  if (!has_cartesian_waypoint()) {
+    clear_type_of_waypoint();
+    set_has_cartesian_waypoint();
+    type_of_waypoint_.cartesian_waypoint_ = new ::Kinova::Api::Base::CartesianWaypoint;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.Waypoint.cartesian_waypoint)
+  return type_of_waypoint_.cartesian_waypoint_;
+}
+
+inline bool Waypoint::has_type_of_waypoint() const {
+  return type_of_waypoint_case() != TYPE_OF_WAYPOINT_NOT_SET;
+}
+inline void Waypoint::clear_has_type_of_waypoint() {
+  _oneof_case_[0] = TYPE_OF_WAYPOINT_NOT_SET;
+}
+inline Waypoint::TypeOfWaypointCase Waypoint::type_of_waypoint_case() const {
+  return Waypoint::TypeOfWaypointCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// AngularWaypoint
+
+// repeated float angles = 1;
+inline int AngularWaypoint::angles_size() const {
+  return angles_.size();
+}
+inline void AngularWaypoint::clear_angles() {
+  angles_.Clear();
+}
+inline float AngularWaypoint::angles(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.AngularWaypoint.angles)
+  return angles_.Get(index);
+}
+inline void AngularWaypoint::set_angles(int index, float value) {
+  angles_.Set(index, value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.AngularWaypoint.angles)
+}
+inline void AngularWaypoint::add_angles(float value) {
+  angles_.Add(value);
+  // @@protoc_insertion_point(field_add:Kinova.Api.Base.AngularWaypoint.angles)
+}
+inline const ::google::protobuf::RepeatedField< float >&
+AngularWaypoint::angles() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.Base.AngularWaypoint.angles)
+  return angles_;
+}
+inline ::google::protobuf::RepeatedField< float >*
+AngularWaypoint::mutable_angles() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.Base.AngularWaypoint.angles)
+  return &angles_;
+}
+
+// repeated float maximum_velocities = 2;
+inline int AngularWaypoint::maximum_velocities_size() const {
+  return maximum_velocities_.size();
+}
+inline void AngularWaypoint::clear_maximum_velocities() {
+  maximum_velocities_.Clear();
+}
+inline float AngularWaypoint::maximum_velocities(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.AngularWaypoint.maximum_velocities)
+  return maximum_velocities_.Get(index);
+}
+inline void AngularWaypoint::set_maximum_velocities(int index, float value) {
+  maximum_velocities_.Set(index, value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.AngularWaypoint.maximum_velocities)
+}
+inline void AngularWaypoint::add_maximum_velocities(float value) {
+  maximum_velocities_.Add(value);
+  // @@protoc_insertion_point(field_add:Kinova.Api.Base.AngularWaypoint.maximum_velocities)
+}
+inline const ::google::protobuf::RepeatedField< float >&
+AngularWaypoint::maximum_velocities() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.Base.AngularWaypoint.maximum_velocities)
+  return maximum_velocities_;
+}
+inline ::google::protobuf::RepeatedField< float >*
+AngularWaypoint::mutable_maximum_velocities() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.Base.AngularWaypoint.maximum_velocities)
+  return &maximum_velocities_;
+}
+
+// float duration = 3;
+inline void AngularWaypoint::clear_duration() {
+  duration_ = 0;
+}
+inline float AngularWaypoint::duration() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.AngularWaypoint.duration)
+  return duration_;
+}
+inline void AngularWaypoint::set_duration(float value) {
+  
+  duration_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.AngularWaypoint.duration)
+}
+
+// -------------------------------------------------------------------
+
+// CartesianWaypoint
+
+// .Kinova.Api.Base.Pose pose = 1;
+inline bool CartesianWaypoint::has_pose() const {
+  return this != internal_default_instance() && pose_ != NULL;
+}
+inline void CartesianWaypoint::clear_pose() {
+  if (GetArenaNoVirtual() == NULL && pose_ != NULL) {
+    delete pose_;
+  }
+  pose_ = NULL;
+}
+inline const ::Kinova::Api::Base::Pose& CartesianWaypoint::pose() const {
+  const ::Kinova::Api::Base::Pose* p = pose_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.CartesianWaypoint.pose)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::Pose*>(
+      &::Kinova::Api::Base::_Pose_default_instance_);
+}
+inline ::Kinova::Api::Base::Pose* CartesianWaypoint::release_pose() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.CartesianWaypoint.pose)
+  
+  ::Kinova::Api::Base::Pose* temp = pose_;
+  pose_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::Pose* CartesianWaypoint::mutable_pose() {
+  
+  if (pose_ == NULL) {
+    pose_ = new ::Kinova::Api::Base::Pose;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.CartesianWaypoint.pose)
+  return pose_;
+}
+inline void CartesianWaypoint::set_allocated_pose(::Kinova::Api::Base::Pose* pose) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete pose_;
+  }
+  if (pose) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      pose = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, pose, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  pose_ = pose;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.CartesianWaypoint.pose)
+}
+
+// .Kinova.Api.Common.CartesianReferenceFrame reference_frame = 2;
+inline void CartesianWaypoint::clear_reference_frame() {
+  reference_frame_ = 0;
+}
+inline ::Kinova::Api::Common::CartesianReferenceFrame CartesianWaypoint::reference_frame() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.CartesianWaypoint.reference_frame)
+  return static_cast< ::Kinova::Api::Common::CartesianReferenceFrame >(reference_frame_);
+}
+inline void CartesianWaypoint::set_reference_frame(::Kinova::Api::Common::CartesianReferenceFrame value) {
+  
+  reference_frame_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.CartesianWaypoint.reference_frame)
+}
+
+// float maximum_linear_velocity = 3;
+inline void CartesianWaypoint::clear_maximum_linear_velocity() {
+  maximum_linear_velocity_ = 0;
+}
+inline float CartesianWaypoint::maximum_linear_velocity() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.CartesianWaypoint.maximum_linear_velocity)
+  return maximum_linear_velocity_;
+}
+inline void CartesianWaypoint::set_maximum_linear_velocity(float value) {
+  
+  maximum_linear_velocity_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.CartesianWaypoint.maximum_linear_velocity)
+}
+
+// float maximum_angular_velocity = 4;
+inline void CartesianWaypoint::clear_maximum_angular_velocity() {
+  maximum_angular_velocity_ = 0;
+}
+inline float CartesianWaypoint::maximum_angular_velocity() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.CartesianWaypoint.maximum_angular_velocity)
+  return maximum_angular_velocity_;
+}
+inline void CartesianWaypoint::set_maximum_angular_velocity(float value) {
+  
+  maximum_angular_velocity_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.CartesianWaypoint.maximum_angular_velocity)
+}
+
+// float blending_radius = 5;
+inline void CartesianWaypoint::clear_blending_radius() {
+  blending_radius_ = 0;
+}
+inline float CartesianWaypoint::blending_radius() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.CartesianWaypoint.blending_radius)
+  return blending_radius_;
+}
+inline void CartesianWaypoint::set_blending_radius(float value) {
+  
+  blending_radius_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.CartesianWaypoint.blending_radius)
+}
+
+// -------------------------------------------------------------------
+
+// WaypointList
+
+// repeated .Kinova.Api.Base.Waypoint waypoints = 1;
+inline int WaypointList::waypoints_size() const {
+  return waypoints_.size();
+}
+inline void WaypointList::clear_waypoints() {
+  waypoints_.Clear();
+}
+inline const ::Kinova::Api::Base::Waypoint& WaypointList::waypoints(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.WaypointList.waypoints)
+  return waypoints_.Get(index);
+}
+inline ::Kinova::Api::Base::Waypoint* WaypointList::mutable_waypoints(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.WaypointList.waypoints)
+  return waypoints_.Mutable(index);
+}
+inline ::Kinova::Api::Base::Waypoint* WaypointList::add_waypoints() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.Base.WaypointList.waypoints)
+  return waypoints_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::Waypoint >*
+WaypointList::mutable_waypoints() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.Base.WaypointList.waypoints)
+  return &waypoints_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::Waypoint >&
+WaypointList::waypoints() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.Base.WaypointList.waypoints)
+  return waypoints_;
+}
+
+// float duration = 2;
+inline void WaypointList::clear_duration() {
+  duration_ = 0;
+}
+inline float WaypointList::duration() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.WaypointList.duration)
+  return duration_;
+}
+inline void WaypointList::set_duration(float value) {
+  
+  duration_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.WaypointList.duration)
+}
+
+// bool use_optimal_blending = 3;
+inline void WaypointList::clear_use_optimal_blending() {
+  use_optimal_blending_ = false;
+}
+inline bool WaypointList::use_optimal_blending() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.WaypointList.use_optimal_blending)
+  return use_optimal_blending_;
+}
+inline void WaypointList::set_use_optimal_blending(bool value) {
+  
+  use_optimal_blending_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.WaypointList.use_optimal_blending)
+}
+
+// -------------------------------------------------------------------
+
+// KinematicTrajectoryConstraints
+
+// repeated float angular_velocities = 1;
+inline int KinematicTrajectoryConstraints::angular_velocities_size() const {
+  return angular_velocities_.size();
+}
+inline void KinematicTrajectoryConstraints::clear_angular_velocities() {
+  angular_velocities_.Clear();
+}
+inline float KinematicTrajectoryConstraints::angular_velocities(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.KinematicTrajectoryConstraints.angular_velocities)
+  return angular_velocities_.Get(index);
+}
+inline void KinematicTrajectoryConstraints::set_angular_velocities(int index, float value) {
+  angular_velocities_.Set(index, value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.KinematicTrajectoryConstraints.angular_velocities)
+}
+inline void KinematicTrajectoryConstraints::add_angular_velocities(float value) {
+  angular_velocities_.Add(value);
+  // @@protoc_insertion_point(field_add:Kinova.Api.Base.KinematicTrajectoryConstraints.angular_velocities)
+}
+inline const ::google::protobuf::RepeatedField< float >&
+KinematicTrajectoryConstraints::angular_velocities() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.Base.KinematicTrajectoryConstraints.angular_velocities)
+  return angular_velocities_;
+}
+inline ::google::protobuf::RepeatedField< float >*
+KinematicTrajectoryConstraints::mutable_angular_velocities() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.Base.KinematicTrajectoryConstraints.angular_velocities)
+  return &angular_velocities_;
+}
+
+// float linear_velocity = 2;
+inline void KinematicTrajectoryConstraints::clear_linear_velocity() {
+  linear_velocity_ = 0;
+}
+inline float KinematicTrajectoryConstraints::linear_velocity() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.KinematicTrajectoryConstraints.linear_velocity)
+  return linear_velocity_;
+}
+inline void KinematicTrajectoryConstraints::set_linear_velocity(float value) {
+  
+  linear_velocity_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.KinematicTrajectoryConstraints.linear_velocity)
+}
+
+// float angular_velocity = 3;
+inline void KinematicTrajectoryConstraints::clear_angular_velocity() {
+  angular_velocity_ = 0;
+}
+inline float KinematicTrajectoryConstraints::angular_velocity() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.KinematicTrajectoryConstraints.angular_velocity)
+  return angular_velocity_;
+}
+inline void KinematicTrajectoryConstraints::set_angular_velocity(float value) {
+  
+  angular_velocity_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.KinematicTrajectoryConstraints.angular_velocity)
+}
+
+// -------------------------------------------------------------------
+
+// FirmwareBundleVersions
+
+// string main_bundle_version = 1;
+inline void FirmwareBundleVersions::clear_main_bundle_version() {
+  main_bundle_version_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& FirmwareBundleVersions::main_bundle_version() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.FirmwareBundleVersions.main_bundle_version)
+  return main_bundle_version_.GetNoArena();
+}
+inline void FirmwareBundleVersions::set_main_bundle_version(const ::std::string& value) {
+  
+  main_bundle_version_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.FirmwareBundleVersions.main_bundle_version)
+}
+#if LANG_CXX11
+inline void FirmwareBundleVersions::set_main_bundle_version(::std::string&& value) {
+  
+  main_bundle_version_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:Kinova.Api.Base.FirmwareBundleVersions.main_bundle_version)
+}
+#endif
+inline void FirmwareBundleVersions::set_main_bundle_version(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  main_bundle_version_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:Kinova.Api.Base.FirmwareBundleVersions.main_bundle_version)
+}
+inline void FirmwareBundleVersions::set_main_bundle_version(const char* value, size_t size) {
+  
+  main_bundle_version_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:Kinova.Api.Base.FirmwareBundleVersions.main_bundle_version)
+}
+inline ::std::string* FirmwareBundleVersions::mutable_main_bundle_version() {
+  
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.FirmwareBundleVersions.main_bundle_version)
+  return main_bundle_version_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* FirmwareBundleVersions::release_main_bundle_version() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.FirmwareBundleVersions.main_bundle_version)
+  
+  return main_bundle_version_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void FirmwareBundleVersions::set_allocated_main_bundle_version(::std::string* main_bundle_version) {
+  if (main_bundle_version != NULL) {
+    
+  } else {
+    
+  }
+  main_bundle_version_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), main_bundle_version);
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.FirmwareBundleVersions.main_bundle_version)
+}
+
+// repeated .Kinova.Api.Base.FirmwareComponentVersion components_versions = 2;
+inline int FirmwareBundleVersions::components_versions_size() const {
+  return components_versions_.size();
+}
+inline void FirmwareBundleVersions::clear_components_versions() {
+  components_versions_.Clear();
+}
+inline const ::Kinova::Api::Base::FirmwareComponentVersion& FirmwareBundleVersions::components_versions(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.FirmwareBundleVersions.components_versions)
+  return components_versions_.Get(index);
+}
+inline ::Kinova::Api::Base::FirmwareComponentVersion* FirmwareBundleVersions::mutable_components_versions(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.FirmwareBundleVersions.components_versions)
+  return components_versions_.Mutable(index);
+}
+inline ::Kinova::Api::Base::FirmwareComponentVersion* FirmwareBundleVersions::add_components_versions() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.Base.FirmwareBundleVersions.components_versions)
+  return components_versions_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::FirmwareComponentVersion >*
+FirmwareBundleVersions::mutable_components_versions() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.Base.FirmwareBundleVersions.components_versions)
+  return &components_versions_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Base::FirmwareComponentVersion >&
+FirmwareBundleVersions::components_versions() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.Base.FirmwareBundleVersions.components_versions)
+  return components_versions_;
+}
+
+// -------------------------------------------------------------------
+
+// FirmwareComponentVersion
+
+// string name = 1;
+inline void FirmwareComponentVersion::clear_name() {
+  name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& FirmwareComponentVersion::name() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.FirmwareComponentVersion.name)
+  return name_.GetNoArena();
+}
+inline void FirmwareComponentVersion::set_name(const ::std::string& value) {
+  
+  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.FirmwareComponentVersion.name)
+}
+#if LANG_CXX11
+inline void FirmwareComponentVersion::set_name(::std::string&& value) {
+  
+  name_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:Kinova.Api.Base.FirmwareComponentVersion.name)
+}
+#endif
+inline void FirmwareComponentVersion::set_name(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:Kinova.Api.Base.FirmwareComponentVersion.name)
+}
+inline void FirmwareComponentVersion::set_name(const char* value, size_t size) {
+  
+  name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:Kinova.Api.Base.FirmwareComponentVersion.name)
+}
+inline ::std::string* FirmwareComponentVersion::mutable_name() {
+  
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.FirmwareComponentVersion.name)
+  return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* FirmwareComponentVersion::release_name() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.FirmwareComponentVersion.name)
+  
+  return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void FirmwareComponentVersion::set_allocated_name(::std::string* name) {
+  if (name != NULL) {
+    
+  } else {
+    
+  }
+  name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name);
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.FirmwareComponentVersion.name)
+}
+
+// string version = 2;
+inline void FirmwareComponentVersion::clear_version() {
+  version_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& FirmwareComponentVersion::version() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.FirmwareComponentVersion.version)
+  return version_.GetNoArena();
+}
+inline void FirmwareComponentVersion::set_version(const ::std::string& value) {
+  
+  version_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.FirmwareComponentVersion.version)
+}
+#if LANG_CXX11
+inline void FirmwareComponentVersion::set_version(::std::string&& value) {
+  
+  version_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:Kinova.Api.Base.FirmwareComponentVersion.version)
+}
+#endif
+inline void FirmwareComponentVersion::set_version(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  version_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:Kinova.Api.Base.FirmwareComponentVersion.version)
+}
+inline void FirmwareComponentVersion::set_version(const char* value, size_t size) {
+  
+  version_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:Kinova.Api.Base.FirmwareComponentVersion.version)
+}
+inline ::std::string* FirmwareComponentVersion::mutable_version() {
+  
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.FirmwareComponentVersion.version)
+  return version_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* FirmwareComponentVersion::release_version() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.FirmwareComponentVersion.version)
+  
+  return version_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void FirmwareComponentVersion::set_allocated_version(::std::string* version) {
+  if (version != NULL) {
+    
+  } else {
+    
+  }
+  version_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), version);
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.FirmwareComponentVersion.version)
+}
+
+// uint32 device_id = 3;
+inline void FirmwareComponentVersion::clear_device_id() {
+  device_id_ = 0u;
+}
+inline ::google::protobuf::uint32 FirmwareComponentVersion::device_id() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.FirmwareComponentVersion.device_id)
+  return device_id_;
+}
+inline void FirmwareComponentVersion::set_device_id(::google::protobuf::uint32 value) {
+  
+  device_id_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Base.FirmwareComponentVersion.device_id)
+}
+
+// -------------------------------------------------------------------
+
+// IKData
+
+// .Kinova.Api.Base.Pose cartesian_pose = 1;
+inline bool IKData::has_cartesian_pose() const {
+  return this != internal_default_instance() && cartesian_pose_ != NULL;
+}
+inline void IKData::clear_cartesian_pose() {
+  if (GetArenaNoVirtual() == NULL && cartesian_pose_ != NULL) {
+    delete cartesian_pose_;
+  }
+  cartesian_pose_ = NULL;
+}
+inline const ::Kinova::Api::Base::Pose& IKData::cartesian_pose() const {
+  const ::Kinova::Api::Base::Pose* p = cartesian_pose_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.IKData.cartesian_pose)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::Pose*>(
+      &::Kinova::Api::Base::_Pose_default_instance_);
+}
+inline ::Kinova::Api::Base::Pose* IKData::release_cartesian_pose() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.IKData.cartesian_pose)
+  
+  ::Kinova::Api::Base::Pose* temp = cartesian_pose_;
+  cartesian_pose_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::Pose* IKData::mutable_cartesian_pose() {
+  
+  if (cartesian_pose_ == NULL) {
+    cartesian_pose_ = new ::Kinova::Api::Base::Pose;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.IKData.cartesian_pose)
+  return cartesian_pose_;
+}
+inline void IKData::set_allocated_cartesian_pose(::Kinova::Api::Base::Pose* cartesian_pose) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete cartesian_pose_;
+  }
+  if (cartesian_pose) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      cartesian_pose = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, cartesian_pose, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  cartesian_pose_ = cartesian_pose;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.IKData.cartesian_pose)
+}
+
+// .Kinova.Api.Base.JointAngles guess = 2;
+inline bool IKData::has_guess() const {
+  return this != internal_default_instance() && guess_ != NULL;
+}
+inline void IKData::clear_guess() {
+  if (GetArenaNoVirtual() == NULL && guess_ != NULL) {
+    delete guess_;
+  }
+  guess_ = NULL;
+}
+inline const ::Kinova::Api::Base::JointAngles& IKData::guess() const {
+  const ::Kinova::Api::Base::JointAngles* p = guess_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Base.IKData.guess)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Base::JointAngles*>(
+      &::Kinova::Api::Base::_JointAngles_default_instance_);
+}
+inline ::Kinova::Api::Base::JointAngles* IKData::release_guess() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Base.IKData.guess)
+  
+  ::Kinova::Api::Base::JointAngles* temp = guess_;
+  guess_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Base::JointAngles* IKData::mutable_guess() {
+  
+  if (guess_ == NULL) {
+    guess_ = new ::Kinova::Api::Base::JointAngles;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Base.IKData.guess)
+  return guess_;
+}
+inline void IKData::set_allocated_guess(::Kinova::Api::Base::JointAngles* guess) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete guess_;
+  }
+  if (guess) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      guess = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, guess, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  guess_ = guess;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Base.IKData.guess)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace Base
+}  // namespace Api
+}  // namespace Kinova
+
+namespace google {
+namespace protobuf {
+
+template <> struct is_proto_enum< ::Kinova::Api::Base::GpioPinPropertyFlags> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Base::GpioPinPropertyFlags>() {
+  return ::Kinova::Api::Base::GpioPinPropertyFlags_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::Base::ServiceVersion> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Base::ServiceVersion>() {
+  return ::Kinova::Api::Base::ServiceVersion_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::Base::ActionType> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Base::ActionType>() {
+  return ::Kinova::Api::Base::ActionType_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::Base::SnapshotType> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Base::SnapshotType>() {
+  return ::Kinova::Api::Base::SnapshotType_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::Base::NetworkType> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Base::NetworkType>() {
+  return ::Kinova::Api::Base::NetworkType_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::Base::WifiSecurityType> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Base::WifiSecurityType>() {
+  return ::Kinova::Api::Base::WifiSecurityType_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::Base::WifiEncryptionType> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Base::WifiEncryptionType>() {
+  return ::Kinova::Api::Base::WifiEncryptionType_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::Base::SignalQuality> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Base::SignalQuality>() {
+  return ::Kinova::Api::Base::SignalQuality_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::Base::ShapeType> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Base::ShapeType>() {
+  return ::Kinova::Api::Base::ShapeType_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::Base::LimitationType> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Base::LimitationType>() {
+  return ::Kinova::Api::Base::LimitationType_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::Base::ConfigurationNotificationEvent> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Base::ConfigurationNotificationEvent>() {
+  return ::Kinova::Api::Base::ConfigurationNotificationEvent_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::Base::OperatingMode> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Base::OperatingMode>() {
+  return ::Kinova::Api::Base::OperatingMode_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::Base::ServoingMode> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Base::ServoingMode>() {
+  return ::Kinova::Api::Base::ServoingMode_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::Base::EventIdSequenceInfoNotification> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Base::EventIdSequenceInfoNotification>() {
+  return ::Kinova::Api::Base::EventIdSequenceInfoNotification_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::Base::ProtectionZoneEvent> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Base::ProtectionZoneEvent>() {
+  return ::Kinova::Api::Base::ProtectionZoneEvent_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::Base::UserEvent> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Base::UserEvent>() {
+  return ::Kinova::Api::Base::UserEvent_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::Base::ControllerType> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Base::ControllerType>() {
+  return ::Kinova::Api::Base::ControllerType_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::Base::ControllerEventType> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Base::ControllerEventType>() {
+  return ::Kinova::Api::Base::ControllerEventType_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::Base::ControllerElementEventType> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Base::ControllerElementEventType>() {
+  return ::Kinova::Api::Base::ControllerElementEventType_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::Base::ActionEvent> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Base::ActionEvent>() {
+  return ::Kinova::Api::Base::ActionEvent_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::Base::RobotEvent> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Base::RobotEvent>() {
+  return ::Kinova::Api::Base::RobotEvent_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::Base::FactoryEvent> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Base::FactoryEvent>() {
+  return ::Kinova::Api::Base::FactoryEvent_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::Base::NetworkEvent> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Base::NetworkEvent>() {
+  return ::Kinova::Api::Base::NetworkEvent_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::Base::ControllerInputType> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Base::ControllerInputType>() {
+  return ::Kinova::Api::Base::ControllerInputType_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::Base::ControllerBehavior> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Base::ControllerBehavior>() {
+  return ::Kinova::Api::Base::ControllerBehavior_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::Base::SafetyIdentifier> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Base::SafetyIdentifier>() {
+  return ::Kinova::Api::Base::SafetyIdentifier_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::Base::JointTrajectoryConstraintType> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Base::JointTrajectoryConstraintType>() {
+  return ::Kinova::Api::Base::JointTrajectoryConstraintType_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::Base::WrenchMode> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Base::WrenchMode>() {
+  return ::Kinova::Api::Base::WrenchMode_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::Base::AdmittanceMode> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Base::AdmittanceMode>() {
+  return ::Kinova::Api::Base::AdmittanceMode_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::Base::GripperMode> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Base::GripperMode>() {
+  return ::Kinova::Api::Base::GripperMode_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::Base::GpioAction> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Base::GpioAction>() {
+  return ::Kinova::Api::Base::GpioAction_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::Base::NavigationDirection> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Base::NavigationDirection>() {
+  return ::Kinova::Api::Base::NavigationDirection_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::Base::JointNavigationDirection> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Base::JointNavigationDirection>() {
+  return ::Kinova::Api::Base::JointNavigationDirection_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::Base::GpioBehavior> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Base::GpioBehavior>() {
+  return ::Kinova::Api::Base::GpioBehavior_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::Base::Gen3GpioPinId> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Base::Gen3GpioPinId>() {
+  return ::Kinova::Api::Base::Gen3GpioPinId_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::Base::Xbox360DigitalInputIdentifier> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Base::Xbox360DigitalInputIdentifier>() {
+  return ::Kinova::Api::Base::Xbox360DigitalInputIdentifier_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::Base::Xbox360AnalogInputIdentifier> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Base::Xbox360AnalogInputIdentifier>() {
+  return ::Kinova::Api::Base::Xbox360AnalogInputIdentifier_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::Base::WristDigitalInputIdentifier> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Base::WristDigitalInputIdentifier>() {
+  return ::Kinova::Api::Base::WristDigitalInputIdentifier_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::Base::CapSenseMode> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Base::CapSenseMode>() {
+  return ::Kinova::Api::Base::CapSenseMode_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::Base::BridgeStatus> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Base::BridgeStatus>() {
+  return ::Kinova::Api::Base::BridgeStatus_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::Base::BridgeType> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Base::BridgeType>() {
+  return ::Kinova::Api::Base::BridgeType_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::Base::TrajectoryContinuityMode> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Base::TrajectoryContinuityMode>() {
+  return ::Kinova::Api::Base::TrajectoryContinuityMode_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::Base::TrajectoryErrorType> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Base::TrajectoryErrorType>() {
+  return ::Kinova::Api::Base::TrajectoryErrorType_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::Base::TrajectoryInfoType> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Base::TrajectoryInfoType>() {
+  return ::Kinova::Api::Base::TrajectoryInfoType_descriptor();
+}
+
+}  // namespace protobuf
+}  // namespace google
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_Base_2eproto__INCLUDED
diff --git a/kortex_api/include/messages/BaseCyclic.pb.h b/kortex_api/include/messages/BaseCyclic.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..cc7631fb290ff386482569eff1cd113302454e06
--- /dev/null
+++ b/kortex_api/include/messages/BaseCyclic.pb.h
@@ -0,0 +1,3038 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: BaseCyclic.proto
+
+#ifndef PROTOBUF_BaseCyclic_2eproto__INCLUDED
+#define PROTOBUF_BaseCyclic_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 3005000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 3005001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "Common.pb.h"  // IWYU pragma: export
+#include "InterconnectCyclicMessage.pb.h"  // IWYU pragma: export
+// @@protoc_insertion_point(includes)
+
+namespace protobuf_BaseCyclic_2eproto {
+// Internal implementation detail -- do not use these members.
+struct TableStruct {
+  static const ::google::protobuf::internal::ParseTableField entries[];
+  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
+  static const ::google::protobuf::internal::ParseTable schema[7];
+  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
+  static const ::google::protobuf::internal::SerializationTable serialization_table[];
+  static const ::google::protobuf::uint32 offsets[];
+};
+void AddDescriptors();
+void InitDefaultsActuatorCommandImpl();
+void InitDefaultsActuatorCommand();
+void InitDefaultsActuatorFeedbackImpl();
+void InitDefaultsActuatorFeedback();
+void InitDefaultsActuatorCustomDataImpl();
+void InitDefaultsActuatorCustomData();
+void InitDefaultsBaseFeedbackImpl();
+void InitDefaultsBaseFeedback();
+void InitDefaultsCustomDataImpl();
+void InitDefaultsCustomData();
+void InitDefaultsCommandImpl();
+void InitDefaultsCommand();
+void InitDefaultsFeedbackImpl();
+void InitDefaultsFeedback();
+inline void InitDefaults() {
+  InitDefaultsActuatorCommand();
+  InitDefaultsActuatorFeedback();
+  InitDefaultsActuatorCustomData();
+  InitDefaultsBaseFeedback();
+  InitDefaultsCustomData();
+  InitDefaultsCommand();
+  InitDefaultsFeedback();
+}
+}  // namespace protobuf_BaseCyclic_2eproto
+namespace Kinova {
+namespace Api {
+namespace BaseCyclic {
+class ActuatorCommand;
+class ActuatorCommandDefaultTypeInternal;
+extern ActuatorCommandDefaultTypeInternal _ActuatorCommand_default_instance_;
+class ActuatorCustomData;
+class ActuatorCustomDataDefaultTypeInternal;
+extern ActuatorCustomDataDefaultTypeInternal _ActuatorCustomData_default_instance_;
+class ActuatorFeedback;
+class ActuatorFeedbackDefaultTypeInternal;
+extern ActuatorFeedbackDefaultTypeInternal _ActuatorFeedback_default_instance_;
+class BaseFeedback;
+class BaseFeedbackDefaultTypeInternal;
+extern BaseFeedbackDefaultTypeInternal _BaseFeedback_default_instance_;
+class Command;
+class CommandDefaultTypeInternal;
+extern CommandDefaultTypeInternal _Command_default_instance_;
+class CustomData;
+class CustomDataDefaultTypeInternal;
+extern CustomDataDefaultTypeInternal _CustomData_default_instance_;
+class Feedback;
+class FeedbackDefaultTypeInternal;
+extern FeedbackDefaultTypeInternal _Feedback_default_instance_;
+}  // namespace BaseCyclic
+}  // namespace Api
+}  // namespace Kinova
+namespace Kinova {
+namespace Api {
+namespace BaseCyclic {
+
+enum ServiceVersion {
+  RESERVED_0 = 0,
+  CURRENT_VERSION = 1,
+  ServiceVersion_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  ServiceVersion_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool ServiceVersion_IsValid(int value);
+const ServiceVersion ServiceVersion_MIN = RESERVED_0;
+const ServiceVersion ServiceVersion_MAX = CURRENT_VERSION;
+const int ServiceVersion_ARRAYSIZE = ServiceVersion_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* ServiceVersion_descriptor();
+inline const ::std::string& ServiceVersion_Name(ServiceVersion value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    ServiceVersion_descriptor(), value);
+}
+inline bool ServiceVersion_Parse(
+    const ::std::string& name, ServiceVersion* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<ServiceVersion>(
+    ServiceVersion_descriptor(), name, value);
+}
+// ===================================================================
+
+class ActuatorCommand : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.BaseCyclic.ActuatorCommand) */ {
+ public:
+  ActuatorCommand();
+  virtual ~ActuatorCommand();
+
+  ActuatorCommand(const ActuatorCommand& from);
+
+  inline ActuatorCommand& operator=(const ActuatorCommand& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ActuatorCommand(ActuatorCommand&& from) noexcept
+    : ActuatorCommand() {
+    *this = ::std::move(from);
+  }
+
+  inline ActuatorCommand& operator=(ActuatorCommand&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ActuatorCommand& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ActuatorCommand* internal_default_instance() {
+    return reinterpret_cast<const ActuatorCommand*>(
+               &_ActuatorCommand_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    0;
+
+  void Swap(ActuatorCommand* other);
+  friend void swap(ActuatorCommand& a, ActuatorCommand& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ActuatorCommand* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ActuatorCommand* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ActuatorCommand& from);
+  void MergeFrom(const ActuatorCommand& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ActuatorCommand* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // fixed32 command_id = 1;
+  void clear_command_id();
+  static const int kCommandIdFieldNumber = 1;
+  ::google::protobuf::uint32 command_id() const;
+  void set_command_id(::google::protobuf::uint32 value);
+
+  // fixed32 flags = 2;
+  void clear_flags();
+  static const int kFlagsFieldNumber = 2;
+  ::google::protobuf::uint32 flags() const;
+  void set_flags(::google::protobuf::uint32 value);
+
+  // float position = 3;
+  void clear_position();
+  static const int kPositionFieldNumber = 3;
+  float position() const;
+  void set_position(float value);
+
+  // float velocity = 4;
+  void clear_velocity();
+  static const int kVelocityFieldNumber = 4;
+  float velocity() const;
+  void set_velocity(float value);
+
+  // float torque_joint = 5;
+  void clear_torque_joint();
+  static const int kTorqueJointFieldNumber = 5;
+  float torque_joint() const;
+  void set_torque_joint(float value);
+
+  // float current_motor = 6;
+  void clear_current_motor();
+  static const int kCurrentMotorFieldNumber = 6;
+  float current_motor() const;
+  void set_current_motor(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.BaseCyclic.ActuatorCommand)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 command_id_;
+  ::google::protobuf::uint32 flags_;
+  float position_;
+  float velocity_;
+  float torque_joint_;
+  float current_motor_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_BaseCyclic_2eproto::TableStruct;
+  friend void ::protobuf_BaseCyclic_2eproto::InitDefaultsActuatorCommandImpl();
+};
+// -------------------------------------------------------------------
+
+class ActuatorFeedback : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.BaseCyclic.ActuatorFeedback) */ {
+ public:
+  ActuatorFeedback();
+  virtual ~ActuatorFeedback();
+
+  ActuatorFeedback(const ActuatorFeedback& from);
+
+  inline ActuatorFeedback& operator=(const ActuatorFeedback& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ActuatorFeedback(ActuatorFeedback&& from) noexcept
+    : ActuatorFeedback() {
+    *this = ::std::move(from);
+  }
+
+  inline ActuatorFeedback& operator=(ActuatorFeedback&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ActuatorFeedback& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ActuatorFeedback* internal_default_instance() {
+    return reinterpret_cast<const ActuatorFeedback*>(
+               &_ActuatorFeedback_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    1;
+
+  void Swap(ActuatorFeedback* other);
+  friend void swap(ActuatorFeedback& a, ActuatorFeedback& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ActuatorFeedback* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ActuatorFeedback* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ActuatorFeedback& from);
+  void MergeFrom(const ActuatorFeedback& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ActuatorFeedback* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // fixed32 command_id = 1;
+  void clear_command_id();
+  static const int kCommandIdFieldNumber = 1;
+  ::google::protobuf::uint32 command_id() const;
+  void set_command_id(::google::protobuf::uint32 value);
+
+  // fixed32 status_flags = 2;
+  void clear_status_flags();
+  static const int kStatusFlagsFieldNumber = 2;
+  ::google::protobuf::uint32 status_flags() const;
+  void set_status_flags(::google::protobuf::uint32 value);
+
+  // fixed32 jitter_comm = 3;
+  void clear_jitter_comm();
+  static const int kJitterCommFieldNumber = 3;
+  ::google::protobuf::uint32 jitter_comm() const;
+  void set_jitter_comm(::google::protobuf::uint32 value);
+
+  // float position = 4;
+  void clear_position();
+  static const int kPositionFieldNumber = 4;
+  float position() const;
+  void set_position(float value);
+
+  // float velocity = 5;
+  void clear_velocity();
+  static const int kVelocityFieldNumber = 5;
+  float velocity() const;
+  void set_velocity(float value);
+
+  // float torque = 6;
+  void clear_torque();
+  static const int kTorqueFieldNumber = 6;
+  float torque() const;
+  void set_torque(float value);
+
+  // float current_motor = 7;
+  void clear_current_motor();
+  static const int kCurrentMotorFieldNumber = 7;
+  float current_motor() const;
+  void set_current_motor(float value);
+
+  // float voltage = 8;
+  void clear_voltage();
+  static const int kVoltageFieldNumber = 8;
+  float voltage() const;
+  void set_voltage(float value);
+
+  // float temperature_motor = 9;
+  void clear_temperature_motor();
+  static const int kTemperatureMotorFieldNumber = 9;
+  float temperature_motor() const;
+  void set_temperature_motor(float value);
+
+  // float temperature_core = 10;
+  void clear_temperature_core();
+  static const int kTemperatureCoreFieldNumber = 10;
+  float temperature_core() const;
+  void set_temperature_core(float value);
+
+  // fixed32 fault_bank_a = 11;
+  void clear_fault_bank_a();
+  static const int kFaultBankAFieldNumber = 11;
+  ::google::protobuf::uint32 fault_bank_a() const;
+  void set_fault_bank_a(::google::protobuf::uint32 value);
+
+  // fixed32 fault_bank_b = 12;
+  void clear_fault_bank_b();
+  static const int kFaultBankBFieldNumber = 12;
+  ::google::protobuf::uint32 fault_bank_b() const;
+  void set_fault_bank_b(::google::protobuf::uint32 value);
+
+  // fixed32 warning_bank_a = 13;
+  void clear_warning_bank_a();
+  static const int kWarningBankAFieldNumber = 13;
+  ::google::protobuf::uint32 warning_bank_a() const;
+  void set_warning_bank_a(::google::protobuf::uint32 value);
+
+  // fixed32 warning_bank_b = 14;
+  void clear_warning_bank_b();
+  static const int kWarningBankBFieldNumber = 14;
+  ::google::protobuf::uint32 warning_bank_b() const;
+  void set_warning_bank_b(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.BaseCyclic.ActuatorFeedback)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 command_id_;
+  ::google::protobuf::uint32 status_flags_;
+  ::google::protobuf::uint32 jitter_comm_;
+  float position_;
+  float velocity_;
+  float torque_;
+  float current_motor_;
+  float voltage_;
+  float temperature_motor_;
+  float temperature_core_;
+  ::google::protobuf::uint32 fault_bank_a_;
+  ::google::protobuf::uint32 fault_bank_b_;
+  ::google::protobuf::uint32 warning_bank_a_;
+  ::google::protobuf::uint32 warning_bank_b_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_BaseCyclic_2eproto::TableStruct;
+  friend void ::protobuf_BaseCyclic_2eproto::InitDefaultsActuatorFeedbackImpl();
+};
+// -------------------------------------------------------------------
+
+class ActuatorCustomData : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.BaseCyclic.ActuatorCustomData) */ {
+ public:
+  ActuatorCustomData();
+  virtual ~ActuatorCustomData();
+
+  ActuatorCustomData(const ActuatorCustomData& from);
+
+  inline ActuatorCustomData& operator=(const ActuatorCustomData& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ActuatorCustomData(ActuatorCustomData&& from) noexcept
+    : ActuatorCustomData() {
+    *this = ::std::move(from);
+  }
+
+  inline ActuatorCustomData& operator=(ActuatorCustomData&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ActuatorCustomData& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ActuatorCustomData* internal_default_instance() {
+    return reinterpret_cast<const ActuatorCustomData*>(
+               &_ActuatorCustomData_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    2;
+
+  void Swap(ActuatorCustomData* other);
+  friend void swap(ActuatorCustomData& a, ActuatorCustomData& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ActuatorCustomData* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ActuatorCustomData* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ActuatorCustomData& from);
+  void MergeFrom(const ActuatorCustomData& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ActuatorCustomData* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // fixed32 command_id = 1;
+  void clear_command_id();
+  static const int kCommandIdFieldNumber = 1;
+  ::google::protobuf::uint32 command_id() const;
+  void set_command_id(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_0 = 2;
+  void clear_custom_data_0();
+  static const int kCustomData0FieldNumber = 2;
+  ::google::protobuf::uint32 custom_data_0() const;
+  void set_custom_data_0(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_1 = 3;
+  void clear_custom_data_1();
+  static const int kCustomData1FieldNumber = 3;
+  ::google::protobuf::uint32 custom_data_1() const;
+  void set_custom_data_1(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_2 = 4;
+  void clear_custom_data_2();
+  static const int kCustomData2FieldNumber = 4;
+  ::google::protobuf::uint32 custom_data_2() const;
+  void set_custom_data_2(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_3 = 5;
+  void clear_custom_data_3();
+  static const int kCustomData3FieldNumber = 5;
+  ::google::protobuf::uint32 custom_data_3() const;
+  void set_custom_data_3(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_4 = 6;
+  void clear_custom_data_4();
+  static const int kCustomData4FieldNumber = 6;
+  ::google::protobuf::uint32 custom_data_4() const;
+  void set_custom_data_4(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_5 = 7;
+  void clear_custom_data_5();
+  static const int kCustomData5FieldNumber = 7;
+  ::google::protobuf::uint32 custom_data_5() const;
+  void set_custom_data_5(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_6 = 8;
+  void clear_custom_data_6();
+  static const int kCustomData6FieldNumber = 8;
+  ::google::protobuf::uint32 custom_data_6() const;
+  void set_custom_data_6(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_7 = 9;
+  void clear_custom_data_7();
+  static const int kCustomData7FieldNumber = 9;
+  ::google::protobuf::uint32 custom_data_7() const;
+  void set_custom_data_7(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_8 = 10;
+  void clear_custom_data_8();
+  static const int kCustomData8FieldNumber = 10;
+  ::google::protobuf::uint32 custom_data_8() const;
+  void set_custom_data_8(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_9 = 11;
+  void clear_custom_data_9();
+  static const int kCustomData9FieldNumber = 11;
+  ::google::protobuf::uint32 custom_data_9() const;
+  void set_custom_data_9(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_10 = 12;
+  void clear_custom_data_10();
+  static const int kCustomData10FieldNumber = 12;
+  ::google::protobuf::uint32 custom_data_10() const;
+  void set_custom_data_10(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_11 = 13;
+  void clear_custom_data_11();
+  static const int kCustomData11FieldNumber = 13;
+  ::google::protobuf::uint32 custom_data_11() const;
+  void set_custom_data_11(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_12 = 14;
+  void clear_custom_data_12();
+  static const int kCustomData12FieldNumber = 14;
+  ::google::protobuf::uint32 custom_data_12() const;
+  void set_custom_data_12(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_13 = 15;
+  void clear_custom_data_13();
+  static const int kCustomData13FieldNumber = 15;
+  ::google::protobuf::uint32 custom_data_13() const;
+  void set_custom_data_13(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_14 = 16;
+  void clear_custom_data_14();
+  static const int kCustomData14FieldNumber = 16;
+  ::google::protobuf::uint32 custom_data_14() const;
+  void set_custom_data_14(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_15 = 17;
+  void clear_custom_data_15();
+  static const int kCustomData15FieldNumber = 17;
+  ::google::protobuf::uint32 custom_data_15() const;
+  void set_custom_data_15(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.BaseCyclic.ActuatorCustomData)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 command_id_;
+  ::google::protobuf::uint32 custom_data_0_;
+  ::google::protobuf::uint32 custom_data_1_;
+  ::google::protobuf::uint32 custom_data_2_;
+  ::google::protobuf::uint32 custom_data_3_;
+  ::google::protobuf::uint32 custom_data_4_;
+  ::google::protobuf::uint32 custom_data_5_;
+  ::google::protobuf::uint32 custom_data_6_;
+  ::google::protobuf::uint32 custom_data_7_;
+  ::google::protobuf::uint32 custom_data_8_;
+  ::google::protobuf::uint32 custom_data_9_;
+  ::google::protobuf::uint32 custom_data_10_;
+  ::google::protobuf::uint32 custom_data_11_;
+  ::google::protobuf::uint32 custom_data_12_;
+  ::google::protobuf::uint32 custom_data_13_;
+  ::google::protobuf::uint32 custom_data_14_;
+  ::google::protobuf::uint32 custom_data_15_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_BaseCyclic_2eproto::TableStruct;
+  friend void ::protobuf_BaseCyclic_2eproto::InitDefaultsActuatorCustomDataImpl();
+};
+// -------------------------------------------------------------------
+
+class BaseFeedback : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.BaseCyclic.BaseFeedback) */ {
+ public:
+  BaseFeedback();
+  virtual ~BaseFeedback();
+
+  BaseFeedback(const BaseFeedback& from);
+
+  inline BaseFeedback& operator=(const BaseFeedback& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  BaseFeedback(BaseFeedback&& from) noexcept
+    : BaseFeedback() {
+    *this = ::std::move(from);
+  }
+
+  inline BaseFeedback& operator=(BaseFeedback&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const BaseFeedback& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const BaseFeedback* internal_default_instance() {
+    return reinterpret_cast<const BaseFeedback*>(
+               &_BaseFeedback_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    3;
+
+  void Swap(BaseFeedback* other);
+  friend void swap(BaseFeedback& a, BaseFeedback& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline BaseFeedback* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  BaseFeedback* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const BaseFeedback& from);
+  void MergeFrom(const BaseFeedback& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(BaseFeedback* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // uint32 active_state_connection_identifier = 1;
+  void clear_active_state_connection_identifier();
+  static const int kActiveStateConnectionIdentifierFieldNumber = 1;
+  ::google::protobuf::uint32 active_state_connection_identifier() const;
+  void set_active_state_connection_identifier(::google::protobuf::uint32 value);
+
+  // .Kinova.Api.Common.ArmState active_state = 2;
+  void clear_active_state();
+  static const int kActiveStateFieldNumber = 2;
+  ::Kinova::Api::Common::ArmState active_state() const;
+  void set_active_state(::Kinova::Api::Common::ArmState value);
+
+  // float arm_voltage = 3;
+  void clear_arm_voltage();
+  static const int kArmVoltageFieldNumber = 3;
+  float arm_voltage() const;
+  void set_arm_voltage(float value);
+
+  // float arm_current = 4;
+  void clear_arm_current();
+  static const int kArmCurrentFieldNumber = 4;
+  float arm_current() const;
+  void set_arm_current(float value);
+
+  // float temperature_cpu = 5;
+  void clear_temperature_cpu();
+  static const int kTemperatureCpuFieldNumber = 5;
+  float temperature_cpu() const;
+  void set_temperature_cpu(float value);
+
+  // float temperature_ambient = 6;
+  void clear_temperature_ambient();
+  static const int kTemperatureAmbientFieldNumber = 6;
+  float temperature_ambient() const;
+  void set_temperature_ambient(float value);
+
+  // float imu_acceleration_x = 7;
+  void clear_imu_acceleration_x();
+  static const int kImuAccelerationXFieldNumber = 7;
+  float imu_acceleration_x() const;
+  void set_imu_acceleration_x(float value);
+
+  // float imu_acceleration_y = 8;
+  void clear_imu_acceleration_y();
+  static const int kImuAccelerationYFieldNumber = 8;
+  float imu_acceleration_y() const;
+  void set_imu_acceleration_y(float value);
+
+  // float imu_acceleration_z = 9;
+  void clear_imu_acceleration_z();
+  static const int kImuAccelerationZFieldNumber = 9;
+  float imu_acceleration_z() const;
+  void set_imu_acceleration_z(float value);
+
+  // float imu_angular_velocity_x = 10;
+  void clear_imu_angular_velocity_x();
+  static const int kImuAngularVelocityXFieldNumber = 10;
+  float imu_angular_velocity_x() const;
+  void set_imu_angular_velocity_x(float value);
+
+  // float imu_angular_velocity_y = 11;
+  void clear_imu_angular_velocity_y();
+  static const int kImuAngularVelocityYFieldNumber = 11;
+  float imu_angular_velocity_y() const;
+  void set_imu_angular_velocity_y(float value);
+
+  // float imu_angular_velocity_z = 12;
+  void clear_imu_angular_velocity_z();
+  static const int kImuAngularVelocityZFieldNumber = 12;
+  float imu_angular_velocity_z() const;
+  void set_imu_angular_velocity_z(float value);
+
+  // float tool_pose_x = 13;
+  void clear_tool_pose_x();
+  static const int kToolPoseXFieldNumber = 13;
+  float tool_pose_x() const;
+  void set_tool_pose_x(float value);
+
+  // float tool_pose_y = 14;
+  void clear_tool_pose_y();
+  static const int kToolPoseYFieldNumber = 14;
+  float tool_pose_y() const;
+  void set_tool_pose_y(float value);
+
+  // float tool_pose_z = 15;
+  void clear_tool_pose_z();
+  static const int kToolPoseZFieldNumber = 15;
+  float tool_pose_z() const;
+  void set_tool_pose_z(float value);
+
+  // float tool_pose_theta_x = 16;
+  void clear_tool_pose_theta_x();
+  static const int kToolPoseThetaXFieldNumber = 16;
+  float tool_pose_theta_x() const;
+  void set_tool_pose_theta_x(float value);
+
+  // float tool_pose_theta_y = 17;
+  void clear_tool_pose_theta_y();
+  static const int kToolPoseThetaYFieldNumber = 17;
+  float tool_pose_theta_y() const;
+  void set_tool_pose_theta_y(float value);
+
+  // float tool_pose_theta_z = 18;
+  void clear_tool_pose_theta_z();
+  static const int kToolPoseThetaZFieldNumber = 18;
+  float tool_pose_theta_z() const;
+  void set_tool_pose_theta_z(float value);
+
+  // float tool_twist_linear_x = 19;
+  void clear_tool_twist_linear_x();
+  static const int kToolTwistLinearXFieldNumber = 19;
+  float tool_twist_linear_x() const;
+  void set_tool_twist_linear_x(float value);
+
+  // float tool_twist_linear_y = 20;
+  void clear_tool_twist_linear_y();
+  static const int kToolTwistLinearYFieldNumber = 20;
+  float tool_twist_linear_y() const;
+  void set_tool_twist_linear_y(float value);
+
+  // float tool_twist_linear_z = 21;
+  void clear_tool_twist_linear_z();
+  static const int kToolTwistLinearZFieldNumber = 21;
+  float tool_twist_linear_z() const;
+  void set_tool_twist_linear_z(float value);
+
+  // float tool_twist_angular_x = 22;
+  void clear_tool_twist_angular_x();
+  static const int kToolTwistAngularXFieldNumber = 22;
+  float tool_twist_angular_x() const;
+  void set_tool_twist_angular_x(float value);
+
+  // float tool_twist_angular_y = 23;
+  void clear_tool_twist_angular_y();
+  static const int kToolTwistAngularYFieldNumber = 23;
+  float tool_twist_angular_y() const;
+  void set_tool_twist_angular_y(float value);
+
+  // float tool_twist_angular_z = 24;
+  void clear_tool_twist_angular_z();
+  static const int kToolTwistAngularZFieldNumber = 24;
+  float tool_twist_angular_z() const;
+  void set_tool_twist_angular_z(float value);
+
+  // float tool_external_wrench_force_x = 25;
+  void clear_tool_external_wrench_force_x();
+  static const int kToolExternalWrenchForceXFieldNumber = 25;
+  float tool_external_wrench_force_x() const;
+  void set_tool_external_wrench_force_x(float value);
+
+  // float tool_external_wrench_force_y = 26;
+  void clear_tool_external_wrench_force_y();
+  static const int kToolExternalWrenchForceYFieldNumber = 26;
+  float tool_external_wrench_force_y() const;
+  void set_tool_external_wrench_force_y(float value);
+
+  // float tool_external_wrench_force_z = 27;
+  void clear_tool_external_wrench_force_z();
+  static const int kToolExternalWrenchForceZFieldNumber = 27;
+  float tool_external_wrench_force_z() const;
+  void set_tool_external_wrench_force_z(float value);
+
+  // float tool_external_wrench_torque_x = 28;
+  void clear_tool_external_wrench_torque_x();
+  static const int kToolExternalWrenchTorqueXFieldNumber = 28;
+  float tool_external_wrench_torque_x() const;
+  void set_tool_external_wrench_torque_x(float value);
+
+  // float tool_external_wrench_torque_y = 29;
+  void clear_tool_external_wrench_torque_y();
+  static const int kToolExternalWrenchTorqueYFieldNumber = 29;
+  float tool_external_wrench_torque_y() const;
+  void set_tool_external_wrench_torque_y(float value);
+
+  // float tool_external_wrench_torque_z = 30;
+  void clear_tool_external_wrench_torque_z();
+  static const int kToolExternalWrenchTorqueZFieldNumber = 30;
+  float tool_external_wrench_torque_z() const;
+  void set_tool_external_wrench_torque_z(float value);
+
+  // fixed32 fault_bank_a = 31;
+  void clear_fault_bank_a();
+  static const int kFaultBankAFieldNumber = 31;
+  ::google::protobuf::uint32 fault_bank_a() const;
+  void set_fault_bank_a(::google::protobuf::uint32 value);
+
+  // fixed32 fault_bank_b = 32;
+  void clear_fault_bank_b();
+  static const int kFaultBankBFieldNumber = 32;
+  ::google::protobuf::uint32 fault_bank_b() const;
+  void set_fault_bank_b(::google::protobuf::uint32 value);
+
+  // fixed32 warning_bank_a = 33;
+  void clear_warning_bank_a();
+  static const int kWarningBankAFieldNumber = 33;
+  ::google::protobuf::uint32 warning_bank_a() const;
+  void set_warning_bank_a(::google::protobuf::uint32 value);
+
+  // fixed32 warning_bank_b = 34;
+  void clear_warning_bank_b();
+  static const int kWarningBankBFieldNumber = 34;
+  ::google::protobuf::uint32 warning_bank_b() const;
+  void set_warning_bank_b(::google::protobuf::uint32 value);
+
+  // float commanded_tool_pose_x = 35;
+  void clear_commanded_tool_pose_x();
+  static const int kCommandedToolPoseXFieldNumber = 35;
+  float commanded_tool_pose_x() const;
+  void set_commanded_tool_pose_x(float value);
+
+  // float commanded_tool_pose_y = 36;
+  void clear_commanded_tool_pose_y();
+  static const int kCommandedToolPoseYFieldNumber = 36;
+  float commanded_tool_pose_y() const;
+  void set_commanded_tool_pose_y(float value);
+
+  // float commanded_tool_pose_z = 37;
+  void clear_commanded_tool_pose_z();
+  static const int kCommandedToolPoseZFieldNumber = 37;
+  float commanded_tool_pose_z() const;
+  void set_commanded_tool_pose_z(float value);
+
+  // float commanded_tool_pose_theta_x = 38;
+  void clear_commanded_tool_pose_theta_x();
+  static const int kCommandedToolPoseThetaXFieldNumber = 38;
+  float commanded_tool_pose_theta_x() const;
+  void set_commanded_tool_pose_theta_x(float value);
+
+  // float commanded_tool_pose_theta_y = 39;
+  void clear_commanded_tool_pose_theta_y();
+  static const int kCommandedToolPoseThetaYFieldNumber = 39;
+  float commanded_tool_pose_theta_y() const;
+  void set_commanded_tool_pose_theta_y(float value);
+
+  // float commanded_tool_pose_theta_z = 40;
+  void clear_commanded_tool_pose_theta_z();
+  static const int kCommandedToolPoseThetaZFieldNumber = 40;
+  float commanded_tool_pose_theta_z() const;
+  void set_commanded_tool_pose_theta_z(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.BaseCyclic.BaseFeedback)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 active_state_connection_identifier_;
+  int active_state_;
+  float arm_voltage_;
+  float arm_current_;
+  float temperature_cpu_;
+  float temperature_ambient_;
+  float imu_acceleration_x_;
+  float imu_acceleration_y_;
+  float imu_acceleration_z_;
+  float imu_angular_velocity_x_;
+  float imu_angular_velocity_y_;
+  float imu_angular_velocity_z_;
+  float tool_pose_x_;
+  float tool_pose_y_;
+  float tool_pose_z_;
+  float tool_pose_theta_x_;
+  float tool_pose_theta_y_;
+  float tool_pose_theta_z_;
+  float tool_twist_linear_x_;
+  float tool_twist_linear_y_;
+  float tool_twist_linear_z_;
+  float tool_twist_angular_x_;
+  float tool_twist_angular_y_;
+  float tool_twist_angular_z_;
+  float tool_external_wrench_force_x_;
+  float tool_external_wrench_force_y_;
+  float tool_external_wrench_force_z_;
+  float tool_external_wrench_torque_x_;
+  float tool_external_wrench_torque_y_;
+  float tool_external_wrench_torque_z_;
+  ::google::protobuf::uint32 fault_bank_a_;
+  ::google::protobuf::uint32 fault_bank_b_;
+  ::google::protobuf::uint32 warning_bank_a_;
+  ::google::protobuf::uint32 warning_bank_b_;
+  float commanded_tool_pose_x_;
+  float commanded_tool_pose_y_;
+  float commanded_tool_pose_z_;
+  float commanded_tool_pose_theta_x_;
+  float commanded_tool_pose_theta_y_;
+  float commanded_tool_pose_theta_z_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_BaseCyclic_2eproto::TableStruct;
+  friend void ::protobuf_BaseCyclic_2eproto::InitDefaultsBaseFeedbackImpl();
+};
+// -------------------------------------------------------------------
+
+class CustomData : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.BaseCyclic.CustomData) */ {
+ public:
+  CustomData();
+  virtual ~CustomData();
+
+  CustomData(const CustomData& from);
+
+  inline CustomData& operator=(const CustomData& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  CustomData(CustomData&& from) noexcept
+    : CustomData() {
+    *this = ::std::move(from);
+  }
+
+  inline CustomData& operator=(CustomData&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const CustomData& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const CustomData* internal_default_instance() {
+    return reinterpret_cast<const CustomData*>(
+               &_CustomData_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    4;
+
+  void Swap(CustomData* other);
+  friend void swap(CustomData& a, CustomData& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline CustomData* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  CustomData* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const CustomData& from);
+  void MergeFrom(const CustomData& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(CustomData* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .Kinova.Api.BaseCyclic.ActuatorCustomData actuators_custom_data = 10;
+  int actuators_custom_data_size() const;
+  void clear_actuators_custom_data();
+  static const int kActuatorsCustomDataFieldNumber = 10;
+  const ::Kinova::Api::BaseCyclic::ActuatorCustomData& actuators_custom_data(int index) const;
+  ::Kinova::Api::BaseCyclic::ActuatorCustomData* mutable_actuators_custom_data(int index);
+  ::Kinova::Api::BaseCyclic::ActuatorCustomData* add_actuators_custom_data();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::BaseCyclic::ActuatorCustomData >*
+      mutable_actuators_custom_data();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::BaseCyclic::ActuatorCustomData >&
+      actuators_custom_data() const;
+
+  // .Kinova.Api.InterconnectCyclic.CustomData interconnect_custom_data = 11;
+  bool has_interconnect_custom_data() const;
+  void clear_interconnect_custom_data();
+  static const int kInterconnectCustomDataFieldNumber = 11;
+  const ::Kinova::Api::InterconnectCyclic::CustomData& interconnect_custom_data() const;
+  ::Kinova::Api::InterconnectCyclic::CustomData* release_interconnect_custom_data();
+  ::Kinova::Api::InterconnectCyclic::CustomData* mutable_interconnect_custom_data();
+  void set_allocated_interconnect_custom_data(::Kinova::Api::InterconnectCyclic::CustomData* interconnect_custom_data);
+
+  // fixed32 frame_id = 1;
+  void clear_frame_id();
+  static const int kFrameIdFieldNumber = 1;
+  ::google::protobuf::uint32 frame_id() const;
+  void set_frame_id(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_0 = 2;
+  void clear_custom_data_0();
+  static const int kCustomData0FieldNumber = 2;
+  ::google::protobuf::uint32 custom_data_0() const;
+  void set_custom_data_0(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_1 = 3;
+  void clear_custom_data_1();
+  static const int kCustomData1FieldNumber = 3;
+  ::google::protobuf::uint32 custom_data_1() const;
+  void set_custom_data_1(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_2 = 4;
+  void clear_custom_data_2();
+  static const int kCustomData2FieldNumber = 4;
+  ::google::protobuf::uint32 custom_data_2() const;
+  void set_custom_data_2(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_3 = 5;
+  void clear_custom_data_3();
+  static const int kCustomData3FieldNumber = 5;
+  ::google::protobuf::uint32 custom_data_3() const;
+  void set_custom_data_3(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_4 = 6;
+  void clear_custom_data_4();
+  static const int kCustomData4FieldNumber = 6;
+  ::google::protobuf::uint32 custom_data_4() const;
+  void set_custom_data_4(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_5 = 7;
+  void clear_custom_data_5();
+  static const int kCustomData5FieldNumber = 7;
+  ::google::protobuf::uint32 custom_data_5() const;
+  void set_custom_data_5(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_6 = 8;
+  void clear_custom_data_6();
+  static const int kCustomData6FieldNumber = 8;
+  ::google::protobuf::uint32 custom_data_6() const;
+  void set_custom_data_6(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_7 = 9;
+  void clear_custom_data_7();
+  static const int kCustomData7FieldNumber = 9;
+  ::google::protobuf::uint32 custom_data_7() const;
+  void set_custom_data_7(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.BaseCyclic.CustomData)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::BaseCyclic::ActuatorCustomData > actuators_custom_data_;
+  ::Kinova::Api::InterconnectCyclic::CustomData* interconnect_custom_data_;
+  ::google::protobuf::uint32 frame_id_;
+  ::google::protobuf::uint32 custom_data_0_;
+  ::google::protobuf::uint32 custom_data_1_;
+  ::google::protobuf::uint32 custom_data_2_;
+  ::google::protobuf::uint32 custom_data_3_;
+  ::google::protobuf::uint32 custom_data_4_;
+  ::google::protobuf::uint32 custom_data_5_;
+  ::google::protobuf::uint32 custom_data_6_;
+  ::google::protobuf::uint32 custom_data_7_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_BaseCyclic_2eproto::TableStruct;
+  friend void ::protobuf_BaseCyclic_2eproto::InitDefaultsCustomDataImpl();
+};
+// -------------------------------------------------------------------
+
+class Command : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.BaseCyclic.Command) */ {
+ public:
+  Command();
+  virtual ~Command();
+
+  Command(const Command& from);
+
+  inline Command& operator=(const Command& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Command(Command&& from) noexcept
+    : Command() {
+    *this = ::std::move(from);
+  }
+
+  inline Command& operator=(Command&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Command& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Command* internal_default_instance() {
+    return reinterpret_cast<const Command*>(
+               &_Command_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    5;
+
+  void Swap(Command* other);
+  friend void swap(Command& a, Command& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Command* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Command* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Command& from);
+  void MergeFrom(const Command& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Command* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .Kinova.Api.BaseCyclic.ActuatorCommand actuators = 2;
+  int actuators_size() const;
+  void clear_actuators();
+  static const int kActuatorsFieldNumber = 2;
+  const ::Kinova::Api::BaseCyclic::ActuatorCommand& actuators(int index) const;
+  ::Kinova::Api::BaseCyclic::ActuatorCommand* mutable_actuators(int index);
+  ::Kinova::Api::BaseCyclic::ActuatorCommand* add_actuators();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::BaseCyclic::ActuatorCommand >*
+      mutable_actuators();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::BaseCyclic::ActuatorCommand >&
+      actuators() const;
+
+  // .Kinova.Api.InterconnectCyclic.Command interconnect = 3;
+  bool has_interconnect() const;
+  void clear_interconnect();
+  static const int kInterconnectFieldNumber = 3;
+  const ::Kinova::Api::InterconnectCyclic::Command& interconnect() const;
+  ::Kinova::Api::InterconnectCyclic::Command* release_interconnect();
+  ::Kinova::Api::InterconnectCyclic::Command* mutable_interconnect();
+  void set_allocated_interconnect(::Kinova::Api::InterconnectCyclic::Command* interconnect);
+
+  // fixed32 frame_id = 1;
+  void clear_frame_id();
+  static const int kFrameIdFieldNumber = 1;
+  ::google::protobuf::uint32 frame_id() const;
+  void set_frame_id(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.BaseCyclic.Command)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::BaseCyclic::ActuatorCommand > actuators_;
+  ::Kinova::Api::InterconnectCyclic::Command* interconnect_;
+  ::google::protobuf::uint32 frame_id_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_BaseCyclic_2eproto::TableStruct;
+  friend void ::protobuf_BaseCyclic_2eproto::InitDefaultsCommandImpl();
+};
+// -------------------------------------------------------------------
+
+class Feedback : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.BaseCyclic.Feedback) */ {
+ public:
+  Feedback();
+  virtual ~Feedback();
+
+  Feedback(const Feedback& from);
+
+  inline Feedback& operator=(const Feedback& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Feedback(Feedback&& from) noexcept
+    : Feedback() {
+    *this = ::std::move(from);
+  }
+
+  inline Feedback& operator=(Feedback&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Feedback& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Feedback* internal_default_instance() {
+    return reinterpret_cast<const Feedback*>(
+               &_Feedback_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    6;
+
+  void Swap(Feedback* other);
+  friend void swap(Feedback& a, Feedback& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Feedback* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Feedback* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Feedback& from);
+  void MergeFrom(const Feedback& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Feedback* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .Kinova.Api.BaseCyclic.ActuatorFeedback actuators = 3;
+  int actuators_size() const;
+  void clear_actuators();
+  static const int kActuatorsFieldNumber = 3;
+  const ::Kinova::Api::BaseCyclic::ActuatorFeedback& actuators(int index) const;
+  ::Kinova::Api::BaseCyclic::ActuatorFeedback* mutable_actuators(int index);
+  ::Kinova::Api::BaseCyclic::ActuatorFeedback* add_actuators();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::BaseCyclic::ActuatorFeedback >*
+      mutable_actuators();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::BaseCyclic::ActuatorFeedback >&
+      actuators() const;
+
+  // .Kinova.Api.BaseCyclic.BaseFeedback base = 2;
+  bool has_base() const;
+  void clear_base();
+  static const int kBaseFieldNumber = 2;
+  const ::Kinova::Api::BaseCyclic::BaseFeedback& base() const;
+  ::Kinova::Api::BaseCyclic::BaseFeedback* release_base();
+  ::Kinova::Api::BaseCyclic::BaseFeedback* mutable_base();
+  void set_allocated_base(::Kinova::Api::BaseCyclic::BaseFeedback* base);
+
+  // .Kinova.Api.InterconnectCyclic.Feedback interconnect = 4;
+  bool has_interconnect() const;
+  void clear_interconnect();
+  static const int kInterconnectFieldNumber = 4;
+  const ::Kinova::Api::InterconnectCyclic::Feedback& interconnect() const;
+  ::Kinova::Api::InterconnectCyclic::Feedback* release_interconnect();
+  ::Kinova::Api::InterconnectCyclic::Feedback* mutable_interconnect();
+  void set_allocated_interconnect(::Kinova::Api::InterconnectCyclic::Feedback* interconnect);
+
+  // fixed32 frame_id = 1;
+  void clear_frame_id();
+  static const int kFrameIdFieldNumber = 1;
+  ::google::protobuf::uint32 frame_id() const;
+  void set_frame_id(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.BaseCyclic.Feedback)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::BaseCyclic::ActuatorFeedback > actuators_;
+  ::Kinova::Api::BaseCyclic::BaseFeedback* base_;
+  ::Kinova::Api::InterconnectCyclic::Feedback* interconnect_;
+  ::google::protobuf::uint32 frame_id_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_BaseCyclic_2eproto::TableStruct;
+  friend void ::protobuf_BaseCyclic_2eproto::InitDefaultsFeedbackImpl();
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// ActuatorCommand
+
+// fixed32 command_id = 1;
+inline void ActuatorCommand::clear_command_id() {
+  command_id_ = 0u;
+}
+inline ::google::protobuf::uint32 ActuatorCommand::command_id() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.ActuatorCommand.command_id)
+  return command_id_;
+}
+inline void ActuatorCommand::set_command_id(::google::protobuf::uint32 value) {
+  
+  command_id_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.ActuatorCommand.command_id)
+}
+
+// fixed32 flags = 2;
+inline void ActuatorCommand::clear_flags() {
+  flags_ = 0u;
+}
+inline ::google::protobuf::uint32 ActuatorCommand::flags() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.ActuatorCommand.flags)
+  return flags_;
+}
+inline void ActuatorCommand::set_flags(::google::protobuf::uint32 value) {
+  
+  flags_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.ActuatorCommand.flags)
+}
+
+// float position = 3;
+inline void ActuatorCommand::clear_position() {
+  position_ = 0;
+}
+inline float ActuatorCommand::position() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.ActuatorCommand.position)
+  return position_;
+}
+inline void ActuatorCommand::set_position(float value) {
+  
+  position_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.ActuatorCommand.position)
+}
+
+// float velocity = 4;
+inline void ActuatorCommand::clear_velocity() {
+  velocity_ = 0;
+}
+inline float ActuatorCommand::velocity() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.ActuatorCommand.velocity)
+  return velocity_;
+}
+inline void ActuatorCommand::set_velocity(float value) {
+  
+  velocity_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.ActuatorCommand.velocity)
+}
+
+// float torque_joint = 5;
+inline void ActuatorCommand::clear_torque_joint() {
+  torque_joint_ = 0;
+}
+inline float ActuatorCommand::torque_joint() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.ActuatorCommand.torque_joint)
+  return torque_joint_;
+}
+inline void ActuatorCommand::set_torque_joint(float value) {
+  
+  torque_joint_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.ActuatorCommand.torque_joint)
+}
+
+// float current_motor = 6;
+inline void ActuatorCommand::clear_current_motor() {
+  current_motor_ = 0;
+}
+inline float ActuatorCommand::current_motor() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.ActuatorCommand.current_motor)
+  return current_motor_;
+}
+inline void ActuatorCommand::set_current_motor(float value) {
+  
+  current_motor_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.ActuatorCommand.current_motor)
+}
+
+// -------------------------------------------------------------------
+
+// ActuatorFeedback
+
+// fixed32 command_id = 1;
+inline void ActuatorFeedback::clear_command_id() {
+  command_id_ = 0u;
+}
+inline ::google::protobuf::uint32 ActuatorFeedback::command_id() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.ActuatorFeedback.command_id)
+  return command_id_;
+}
+inline void ActuatorFeedback::set_command_id(::google::protobuf::uint32 value) {
+  
+  command_id_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.ActuatorFeedback.command_id)
+}
+
+// fixed32 status_flags = 2;
+inline void ActuatorFeedback::clear_status_flags() {
+  status_flags_ = 0u;
+}
+inline ::google::protobuf::uint32 ActuatorFeedback::status_flags() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.ActuatorFeedback.status_flags)
+  return status_flags_;
+}
+inline void ActuatorFeedback::set_status_flags(::google::protobuf::uint32 value) {
+  
+  status_flags_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.ActuatorFeedback.status_flags)
+}
+
+// fixed32 jitter_comm = 3;
+inline void ActuatorFeedback::clear_jitter_comm() {
+  jitter_comm_ = 0u;
+}
+inline ::google::protobuf::uint32 ActuatorFeedback::jitter_comm() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.ActuatorFeedback.jitter_comm)
+  return jitter_comm_;
+}
+inline void ActuatorFeedback::set_jitter_comm(::google::protobuf::uint32 value) {
+  
+  jitter_comm_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.ActuatorFeedback.jitter_comm)
+}
+
+// float position = 4;
+inline void ActuatorFeedback::clear_position() {
+  position_ = 0;
+}
+inline float ActuatorFeedback::position() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.ActuatorFeedback.position)
+  return position_;
+}
+inline void ActuatorFeedback::set_position(float value) {
+  
+  position_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.ActuatorFeedback.position)
+}
+
+// float velocity = 5;
+inline void ActuatorFeedback::clear_velocity() {
+  velocity_ = 0;
+}
+inline float ActuatorFeedback::velocity() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.ActuatorFeedback.velocity)
+  return velocity_;
+}
+inline void ActuatorFeedback::set_velocity(float value) {
+  
+  velocity_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.ActuatorFeedback.velocity)
+}
+
+// float torque = 6;
+inline void ActuatorFeedback::clear_torque() {
+  torque_ = 0;
+}
+inline float ActuatorFeedback::torque() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.ActuatorFeedback.torque)
+  return torque_;
+}
+inline void ActuatorFeedback::set_torque(float value) {
+  
+  torque_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.ActuatorFeedback.torque)
+}
+
+// float current_motor = 7;
+inline void ActuatorFeedback::clear_current_motor() {
+  current_motor_ = 0;
+}
+inline float ActuatorFeedback::current_motor() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.ActuatorFeedback.current_motor)
+  return current_motor_;
+}
+inline void ActuatorFeedback::set_current_motor(float value) {
+  
+  current_motor_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.ActuatorFeedback.current_motor)
+}
+
+// float voltage = 8;
+inline void ActuatorFeedback::clear_voltage() {
+  voltage_ = 0;
+}
+inline float ActuatorFeedback::voltage() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.ActuatorFeedback.voltage)
+  return voltage_;
+}
+inline void ActuatorFeedback::set_voltage(float value) {
+  
+  voltage_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.ActuatorFeedback.voltage)
+}
+
+// float temperature_motor = 9;
+inline void ActuatorFeedback::clear_temperature_motor() {
+  temperature_motor_ = 0;
+}
+inline float ActuatorFeedback::temperature_motor() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.ActuatorFeedback.temperature_motor)
+  return temperature_motor_;
+}
+inline void ActuatorFeedback::set_temperature_motor(float value) {
+  
+  temperature_motor_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.ActuatorFeedback.temperature_motor)
+}
+
+// float temperature_core = 10;
+inline void ActuatorFeedback::clear_temperature_core() {
+  temperature_core_ = 0;
+}
+inline float ActuatorFeedback::temperature_core() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.ActuatorFeedback.temperature_core)
+  return temperature_core_;
+}
+inline void ActuatorFeedback::set_temperature_core(float value) {
+  
+  temperature_core_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.ActuatorFeedback.temperature_core)
+}
+
+// fixed32 fault_bank_a = 11;
+inline void ActuatorFeedback::clear_fault_bank_a() {
+  fault_bank_a_ = 0u;
+}
+inline ::google::protobuf::uint32 ActuatorFeedback::fault_bank_a() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.ActuatorFeedback.fault_bank_a)
+  return fault_bank_a_;
+}
+inline void ActuatorFeedback::set_fault_bank_a(::google::protobuf::uint32 value) {
+  
+  fault_bank_a_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.ActuatorFeedback.fault_bank_a)
+}
+
+// fixed32 fault_bank_b = 12;
+inline void ActuatorFeedback::clear_fault_bank_b() {
+  fault_bank_b_ = 0u;
+}
+inline ::google::protobuf::uint32 ActuatorFeedback::fault_bank_b() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.ActuatorFeedback.fault_bank_b)
+  return fault_bank_b_;
+}
+inline void ActuatorFeedback::set_fault_bank_b(::google::protobuf::uint32 value) {
+  
+  fault_bank_b_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.ActuatorFeedback.fault_bank_b)
+}
+
+// fixed32 warning_bank_a = 13;
+inline void ActuatorFeedback::clear_warning_bank_a() {
+  warning_bank_a_ = 0u;
+}
+inline ::google::protobuf::uint32 ActuatorFeedback::warning_bank_a() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.ActuatorFeedback.warning_bank_a)
+  return warning_bank_a_;
+}
+inline void ActuatorFeedback::set_warning_bank_a(::google::protobuf::uint32 value) {
+  
+  warning_bank_a_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.ActuatorFeedback.warning_bank_a)
+}
+
+// fixed32 warning_bank_b = 14;
+inline void ActuatorFeedback::clear_warning_bank_b() {
+  warning_bank_b_ = 0u;
+}
+inline ::google::protobuf::uint32 ActuatorFeedback::warning_bank_b() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.ActuatorFeedback.warning_bank_b)
+  return warning_bank_b_;
+}
+inline void ActuatorFeedback::set_warning_bank_b(::google::protobuf::uint32 value) {
+  
+  warning_bank_b_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.ActuatorFeedback.warning_bank_b)
+}
+
+// -------------------------------------------------------------------
+
+// ActuatorCustomData
+
+// fixed32 command_id = 1;
+inline void ActuatorCustomData::clear_command_id() {
+  command_id_ = 0u;
+}
+inline ::google::protobuf::uint32 ActuatorCustomData::command_id() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.ActuatorCustomData.command_id)
+  return command_id_;
+}
+inline void ActuatorCustomData::set_command_id(::google::protobuf::uint32 value) {
+  
+  command_id_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.ActuatorCustomData.command_id)
+}
+
+// fixed32 custom_data_0 = 2;
+inline void ActuatorCustomData::clear_custom_data_0() {
+  custom_data_0_ = 0u;
+}
+inline ::google::protobuf::uint32 ActuatorCustomData::custom_data_0() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.ActuatorCustomData.custom_data_0)
+  return custom_data_0_;
+}
+inline void ActuatorCustomData::set_custom_data_0(::google::protobuf::uint32 value) {
+  
+  custom_data_0_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.ActuatorCustomData.custom_data_0)
+}
+
+// fixed32 custom_data_1 = 3;
+inline void ActuatorCustomData::clear_custom_data_1() {
+  custom_data_1_ = 0u;
+}
+inline ::google::protobuf::uint32 ActuatorCustomData::custom_data_1() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.ActuatorCustomData.custom_data_1)
+  return custom_data_1_;
+}
+inline void ActuatorCustomData::set_custom_data_1(::google::protobuf::uint32 value) {
+  
+  custom_data_1_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.ActuatorCustomData.custom_data_1)
+}
+
+// fixed32 custom_data_2 = 4;
+inline void ActuatorCustomData::clear_custom_data_2() {
+  custom_data_2_ = 0u;
+}
+inline ::google::protobuf::uint32 ActuatorCustomData::custom_data_2() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.ActuatorCustomData.custom_data_2)
+  return custom_data_2_;
+}
+inline void ActuatorCustomData::set_custom_data_2(::google::protobuf::uint32 value) {
+  
+  custom_data_2_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.ActuatorCustomData.custom_data_2)
+}
+
+// fixed32 custom_data_3 = 5;
+inline void ActuatorCustomData::clear_custom_data_3() {
+  custom_data_3_ = 0u;
+}
+inline ::google::protobuf::uint32 ActuatorCustomData::custom_data_3() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.ActuatorCustomData.custom_data_3)
+  return custom_data_3_;
+}
+inline void ActuatorCustomData::set_custom_data_3(::google::protobuf::uint32 value) {
+  
+  custom_data_3_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.ActuatorCustomData.custom_data_3)
+}
+
+// fixed32 custom_data_4 = 6;
+inline void ActuatorCustomData::clear_custom_data_4() {
+  custom_data_4_ = 0u;
+}
+inline ::google::protobuf::uint32 ActuatorCustomData::custom_data_4() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.ActuatorCustomData.custom_data_4)
+  return custom_data_4_;
+}
+inline void ActuatorCustomData::set_custom_data_4(::google::protobuf::uint32 value) {
+  
+  custom_data_4_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.ActuatorCustomData.custom_data_4)
+}
+
+// fixed32 custom_data_5 = 7;
+inline void ActuatorCustomData::clear_custom_data_5() {
+  custom_data_5_ = 0u;
+}
+inline ::google::protobuf::uint32 ActuatorCustomData::custom_data_5() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.ActuatorCustomData.custom_data_5)
+  return custom_data_5_;
+}
+inline void ActuatorCustomData::set_custom_data_5(::google::protobuf::uint32 value) {
+  
+  custom_data_5_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.ActuatorCustomData.custom_data_5)
+}
+
+// fixed32 custom_data_6 = 8;
+inline void ActuatorCustomData::clear_custom_data_6() {
+  custom_data_6_ = 0u;
+}
+inline ::google::protobuf::uint32 ActuatorCustomData::custom_data_6() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.ActuatorCustomData.custom_data_6)
+  return custom_data_6_;
+}
+inline void ActuatorCustomData::set_custom_data_6(::google::protobuf::uint32 value) {
+  
+  custom_data_6_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.ActuatorCustomData.custom_data_6)
+}
+
+// fixed32 custom_data_7 = 9;
+inline void ActuatorCustomData::clear_custom_data_7() {
+  custom_data_7_ = 0u;
+}
+inline ::google::protobuf::uint32 ActuatorCustomData::custom_data_7() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.ActuatorCustomData.custom_data_7)
+  return custom_data_7_;
+}
+inline void ActuatorCustomData::set_custom_data_7(::google::protobuf::uint32 value) {
+  
+  custom_data_7_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.ActuatorCustomData.custom_data_7)
+}
+
+// fixed32 custom_data_8 = 10;
+inline void ActuatorCustomData::clear_custom_data_8() {
+  custom_data_8_ = 0u;
+}
+inline ::google::protobuf::uint32 ActuatorCustomData::custom_data_8() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.ActuatorCustomData.custom_data_8)
+  return custom_data_8_;
+}
+inline void ActuatorCustomData::set_custom_data_8(::google::protobuf::uint32 value) {
+  
+  custom_data_8_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.ActuatorCustomData.custom_data_8)
+}
+
+// fixed32 custom_data_9 = 11;
+inline void ActuatorCustomData::clear_custom_data_9() {
+  custom_data_9_ = 0u;
+}
+inline ::google::protobuf::uint32 ActuatorCustomData::custom_data_9() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.ActuatorCustomData.custom_data_9)
+  return custom_data_9_;
+}
+inline void ActuatorCustomData::set_custom_data_9(::google::protobuf::uint32 value) {
+  
+  custom_data_9_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.ActuatorCustomData.custom_data_9)
+}
+
+// fixed32 custom_data_10 = 12;
+inline void ActuatorCustomData::clear_custom_data_10() {
+  custom_data_10_ = 0u;
+}
+inline ::google::protobuf::uint32 ActuatorCustomData::custom_data_10() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.ActuatorCustomData.custom_data_10)
+  return custom_data_10_;
+}
+inline void ActuatorCustomData::set_custom_data_10(::google::protobuf::uint32 value) {
+  
+  custom_data_10_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.ActuatorCustomData.custom_data_10)
+}
+
+// fixed32 custom_data_11 = 13;
+inline void ActuatorCustomData::clear_custom_data_11() {
+  custom_data_11_ = 0u;
+}
+inline ::google::protobuf::uint32 ActuatorCustomData::custom_data_11() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.ActuatorCustomData.custom_data_11)
+  return custom_data_11_;
+}
+inline void ActuatorCustomData::set_custom_data_11(::google::protobuf::uint32 value) {
+  
+  custom_data_11_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.ActuatorCustomData.custom_data_11)
+}
+
+// fixed32 custom_data_12 = 14;
+inline void ActuatorCustomData::clear_custom_data_12() {
+  custom_data_12_ = 0u;
+}
+inline ::google::protobuf::uint32 ActuatorCustomData::custom_data_12() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.ActuatorCustomData.custom_data_12)
+  return custom_data_12_;
+}
+inline void ActuatorCustomData::set_custom_data_12(::google::protobuf::uint32 value) {
+  
+  custom_data_12_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.ActuatorCustomData.custom_data_12)
+}
+
+// fixed32 custom_data_13 = 15;
+inline void ActuatorCustomData::clear_custom_data_13() {
+  custom_data_13_ = 0u;
+}
+inline ::google::protobuf::uint32 ActuatorCustomData::custom_data_13() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.ActuatorCustomData.custom_data_13)
+  return custom_data_13_;
+}
+inline void ActuatorCustomData::set_custom_data_13(::google::protobuf::uint32 value) {
+  
+  custom_data_13_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.ActuatorCustomData.custom_data_13)
+}
+
+// fixed32 custom_data_14 = 16;
+inline void ActuatorCustomData::clear_custom_data_14() {
+  custom_data_14_ = 0u;
+}
+inline ::google::protobuf::uint32 ActuatorCustomData::custom_data_14() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.ActuatorCustomData.custom_data_14)
+  return custom_data_14_;
+}
+inline void ActuatorCustomData::set_custom_data_14(::google::protobuf::uint32 value) {
+  
+  custom_data_14_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.ActuatorCustomData.custom_data_14)
+}
+
+// fixed32 custom_data_15 = 17;
+inline void ActuatorCustomData::clear_custom_data_15() {
+  custom_data_15_ = 0u;
+}
+inline ::google::protobuf::uint32 ActuatorCustomData::custom_data_15() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.ActuatorCustomData.custom_data_15)
+  return custom_data_15_;
+}
+inline void ActuatorCustomData::set_custom_data_15(::google::protobuf::uint32 value) {
+  
+  custom_data_15_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.ActuatorCustomData.custom_data_15)
+}
+
+// -------------------------------------------------------------------
+
+// BaseFeedback
+
+// uint32 active_state_connection_identifier = 1;
+inline void BaseFeedback::clear_active_state_connection_identifier() {
+  active_state_connection_identifier_ = 0u;
+}
+inline ::google::protobuf::uint32 BaseFeedback::active_state_connection_identifier() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.BaseFeedback.active_state_connection_identifier)
+  return active_state_connection_identifier_;
+}
+inline void BaseFeedback::set_active_state_connection_identifier(::google::protobuf::uint32 value) {
+  
+  active_state_connection_identifier_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.BaseFeedback.active_state_connection_identifier)
+}
+
+// .Kinova.Api.Common.ArmState active_state = 2;
+inline void BaseFeedback::clear_active_state() {
+  active_state_ = 0;
+}
+inline ::Kinova::Api::Common::ArmState BaseFeedback::active_state() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.BaseFeedback.active_state)
+  return static_cast< ::Kinova::Api::Common::ArmState >(active_state_);
+}
+inline void BaseFeedback::set_active_state(::Kinova::Api::Common::ArmState value) {
+  
+  active_state_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.BaseFeedback.active_state)
+}
+
+// float arm_voltage = 3;
+inline void BaseFeedback::clear_arm_voltage() {
+  arm_voltage_ = 0;
+}
+inline float BaseFeedback::arm_voltage() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.BaseFeedback.arm_voltage)
+  return arm_voltage_;
+}
+inline void BaseFeedback::set_arm_voltage(float value) {
+  
+  arm_voltage_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.BaseFeedback.arm_voltage)
+}
+
+// float arm_current = 4;
+inline void BaseFeedback::clear_arm_current() {
+  arm_current_ = 0;
+}
+inline float BaseFeedback::arm_current() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.BaseFeedback.arm_current)
+  return arm_current_;
+}
+inline void BaseFeedback::set_arm_current(float value) {
+  
+  arm_current_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.BaseFeedback.arm_current)
+}
+
+// float temperature_cpu = 5;
+inline void BaseFeedback::clear_temperature_cpu() {
+  temperature_cpu_ = 0;
+}
+inline float BaseFeedback::temperature_cpu() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.BaseFeedback.temperature_cpu)
+  return temperature_cpu_;
+}
+inline void BaseFeedback::set_temperature_cpu(float value) {
+  
+  temperature_cpu_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.BaseFeedback.temperature_cpu)
+}
+
+// float temperature_ambient = 6;
+inline void BaseFeedback::clear_temperature_ambient() {
+  temperature_ambient_ = 0;
+}
+inline float BaseFeedback::temperature_ambient() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.BaseFeedback.temperature_ambient)
+  return temperature_ambient_;
+}
+inline void BaseFeedback::set_temperature_ambient(float value) {
+  
+  temperature_ambient_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.BaseFeedback.temperature_ambient)
+}
+
+// float imu_acceleration_x = 7;
+inline void BaseFeedback::clear_imu_acceleration_x() {
+  imu_acceleration_x_ = 0;
+}
+inline float BaseFeedback::imu_acceleration_x() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.BaseFeedback.imu_acceleration_x)
+  return imu_acceleration_x_;
+}
+inline void BaseFeedback::set_imu_acceleration_x(float value) {
+  
+  imu_acceleration_x_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.BaseFeedback.imu_acceleration_x)
+}
+
+// float imu_acceleration_y = 8;
+inline void BaseFeedback::clear_imu_acceleration_y() {
+  imu_acceleration_y_ = 0;
+}
+inline float BaseFeedback::imu_acceleration_y() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.BaseFeedback.imu_acceleration_y)
+  return imu_acceleration_y_;
+}
+inline void BaseFeedback::set_imu_acceleration_y(float value) {
+  
+  imu_acceleration_y_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.BaseFeedback.imu_acceleration_y)
+}
+
+// float imu_acceleration_z = 9;
+inline void BaseFeedback::clear_imu_acceleration_z() {
+  imu_acceleration_z_ = 0;
+}
+inline float BaseFeedback::imu_acceleration_z() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.BaseFeedback.imu_acceleration_z)
+  return imu_acceleration_z_;
+}
+inline void BaseFeedback::set_imu_acceleration_z(float value) {
+  
+  imu_acceleration_z_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.BaseFeedback.imu_acceleration_z)
+}
+
+// float imu_angular_velocity_x = 10;
+inline void BaseFeedback::clear_imu_angular_velocity_x() {
+  imu_angular_velocity_x_ = 0;
+}
+inline float BaseFeedback::imu_angular_velocity_x() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.BaseFeedback.imu_angular_velocity_x)
+  return imu_angular_velocity_x_;
+}
+inline void BaseFeedback::set_imu_angular_velocity_x(float value) {
+  
+  imu_angular_velocity_x_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.BaseFeedback.imu_angular_velocity_x)
+}
+
+// float imu_angular_velocity_y = 11;
+inline void BaseFeedback::clear_imu_angular_velocity_y() {
+  imu_angular_velocity_y_ = 0;
+}
+inline float BaseFeedback::imu_angular_velocity_y() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.BaseFeedback.imu_angular_velocity_y)
+  return imu_angular_velocity_y_;
+}
+inline void BaseFeedback::set_imu_angular_velocity_y(float value) {
+  
+  imu_angular_velocity_y_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.BaseFeedback.imu_angular_velocity_y)
+}
+
+// float imu_angular_velocity_z = 12;
+inline void BaseFeedback::clear_imu_angular_velocity_z() {
+  imu_angular_velocity_z_ = 0;
+}
+inline float BaseFeedback::imu_angular_velocity_z() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.BaseFeedback.imu_angular_velocity_z)
+  return imu_angular_velocity_z_;
+}
+inline void BaseFeedback::set_imu_angular_velocity_z(float value) {
+  
+  imu_angular_velocity_z_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.BaseFeedback.imu_angular_velocity_z)
+}
+
+// float tool_pose_x = 13;
+inline void BaseFeedback::clear_tool_pose_x() {
+  tool_pose_x_ = 0;
+}
+inline float BaseFeedback::tool_pose_x() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.BaseFeedback.tool_pose_x)
+  return tool_pose_x_;
+}
+inline void BaseFeedback::set_tool_pose_x(float value) {
+  
+  tool_pose_x_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.BaseFeedback.tool_pose_x)
+}
+
+// float tool_pose_y = 14;
+inline void BaseFeedback::clear_tool_pose_y() {
+  tool_pose_y_ = 0;
+}
+inline float BaseFeedback::tool_pose_y() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.BaseFeedback.tool_pose_y)
+  return tool_pose_y_;
+}
+inline void BaseFeedback::set_tool_pose_y(float value) {
+  
+  tool_pose_y_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.BaseFeedback.tool_pose_y)
+}
+
+// float tool_pose_z = 15;
+inline void BaseFeedback::clear_tool_pose_z() {
+  tool_pose_z_ = 0;
+}
+inline float BaseFeedback::tool_pose_z() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.BaseFeedback.tool_pose_z)
+  return tool_pose_z_;
+}
+inline void BaseFeedback::set_tool_pose_z(float value) {
+  
+  tool_pose_z_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.BaseFeedback.tool_pose_z)
+}
+
+// float tool_pose_theta_x = 16;
+inline void BaseFeedback::clear_tool_pose_theta_x() {
+  tool_pose_theta_x_ = 0;
+}
+inline float BaseFeedback::tool_pose_theta_x() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.BaseFeedback.tool_pose_theta_x)
+  return tool_pose_theta_x_;
+}
+inline void BaseFeedback::set_tool_pose_theta_x(float value) {
+  
+  tool_pose_theta_x_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.BaseFeedback.tool_pose_theta_x)
+}
+
+// float tool_pose_theta_y = 17;
+inline void BaseFeedback::clear_tool_pose_theta_y() {
+  tool_pose_theta_y_ = 0;
+}
+inline float BaseFeedback::tool_pose_theta_y() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.BaseFeedback.tool_pose_theta_y)
+  return tool_pose_theta_y_;
+}
+inline void BaseFeedback::set_tool_pose_theta_y(float value) {
+  
+  tool_pose_theta_y_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.BaseFeedback.tool_pose_theta_y)
+}
+
+// float tool_pose_theta_z = 18;
+inline void BaseFeedback::clear_tool_pose_theta_z() {
+  tool_pose_theta_z_ = 0;
+}
+inline float BaseFeedback::tool_pose_theta_z() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.BaseFeedback.tool_pose_theta_z)
+  return tool_pose_theta_z_;
+}
+inline void BaseFeedback::set_tool_pose_theta_z(float value) {
+  
+  tool_pose_theta_z_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.BaseFeedback.tool_pose_theta_z)
+}
+
+// float tool_twist_linear_x = 19;
+inline void BaseFeedback::clear_tool_twist_linear_x() {
+  tool_twist_linear_x_ = 0;
+}
+inline float BaseFeedback::tool_twist_linear_x() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.BaseFeedback.tool_twist_linear_x)
+  return tool_twist_linear_x_;
+}
+inline void BaseFeedback::set_tool_twist_linear_x(float value) {
+  
+  tool_twist_linear_x_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.BaseFeedback.tool_twist_linear_x)
+}
+
+// float tool_twist_linear_y = 20;
+inline void BaseFeedback::clear_tool_twist_linear_y() {
+  tool_twist_linear_y_ = 0;
+}
+inline float BaseFeedback::tool_twist_linear_y() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.BaseFeedback.tool_twist_linear_y)
+  return tool_twist_linear_y_;
+}
+inline void BaseFeedback::set_tool_twist_linear_y(float value) {
+  
+  tool_twist_linear_y_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.BaseFeedback.tool_twist_linear_y)
+}
+
+// float tool_twist_linear_z = 21;
+inline void BaseFeedback::clear_tool_twist_linear_z() {
+  tool_twist_linear_z_ = 0;
+}
+inline float BaseFeedback::tool_twist_linear_z() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.BaseFeedback.tool_twist_linear_z)
+  return tool_twist_linear_z_;
+}
+inline void BaseFeedback::set_tool_twist_linear_z(float value) {
+  
+  tool_twist_linear_z_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.BaseFeedback.tool_twist_linear_z)
+}
+
+// float tool_twist_angular_x = 22;
+inline void BaseFeedback::clear_tool_twist_angular_x() {
+  tool_twist_angular_x_ = 0;
+}
+inline float BaseFeedback::tool_twist_angular_x() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.BaseFeedback.tool_twist_angular_x)
+  return tool_twist_angular_x_;
+}
+inline void BaseFeedback::set_tool_twist_angular_x(float value) {
+  
+  tool_twist_angular_x_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.BaseFeedback.tool_twist_angular_x)
+}
+
+// float tool_twist_angular_y = 23;
+inline void BaseFeedback::clear_tool_twist_angular_y() {
+  tool_twist_angular_y_ = 0;
+}
+inline float BaseFeedback::tool_twist_angular_y() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.BaseFeedback.tool_twist_angular_y)
+  return tool_twist_angular_y_;
+}
+inline void BaseFeedback::set_tool_twist_angular_y(float value) {
+  
+  tool_twist_angular_y_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.BaseFeedback.tool_twist_angular_y)
+}
+
+// float tool_twist_angular_z = 24;
+inline void BaseFeedback::clear_tool_twist_angular_z() {
+  tool_twist_angular_z_ = 0;
+}
+inline float BaseFeedback::tool_twist_angular_z() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.BaseFeedback.tool_twist_angular_z)
+  return tool_twist_angular_z_;
+}
+inline void BaseFeedback::set_tool_twist_angular_z(float value) {
+  
+  tool_twist_angular_z_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.BaseFeedback.tool_twist_angular_z)
+}
+
+// float tool_external_wrench_force_x = 25;
+inline void BaseFeedback::clear_tool_external_wrench_force_x() {
+  tool_external_wrench_force_x_ = 0;
+}
+inline float BaseFeedback::tool_external_wrench_force_x() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.BaseFeedback.tool_external_wrench_force_x)
+  return tool_external_wrench_force_x_;
+}
+inline void BaseFeedback::set_tool_external_wrench_force_x(float value) {
+  
+  tool_external_wrench_force_x_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.BaseFeedback.tool_external_wrench_force_x)
+}
+
+// float tool_external_wrench_force_y = 26;
+inline void BaseFeedback::clear_tool_external_wrench_force_y() {
+  tool_external_wrench_force_y_ = 0;
+}
+inline float BaseFeedback::tool_external_wrench_force_y() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.BaseFeedback.tool_external_wrench_force_y)
+  return tool_external_wrench_force_y_;
+}
+inline void BaseFeedback::set_tool_external_wrench_force_y(float value) {
+  
+  tool_external_wrench_force_y_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.BaseFeedback.tool_external_wrench_force_y)
+}
+
+// float tool_external_wrench_force_z = 27;
+inline void BaseFeedback::clear_tool_external_wrench_force_z() {
+  tool_external_wrench_force_z_ = 0;
+}
+inline float BaseFeedback::tool_external_wrench_force_z() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.BaseFeedback.tool_external_wrench_force_z)
+  return tool_external_wrench_force_z_;
+}
+inline void BaseFeedback::set_tool_external_wrench_force_z(float value) {
+  
+  tool_external_wrench_force_z_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.BaseFeedback.tool_external_wrench_force_z)
+}
+
+// float tool_external_wrench_torque_x = 28;
+inline void BaseFeedback::clear_tool_external_wrench_torque_x() {
+  tool_external_wrench_torque_x_ = 0;
+}
+inline float BaseFeedback::tool_external_wrench_torque_x() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.BaseFeedback.tool_external_wrench_torque_x)
+  return tool_external_wrench_torque_x_;
+}
+inline void BaseFeedback::set_tool_external_wrench_torque_x(float value) {
+  
+  tool_external_wrench_torque_x_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.BaseFeedback.tool_external_wrench_torque_x)
+}
+
+// float tool_external_wrench_torque_y = 29;
+inline void BaseFeedback::clear_tool_external_wrench_torque_y() {
+  tool_external_wrench_torque_y_ = 0;
+}
+inline float BaseFeedback::tool_external_wrench_torque_y() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.BaseFeedback.tool_external_wrench_torque_y)
+  return tool_external_wrench_torque_y_;
+}
+inline void BaseFeedback::set_tool_external_wrench_torque_y(float value) {
+  
+  tool_external_wrench_torque_y_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.BaseFeedback.tool_external_wrench_torque_y)
+}
+
+// float tool_external_wrench_torque_z = 30;
+inline void BaseFeedback::clear_tool_external_wrench_torque_z() {
+  tool_external_wrench_torque_z_ = 0;
+}
+inline float BaseFeedback::tool_external_wrench_torque_z() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.BaseFeedback.tool_external_wrench_torque_z)
+  return tool_external_wrench_torque_z_;
+}
+inline void BaseFeedback::set_tool_external_wrench_torque_z(float value) {
+  
+  tool_external_wrench_torque_z_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.BaseFeedback.tool_external_wrench_torque_z)
+}
+
+// fixed32 fault_bank_a = 31;
+inline void BaseFeedback::clear_fault_bank_a() {
+  fault_bank_a_ = 0u;
+}
+inline ::google::protobuf::uint32 BaseFeedback::fault_bank_a() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.BaseFeedback.fault_bank_a)
+  return fault_bank_a_;
+}
+inline void BaseFeedback::set_fault_bank_a(::google::protobuf::uint32 value) {
+  
+  fault_bank_a_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.BaseFeedback.fault_bank_a)
+}
+
+// fixed32 fault_bank_b = 32;
+inline void BaseFeedback::clear_fault_bank_b() {
+  fault_bank_b_ = 0u;
+}
+inline ::google::protobuf::uint32 BaseFeedback::fault_bank_b() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.BaseFeedback.fault_bank_b)
+  return fault_bank_b_;
+}
+inline void BaseFeedback::set_fault_bank_b(::google::protobuf::uint32 value) {
+  
+  fault_bank_b_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.BaseFeedback.fault_bank_b)
+}
+
+// fixed32 warning_bank_a = 33;
+inline void BaseFeedback::clear_warning_bank_a() {
+  warning_bank_a_ = 0u;
+}
+inline ::google::protobuf::uint32 BaseFeedback::warning_bank_a() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.BaseFeedback.warning_bank_a)
+  return warning_bank_a_;
+}
+inline void BaseFeedback::set_warning_bank_a(::google::protobuf::uint32 value) {
+  
+  warning_bank_a_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.BaseFeedback.warning_bank_a)
+}
+
+// fixed32 warning_bank_b = 34;
+inline void BaseFeedback::clear_warning_bank_b() {
+  warning_bank_b_ = 0u;
+}
+inline ::google::protobuf::uint32 BaseFeedback::warning_bank_b() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.BaseFeedback.warning_bank_b)
+  return warning_bank_b_;
+}
+inline void BaseFeedback::set_warning_bank_b(::google::protobuf::uint32 value) {
+  
+  warning_bank_b_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.BaseFeedback.warning_bank_b)
+}
+
+// float commanded_tool_pose_x = 35;
+inline void BaseFeedback::clear_commanded_tool_pose_x() {
+  commanded_tool_pose_x_ = 0;
+}
+inline float BaseFeedback::commanded_tool_pose_x() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.BaseFeedback.commanded_tool_pose_x)
+  return commanded_tool_pose_x_;
+}
+inline void BaseFeedback::set_commanded_tool_pose_x(float value) {
+  
+  commanded_tool_pose_x_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.BaseFeedback.commanded_tool_pose_x)
+}
+
+// float commanded_tool_pose_y = 36;
+inline void BaseFeedback::clear_commanded_tool_pose_y() {
+  commanded_tool_pose_y_ = 0;
+}
+inline float BaseFeedback::commanded_tool_pose_y() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.BaseFeedback.commanded_tool_pose_y)
+  return commanded_tool_pose_y_;
+}
+inline void BaseFeedback::set_commanded_tool_pose_y(float value) {
+  
+  commanded_tool_pose_y_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.BaseFeedback.commanded_tool_pose_y)
+}
+
+// float commanded_tool_pose_z = 37;
+inline void BaseFeedback::clear_commanded_tool_pose_z() {
+  commanded_tool_pose_z_ = 0;
+}
+inline float BaseFeedback::commanded_tool_pose_z() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.BaseFeedback.commanded_tool_pose_z)
+  return commanded_tool_pose_z_;
+}
+inline void BaseFeedback::set_commanded_tool_pose_z(float value) {
+  
+  commanded_tool_pose_z_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.BaseFeedback.commanded_tool_pose_z)
+}
+
+// float commanded_tool_pose_theta_x = 38;
+inline void BaseFeedback::clear_commanded_tool_pose_theta_x() {
+  commanded_tool_pose_theta_x_ = 0;
+}
+inline float BaseFeedback::commanded_tool_pose_theta_x() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.BaseFeedback.commanded_tool_pose_theta_x)
+  return commanded_tool_pose_theta_x_;
+}
+inline void BaseFeedback::set_commanded_tool_pose_theta_x(float value) {
+  
+  commanded_tool_pose_theta_x_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.BaseFeedback.commanded_tool_pose_theta_x)
+}
+
+// float commanded_tool_pose_theta_y = 39;
+inline void BaseFeedback::clear_commanded_tool_pose_theta_y() {
+  commanded_tool_pose_theta_y_ = 0;
+}
+inline float BaseFeedback::commanded_tool_pose_theta_y() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.BaseFeedback.commanded_tool_pose_theta_y)
+  return commanded_tool_pose_theta_y_;
+}
+inline void BaseFeedback::set_commanded_tool_pose_theta_y(float value) {
+  
+  commanded_tool_pose_theta_y_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.BaseFeedback.commanded_tool_pose_theta_y)
+}
+
+// float commanded_tool_pose_theta_z = 40;
+inline void BaseFeedback::clear_commanded_tool_pose_theta_z() {
+  commanded_tool_pose_theta_z_ = 0;
+}
+inline float BaseFeedback::commanded_tool_pose_theta_z() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.BaseFeedback.commanded_tool_pose_theta_z)
+  return commanded_tool_pose_theta_z_;
+}
+inline void BaseFeedback::set_commanded_tool_pose_theta_z(float value) {
+  
+  commanded_tool_pose_theta_z_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.BaseFeedback.commanded_tool_pose_theta_z)
+}
+
+// -------------------------------------------------------------------
+
+// CustomData
+
+// fixed32 frame_id = 1;
+inline void CustomData::clear_frame_id() {
+  frame_id_ = 0u;
+}
+inline ::google::protobuf::uint32 CustomData::frame_id() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.CustomData.frame_id)
+  return frame_id_;
+}
+inline void CustomData::set_frame_id(::google::protobuf::uint32 value) {
+  
+  frame_id_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.CustomData.frame_id)
+}
+
+// fixed32 custom_data_0 = 2;
+inline void CustomData::clear_custom_data_0() {
+  custom_data_0_ = 0u;
+}
+inline ::google::protobuf::uint32 CustomData::custom_data_0() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.CustomData.custom_data_0)
+  return custom_data_0_;
+}
+inline void CustomData::set_custom_data_0(::google::protobuf::uint32 value) {
+  
+  custom_data_0_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.CustomData.custom_data_0)
+}
+
+// fixed32 custom_data_1 = 3;
+inline void CustomData::clear_custom_data_1() {
+  custom_data_1_ = 0u;
+}
+inline ::google::protobuf::uint32 CustomData::custom_data_1() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.CustomData.custom_data_1)
+  return custom_data_1_;
+}
+inline void CustomData::set_custom_data_1(::google::protobuf::uint32 value) {
+  
+  custom_data_1_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.CustomData.custom_data_1)
+}
+
+// fixed32 custom_data_2 = 4;
+inline void CustomData::clear_custom_data_2() {
+  custom_data_2_ = 0u;
+}
+inline ::google::protobuf::uint32 CustomData::custom_data_2() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.CustomData.custom_data_2)
+  return custom_data_2_;
+}
+inline void CustomData::set_custom_data_2(::google::protobuf::uint32 value) {
+  
+  custom_data_2_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.CustomData.custom_data_2)
+}
+
+// fixed32 custom_data_3 = 5;
+inline void CustomData::clear_custom_data_3() {
+  custom_data_3_ = 0u;
+}
+inline ::google::protobuf::uint32 CustomData::custom_data_3() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.CustomData.custom_data_3)
+  return custom_data_3_;
+}
+inline void CustomData::set_custom_data_3(::google::protobuf::uint32 value) {
+  
+  custom_data_3_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.CustomData.custom_data_3)
+}
+
+// fixed32 custom_data_4 = 6;
+inline void CustomData::clear_custom_data_4() {
+  custom_data_4_ = 0u;
+}
+inline ::google::protobuf::uint32 CustomData::custom_data_4() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.CustomData.custom_data_4)
+  return custom_data_4_;
+}
+inline void CustomData::set_custom_data_4(::google::protobuf::uint32 value) {
+  
+  custom_data_4_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.CustomData.custom_data_4)
+}
+
+// fixed32 custom_data_5 = 7;
+inline void CustomData::clear_custom_data_5() {
+  custom_data_5_ = 0u;
+}
+inline ::google::protobuf::uint32 CustomData::custom_data_5() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.CustomData.custom_data_5)
+  return custom_data_5_;
+}
+inline void CustomData::set_custom_data_5(::google::protobuf::uint32 value) {
+  
+  custom_data_5_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.CustomData.custom_data_5)
+}
+
+// fixed32 custom_data_6 = 8;
+inline void CustomData::clear_custom_data_6() {
+  custom_data_6_ = 0u;
+}
+inline ::google::protobuf::uint32 CustomData::custom_data_6() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.CustomData.custom_data_6)
+  return custom_data_6_;
+}
+inline void CustomData::set_custom_data_6(::google::protobuf::uint32 value) {
+  
+  custom_data_6_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.CustomData.custom_data_6)
+}
+
+// fixed32 custom_data_7 = 9;
+inline void CustomData::clear_custom_data_7() {
+  custom_data_7_ = 0u;
+}
+inline ::google::protobuf::uint32 CustomData::custom_data_7() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.CustomData.custom_data_7)
+  return custom_data_7_;
+}
+inline void CustomData::set_custom_data_7(::google::protobuf::uint32 value) {
+  
+  custom_data_7_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.CustomData.custom_data_7)
+}
+
+// repeated .Kinova.Api.BaseCyclic.ActuatorCustomData actuators_custom_data = 10;
+inline int CustomData::actuators_custom_data_size() const {
+  return actuators_custom_data_.size();
+}
+inline void CustomData::clear_actuators_custom_data() {
+  actuators_custom_data_.Clear();
+}
+inline const ::Kinova::Api::BaseCyclic::ActuatorCustomData& CustomData::actuators_custom_data(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.CustomData.actuators_custom_data)
+  return actuators_custom_data_.Get(index);
+}
+inline ::Kinova::Api::BaseCyclic::ActuatorCustomData* CustomData::mutable_actuators_custom_data(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.BaseCyclic.CustomData.actuators_custom_data)
+  return actuators_custom_data_.Mutable(index);
+}
+inline ::Kinova::Api::BaseCyclic::ActuatorCustomData* CustomData::add_actuators_custom_data() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.BaseCyclic.CustomData.actuators_custom_data)
+  return actuators_custom_data_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::BaseCyclic::ActuatorCustomData >*
+CustomData::mutable_actuators_custom_data() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.BaseCyclic.CustomData.actuators_custom_data)
+  return &actuators_custom_data_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::BaseCyclic::ActuatorCustomData >&
+CustomData::actuators_custom_data() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.BaseCyclic.CustomData.actuators_custom_data)
+  return actuators_custom_data_;
+}
+
+// .Kinova.Api.InterconnectCyclic.CustomData interconnect_custom_data = 11;
+inline bool CustomData::has_interconnect_custom_data() const {
+  return this != internal_default_instance() && interconnect_custom_data_ != NULL;
+}
+inline const ::Kinova::Api::InterconnectCyclic::CustomData& CustomData::interconnect_custom_data() const {
+  const ::Kinova::Api::InterconnectCyclic::CustomData* p = interconnect_custom_data_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.CustomData.interconnect_custom_data)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::InterconnectCyclic::CustomData*>(
+      &::Kinova::Api::InterconnectCyclic::_CustomData_default_instance_);
+}
+inline ::Kinova::Api::InterconnectCyclic::CustomData* CustomData::release_interconnect_custom_data() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.BaseCyclic.CustomData.interconnect_custom_data)
+  
+  ::Kinova::Api::InterconnectCyclic::CustomData* temp = interconnect_custom_data_;
+  interconnect_custom_data_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::InterconnectCyclic::CustomData* CustomData::mutable_interconnect_custom_data() {
+  
+  if (interconnect_custom_data_ == NULL) {
+    interconnect_custom_data_ = new ::Kinova::Api::InterconnectCyclic::CustomData;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.BaseCyclic.CustomData.interconnect_custom_data)
+  return interconnect_custom_data_;
+}
+inline void CustomData::set_allocated_interconnect_custom_data(::Kinova::Api::InterconnectCyclic::CustomData* interconnect_custom_data) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(interconnect_custom_data_);
+  }
+  if (interconnect_custom_data) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      interconnect_custom_data = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, interconnect_custom_data, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  interconnect_custom_data_ = interconnect_custom_data;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.BaseCyclic.CustomData.interconnect_custom_data)
+}
+
+// -------------------------------------------------------------------
+
+// Command
+
+// fixed32 frame_id = 1;
+inline void Command::clear_frame_id() {
+  frame_id_ = 0u;
+}
+inline ::google::protobuf::uint32 Command::frame_id() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.Command.frame_id)
+  return frame_id_;
+}
+inline void Command::set_frame_id(::google::protobuf::uint32 value) {
+  
+  frame_id_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.Command.frame_id)
+}
+
+// repeated .Kinova.Api.BaseCyclic.ActuatorCommand actuators = 2;
+inline int Command::actuators_size() const {
+  return actuators_.size();
+}
+inline void Command::clear_actuators() {
+  actuators_.Clear();
+}
+inline const ::Kinova::Api::BaseCyclic::ActuatorCommand& Command::actuators(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.Command.actuators)
+  return actuators_.Get(index);
+}
+inline ::Kinova::Api::BaseCyclic::ActuatorCommand* Command::mutable_actuators(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.BaseCyclic.Command.actuators)
+  return actuators_.Mutable(index);
+}
+inline ::Kinova::Api::BaseCyclic::ActuatorCommand* Command::add_actuators() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.BaseCyclic.Command.actuators)
+  return actuators_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::BaseCyclic::ActuatorCommand >*
+Command::mutable_actuators() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.BaseCyclic.Command.actuators)
+  return &actuators_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::BaseCyclic::ActuatorCommand >&
+Command::actuators() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.BaseCyclic.Command.actuators)
+  return actuators_;
+}
+
+// .Kinova.Api.InterconnectCyclic.Command interconnect = 3;
+inline bool Command::has_interconnect() const {
+  return this != internal_default_instance() && interconnect_ != NULL;
+}
+inline const ::Kinova::Api::InterconnectCyclic::Command& Command::interconnect() const {
+  const ::Kinova::Api::InterconnectCyclic::Command* p = interconnect_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.Command.interconnect)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::InterconnectCyclic::Command*>(
+      &::Kinova::Api::InterconnectCyclic::_Command_default_instance_);
+}
+inline ::Kinova::Api::InterconnectCyclic::Command* Command::release_interconnect() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.BaseCyclic.Command.interconnect)
+  
+  ::Kinova::Api::InterconnectCyclic::Command* temp = interconnect_;
+  interconnect_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::InterconnectCyclic::Command* Command::mutable_interconnect() {
+  
+  if (interconnect_ == NULL) {
+    interconnect_ = new ::Kinova::Api::InterconnectCyclic::Command;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.BaseCyclic.Command.interconnect)
+  return interconnect_;
+}
+inline void Command::set_allocated_interconnect(::Kinova::Api::InterconnectCyclic::Command* interconnect) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(interconnect_);
+  }
+  if (interconnect) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      interconnect = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, interconnect, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  interconnect_ = interconnect;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.BaseCyclic.Command.interconnect)
+}
+
+// -------------------------------------------------------------------
+
+// Feedback
+
+// fixed32 frame_id = 1;
+inline void Feedback::clear_frame_id() {
+  frame_id_ = 0u;
+}
+inline ::google::protobuf::uint32 Feedback::frame_id() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.Feedback.frame_id)
+  return frame_id_;
+}
+inline void Feedback::set_frame_id(::google::protobuf::uint32 value) {
+  
+  frame_id_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.BaseCyclic.Feedback.frame_id)
+}
+
+// .Kinova.Api.BaseCyclic.BaseFeedback base = 2;
+inline bool Feedback::has_base() const {
+  return this != internal_default_instance() && base_ != NULL;
+}
+inline void Feedback::clear_base() {
+  if (GetArenaNoVirtual() == NULL && base_ != NULL) {
+    delete base_;
+  }
+  base_ = NULL;
+}
+inline const ::Kinova::Api::BaseCyclic::BaseFeedback& Feedback::base() const {
+  const ::Kinova::Api::BaseCyclic::BaseFeedback* p = base_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.Feedback.base)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::BaseCyclic::BaseFeedback*>(
+      &::Kinova::Api::BaseCyclic::_BaseFeedback_default_instance_);
+}
+inline ::Kinova::Api::BaseCyclic::BaseFeedback* Feedback::release_base() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.BaseCyclic.Feedback.base)
+  
+  ::Kinova::Api::BaseCyclic::BaseFeedback* temp = base_;
+  base_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::BaseCyclic::BaseFeedback* Feedback::mutable_base() {
+  
+  if (base_ == NULL) {
+    base_ = new ::Kinova::Api::BaseCyclic::BaseFeedback;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.BaseCyclic.Feedback.base)
+  return base_;
+}
+inline void Feedback::set_allocated_base(::Kinova::Api::BaseCyclic::BaseFeedback* base) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete base_;
+  }
+  if (base) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      base = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, base, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  base_ = base;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.BaseCyclic.Feedback.base)
+}
+
+// repeated .Kinova.Api.BaseCyclic.ActuatorFeedback actuators = 3;
+inline int Feedback::actuators_size() const {
+  return actuators_.size();
+}
+inline void Feedback::clear_actuators() {
+  actuators_.Clear();
+}
+inline const ::Kinova::Api::BaseCyclic::ActuatorFeedback& Feedback::actuators(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.Feedback.actuators)
+  return actuators_.Get(index);
+}
+inline ::Kinova::Api::BaseCyclic::ActuatorFeedback* Feedback::mutable_actuators(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.BaseCyclic.Feedback.actuators)
+  return actuators_.Mutable(index);
+}
+inline ::Kinova::Api::BaseCyclic::ActuatorFeedback* Feedback::add_actuators() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.BaseCyclic.Feedback.actuators)
+  return actuators_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::BaseCyclic::ActuatorFeedback >*
+Feedback::mutable_actuators() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.BaseCyclic.Feedback.actuators)
+  return &actuators_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::BaseCyclic::ActuatorFeedback >&
+Feedback::actuators() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.BaseCyclic.Feedback.actuators)
+  return actuators_;
+}
+
+// .Kinova.Api.InterconnectCyclic.Feedback interconnect = 4;
+inline bool Feedback::has_interconnect() const {
+  return this != internal_default_instance() && interconnect_ != NULL;
+}
+inline const ::Kinova::Api::InterconnectCyclic::Feedback& Feedback::interconnect() const {
+  const ::Kinova::Api::InterconnectCyclic::Feedback* p = interconnect_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.BaseCyclic.Feedback.interconnect)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::InterconnectCyclic::Feedback*>(
+      &::Kinova::Api::InterconnectCyclic::_Feedback_default_instance_);
+}
+inline ::Kinova::Api::InterconnectCyclic::Feedback* Feedback::release_interconnect() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.BaseCyclic.Feedback.interconnect)
+  
+  ::Kinova::Api::InterconnectCyclic::Feedback* temp = interconnect_;
+  interconnect_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::InterconnectCyclic::Feedback* Feedback::mutable_interconnect() {
+  
+  if (interconnect_ == NULL) {
+    interconnect_ = new ::Kinova::Api::InterconnectCyclic::Feedback;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.BaseCyclic.Feedback.interconnect)
+  return interconnect_;
+}
+inline void Feedback::set_allocated_interconnect(::Kinova::Api::InterconnectCyclic::Feedback* interconnect) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(interconnect_);
+  }
+  if (interconnect) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      interconnect = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, interconnect, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  interconnect_ = interconnect;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.BaseCyclic.Feedback.interconnect)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace BaseCyclic
+}  // namespace Api
+}  // namespace Kinova
+
+namespace google {
+namespace protobuf {
+
+template <> struct is_proto_enum< ::Kinova::Api::BaseCyclic::ServiceVersion> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::BaseCyclic::ServiceVersion>() {
+  return ::Kinova::Api::BaseCyclic::ServiceVersion_descriptor();
+}
+
+}  // namespace protobuf
+}  // namespace google
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_BaseCyclic_2eproto__INCLUDED
diff --git a/kortex_api/include/messages/Common.pb.h b/kortex_api/include/messages/Common.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..4a9c16989a39a102aaf0468f426ccbf644c0a727
--- /dev/null
+++ b/kortex_api/include/messages/Common.pb.h
@@ -0,0 +1,2641 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: Common.proto
+
+#ifndef PROTOBUF_Common_2eproto__INCLUDED
+#define PROTOBUF_Common_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 3005000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 3005001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+// @@protoc_insertion_point(includes)
+
+namespace protobuf_Common_2eproto {
+// Internal implementation detail -- do not use these members.
+struct TableStruct {
+  static const ::google::protobuf::internal::ParseTableField entries[];
+  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
+  static const ::google::protobuf::internal::ParseTable schema[12];
+  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
+  static const ::google::protobuf::internal::SerializationTable serialization_table[];
+  static const ::google::protobuf::uint32 offsets[];
+};
+void AddDescriptors();
+void InitDefaultsDeviceHandleImpl();
+void InitDefaultsDeviceHandle();
+void InitDefaultsEmptyImpl();
+void InitDefaultsEmpty();
+void InitDefaultsNotificationOptionsImpl();
+void InitDefaultsNotificationOptions();
+void InitDefaultsSafetyHandleImpl();
+void InitDefaultsSafetyHandle();
+void InitDefaultsNotificationHandleImpl();
+void InitDefaultsNotificationHandle();
+void InitDefaultsSafetyNotificationImpl();
+void InitDefaultsSafetyNotification();
+void InitDefaultsTimestampImpl();
+void InitDefaultsTimestamp();
+void InitDefaultsUserProfileHandleImpl();
+void InitDefaultsUserProfileHandle();
+void InitDefaultsConnectionImpl();
+void InitDefaultsConnection();
+void InitDefaultsUARTConfigurationImpl();
+void InitDefaultsUARTConfiguration();
+void InitDefaultsUARTDeviceIdentificationImpl();
+void InitDefaultsUARTDeviceIdentification();
+void InitDefaultsCountryCodeImpl();
+void InitDefaultsCountryCode();
+inline void InitDefaults() {
+  InitDefaultsDeviceHandle();
+  InitDefaultsEmpty();
+  InitDefaultsNotificationOptions();
+  InitDefaultsSafetyHandle();
+  InitDefaultsNotificationHandle();
+  InitDefaultsSafetyNotification();
+  InitDefaultsTimestamp();
+  InitDefaultsUserProfileHandle();
+  InitDefaultsConnection();
+  InitDefaultsUARTConfiguration();
+  InitDefaultsUARTDeviceIdentification();
+  InitDefaultsCountryCode();
+}
+}  // namespace protobuf_Common_2eproto
+namespace Kinova {
+namespace Api {
+namespace Common {
+class Connection;
+class ConnectionDefaultTypeInternal;
+extern ConnectionDefaultTypeInternal _Connection_default_instance_;
+class CountryCode;
+class CountryCodeDefaultTypeInternal;
+extern CountryCodeDefaultTypeInternal _CountryCode_default_instance_;
+class DeviceHandle;
+class DeviceHandleDefaultTypeInternal;
+extern DeviceHandleDefaultTypeInternal _DeviceHandle_default_instance_;
+class Empty;
+class EmptyDefaultTypeInternal;
+extern EmptyDefaultTypeInternal _Empty_default_instance_;
+class NotificationHandle;
+class NotificationHandleDefaultTypeInternal;
+extern NotificationHandleDefaultTypeInternal _NotificationHandle_default_instance_;
+class NotificationOptions;
+class NotificationOptionsDefaultTypeInternal;
+extern NotificationOptionsDefaultTypeInternal _NotificationOptions_default_instance_;
+class SafetyHandle;
+class SafetyHandleDefaultTypeInternal;
+extern SafetyHandleDefaultTypeInternal _SafetyHandle_default_instance_;
+class SafetyNotification;
+class SafetyNotificationDefaultTypeInternal;
+extern SafetyNotificationDefaultTypeInternal _SafetyNotification_default_instance_;
+class Timestamp;
+class TimestampDefaultTypeInternal;
+extern TimestampDefaultTypeInternal _Timestamp_default_instance_;
+class UARTConfiguration;
+class UARTConfigurationDefaultTypeInternal;
+extern UARTConfigurationDefaultTypeInternal _UARTConfiguration_default_instance_;
+class UARTDeviceIdentification;
+class UARTDeviceIdentificationDefaultTypeInternal;
+extern UARTDeviceIdentificationDefaultTypeInternal _UARTDeviceIdentification_default_instance_;
+class UserProfileHandle;
+class UserProfileHandleDefaultTypeInternal;
+extern UserProfileHandleDefaultTypeInternal _UserProfileHandle_default_instance_;
+}  // namespace Common
+}  // namespace Api
+}  // namespace Kinova
+namespace Kinova {
+namespace Api {
+namespace Common {
+
+enum DeviceTypes {
+  UNSPECIFIED_DEVICE_TYPE = 0,
+  BASE = 1,
+  VISION = 2,
+  BIG_ACTUATOR = 3,
+  SMALL_ACTUATOR = 4,
+  INTERCONNECT = 5,
+  GRIPPER = 6,
+  MEDIUM_ACTUATOR = 7,
+  XBIG_ACTUATOR = 8,
+  DeviceTypes_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  DeviceTypes_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool DeviceTypes_IsValid(int value);
+const DeviceTypes DeviceTypes_MIN = UNSPECIFIED_DEVICE_TYPE;
+const DeviceTypes DeviceTypes_MAX = XBIG_ACTUATOR;
+const int DeviceTypes_ARRAYSIZE = DeviceTypes_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* DeviceTypes_descriptor();
+inline const ::std::string& DeviceTypes_Name(DeviceTypes value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    DeviceTypes_descriptor(), value);
+}
+inline bool DeviceTypes_Parse(
+    const ::std::string& name, DeviceTypes* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<DeviceTypes>(
+    DeviceTypes_descriptor(), name, value);
+}
+enum SafetyStatusValue {
+  SAFETY_STATUS_UNSPECIFIED = 0,
+  SAFETY_STATUS_WARNING = 1,
+  SAFETY_STATUS_ERROR = 2,
+  SAFETY_STATUS_NORMAL = 3,
+  SafetyStatusValue_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  SafetyStatusValue_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool SafetyStatusValue_IsValid(int value);
+const SafetyStatusValue SafetyStatusValue_MIN = SAFETY_STATUS_UNSPECIFIED;
+const SafetyStatusValue SafetyStatusValue_MAX = SAFETY_STATUS_NORMAL;
+const int SafetyStatusValue_ARRAYSIZE = SafetyStatusValue_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* SafetyStatusValue_descriptor();
+inline const ::std::string& SafetyStatusValue_Name(SafetyStatusValue value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    SafetyStatusValue_descriptor(), value);
+}
+inline bool SafetyStatusValue_Parse(
+    const ::std::string& name, SafetyStatusValue* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<SafetyStatusValue>(
+    SafetyStatusValue_descriptor(), name, value);
+}
+enum Permission {
+  NO_PERMISSION = 0,
+  READ_PERMISSION = 1,
+  UPDATE_PERMISSION = 2,
+  DELETE_PERMISSION = 4,
+  Permission_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  Permission_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool Permission_IsValid(int value);
+const Permission Permission_MIN = NO_PERMISSION;
+const Permission Permission_MAX = DELETE_PERMISSION;
+const int Permission_ARRAYSIZE = Permission_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* Permission_descriptor();
+inline const ::std::string& Permission_Name(Permission value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    Permission_descriptor(), value);
+}
+inline bool Permission_Parse(
+    const ::std::string& name, Permission* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<Permission>(
+    Permission_descriptor(), name, value);
+}
+enum NotificationType {
+  NOTIFICATION_TYPE_UNSPECIFIED = 0,
+  NOTIFICATION_TYPE_THRESHOLD = 1,
+  NOTIFICATION_TYPE_FIX_RATE = 2,
+  NOTIFICATION_TYPE_EVENT = 3,
+  NotificationType_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  NotificationType_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool NotificationType_IsValid(int value);
+const NotificationType NotificationType_MIN = NOTIFICATION_TYPE_UNSPECIFIED;
+const NotificationType NotificationType_MAX = NOTIFICATION_TYPE_EVENT;
+const int NotificationType_ARRAYSIZE = NotificationType_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* NotificationType_descriptor();
+inline const ::std::string& NotificationType_Name(NotificationType value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    NotificationType_descriptor(), value);
+}
+inline bool NotificationType_Parse(
+    const ::std::string& name, NotificationType* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<NotificationType>(
+    NotificationType_descriptor(), name, value);
+}
+enum Unit {
+  UNSPECIFIED_UNIT = 0,
+  CELSIUS = 1,
+  AMPERE = 2,
+  VOLT = 3,
+  METER_PER_SECOND = 4,
+  DEGREE_PER_SECOND = 5,
+  METER_PER_SECOND_2 = 6,
+  DEGREE_PER_SECOND_2 = 7,
+  NEWTON = 8,
+  NEWTON_METER = 9,
+  KILOGRAM = 10,
+  DEGREE = 11,
+  TICK = 12,
+  DEGREE_PER_MILLISECOND = 13,
+  Unit_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  Unit_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool Unit_IsValid(int value);
+const Unit Unit_MIN = UNSPECIFIED_UNIT;
+const Unit Unit_MAX = DEGREE_PER_MILLISECOND;
+const int Unit_ARRAYSIZE = Unit_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* Unit_descriptor();
+inline const ::std::string& Unit_Name(Unit value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    Unit_descriptor(), value);
+}
+inline bool Unit_Parse(
+    const ::std::string& name, Unit* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<Unit>(
+    Unit_descriptor(), name, value);
+}
+enum ArmState {
+  ARMSTATE_UNSPECIFIED = 0,
+  ARMSTATE_BASE_INITIALIZATION = 1,
+  ARMSTATE_IDLE = 2,
+  ARMSTATE_INITIALIZATION = 3,
+  ARMSTATE_IN_FAULT = 4,
+  ARMSTATE_MAINTENANCE = 5,
+  ARMSTATE_SERVOING_LOW_LEVEL = 6,
+  ARMSTATE_SERVOING_READY = 7,
+  ARMSTATE_SERVOING_PLAYING_SEQUENCE = 8,
+  ARMSTATE_SERVOING_MANUALLY_CONTROLLED = 9,
+  ARMSTATE_RESERVED = 255,
+  ArmState_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  ArmState_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool ArmState_IsValid(int value);
+const ArmState ArmState_MIN = ARMSTATE_UNSPECIFIED;
+const ArmState ArmState_MAX = ARMSTATE_RESERVED;
+const int ArmState_ARRAYSIZE = ArmState_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* ArmState_descriptor();
+inline const ::std::string& ArmState_Name(ArmState value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    ArmState_descriptor(), value);
+}
+inline bool ArmState_Parse(
+    const ::std::string& name, ArmState* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<ArmState>(
+    ArmState_descriptor(), name, value);
+}
+enum UARTSpeed {
+  UART_SPEED_UNSPECIFIED = 0,
+  UART_SPEED_4800 = 1,
+  UART_SPEED_9600 = 2,
+  UART_SPEED_19200 = 3,
+  UART_SPEED_38400 = 4,
+  UART_SPEED_57600 = 5,
+  UART_SPEED_115200 = 6,
+  UART_SPEED_230400 = 7,
+  UART_SPEED_460800 = 8,
+  UART_SPEED_921600 = 9,
+  UART_SPEED_1382400 = 10,
+  UART_SPEED_1612800 = 11,
+  UART_SPEED_1843200 = 12,
+  UART_SPEED_2073600 = 13,
+  UART_SPEED_2188800 = 14,
+  UART_SPEED_2246400 = 15,
+  UARTSpeed_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  UARTSpeed_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool UARTSpeed_IsValid(int value);
+const UARTSpeed UARTSpeed_MIN = UART_SPEED_UNSPECIFIED;
+const UARTSpeed UARTSpeed_MAX = UART_SPEED_2246400;
+const int UARTSpeed_ARRAYSIZE = UARTSpeed_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* UARTSpeed_descriptor();
+inline const ::std::string& UARTSpeed_Name(UARTSpeed value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    UARTSpeed_descriptor(), value);
+}
+inline bool UARTSpeed_Parse(
+    const ::std::string& name, UARTSpeed* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<UARTSpeed>(
+    UARTSpeed_descriptor(), name, value);
+}
+enum UARTWordLength {
+  UART_WORD_LENGTH_UNSPECIFIED = 0,
+  UART_WORD_LENGTH_7 = 1,
+  UART_WORD_LENGTH_8 = 2,
+  UART_WORD_LENGTH_9 = 3,
+  UARTWordLength_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  UARTWordLength_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool UARTWordLength_IsValid(int value);
+const UARTWordLength UARTWordLength_MIN = UART_WORD_LENGTH_UNSPECIFIED;
+const UARTWordLength UARTWordLength_MAX = UART_WORD_LENGTH_9;
+const int UARTWordLength_ARRAYSIZE = UARTWordLength_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* UARTWordLength_descriptor();
+inline const ::std::string& UARTWordLength_Name(UARTWordLength value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    UARTWordLength_descriptor(), value);
+}
+inline bool UARTWordLength_Parse(
+    const ::std::string& name, UARTWordLength* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<UARTWordLength>(
+    UARTWordLength_descriptor(), name, value);
+}
+enum UARTStopBits {
+  UART_STOP_BITS_UNSPECIFIED = 0,
+  UART_STOP_BITS_0_5 = 1,
+  UART_STOP_BITS_1 = 2,
+  UART_STOP_BITS_1_5 = 3,
+  UART_STOP_BITS_2 = 4,
+  UARTStopBits_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  UARTStopBits_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool UARTStopBits_IsValid(int value);
+const UARTStopBits UARTStopBits_MIN = UART_STOP_BITS_UNSPECIFIED;
+const UARTStopBits UARTStopBits_MAX = UART_STOP_BITS_2;
+const int UARTStopBits_ARRAYSIZE = UARTStopBits_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* UARTStopBits_descriptor();
+inline const ::std::string& UARTStopBits_Name(UARTStopBits value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    UARTStopBits_descriptor(), value);
+}
+inline bool UARTStopBits_Parse(
+    const ::std::string& name, UARTStopBits* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<UARTStopBits>(
+    UARTStopBits_descriptor(), name, value);
+}
+enum UARTParity {
+  UART_PARITY_UNSPECIFIED = 0,
+  UART_PARITY_NONE = 1,
+  UART_PARITY_ODD = 2,
+  UART_PARITY_EVEN = 3,
+  UARTParity_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  UARTParity_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool UARTParity_IsValid(int value);
+const UARTParity UARTParity_MIN = UART_PARITY_UNSPECIFIED;
+const UARTParity UARTParity_MAX = UART_PARITY_EVEN;
+const int UARTParity_ARRAYSIZE = UARTParity_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* UARTParity_descriptor();
+inline const ::std::string& UARTParity_Name(UARTParity value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    UARTParity_descriptor(), value);
+}
+inline bool UARTParity_Parse(
+    const ::std::string& name, UARTParity* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<UARTParity>(
+    UARTParity_descriptor(), name, value);
+}
+enum CartesianReferenceFrame {
+  CARTESIAN_REFERENCE_FRAME_UNSPECIFIED = 0,
+  CARTESIAN_REFERENCE_FRAME_MIXED = 1,
+  CARTESIAN_REFERENCE_FRAME_TOOL = 2,
+  CARTESIAN_REFERENCE_FRAME_BASE = 3,
+  CartesianReferenceFrame_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  CartesianReferenceFrame_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool CartesianReferenceFrame_IsValid(int value);
+const CartesianReferenceFrame CartesianReferenceFrame_MIN = CARTESIAN_REFERENCE_FRAME_UNSPECIFIED;
+const CartesianReferenceFrame CartesianReferenceFrame_MAX = CARTESIAN_REFERENCE_FRAME_BASE;
+const int CartesianReferenceFrame_ARRAYSIZE = CartesianReferenceFrame_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* CartesianReferenceFrame_descriptor();
+inline const ::std::string& CartesianReferenceFrame_Name(CartesianReferenceFrame value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    CartesianReferenceFrame_descriptor(), value);
+}
+inline bool CartesianReferenceFrame_Parse(
+    const ::std::string& name, CartesianReferenceFrame* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<CartesianReferenceFrame>(
+    CartesianReferenceFrame_descriptor(), name, value);
+}
+enum CountryCodeIdentifier {
+  UNSPECIFIED_COUNTRY_CODE = 0,
+  UNITED_ARAB_EMIRATES_AE = 1,
+  ANTIGUA_AND_BARBUDA_AG = 2,
+  ANGUILLA_AI = 3,
+  ALBANIA_AL = 4,
+  AMERICAN_SAMOA_AS = 5,
+  AUSTRIA_AT = 6,
+  AUSTRALIA_AU = 7,
+  ARUBA_AW = 8,
+  AZERBAIJAN_AZ = 9,
+  BOSNIA_AND_HERZEGOVINA_BA = 10,
+  BANGLADESH_BD = 11,
+  BELGIUM_BE = 12,
+  BULGARIA_BG = 13,
+  BAHRAIN_BH = 14,
+  BERMUDA_BM = 15,
+  BRUNEI_DARUSSALAM_BN = 16,
+  BRAZIL_BR = 17,
+  BAHAMAS_BS = 18,
+  BELARUS_BY = 19,
+  SWITZERLAND_CH = 20,
+  CANADA_CA = 21,
+  CHINA_CN = 22,
+  COLOMBIA_CO = 23,
+  COSTA_RICA_CR = 24,
+  CYPRUS_CY = 25,
+  CZECH_REPUBLIC_CZ = 26,
+  GERMANY_DE = 27,
+  DENMARK_DK = 28,
+  ECUADOR_EC = 29,
+  ESTONIA_EE = 30,
+  EGYPT_EG = 31,
+  SPAIN_ES = 32,
+  ETHIOPIA_ET = 33,
+  FINLAND_FI = 34,
+  FRANCE_FR = 35,
+  UNITED_KINGDOM_GB = 36,
+  GRENADA_GD = 37,
+  FRENCH_GUIANA_GF = 38,
+  GUADELOUPE_GP = 39,
+  GREECE_GR = 40,
+  GUATEMALA_GT = 41,
+  GUAM_GU = 42,
+  HONG_KONG_HK = 43,
+  CROATIA_HR = 44,
+  HUNGARY_HU = 45,
+  INDIA_IN = 46,
+  INDONESIA_ID = 47,
+  IRELAND_IE = 48,
+  ISRAEL_IL = 49,
+  ICELAND_IS = 50,
+  ITALY_IT = 51,
+  JORDAN_JO = 52,
+  JAPAN_JP = 53,
+  CAMBODIA_KH = 54,
+  REPUBLIC_OF_KOREA_KR = 55,
+  KUWAIT_KW = 56,
+  CAYMAN_ISLANDS_KY = 57,
+  LAO_PDR_LA = 58,
+  LEBANON_LB = 59,
+  LIECHTENSTEIN_LI = 60,
+  SRI_LANKA_LK = 61,
+  LESOTHO_LS = 62,
+  LITHUANIA_LT = 63,
+  LUXEMBOURG_LU = 64,
+  LATVIA_LV = 65,
+  MOROCCO_MA = 66,
+  MONACO_MC = 67,
+  MOLDOVA_MD = 68,
+  MONTENEGRO_ME = 69,
+  REPUBLIC_OF_MACEDONIA_MK = 70,
+  MONGOLIA_MN = 71,
+  MARTINIQUE_MQ = 72,
+  MAURITANIA_MR = 73,
+  MALTA_MT = 74,
+  MAURITIUS_MU = 75,
+  MALDIVES_MV = 76,
+  MALAWI_MW = 77,
+  MEXICO_MX = 78,
+  MALAYSIA_MY = 79,
+  NICARAGUA_NI = 80,
+  NETHERLANDS_NL = 81,
+  NORWAY_NO = 82,
+  NEW_ZEALAND_NZ = 83,
+  OMAN_OM = 84,
+  PANAMA_PA = 85,
+  PERU_PE = 86,
+  PHILIPPINES_PH = 87,
+  POLAND_PL = 88,
+  PUERTO_RICO_PR = 89,
+  PORTUGAL_PT = 90,
+  PARAGUAY_PY = 91,
+  REUNION_RE = 92,
+  ROMANIA_RO = 93,
+  SERBIA_RS = 94,
+  RUSSIAN_FEDERATION_RU = 95,
+  SWEDEN_SE = 96,
+  SINGAPORE_SI = 97,
+  SLOVAKIA_SK = 98,
+  EL_SALVADOR_SV = 99,
+  THAILAND_TH = 100,
+  TUNISIA_TN = 101,
+  TURKEY_TR = 102,
+  TRINIDAD_AND_TOBAGO_TT = 103,
+  TAIWAN_PROVINCE_OF_CHINA_TW = 104,
+  UKRAINE_UA = 105,
+  UNITED_STATES_US = 106,
+  HOLY_SEE_VATICAN_CITY_STATE_VA = 107,
+  BOLIVARIAN_REPUBLIC_OF_VENEZUELA_VE = 108,
+  BRITISH_VIRGIN_ISLANDS_VG = 109,
+  VIETNAM_VN = 110,
+  MAYOTTE_YT = 111,
+  SOUTH_AFRICA_ZA = 112,
+  CountryCodeIdentifier_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  CountryCodeIdentifier_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool CountryCodeIdentifier_IsValid(int value);
+const CountryCodeIdentifier CountryCodeIdentifier_MIN = UNSPECIFIED_COUNTRY_CODE;
+const CountryCodeIdentifier CountryCodeIdentifier_MAX = SOUTH_AFRICA_ZA;
+const int CountryCodeIdentifier_ARRAYSIZE = CountryCodeIdentifier_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* CountryCodeIdentifier_descriptor();
+inline const ::std::string& CountryCodeIdentifier_Name(CountryCodeIdentifier value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    CountryCodeIdentifier_descriptor(), value);
+}
+inline bool CountryCodeIdentifier_Parse(
+    const ::std::string& name, CountryCodeIdentifier* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<CountryCodeIdentifier>(
+    CountryCodeIdentifier_descriptor(), name, value);
+}
+// ===================================================================
+
+class DeviceHandle : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Common.DeviceHandle) */ {
+ public:
+  DeviceHandle();
+  virtual ~DeviceHandle();
+
+  DeviceHandle(const DeviceHandle& from);
+
+  inline DeviceHandle& operator=(const DeviceHandle& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  DeviceHandle(DeviceHandle&& from) noexcept
+    : DeviceHandle() {
+    *this = ::std::move(from);
+  }
+
+  inline DeviceHandle& operator=(DeviceHandle&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const DeviceHandle& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const DeviceHandle* internal_default_instance() {
+    return reinterpret_cast<const DeviceHandle*>(
+               &_DeviceHandle_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    0;
+
+  void Swap(DeviceHandle* other);
+  friend void swap(DeviceHandle& a, DeviceHandle& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline DeviceHandle* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  DeviceHandle* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const DeviceHandle& from);
+  void MergeFrom(const DeviceHandle& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(DeviceHandle* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Common.DeviceTypes device_type = 1;
+  void clear_device_type();
+  static const int kDeviceTypeFieldNumber = 1;
+  ::Kinova::Api::Common::DeviceTypes device_type() const;
+  void set_device_type(::Kinova::Api::Common::DeviceTypes value);
+
+  // uint32 device_identifier = 2;
+  void clear_device_identifier();
+  static const int kDeviceIdentifierFieldNumber = 2;
+  ::google::protobuf::uint32 device_identifier() const;
+  void set_device_identifier(::google::protobuf::uint32 value);
+
+  // uint32 order = 3;
+  void clear_order();
+  static const int kOrderFieldNumber = 3;
+  ::google::protobuf::uint32 order() const;
+  void set_order(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Common.DeviceHandle)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  int device_type_;
+  ::google::protobuf::uint32 device_identifier_;
+  ::google::protobuf::uint32 order_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Common_2eproto::TableStruct;
+  friend void ::protobuf_Common_2eproto::InitDefaultsDeviceHandleImpl();
+};
+// -------------------------------------------------------------------
+
+class Empty : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Common.Empty) */ {
+ public:
+  Empty();
+  virtual ~Empty();
+
+  Empty(const Empty& from);
+
+  inline Empty& operator=(const Empty& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Empty(Empty&& from) noexcept
+    : Empty() {
+    *this = ::std::move(from);
+  }
+
+  inline Empty& operator=(Empty&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Empty& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Empty* internal_default_instance() {
+    return reinterpret_cast<const Empty*>(
+               &_Empty_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    1;
+
+  void Swap(Empty* other);
+  friend void swap(Empty& a, Empty& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Empty* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Empty* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Empty& from);
+  void MergeFrom(const Empty& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Empty* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Common.Empty)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Common_2eproto::TableStruct;
+  friend void ::protobuf_Common_2eproto::InitDefaultsEmptyImpl();
+};
+// -------------------------------------------------------------------
+
+class NotificationOptions : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Common.NotificationOptions) */ {
+ public:
+  NotificationOptions();
+  virtual ~NotificationOptions();
+
+  NotificationOptions(const NotificationOptions& from);
+
+  inline NotificationOptions& operator=(const NotificationOptions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  NotificationOptions(NotificationOptions&& from) noexcept
+    : NotificationOptions() {
+    *this = ::std::move(from);
+  }
+
+  inline NotificationOptions& operator=(NotificationOptions&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const NotificationOptions& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const NotificationOptions* internal_default_instance() {
+    return reinterpret_cast<const NotificationOptions*>(
+               &_NotificationOptions_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    2;
+
+  void Swap(NotificationOptions* other);
+  friend void swap(NotificationOptions& a, NotificationOptions& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline NotificationOptions* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  NotificationOptions* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const NotificationOptions& from);
+  void MergeFrom(const NotificationOptions& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(NotificationOptions* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Common.NotificationType type = 1;
+  void clear_type();
+  static const int kTypeFieldNumber = 1;
+  ::Kinova::Api::Common::NotificationType type() const;
+  void set_type(::Kinova::Api::Common::NotificationType value);
+
+  // uint32 rate_m_sec = 2;
+  void clear_rate_m_sec();
+  static const int kRateMSecFieldNumber = 2;
+  ::google::protobuf::uint32 rate_m_sec() const;
+  void set_rate_m_sec(::google::protobuf::uint32 value);
+
+  // float threshold_value = 3;
+  void clear_threshold_value();
+  static const int kThresholdValueFieldNumber = 3;
+  float threshold_value() const;
+  void set_threshold_value(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Common.NotificationOptions)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  int type_;
+  ::google::protobuf::uint32 rate_m_sec_;
+  float threshold_value_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Common_2eproto::TableStruct;
+  friend void ::protobuf_Common_2eproto::InitDefaultsNotificationOptionsImpl();
+};
+// -------------------------------------------------------------------
+
+class SafetyHandle : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Common.SafetyHandle) */ {
+ public:
+  SafetyHandle();
+  virtual ~SafetyHandle();
+
+  SafetyHandle(const SafetyHandle& from);
+
+  inline SafetyHandle& operator=(const SafetyHandle& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  SafetyHandle(SafetyHandle&& from) noexcept
+    : SafetyHandle() {
+    *this = ::std::move(from);
+  }
+
+  inline SafetyHandle& operator=(SafetyHandle&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SafetyHandle& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const SafetyHandle* internal_default_instance() {
+    return reinterpret_cast<const SafetyHandle*>(
+               &_SafetyHandle_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    3;
+
+  void Swap(SafetyHandle* other);
+  friend void swap(SafetyHandle& a, SafetyHandle& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SafetyHandle* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  SafetyHandle* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const SafetyHandle& from);
+  void MergeFrom(const SafetyHandle& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(SafetyHandle* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // uint32 identifier = 1;
+  void clear_identifier();
+  static const int kIdentifierFieldNumber = 1;
+  ::google::protobuf::uint32 identifier() const;
+  void set_identifier(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Common.SafetyHandle)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 identifier_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Common_2eproto::TableStruct;
+  friend void ::protobuf_Common_2eproto::InitDefaultsSafetyHandleImpl();
+};
+// -------------------------------------------------------------------
+
+class NotificationHandle : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Common.NotificationHandle) */ {
+ public:
+  NotificationHandle();
+  virtual ~NotificationHandle();
+
+  NotificationHandle(const NotificationHandle& from);
+
+  inline NotificationHandle& operator=(const NotificationHandle& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  NotificationHandle(NotificationHandle&& from) noexcept
+    : NotificationHandle() {
+    *this = ::std::move(from);
+  }
+
+  inline NotificationHandle& operator=(NotificationHandle&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const NotificationHandle& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const NotificationHandle* internal_default_instance() {
+    return reinterpret_cast<const NotificationHandle*>(
+               &_NotificationHandle_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    4;
+
+  void Swap(NotificationHandle* other);
+  friend void swap(NotificationHandle& a, NotificationHandle& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline NotificationHandle* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  NotificationHandle* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const NotificationHandle& from);
+  void MergeFrom(const NotificationHandle& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(NotificationHandle* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // uint32 identifier = 1;
+  void clear_identifier();
+  static const int kIdentifierFieldNumber = 1;
+  ::google::protobuf::uint32 identifier() const;
+  void set_identifier(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Common.NotificationHandle)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 identifier_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Common_2eproto::TableStruct;
+  friend void ::protobuf_Common_2eproto::InitDefaultsNotificationHandleImpl();
+};
+// -------------------------------------------------------------------
+
+class SafetyNotification : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Common.SafetyNotification) */ {
+ public:
+  SafetyNotification();
+  virtual ~SafetyNotification();
+
+  SafetyNotification(const SafetyNotification& from);
+
+  inline SafetyNotification& operator=(const SafetyNotification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  SafetyNotification(SafetyNotification&& from) noexcept
+    : SafetyNotification() {
+    *this = ::std::move(from);
+  }
+
+  inline SafetyNotification& operator=(SafetyNotification&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SafetyNotification& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const SafetyNotification* internal_default_instance() {
+    return reinterpret_cast<const SafetyNotification*>(
+               &_SafetyNotification_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    5;
+
+  void Swap(SafetyNotification* other);
+  friend void swap(SafetyNotification& a, SafetyNotification& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SafetyNotification* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  SafetyNotification* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const SafetyNotification& from);
+  void MergeFrom(const SafetyNotification& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(SafetyNotification* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Common.SafetyHandle safety_handle = 1;
+  bool has_safety_handle() const;
+  void clear_safety_handle();
+  static const int kSafetyHandleFieldNumber = 1;
+  const ::Kinova::Api::Common::SafetyHandle& safety_handle() const;
+  ::Kinova::Api::Common::SafetyHandle* release_safety_handle();
+  ::Kinova::Api::Common::SafetyHandle* mutable_safety_handle();
+  void set_allocated_safety_handle(::Kinova::Api::Common::SafetyHandle* safety_handle);
+
+  // .Kinova.Api.Common.Timestamp timestamp = 3;
+  bool has_timestamp() const;
+  void clear_timestamp();
+  static const int kTimestampFieldNumber = 3;
+  const ::Kinova::Api::Common::Timestamp& timestamp() const;
+  ::Kinova::Api::Common::Timestamp* release_timestamp();
+  ::Kinova::Api::Common::Timestamp* mutable_timestamp();
+  void set_allocated_timestamp(::Kinova::Api::Common::Timestamp* timestamp);
+
+  // .Kinova.Api.Common.UserProfileHandle user_handle = 4;
+  bool has_user_handle() const;
+  void clear_user_handle();
+  static const int kUserHandleFieldNumber = 4;
+  const ::Kinova::Api::Common::UserProfileHandle& user_handle() const;
+  ::Kinova::Api::Common::UserProfileHandle* release_user_handle();
+  ::Kinova::Api::Common::UserProfileHandle* mutable_user_handle();
+  void set_allocated_user_handle(::Kinova::Api::Common::UserProfileHandle* user_handle);
+
+  // .Kinova.Api.Common.Connection connection = 5;
+  bool has_connection() const;
+  void clear_connection();
+  static const int kConnectionFieldNumber = 5;
+  const ::Kinova::Api::Common::Connection& connection() const;
+  ::Kinova::Api::Common::Connection* release_connection();
+  ::Kinova::Api::Common::Connection* mutable_connection();
+  void set_allocated_connection(::Kinova::Api::Common::Connection* connection);
+
+  // .Kinova.Api.Common.SafetyStatusValue value = 2;
+  void clear_value();
+  static const int kValueFieldNumber = 2;
+  ::Kinova::Api::Common::SafetyStatusValue value() const;
+  void set_value(::Kinova::Api::Common::SafetyStatusValue value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Common.SafetyNotification)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::Common::SafetyHandle* safety_handle_;
+  ::Kinova::Api::Common::Timestamp* timestamp_;
+  ::Kinova::Api::Common::UserProfileHandle* user_handle_;
+  ::Kinova::Api::Common::Connection* connection_;
+  int value_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Common_2eproto::TableStruct;
+  friend void ::protobuf_Common_2eproto::InitDefaultsSafetyNotificationImpl();
+};
+// -------------------------------------------------------------------
+
+class Timestamp : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Common.Timestamp) */ {
+ public:
+  Timestamp();
+  virtual ~Timestamp();
+
+  Timestamp(const Timestamp& from);
+
+  inline Timestamp& operator=(const Timestamp& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Timestamp(Timestamp&& from) noexcept
+    : Timestamp() {
+    *this = ::std::move(from);
+  }
+
+  inline Timestamp& operator=(Timestamp&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Timestamp& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Timestamp* internal_default_instance() {
+    return reinterpret_cast<const Timestamp*>(
+               &_Timestamp_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    6;
+
+  void Swap(Timestamp* other);
+  friend void swap(Timestamp& a, Timestamp& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Timestamp* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Timestamp* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Timestamp& from);
+  void MergeFrom(const Timestamp& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Timestamp* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // uint32 sec = 1;
+  void clear_sec();
+  static const int kSecFieldNumber = 1;
+  ::google::protobuf::uint32 sec() const;
+  void set_sec(::google::protobuf::uint32 value);
+
+  // uint32 usec = 2;
+  void clear_usec();
+  static const int kUsecFieldNumber = 2;
+  ::google::protobuf::uint32 usec() const;
+  void set_usec(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Common.Timestamp)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 sec_;
+  ::google::protobuf::uint32 usec_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Common_2eproto::TableStruct;
+  friend void ::protobuf_Common_2eproto::InitDefaultsTimestampImpl();
+};
+// -------------------------------------------------------------------
+
+class UserProfileHandle : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Common.UserProfileHandle) */ {
+ public:
+  UserProfileHandle();
+  virtual ~UserProfileHandle();
+
+  UserProfileHandle(const UserProfileHandle& from);
+
+  inline UserProfileHandle& operator=(const UserProfileHandle& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  UserProfileHandle(UserProfileHandle&& from) noexcept
+    : UserProfileHandle() {
+    *this = ::std::move(from);
+  }
+
+  inline UserProfileHandle& operator=(UserProfileHandle&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const UserProfileHandle& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const UserProfileHandle* internal_default_instance() {
+    return reinterpret_cast<const UserProfileHandle*>(
+               &_UserProfileHandle_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    7;
+
+  void Swap(UserProfileHandle* other);
+  friend void swap(UserProfileHandle& a, UserProfileHandle& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline UserProfileHandle* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  UserProfileHandle* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const UserProfileHandle& from);
+  void MergeFrom(const UserProfileHandle& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(UserProfileHandle* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // uint32 identifier = 1;
+  void clear_identifier();
+  static const int kIdentifierFieldNumber = 1;
+  ::google::protobuf::uint32 identifier() const;
+  void set_identifier(::google::protobuf::uint32 value);
+
+  // fixed32 permission = 2;
+  void clear_permission();
+  static const int kPermissionFieldNumber = 2;
+  ::google::protobuf::uint32 permission() const;
+  void set_permission(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Common.UserProfileHandle)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 identifier_;
+  ::google::protobuf::uint32 permission_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Common_2eproto::TableStruct;
+  friend void ::protobuf_Common_2eproto::InitDefaultsUserProfileHandleImpl();
+};
+// -------------------------------------------------------------------
+
+class Connection : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Common.Connection) */ {
+ public:
+  Connection();
+  virtual ~Connection();
+
+  Connection(const Connection& from);
+
+  inline Connection& operator=(const Connection& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Connection(Connection&& from) noexcept
+    : Connection() {
+    *this = ::std::move(from);
+  }
+
+  inline Connection& operator=(Connection&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Connection& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Connection* internal_default_instance() {
+    return reinterpret_cast<const Connection*>(
+               &_Connection_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    8;
+
+  void Swap(Connection* other);
+  friend void swap(Connection& a, Connection& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Connection* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Connection* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Connection& from);
+  void MergeFrom(const Connection& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Connection* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // string connection_information = 2;
+  void clear_connection_information();
+  static const int kConnectionInformationFieldNumber = 2;
+  const ::std::string& connection_information() const;
+  void set_connection_information(const ::std::string& value);
+  #if LANG_CXX11
+  void set_connection_information(::std::string&& value);
+  #endif
+  void set_connection_information(const char* value);
+  void set_connection_information(const char* value, size_t size);
+  ::std::string* mutable_connection_information();
+  ::std::string* release_connection_information();
+  void set_allocated_connection_information(::std::string* connection_information);
+
+  // .Kinova.Api.Common.UserProfileHandle user_handle = 1;
+  bool has_user_handle() const;
+  void clear_user_handle();
+  static const int kUserHandleFieldNumber = 1;
+  const ::Kinova::Api::Common::UserProfileHandle& user_handle() const;
+  ::Kinova::Api::Common::UserProfileHandle* release_user_handle();
+  ::Kinova::Api::Common::UserProfileHandle* mutable_user_handle();
+  void set_allocated_user_handle(::Kinova::Api::Common::UserProfileHandle* user_handle);
+
+  // uint32 connection_identifier = 3;
+  void clear_connection_identifier();
+  static const int kConnectionIdentifierFieldNumber = 3;
+  ::google::protobuf::uint32 connection_identifier() const;
+  void set_connection_identifier(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Common.Connection)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::internal::ArenaStringPtr connection_information_;
+  ::Kinova::Api::Common::UserProfileHandle* user_handle_;
+  ::google::protobuf::uint32 connection_identifier_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Common_2eproto::TableStruct;
+  friend void ::protobuf_Common_2eproto::InitDefaultsConnectionImpl();
+};
+// -------------------------------------------------------------------
+
+class UARTConfiguration : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Common.UARTConfiguration) */ {
+ public:
+  UARTConfiguration();
+  virtual ~UARTConfiguration();
+
+  UARTConfiguration(const UARTConfiguration& from);
+
+  inline UARTConfiguration& operator=(const UARTConfiguration& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  UARTConfiguration(UARTConfiguration&& from) noexcept
+    : UARTConfiguration() {
+    *this = ::std::move(from);
+  }
+
+  inline UARTConfiguration& operator=(UARTConfiguration&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const UARTConfiguration& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const UARTConfiguration* internal_default_instance() {
+    return reinterpret_cast<const UARTConfiguration*>(
+               &_UARTConfiguration_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    9;
+
+  void Swap(UARTConfiguration* other);
+  friend void swap(UARTConfiguration& a, UARTConfiguration& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline UARTConfiguration* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  UARTConfiguration* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const UARTConfiguration& from);
+  void MergeFrom(const UARTConfiguration& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(UARTConfiguration* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // uint32 port_id = 1;
+  void clear_port_id();
+  static const int kPortIdFieldNumber = 1;
+  ::google::protobuf::uint32 port_id() const;
+  void set_port_id(::google::protobuf::uint32 value);
+
+  // bool enabled = 2;
+  void clear_enabled();
+  static const int kEnabledFieldNumber = 2;
+  bool enabled() const;
+  void set_enabled(bool value);
+
+  // .Kinova.Api.Common.UARTSpeed speed = 3;
+  void clear_speed();
+  static const int kSpeedFieldNumber = 3;
+  ::Kinova::Api::Common::UARTSpeed speed() const;
+  void set_speed(::Kinova::Api::Common::UARTSpeed value);
+
+  // .Kinova.Api.Common.UARTWordLength word_length = 4;
+  void clear_word_length();
+  static const int kWordLengthFieldNumber = 4;
+  ::Kinova::Api::Common::UARTWordLength word_length() const;
+  void set_word_length(::Kinova::Api::Common::UARTWordLength value);
+
+  // .Kinova.Api.Common.UARTStopBits stop_bits = 5;
+  void clear_stop_bits();
+  static const int kStopBitsFieldNumber = 5;
+  ::Kinova::Api::Common::UARTStopBits stop_bits() const;
+  void set_stop_bits(::Kinova::Api::Common::UARTStopBits value);
+
+  // .Kinova.Api.Common.UARTParity parity = 6;
+  void clear_parity();
+  static const int kParityFieldNumber = 6;
+  ::Kinova::Api::Common::UARTParity parity() const;
+  void set_parity(::Kinova::Api::Common::UARTParity value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Common.UARTConfiguration)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 port_id_;
+  bool enabled_;
+  int speed_;
+  int word_length_;
+  int stop_bits_;
+  int parity_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Common_2eproto::TableStruct;
+  friend void ::protobuf_Common_2eproto::InitDefaultsUARTConfigurationImpl();
+};
+// -------------------------------------------------------------------
+
+class UARTDeviceIdentification : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Common.UARTDeviceIdentification) */ {
+ public:
+  UARTDeviceIdentification();
+  virtual ~UARTDeviceIdentification();
+
+  UARTDeviceIdentification(const UARTDeviceIdentification& from);
+
+  inline UARTDeviceIdentification& operator=(const UARTDeviceIdentification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  UARTDeviceIdentification(UARTDeviceIdentification&& from) noexcept
+    : UARTDeviceIdentification() {
+    *this = ::std::move(from);
+  }
+
+  inline UARTDeviceIdentification& operator=(UARTDeviceIdentification&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const UARTDeviceIdentification& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const UARTDeviceIdentification* internal_default_instance() {
+    return reinterpret_cast<const UARTDeviceIdentification*>(
+               &_UARTDeviceIdentification_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    10;
+
+  void Swap(UARTDeviceIdentification* other);
+  friend void swap(UARTDeviceIdentification& a, UARTDeviceIdentification& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline UARTDeviceIdentification* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  UARTDeviceIdentification* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const UARTDeviceIdentification& from);
+  void MergeFrom(const UARTDeviceIdentification& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(UARTDeviceIdentification* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // uint32 port_id = 1;
+  void clear_port_id();
+  static const int kPortIdFieldNumber = 1;
+  ::google::protobuf::uint32 port_id() const;
+  void set_port_id(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Common.UARTDeviceIdentification)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 port_id_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Common_2eproto::TableStruct;
+  friend void ::protobuf_Common_2eproto::InitDefaultsUARTDeviceIdentificationImpl();
+};
+// -------------------------------------------------------------------
+
+class CountryCode : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Common.CountryCode) */ {
+ public:
+  CountryCode();
+  virtual ~CountryCode();
+
+  CountryCode(const CountryCode& from);
+
+  inline CountryCode& operator=(const CountryCode& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  CountryCode(CountryCode&& from) noexcept
+    : CountryCode() {
+    *this = ::std::move(from);
+  }
+
+  inline CountryCode& operator=(CountryCode&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const CountryCode& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const CountryCode* internal_default_instance() {
+    return reinterpret_cast<const CountryCode*>(
+               &_CountryCode_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    11;
+
+  void Swap(CountryCode* other);
+  friend void swap(CountryCode& a, CountryCode& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline CountryCode* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  CountryCode* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const CountryCode& from);
+  void MergeFrom(const CountryCode& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(CountryCode* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Common.CountryCodeIdentifier identifier = 1;
+  void clear_identifier();
+  static const int kIdentifierFieldNumber = 1;
+  ::Kinova::Api::Common::CountryCodeIdentifier identifier() const;
+  void set_identifier(::Kinova::Api::Common::CountryCodeIdentifier value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Common.CountryCode)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  int identifier_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Common_2eproto::TableStruct;
+  friend void ::protobuf_Common_2eproto::InitDefaultsCountryCodeImpl();
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// DeviceHandle
+
+// .Kinova.Api.Common.DeviceTypes device_type = 1;
+inline void DeviceHandle::clear_device_type() {
+  device_type_ = 0;
+}
+inline ::Kinova::Api::Common::DeviceTypes DeviceHandle::device_type() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Common.DeviceHandle.device_type)
+  return static_cast< ::Kinova::Api::Common::DeviceTypes >(device_type_);
+}
+inline void DeviceHandle::set_device_type(::Kinova::Api::Common::DeviceTypes value) {
+  
+  device_type_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Common.DeviceHandle.device_type)
+}
+
+// uint32 device_identifier = 2;
+inline void DeviceHandle::clear_device_identifier() {
+  device_identifier_ = 0u;
+}
+inline ::google::protobuf::uint32 DeviceHandle::device_identifier() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Common.DeviceHandle.device_identifier)
+  return device_identifier_;
+}
+inline void DeviceHandle::set_device_identifier(::google::protobuf::uint32 value) {
+  
+  device_identifier_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Common.DeviceHandle.device_identifier)
+}
+
+// uint32 order = 3;
+inline void DeviceHandle::clear_order() {
+  order_ = 0u;
+}
+inline ::google::protobuf::uint32 DeviceHandle::order() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Common.DeviceHandle.order)
+  return order_;
+}
+inline void DeviceHandle::set_order(::google::protobuf::uint32 value) {
+  
+  order_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Common.DeviceHandle.order)
+}
+
+// -------------------------------------------------------------------
+
+// Empty
+
+// -------------------------------------------------------------------
+
+// NotificationOptions
+
+// .Kinova.Api.Common.NotificationType type = 1;
+inline void NotificationOptions::clear_type() {
+  type_ = 0;
+}
+inline ::Kinova::Api::Common::NotificationType NotificationOptions::type() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Common.NotificationOptions.type)
+  return static_cast< ::Kinova::Api::Common::NotificationType >(type_);
+}
+inline void NotificationOptions::set_type(::Kinova::Api::Common::NotificationType value) {
+  
+  type_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Common.NotificationOptions.type)
+}
+
+// uint32 rate_m_sec = 2;
+inline void NotificationOptions::clear_rate_m_sec() {
+  rate_m_sec_ = 0u;
+}
+inline ::google::protobuf::uint32 NotificationOptions::rate_m_sec() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Common.NotificationOptions.rate_m_sec)
+  return rate_m_sec_;
+}
+inline void NotificationOptions::set_rate_m_sec(::google::protobuf::uint32 value) {
+  
+  rate_m_sec_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Common.NotificationOptions.rate_m_sec)
+}
+
+// float threshold_value = 3;
+inline void NotificationOptions::clear_threshold_value() {
+  threshold_value_ = 0;
+}
+inline float NotificationOptions::threshold_value() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Common.NotificationOptions.threshold_value)
+  return threshold_value_;
+}
+inline void NotificationOptions::set_threshold_value(float value) {
+  
+  threshold_value_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Common.NotificationOptions.threshold_value)
+}
+
+// -------------------------------------------------------------------
+
+// SafetyHandle
+
+// uint32 identifier = 1;
+inline void SafetyHandle::clear_identifier() {
+  identifier_ = 0u;
+}
+inline ::google::protobuf::uint32 SafetyHandle::identifier() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Common.SafetyHandle.identifier)
+  return identifier_;
+}
+inline void SafetyHandle::set_identifier(::google::protobuf::uint32 value) {
+  
+  identifier_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Common.SafetyHandle.identifier)
+}
+
+// -------------------------------------------------------------------
+
+// NotificationHandle
+
+// uint32 identifier = 1;
+inline void NotificationHandle::clear_identifier() {
+  identifier_ = 0u;
+}
+inline ::google::protobuf::uint32 NotificationHandle::identifier() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Common.NotificationHandle.identifier)
+  return identifier_;
+}
+inline void NotificationHandle::set_identifier(::google::protobuf::uint32 value) {
+  
+  identifier_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Common.NotificationHandle.identifier)
+}
+
+// -------------------------------------------------------------------
+
+// SafetyNotification
+
+// .Kinova.Api.Common.SafetyHandle safety_handle = 1;
+inline bool SafetyNotification::has_safety_handle() const {
+  return this != internal_default_instance() && safety_handle_ != NULL;
+}
+inline void SafetyNotification::clear_safety_handle() {
+  if (GetArenaNoVirtual() == NULL && safety_handle_ != NULL) {
+    delete safety_handle_;
+  }
+  safety_handle_ = NULL;
+}
+inline const ::Kinova::Api::Common::SafetyHandle& SafetyNotification::safety_handle() const {
+  const ::Kinova::Api::Common::SafetyHandle* p = safety_handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Common.SafetyNotification.safety_handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::SafetyHandle*>(
+      &::Kinova::Api::Common::_SafetyHandle_default_instance_);
+}
+inline ::Kinova::Api::Common::SafetyHandle* SafetyNotification::release_safety_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Common.SafetyNotification.safety_handle)
+  
+  ::Kinova::Api::Common::SafetyHandle* temp = safety_handle_;
+  safety_handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::SafetyHandle* SafetyNotification::mutable_safety_handle() {
+  
+  if (safety_handle_ == NULL) {
+    safety_handle_ = new ::Kinova::Api::Common::SafetyHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Common.SafetyNotification.safety_handle)
+  return safety_handle_;
+}
+inline void SafetyNotification::set_allocated_safety_handle(::Kinova::Api::Common::SafetyHandle* safety_handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete safety_handle_;
+  }
+  if (safety_handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      safety_handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, safety_handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  safety_handle_ = safety_handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Common.SafetyNotification.safety_handle)
+}
+
+// .Kinova.Api.Common.SafetyStatusValue value = 2;
+inline void SafetyNotification::clear_value() {
+  value_ = 0;
+}
+inline ::Kinova::Api::Common::SafetyStatusValue SafetyNotification::value() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Common.SafetyNotification.value)
+  return static_cast< ::Kinova::Api::Common::SafetyStatusValue >(value_);
+}
+inline void SafetyNotification::set_value(::Kinova::Api::Common::SafetyStatusValue value) {
+  
+  value_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Common.SafetyNotification.value)
+}
+
+// .Kinova.Api.Common.Timestamp timestamp = 3;
+inline bool SafetyNotification::has_timestamp() const {
+  return this != internal_default_instance() && timestamp_ != NULL;
+}
+inline void SafetyNotification::clear_timestamp() {
+  if (GetArenaNoVirtual() == NULL && timestamp_ != NULL) {
+    delete timestamp_;
+  }
+  timestamp_ = NULL;
+}
+inline const ::Kinova::Api::Common::Timestamp& SafetyNotification::timestamp() const {
+  const ::Kinova::Api::Common::Timestamp* p = timestamp_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Common.SafetyNotification.timestamp)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::Timestamp*>(
+      &::Kinova::Api::Common::_Timestamp_default_instance_);
+}
+inline ::Kinova::Api::Common::Timestamp* SafetyNotification::release_timestamp() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Common.SafetyNotification.timestamp)
+  
+  ::Kinova::Api::Common::Timestamp* temp = timestamp_;
+  timestamp_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::Timestamp* SafetyNotification::mutable_timestamp() {
+  
+  if (timestamp_ == NULL) {
+    timestamp_ = new ::Kinova::Api::Common::Timestamp;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Common.SafetyNotification.timestamp)
+  return timestamp_;
+}
+inline void SafetyNotification::set_allocated_timestamp(::Kinova::Api::Common::Timestamp* timestamp) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete timestamp_;
+  }
+  if (timestamp) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      timestamp = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, timestamp, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  timestamp_ = timestamp;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Common.SafetyNotification.timestamp)
+}
+
+// .Kinova.Api.Common.UserProfileHandle user_handle = 4;
+inline bool SafetyNotification::has_user_handle() const {
+  return this != internal_default_instance() && user_handle_ != NULL;
+}
+inline void SafetyNotification::clear_user_handle() {
+  if (GetArenaNoVirtual() == NULL && user_handle_ != NULL) {
+    delete user_handle_;
+  }
+  user_handle_ = NULL;
+}
+inline const ::Kinova::Api::Common::UserProfileHandle& SafetyNotification::user_handle() const {
+  const ::Kinova::Api::Common::UserProfileHandle* p = user_handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Common.SafetyNotification.user_handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::UserProfileHandle*>(
+      &::Kinova::Api::Common::_UserProfileHandle_default_instance_);
+}
+inline ::Kinova::Api::Common::UserProfileHandle* SafetyNotification::release_user_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Common.SafetyNotification.user_handle)
+  
+  ::Kinova::Api::Common::UserProfileHandle* temp = user_handle_;
+  user_handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::UserProfileHandle* SafetyNotification::mutable_user_handle() {
+  
+  if (user_handle_ == NULL) {
+    user_handle_ = new ::Kinova::Api::Common::UserProfileHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Common.SafetyNotification.user_handle)
+  return user_handle_;
+}
+inline void SafetyNotification::set_allocated_user_handle(::Kinova::Api::Common::UserProfileHandle* user_handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete user_handle_;
+  }
+  if (user_handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      user_handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, user_handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  user_handle_ = user_handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Common.SafetyNotification.user_handle)
+}
+
+// .Kinova.Api.Common.Connection connection = 5;
+inline bool SafetyNotification::has_connection() const {
+  return this != internal_default_instance() && connection_ != NULL;
+}
+inline void SafetyNotification::clear_connection() {
+  if (GetArenaNoVirtual() == NULL && connection_ != NULL) {
+    delete connection_;
+  }
+  connection_ = NULL;
+}
+inline const ::Kinova::Api::Common::Connection& SafetyNotification::connection() const {
+  const ::Kinova::Api::Common::Connection* p = connection_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Common.SafetyNotification.connection)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::Connection*>(
+      &::Kinova::Api::Common::_Connection_default_instance_);
+}
+inline ::Kinova::Api::Common::Connection* SafetyNotification::release_connection() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Common.SafetyNotification.connection)
+  
+  ::Kinova::Api::Common::Connection* temp = connection_;
+  connection_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::Connection* SafetyNotification::mutable_connection() {
+  
+  if (connection_ == NULL) {
+    connection_ = new ::Kinova::Api::Common::Connection;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Common.SafetyNotification.connection)
+  return connection_;
+}
+inline void SafetyNotification::set_allocated_connection(::Kinova::Api::Common::Connection* connection) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete connection_;
+  }
+  if (connection) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      connection = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, connection, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  connection_ = connection;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Common.SafetyNotification.connection)
+}
+
+// -------------------------------------------------------------------
+
+// Timestamp
+
+// uint32 sec = 1;
+inline void Timestamp::clear_sec() {
+  sec_ = 0u;
+}
+inline ::google::protobuf::uint32 Timestamp::sec() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Common.Timestamp.sec)
+  return sec_;
+}
+inline void Timestamp::set_sec(::google::protobuf::uint32 value) {
+  
+  sec_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Common.Timestamp.sec)
+}
+
+// uint32 usec = 2;
+inline void Timestamp::clear_usec() {
+  usec_ = 0u;
+}
+inline ::google::protobuf::uint32 Timestamp::usec() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Common.Timestamp.usec)
+  return usec_;
+}
+inline void Timestamp::set_usec(::google::protobuf::uint32 value) {
+  
+  usec_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Common.Timestamp.usec)
+}
+
+// -------------------------------------------------------------------
+
+// UserProfileHandle
+
+// uint32 identifier = 1;
+inline void UserProfileHandle::clear_identifier() {
+  identifier_ = 0u;
+}
+inline ::google::protobuf::uint32 UserProfileHandle::identifier() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Common.UserProfileHandle.identifier)
+  return identifier_;
+}
+inline void UserProfileHandle::set_identifier(::google::protobuf::uint32 value) {
+  
+  identifier_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Common.UserProfileHandle.identifier)
+}
+
+// fixed32 permission = 2;
+inline void UserProfileHandle::clear_permission() {
+  permission_ = 0u;
+}
+inline ::google::protobuf::uint32 UserProfileHandle::permission() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Common.UserProfileHandle.permission)
+  return permission_;
+}
+inline void UserProfileHandle::set_permission(::google::protobuf::uint32 value) {
+  
+  permission_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Common.UserProfileHandle.permission)
+}
+
+// -------------------------------------------------------------------
+
+// Connection
+
+// .Kinova.Api.Common.UserProfileHandle user_handle = 1;
+inline bool Connection::has_user_handle() const {
+  return this != internal_default_instance() && user_handle_ != NULL;
+}
+inline void Connection::clear_user_handle() {
+  if (GetArenaNoVirtual() == NULL && user_handle_ != NULL) {
+    delete user_handle_;
+  }
+  user_handle_ = NULL;
+}
+inline const ::Kinova::Api::Common::UserProfileHandle& Connection::user_handle() const {
+  const ::Kinova::Api::Common::UserProfileHandle* p = user_handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Common.Connection.user_handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::UserProfileHandle*>(
+      &::Kinova::Api::Common::_UserProfileHandle_default_instance_);
+}
+inline ::Kinova::Api::Common::UserProfileHandle* Connection::release_user_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Common.Connection.user_handle)
+  
+  ::Kinova::Api::Common::UserProfileHandle* temp = user_handle_;
+  user_handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::UserProfileHandle* Connection::mutable_user_handle() {
+  
+  if (user_handle_ == NULL) {
+    user_handle_ = new ::Kinova::Api::Common::UserProfileHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Common.Connection.user_handle)
+  return user_handle_;
+}
+inline void Connection::set_allocated_user_handle(::Kinova::Api::Common::UserProfileHandle* user_handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete user_handle_;
+  }
+  if (user_handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      user_handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, user_handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  user_handle_ = user_handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Common.Connection.user_handle)
+}
+
+// string connection_information = 2;
+inline void Connection::clear_connection_information() {
+  connection_information_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& Connection::connection_information() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Common.Connection.connection_information)
+  return connection_information_.GetNoArena();
+}
+inline void Connection::set_connection_information(const ::std::string& value) {
+  
+  connection_information_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.Common.Connection.connection_information)
+}
+#if LANG_CXX11
+inline void Connection::set_connection_information(::std::string&& value) {
+  
+  connection_information_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:Kinova.Api.Common.Connection.connection_information)
+}
+#endif
+inline void Connection::set_connection_information(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  connection_information_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:Kinova.Api.Common.Connection.connection_information)
+}
+inline void Connection::set_connection_information(const char* value, size_t size) {
+  
+  connection_information_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:Kinova.Api.Common.Connection.connection_information)
+}
+inline ::std::string* Connection::mutable_connection_information() {
+  
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Common.Connection.connection_information)
+  return connection_information_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* Connection::release_connection_information() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Common.Connection.connection_information)
+  
+  return connection_information_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void Connection::set_allocated_connection_information(::std::string* connection_information) {
+  if (connection_information != NULL) {
+    
+  } else {
+    
+  }
+  connection_information_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), connection_information);
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Common.Connection.connection_information)
+}
+
+// uint32 connection_identifier = 3;
+inline void Connection::clear_connection_identifier() {
+  connection_identifier_ = 0u;
+}
+inline ::google::protobuf::uint32 Connection::connection_identifier() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Common.Connection.connection_identifier)
+  return connection_identifier_;
+}
+inline void Connection::set_connection_identifier(::google::protobuf::uint32 value) {
+  
+  connection_identifier_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Common.Connection.connection_identifier)
+}
+
+// -------------------------------------------------------------------
+
+// UARTConfiguration
+
+// uint32 port_id = 1;
+inline void UARTConfiguration::clear_port_id() {
+  port_id_ = 0u;
+}
+inline ::google::protobuf::uint32 UARTConfiguration::port_id() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Common.UARTConfiguration.port_id)
+  return port_id_;
+}
+inline void UARTConfiguration::set_port_id(::google::protobuf::uint32 value) {
+  
+  port_id_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Common.UARTConfiguration.port_id)
+}
+
+// bool enabled = 2;
+inline void UARTConfiguration::clear_enabled() {
+  enabled_ = false;
+}
+inline bool UARTConfiguration::enabled() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Common.UARTConfiguration.enabled)
+  return enabled_;
+}
+inline void UARTConfiguration::set_enabled(bool value) {
+  
+  enabled_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Common.UARTConfiguration.enabled)
+}
+
+// .Kinova.Api.Common.UARTSpeed speed = 3;
+inline void UARTConfiguration::clear_speed() {
+  speed_ = 0;
+}
+inline ::Kinova::Api::Common::UARTSpeed UARTConfiguration::speed() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Common.UARTConfiguration.speed)
+  return static_cast< ::Kinova::Api::Common::UARTSpeed >(speed_);
+}
+inline void UARTConfiguration::set_speed(::Kinova::Api::Common::UARTSpeed value) {
+  
+  speed_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Common.UARTConfiguration.speed)
+}
+
+// .Kinova.Api.Common.UARTWordLength word_length = 4;
+inline void UARTConfiguration::clear_word_length() {
+  word_length_ = 0;
+}
+inline ::Kinova::Api::Common::UARTWordLength UARTConfiguration::word_length() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Common.UARTConfiguration.word_length)
+  return static_cast< ::Kinova::Api::Common::UARTWordLength >(word_length_);
+}
+inline void UARTConfiguration::set_word_length(::Kinova::Api::Common::UARTWordLength value) {
+  
+  word_length_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Common.UARTConfiguration.word_length)
+}
+
+// .Kinova.Api.Common.UARTStopBits stop_bits = 5;
+inline void UARTConfiguration::clear_stop_bits() {
+  stop_bits_ = 0;
+}
+inline ::Kinova::Api::Common::UARTStopBits UARTConfiguration::stop_bits() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Common.UARTConfiguration.stop_bits)
+  return static_cast< ::Kinova::Api::Common::UARTStopBits >(stop_bits_);
+}
+inline void UARTConfiguration::set_stop_bits(::Kinova::Api::Common::UARTStopBits value) {
+  
+  stop_bits_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Common.UARTConfiguration.stop_bits)
+}
+
+// .Kinova.Api.Common.UARTParity parity = 6;
+inline void UARTConfiguration::clear_parity() {
+  parity_ = 0;
+}
+inline ::Kinova::Api::Common::UARTParity UARTConfiguration::parity() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Common.UARTConfiguration.parity)
+  return static_cast< ::Kinova::Api::Common::UARTParity >(parity_);
+}
+inline void UARTConfiguration::set_parity(::Kinova::Api::Common::UARTParity value) {
+  
+  parity_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Common.UARTConfiguration.parity)
+}
+
+// -------------------------------------------------------------------
+
+// UARTDeviceIdentification
+
+// uint32 port_id = 1;
+inline void UARTDeviceIdentification::clear_port_id() {
+  port_id_ = 0u;
+}
+inline ::google::protobuf::uint32 UARTDeviceIdentification::port_id() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Common.UARTDeviceIdentification.port_id)
+  return port_id_;
+}
+inline void UARTDeviceIdentification::set_port_id(::google::protobuf::uint32 value) {
+  
+  port_id_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Common.UARTDeviceIdentification.port_id)
+}
+
+// -------------------------------------------------------------------
+
+// CountryCode
+
+// .Kinova.Api.Common.CountryCodeIdentifier identifier = 1;
+inline void CountryCode::clear_identifier() {
+  identifier_ = 0;
+}
+inline ::Kinova::Api::Common::CountryCodeIdentifier CountryCode::identifier() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Common.CountryCode.identifier)
+  return static_cast< ::Kinova::Api::Common::CountryCodeIdentifier >(identifier_);
+}
+inline void CountryCode::set_identifier(::Kinova::Api::Common::CountryCodeIdentifier value) {
+  
+  identifier_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Common.CountryCode.identifier)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace Common
+}  // namespace Api
+}  // namespace Kinova
+
+namespace google {
+namespace protobuf {
+
+template <> struct is_proto_enum< ::Kinova::Api::Common::DeviceTypes> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Common::DeviceTypes>() {
+  return ::Kinova::Api::Common::DeviceTypes_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::Common::SafetyStatusValue> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Common::SafetyStatusValue>() {
+  return ::Kinova::Api::Common::SafetyStatusValue_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::Common::Permission> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Common::Permission>() {
+  return ::Kinova::Api::Common::Permission_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::Common::NotificationType> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Common::NotificationType>() {
+  return ::Kinova::Api::Common::NotificationType_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::Common::Unit> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Common::Unit>() {
+  return ::Kinova::Api::Common::Unit_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::Common::ArmState> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Common::ArmState>() {
+  return ::Kinova::Api::Common::ArmState_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::Common::UARTSpeed> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Common::UARTSpeed>() {
+  return ::Kinova::Api::Common::UARTSpeed_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::Common::UARTWordLength> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Common::UARTWordLength>() {
+  return ::Kinova::Api::Common::UARTWordLength_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::Common::UARTStopBits> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Common::UARTStopBits>() {
+  return ::Kinova::Api::Common::UARTStopBits_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::Common::UARTParity> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Common::UARTParity>() {
+  return ::Kinova::Api::Common::UARTParity_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::Common::CartesianReferenceFrame> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Common::CartesianReferenceFrame>() {
+  return ::Kinova::Api::Common::CartesianReferenceFrame_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::Common::CountryCodeIdentifier> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Common::CountryCodeIdentifier>() {
+  return ::Kinova::Api::Common::CountryCodeIdentifier_descriptor();
+}
+
+}  // namespace protobuf
+}  // namespace google
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_Common_2eproto__INCLUDED
diff --git a/kortex_api/include/messages/ControlConfig.pb.h b/kortex_api/include/messages/ControlConfig.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..6a83920db7362e6c8b37262cda8fa15452b9d5d6
--- /dev/null
+++ b/kortex_api/include/messages/ControlConfig.pb.h
@@ -0,0 +1,3629 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: ControlConfig.proto
+
+#ifndef PROTOBUF_ControlConfig_2eproto__INCLUDED
+#define PROTOBUF_ControlConfig_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 3005000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 3005001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "Common.pb.h"  // IWYU pragma: export
+// @@protoc_insertion_point(includes)
+
+namespace protobuf_ControlConfig_2eproto {
+// Internal implementation detail -- do not use these members.
+struct TableStruct {
+  static const ::google::protobuf::internal::ParseTableField entries[];
+  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
+  static const ::google::protobuf::internal::ParseTable schema[19];
+  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
+  static const ::google::protobuf::internal::SerializationTable serialization_table[];
+  static const ::google::protobuf::uint32 offsets[];
+};
+void AddDescriptors();
+void InitDefaultsGravityVectorImpl();
+void InitDefaultsGravityVector();
+void InitDefaultsPositionImpl();
+void InitDefaultsPosition();
+void InitDefaultsPayloadInformationImpl();
+void InitDefaultsPayloadInformation();
+void InitDefaultsCartesianTransformImpl();
+void InitDefaultsCartesianTransform();
+void InitDefaultsToolConfigurationImpl();
+void InitDefaultsToolConfiguration();
+void InitDefaultsControlConfigurationNotificationImpl();
+void InitDefaultsControlConfigurationNotification();
+void InitDefaultsCartesianReferenceFrameInfoImpl();
+void InitDefaultsCartesianReferenceFrameInfo();
+void InitDefaultsTwistLinearSoftLimitImpl();
+void InitDefaultsTwistLinearSoftLimit();
+void InitDefaultsTwistAngularSoftLimitImpl();
+void InitDefaultsTwistAngularSoftLimit();
+void InitDefaultsJointSpeedSoftLimitsImpl();
+void InitDefaultsJointSpeedSoftLimits();
+void InitDefaultsJointAccelerationSoftLimitsImpl();
+void InitDefaultsJointAccelerationSoftLimits();
+void InitDefaultsKinematicLimitsImpl();
+void InitDefaultsKinematicLimits();
+void InitDefaultsKinematicLimitsListImpl();
+void InitDefaultsKinematicLimitsList();
+void InitDefaultsDesiredSpeedsImpl();
+void InitDefaultsDesiredSpeeds();
+void InitDefaultsLinearTwistImpl();
+void InitDefaultsLinearTwist();
+void InitDefaultsAngularTwistImpl();
+void InitDefaultsAngularTwist();
+void InitDefaultsJointSpeedsImpl();
+void InitDefaultsJointSpeeds();
+void InitDefaultsControlModeInformationImpl();
+void InitDefaultsControlModeInformation();
+void InitDefaultsControlModeNotificationImpl();
+void InitDefaultsControlModeNotification();
+inline void InitDefaults() {
+  InitDefaultsGravityVector();
+  InitDefaultsPosition();
+  InitDefaultsPayloadInformation();
+  InitDefaultsCartesianTransform();
+  InitDefaultsToolConfiguration();
+  InitDefaultsControlConfigurationNotification();
+  InitDefaultsCartesianReferenceFrameInfo();
+  InitDefaultsTwistLinearSoftLimit();
+  InitDefaultsTwistAngularSoftLimit();
+  InitDefaultsJointSpeedSoftLimits();
+  InitDefaultsJointAccelerationSoftLimits();
+  InitDefaultsKinematicLimits();
+  InitDefaultsKinematicLimitsList();
+  InitDefaultsDesiredSpeeds();
+  InitDefaultsLinearTwist();
+  InitDefaultsAngularTwist();
+  InitDefaultsJointSpeeds();
+  InitDefaultsControlModeInformation();
+  InitDefaultsControlModeNotification();
+}
+}  // namespace protobuf_ControlConfig_2eproto
+namespace Kinova {
+namespace Api {
+namespace ControlConfig {
+class AngularTwist;
+class AngularTwistDefaultTypeInternal;
+extern AngularTwistDefaultTypeInternal _AngularTwist_default_instance_;
+class CartesianReferenceFrameInfo;
+class CartesianReferenceFrameInfoDefaultTypeInternal;
+extern CartesianReferenceFrameInfoDefaultTypeInternal _CartesianReferenceFrameInfo_default_instance_;
+class CartesianTransform;
+class CartesianTransformDefaultTypeInternal;
+extern CartesianTransformDefaultTypeInternal _CartesianTransform_default_instance_;
+class ControlConfigurationNotification;
+class ControlConfigurationNotificationDefaultTypeInternal;
+extern ControlConfigurationNotificationDefaultTypeInternal _ControlConfigurationNotification_default_instance_;
+class ControlModeInformation;
+class ControlModeInformationDefaultTypeInternal;
+extern ControlModeInformationDefaultTypeInternal _ControlModeInformation_default_instance_;
+class ControlModeNotification;
+class ControlModeNotificationDefaultTypeInternal;
+extern ControlModeNotificationDefaultTypeInternal _ControlModeNotification_default_instance_;
+class DesiredSpeeds;
+class DesiredSpeedsDefaultTypeInternal;
+extern DesiredSpeedsDefaultTypeInternal _DesiredSpeeds_default_instance_;
+class GravityVector;
+class GravityVectorDefaultTypeInternal;
+extern GravityVectorDefaultTypeInternal _GravityVector_default_instance_;
+class JointAccelerationSoftLimits;
+class JointAccelerationSoftLimitsDefaultTypeInternal;
+extern JointAccelerationSoftLimitsDefaultTypeInternal _JointAccelerationSoftLimits_default_instance_;
+class JointSpeedSoftLimits;
+class JointSpeedSoftLimitsDefaultTypeInternal;
+extern JointSpeedSoftLimitsDefaultTypeInternal _JointSpeedSoftLimits_default_instance_;
+class JointSpeeds;
+class JointSpeedsDefaultTypeInternal;
+extern JointSpeedsDefaultTypeInternal _JointSpeeds_default_instance_;
+class KinematicLimits;
+class KinematicLimitsDefaultTypeInternal;
+extern KinematicLimitsDefaultTypeInternal _KinematicLimits_default_instance_;
+class KinematicLimitsList;
+class KinematicLimitsListDefaultTypeInternal;
+extern KinematicLimitsListDefaultTypeInternal _KinematicLimitsList_default_instance_;
+class LinearTwist;
+class LinearTwistDefaultTypeInternal;
+extern LinearTwistDefaultTypeInternal _LinearTwist_default_instance_;
+class PayloadInformation;
+class PayloadInformationDefaultTypeInternal;
+extern PayloadInformationDefaultTypeInternal _PayloadInformation_default_instance_;
+class Position;
+class PositionDefaultTypeInternal;
+extern PositionDefaultTypeInternal _Position_default_instance_;
+class ToolConfiguration;
+class ToolConfigurationDefaultTypeInternal;
+extern ToolConfigurationDefaultTypeInternal _ToolConfiguration_default_instance_;
+class TwistAngularSoftLimit;
+class TwistAngularSoftLimitDefaultTypeInternal;
+extern TwistAngularSoftLimitDefaultTypeInternal _TwistAngularSoftLimit_default_instance_;
+class TwistLinearSoftLimit;
+class TwistLinearSoftLimitDefaultTypeInternal;
+extern TwistLinearSoftLimitDefaultTypeInternal _TwistLinearSoftLimit_default_instance_;
+}  // namespace ControlConfig
+}  // namespace Api
+}  // namespace Kinova
+namespace Kinova {
+namespace Api {
+namespace ControlConfig {
+
+enum ServiceVersion {
+  RESERVED_0 = 0,
+  CURRENT_VERSION = 1,
+  ServiceVersion_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  ServiceVersion_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool ServiceVersion_IsValid(int value);
+const ServiceVersion ServiceVersion_MIN = RESERVED_0;
+const ServiceVersion ServiceVersion_MAX = CURRENT_VERSION;
+const int ServiceVersion_ARRAYSIZE = ServiceVersion_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* ServiceVersion_descriptor();
+inline const ::std::string& ServiceVersion_Name(ServiceVersion value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    ServiceVersion_descriptor(), value);
+}
+inline bool ServiceVersion_Parse(
+    const ::std::string& name, ServiceVersion* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<ServiceVersion>(
+    ServiceVersion_descriptor(), name, value);
+}
+enum ControlConfigurationEvent {
+  UNSPECIFIED_CONTROL_CONFIGURATION_EVENT = 0,
+  ANGLE_UNIT_CHANGED = 1,
+  GRAVITY_VECTOR_CHANGED = 2,
+  JOINT_ADMITTANCE_CONFIGURATION_CHANGED = 4,
+  NULL_ADMITTANCE_CONFIGURATION_CHANGED = 5,
+  CARTESIAN_ADMITTANCE_CONFIGURATION_CHANGED = 6,
+  JOINT_TORQUE_HYBRID_CONFIGURATION_CHANGED = 7,
+  WRENCH_COMMAND_NORMAL_CONFIGURATION_CHANGED = 8,
+  WRENCH_COMMAND_RESTRICTED_CONFIGURATION_CHANGED = 9,
+  CONTROL_CONFIGURATION_FACTORY_RESTORED = 10,
+  TOOL_CONFIGURATION_CHANGED = 11,
+  PAYLOAD_CONFIGURATION_CHANGED = 12,
+  CARTESIAN_REFERENCE_CHANGED = 13,
+  CHANGE_CONTROL_MODE_FAILED = 14,
+  JOINT_SPEED_SOFT_LIMITS_CHANGED = 16,
+  TWIST_LINEAR_SOFT_LIMIT_CHANGED = 17,
+  TWIST_ANGULAR_SOFT_LIMIT_CHANGED = 18,
+  JOINT_ACCELERATION_SOFT_LIMITS_CHANGED = 19,
+  DESIRED_TWIST_LINEAR_SPEED_CHANGED = 20,
+  DESIRED_TWIST_ANGULAR_SPEED_CHANGED = 21,
+  DESIRED_JOINT_SPEED_CHANGED = 22,
+  ControlConfigurationEvent_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  ControlConfigurationEvent_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool ControlConfigurationEvent_IsValid(int value);
+const ControlConfigurationEvent ControlConfigurationEvent_MIN = UNSPECIFIED_CONTROL_CONFIGURATION_EVENT;
+const ControlConfigurationEvent ControlConfigurationEvent_MAX = DESIRED_JOINT_SPEED_CHANGED;
+const int ControlConfigurationEvent_ARRAYSIZE = ControlConfigurationEvent_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* ControlConfigurationEvent_descriptor();
+inline const ::std::string& ControlConfigurationEvent_Name(ControlConfigurationEvent value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    ControlConfigurationEvent_descriptor(), value);
+}
+inline bool ControlConfigurationEvent_Parse(
+    const ::std::string& name, ControlConfigurationEvent* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<ControlConfigurationEvent>(
+    ControlConfigurationEvent_descriptor(), name, value);
+}
+enum ControlMode {
+  UNSPECIFIED_CONTROL_MODE = 0,
+  ANGULAR_JOYSTICK = 1,
+  CARTESIAN_JOYSTICK = 2,
+  ANGULAR_TRAJECTORY = 4,
+  CARTESIAN_TRAJECTORY = 5,
+  CARTESIAN_ADMITTANCE = 6,
+  JOINT_ADMITTANCE = 7,
+  NULL_SPACE_ADMITTANCE = 8,
+  FORCE_CONTROL = 10,
+  FORCE_CONTROL_MOTION_RESTRICTED = 11,
+  CARTESIAN_WAYPOINT_TRAJECTORY = 12,
+  IDLE = 13,
+  ControlMode_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  ControlMode_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool ControlMode_IsValid(int value);
+const ControlMode ControlMode_MIN = UNSPECIFIED_CONTROL_MODE;
+const ControlMode ControlMode_MAX = IDLE;
+const int ControlMode_ARRAYSIZE = ControlMode_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* ControlMode_descriptor();
+inline const ::std::string& ControlMode_Name(ControlMode value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    ControlMode_descriptor(), value);
+}
+inline bool ControlMode_Parse(
+    const ::std::string& name, ControlMode* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<ControlMode>(
+    ControlMode_descriptor(), name, value);
+}
+// ===================================================================
+
+class GravityVector : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.ControlConfig.GravityVector) */ {
+ public:
+  GravityVector();
+  virtual ~GravityVector();
+
+  GravityVector(const GravityVector& from);
+
+  inline GravityVector& operator=(const GravityVector& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  GravityVector(GravityVector&& from) noexcept
+    : GravityVector() {
+    *this = ::std::move(from);
+  }
+
+  inline GravityVector& operator=(GravityVector&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const GravityVector& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const GravityVector* internal_default_instance() {
+    return reinterpret_cast<const GravityVector*>(
+               &_GravityVector_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    0;
+
+  void Swap(GravityVector* other);
+  friend void swap(GravityVector& a, GravityVector& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline GravityVector* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  GravityVector* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const GravityVector& from);
+  void MergeFrom(const GravityVector& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(GravityVector* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // float x = 1;
+  void clear_x();
+  static const int kXFieldNumber = 1;
+  float x() const;
+  void set_x(float value);
+
+  // float y = 2;
+  void clear_y();
+  static const int kYFieldNumber = 2;
+  float y() const;
+  void set_y(float value);
+
+  // float z = 3;
+  void clear_z();
+  static const int kZFieldNumber = 3;
+  float z() const;
+  void set_z(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.ControlConfig.GravityVector)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  float x_;
+  float y_;
+  float z_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_ControlConfig_2eproto::TableStruct;
+  friend void ::protobuf_ControlConfig_2eproto::InitDefaultsGravityVectorImpl();
+};
+// -------------------------------------------------------------------
+
+class Position : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.ControlConfig.Position) */ {
+ public:
+  Position();
+  virtual ~Position();
+
+  Position(const Position& from);
+
+  inline Position& operator=(const Position& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Position(Position&& from) noexcept
+    : Position() {
+    *this = ::std::move(from);
+  }
+
+  inline Position& operator=(Position&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Position& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Position* internal_default_instance() {
+    return reinterpret_cast<const Position*>(
+               &_Position_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    1;
+
+  void Swap(Position* other);
+  friend void swap(Position& a, Position& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Position* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Position* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Position& from);
+  void MergeFrom(const Position& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Position* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // float x = 1;
+  void clear_x();
+  static const int kXFieldNumber = 1;
+  float x() const;
+  void set_x(float value);
+
+  // float y = 2;
+  void clear_y();
+  static const int kYFieldNumber = 2;
+  float y() const;
+  void set_y(float value);
+
+  // float z = 3;
+  void clear_z();
+  static const int kZFieldNumber = 3;
+  float z() const;
+  void set_z(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.ControlConfig.Position)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  float x_;
+  float y_;
+  float z_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_ControlConfig_2eproto::TableStruct;
+  friend void ::protobuf_ControlConfig_2eproto::InitDefaultsPositionImpl();
+};
+// -------------------------------------------------------------------
+
+class PayloadInformation : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.ControlConfig.PayloadInformation) */ {
+ public:
+  PayloadInformation();
+  virtual ~PayloadInformation();
+
+  PayloadInformation(const PayloadInformation& from);
+
+  inline PayloadInformation& operator=(const PayloadInformation& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  PayloadInformation(PayloadInformation&& from) noexcept
+    : PayloadInformation() {
+    *this = ::std::move(from);
+  }
+
+  inline PayloadInformation& operator=(PayloadInformation&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const PayloadInformation& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const PayloadInformation* internal_default_instance() {
+    return reinterpret_cast<const PayloadInformation*>(
+               &_PayloadInformation_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    2;
+
+  void Swap(PayloadInformation* other);
+  friend void swap(PayloadInformation& a, PayloadInformation& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline PayloadInformation* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  PayloadInformation* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const PayloadInformation& from);
+  void MergeFrom(const PayloadInformation& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(PayloadInformation* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.ControlConfig.Position payload_mass_center = 2;
+  bool has_payload_mass_center() const;
+  void clear_payload_mass_center();
+  static const int kPayloadMassCenterFieldNumber = 2;
+  const ::Kinova::Api::ControlConfig::Position& payload_mass_center() const;
+  ::Kinova::Api::ControlConfig::Position* release_payload_mass_center();
+  ::Kinova::Api::ControlConfig::Position* mutable_payload_mass_center();
+  void set_allocated_payload_mass_center(::Kinova::Api::ControlConfig::Position* payload_mass_center);
+
+  // float payload_mass = 1;
+  void clear_payload_mass();
+  static const int kPayloadMassFieldNumber = 1;
+  float payload_mass() const;
+  void set_payload_mass(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.ControlConfig.PayloadInformation)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::ControlConfig::Position* payload_mass_center_;
+  float payload_mass_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_ControlConfig_2eproto::TableStruct;
+  friend void ::protobuf_ControlConfig_2eproto::InitDefaultsPayloadInformationImpl();
+};
+// -------------------------------------------------------------------
+
+class CartesianTransform : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.ControlConfig.CartesianTransform) */ {
+ public:
+  CartesianTransform();
+  virtual ~CartesianTransform();
+
+  CartesianTransform(const CartesianTransform& from);
+
+  inline CartesianTransform& operator=(const CartesianTransform& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  CartesianTransform(CartesianTransform&& from) noexcept
+    : CartesianTransform() {
+    *this = ::std::move(from);
+  }
+
+  inline CartesianTransform& operator=(CartesianTransform&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const CartesianTransform& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const CartesianTransform* internal_default_instance() {
+    return reinterpret_cast<const CartesianTransform*>(
+               &_CartesianTransform_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    3;
+
+  void Swap(CartesianTransform* other);
+  friend void swap(CartesianTransform& a, CartesianTransform& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline CartesianTransform* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  CartesianTransform* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const CartesianTransform& from);
+  void MergeFrom(const CartesianTransform& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(CartesianTransform* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // float x = 1;
+  void clear_x();
+  static const int kXFieldNumber = 1;
+  float x() const;
+  void set_x(float value);
+
+  // float y = 2;
+  void clear_y();
+  static const int kYFieldNumber = 2;
+  float y() const;
+  void set_y(float value);
+
+  // float z = 3;
+  void clear_z();
+  static const int kZFieldNumber = 3;
+  float z() const;
+  void set_z(float value);
+
+  // float theta_x = 4;
+  void clear_theta_x();
+  static const int kThetaXFieldNumber = 4;
+  float theta_x() const;
+  void set_theta_x(float value);
+
+  // float theta_y = 5;
+  void clear_theta_y();
+  static const int kThetaYFieldNumber = 5;
+  float theta_y() const;
+  void set_theta_y(float value);
+
+  // float theta_z = 6;
+  void clear_theta_z();
+  static const int kThetaZFieldNumber = 6;
+  float theta_z() const;
+  void set_theta_z(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.ControlConfig.CartesianTransform)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  float x_;
+  float y_;
+  float z_;
+  float theta_x_;
+  float theta_y_;
+  float theta_z_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_ControlConfig_2eproto::TableStruct;
+  friend void ::protobuf_ControlConfig_2eproto::InitDefaultsCartesianTransformImpl();
+};
+// -------------------------------------------------------------------
+
+class ToolConfiguration : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.ControlConfig.ToolConfiguration) */ {
+ public:
+  ToolConfiguration();
+  virtual ~ToolConfiguration();
+
+  ToolConfiguration(const ToolConfiguration& from);
+
+  inline ToolConfiguration& operator=(const ToolConfiguration& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ToolConfiguration(ToolConfiguration&& from) noexcept
+    : ToolConfiguration() {
+    *this = ::std::move(from);
+  }
+
+  inline ToolConfiguration& operator=(ToolConfiguration&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ToolConfiguration& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ToolConfiguration* internal_default_instance() {
+    return reinterpret_cast<const ToolConfiguration*>(
+               &_ToolConfiguration_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    4;
+
+  void Swap(ToolConfiguration* other);
+  friend void swap(ToolConfiguration& a, ToolConfiguration& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ToolConfiguration* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ToolConfiguration* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ToolConfiguration& from);
+  void MergeFrom(const ToolConfiguration& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ToolConfiguration* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.ControlConfig.CartesianTransform tool_transform = 1;
+  bool has_tool_transform() const;
+  void clear_tool_transform();
+  static const int kToolTransformFieldNumber = 1;
+  const ::Kinova::Api::ControlConfig::CartesianTransform& tool_transform() const;
+  ::Kinova::Api::ControlConfig::CartesianTransform* release_tool_transform();
+  ::Kinova::Api::ControlConfig::CartesianTransform* mutable_tool_transform();
+  void set_allocated_tool_transform(::Kinova::Api::ControlConfig::CartesianTransform* tool_transform);
+
+  // .Kinova.Api.ControlConfig.Position tool_mass_center = 3;
+  bool has_tool_mass_center() const;
+  void clear_tool_mass_center();
+  static const int kToolMassCenterFieldNumber = 3;
+  const ::Kinova::Api::ControlConfig::Position& tool_mass_center() const;
+  ::Kinova::Api::ControlConfig::Position* release_tool_mass_center();
+  ::Kinova::Api::ControlConfig::Position* mutable_tool_mass_center();
+  void set_allocated_tool_mass_center(::Kinova::Api::ControlConfig::Position* tool_mass_center);
+
+  // float tool_mass = 2;
+  void clear_tool_mass();
+  static const int kToolMassFieldNumber = 2;
+  float tool_mass() const;
+  void set_tool_mass(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.ControlConfig.ToolConfiguration)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::ControlConfig::CartesianTransform* tool_transform_;
+  ::Kinova::Api::ControlConfig::Position* tool_mass_center_;
+  float tool_mass_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_ControlConfig_2eproto::TableStruct;
+  friend void ::protobuf_ControlConfig_2eproto::InitDefaultsToolConfigurationImpl();
+};
+// -------------------------------------------------------------------
+
+class ControlConfigurationNotification : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.ControlConfig.ControlConfigurationNotification) */ {
+ public:
+  ControlConfigurationNotification();
+  virtual ~ControlConfigurationNotification();
+
+  ControlConfigurationNotification(const ControlConfigurationNotification& from);
+
+  inline ControlConfigurationNotification& operator=(const ControlConfigurationNotification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ControlConfigurationNotification(ControlConfigurationNotification&& from) noexcept
+    : ControlConfigurationNotification() {
+    *this = ::std::move(from);
+  }
+
+  inline ControlConfigurationNotification& operator=(ControlConfigurationNotification&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ControlConfigurationNotification& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ControlConfigurationNotification* internal_default_instance() {
+    return reinterpret_cast<const ControlConfigurationNotification*>(
+               &_ControlConfigurationNotification_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    5;
+
+  void Swap(ControlConfigurationNotification* other);
+  friend void swap(ControlConfigurationNotification& a, ControlConfigurationNotification& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ControlConfigurationNotification* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ControlConfigurationNotification* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ControlConfigurationNotification& from);
+  void MergeFrom(const ControlConfigurationNotification& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ControlConfigurationNotification* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Common.Timestamp timestamp = 2;
+  bool has_timestamp() const;
+  void clear_timestamp();
+  static const int kTimestampFieldNumber = 2;
+  const ::Kinova::Api::Common::Timestamp& timestamp() const;
+  ::Kinova::Api::Common::Timestamp* release_timestamp();
+  ::Kinova::Api::Common::Timestamp* mutable_timestamp();
+  void set_allocated_timestamp(::Kinova::Api::Common::Timestamp* timestamp);
+
+  // .Kinova.Api.Common.UserProfileHandle user_handle = 3;
+  bool has_user_handle() const;
+  void clear_user_handle();
+  static const int kUserHandleFieldNumber = 3;
+  const ::Kinova::Api::Common::UserProfileHandle& user_handle() const;
+  ::Kinova::Api::Common::UserProfileHandle* release_user_handle();
+  ::Kinova::Api::Common::UserProfileHandle* mutable_user_handle();
+  void set_allocated_user_handle(::Kinova::Api::Common::UserProfileHandle* user_handle);
+
+  // .Kinova.Api.Common.Connection connection = 4;
+  bool has_connection() const;
+  void clear_connection();
+  static const int kConnectionFieldNumber = 4;
+  const ::Kinova::Api::Common::Connection& connection() const;
+  ::Kinova::Api::Common::Connection* release_connection();
+  ::Kinova::Api::Common::Connection* mutable_connection();
+  void set_allocated_connection(::Kinova::Api::Common::Connection* connection);
+
+  // .Kinova.Api.ControlConfig.ControlConfigurationEvent event = 1;
+  void clear_event();
+  static const int kEventFieldNumber = 1;
+  ::Kinova::Api::ControlConfig::ControlConfigurationEvent event() const;
+  void set_event(::Kinova::Api::ControlConfig::ControlConfigurationEvent value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.ControlConfig.ControlConfigurationNotification)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::Common::Timestamp* timestamp_;
+  ::Kinova::Api::Common::UserProfileHandle* user_handle_;
+  ::Kinova::Api::Common::Connection* connection_;
+  int event_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_ControlConfig_2eproto::TableStruct;
+  friend void ::protobuf_ControlConfig_2eproto::InitDefaultsControlConfigurationNotificationImpl();
+};
+// -------------------------------------------------------------------
+
+class CartesianReferenceFrameInfo : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.ControlConfig.CartesianReferenceFrameInfo) */ {
+ public:
+  CartesianReferenceFrameInfo();
+  virtual ~CartesianReferenceFrameInfo();
+
+  CartesianReferenceFrameInfo(const CartesianReferenceFrameInfo& from);
+
+  inline CartesianReferenceFrameInfo& operator=(const CartesianReferenceFrameInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  CartesianReferenceFrameInfo(CartesianReferenceFrameInfo&& from) noexcept
+    : CartesianReferenceFrameInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline CartesianReferenceFrameInfo& operator=(CartesianReferenceFrameInfo&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const CartesianReferenceFrameInfo& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const CartesianReferenceFrameInfo* internal_default_instance() {
+    return reinterpret_cast<const CartesianReferenceFrameInfo*>(
+               &_CartesianReferenceFrameInfo_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    6;
+
+  void Swap(CartesianReferenceFrameInfo* other);
+  friend void swap(CartesianReferenceFrameInfo& a, CartesianReferenceFrameInfo& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline CartesianReferenceFrameInfo* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  CartesianReferenceFrameInfo* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const CartesianReferenceFrameInfo& from);
+  void MergeFrom(const CartesianReferenceFrameInfo& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(CartesianReferenceFrameInfo* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Common.CartesianReferenceFrame reference_frame = 1;
+  void clear_reference_frame();
+  static const int kReferenceFrameFieldNumber = 1;
+  ::Kinova::Api::Common::CartesianReferenceFrame reference_frame() const;
+  void set_reference_frame(::Kinova::Api::Common::CartesianReferenceFrame value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.ControlConfig.CartesianReferenceFrameInfo)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  int reference_frame_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_ControlConfig_2eproto::TableStruct;
+  friend void ::protobuf_ControlConfig_2eproto::InitDefaultsCartesianReferenceFrameInfoImpl();
+};
+// -------------------------------------------------------------------
+
+class TwistLinearSoftLimit : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.ControlConfig.TwistLinearSoftLimit) */ {
+ public:
+  TwistLinearSoftLimit();
+  virtual ~TwistLinearSoftLimit();
+
+  TwistLinearSoftLimit(const TwistLinearSoftLimit& from);
+
+  inline TwistLinearSoftLimit& operator=(const TwistLinearSoftLimit& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  TwistLinearSoftLimit(TwistLinearSoftLimit&& from) noexcept
+    : TwistLinearSoftLimit() {
+    *this = ::std::move(from);
+  }
+
+  inline TwistLinearSoftLimit& operator=(TwistLinearSoftLimit&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const TwistLinearSoftLimit& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const TwistLinearSoftLimit* internal_default_instance() {
+    return reinterpret_cast<const TwistLinearSoftLimit*>(
+               &_TwistLinearSoftLimit_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    7;
+
+  void Swap(TwistLinearSoftLimit* other);
+  friend void swap(TwistLinearSoftLimit& a, TwistLinearSoftLimit& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline TwistLinearSoftLimit* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  TwistLinearSoftLimit* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const TwistLinearSoftLimit& from);
+  void MergeFrom(const TwistLinearSoftLimit& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(TwistLinearSoftLimit* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.ControlConfig.ControlMode control_mode = 1;
+  void clear_control_mode();
+  static const int kControlModeFieldNumber = 1;
+  ::Kinova::Api::ControlConfig::ControlMode control_mode() const;
+  void set_control_mode(::Kinova::Api::ControlConfig::ControlMode value);
+
+  // float twist_linear_soft_limit = 2;
+  void clear_twist_linear_soft_limit();
+  static const int kTwistLinearSoftLimitFieldNumber = 2;
+  float twist_linear_soft_limit() const;
+  void set_twist_linear_soft_limit(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.ControlConfig.TwistLinearSoftLimit)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  int control_mode_;
+  float twist_linear_soft_limit_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_ControlConfig_2eproto::TableStruct;
+  friend void ::protobuf_ControlConfig_2eproto::InitDefaultsTwistLinearSoftLimitImpl();
+};
+// -------------------------------------------------------------------
+
+class TwistAngularSoftLimit : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.ControlConfig.TwistAngularSoftLimit) */ {
+ public:
+  TwistAngularSoftLimit();
+  virtual ~TwistAngularSoftLimit();
+
+  TwistAngularSoftLimit(const TwistAngularSoftLimit& from);
+
+  inline TwistAngularSoftLimit& operator=(const TwistAngularSoftLimit& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  TwistAngularSoftLimit(TwistAngularSoftLimit&& from) noexcept
+    : TwistAngularSoftLimit() {
+    *this = ::std::move(from);
+  }
+
+  inline TwistAngularSoftLimit& operator=(TwistAngularSoftLimit&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const TwistAngularSoftLimit& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const TwistAngularSoftLimit* internal_default_instance() {
+    return reinterpret_cast<const TwistAngularSoftLimit*>(
+               &_TwistAngularSoftLimit_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    8;
+
+  void Swap(TwistAngularSoftLimit* other);
+  friend void swap(TwistAngularSoftLimit& a, TwistAngularSoftLimit& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline TwistAngularSoftLimit* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  TwistAngularSoftLimit* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const TwistAngularSoftLimit& from);
+  void MergeFrom(const TwistAngularSoftLimit& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(TwistAngularSoftLimit* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.ControlConfig.ControlMode control_mode = 1;
+  void clear_control_mode();
+  static const int kControlModeFieldNumber = 1;
+  ::Kinova::Api::ControlConfig::ControlMode control_mode() const;
+  void set_control_mode(::Kinova::Api::ControlConfig::ControlMode value);
+
+  // float twist_angular_soft_limit = 2;
+  void clear_twist_angular_soft_limit();
+  static const int kTwistAngularSoftLimitFieldNumber = 2;
+  float twist_angular_soft_limit() const;
+  void set_twist_angular_soft_limit(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.ControlConfig.TwistAngularSoftLimit)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  int control_mode_;
+  float twist_angular_soft_limit_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_ControlConfig_2eproto::TableStruct;
+  friend void ::protobuf_ControlConfig_2eproto::InitDefaultsTwistAngularSoftLimitImpl();
+};
+// -------------------------------------------------------------------
+
+class JointSpeedSoftLimits : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.ControlConfig.JointSpeedSoftLimits) */ {
+ public:
+  JointSpeedSoftLimits();
+  virtual ~JointSpeedSoftLimits();
+
+  JointSpeedSoftLimits(const JointSpeedSoftLimits& from);
+
+  inline JointSpeedSoftLimits& operator=(const JointSpeedSoftLimits& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  JointSpeedSoftLimits(JointSpeedSoftLimits&& from) noexcept
+    : JointSpeedSoftLimits() {
+    *this = ::std::move(from);
+  }
+
+  inline JointSpeedSoftLimits& operator=(JointSpeedSoftLimits&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const JointSpeedSoftLimits& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const JointSpeedSoftLimits* internal_default_instance() {
+    return reinterpret_cast<const JointSpeedSoftLimits*>(
+               &_JointSpeedSoftLimits_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    9;
+
+  void Swap(JointSpeedSoftLimits* other);
+  friend void swap(JointSpeedSoftLimits& a, JointSpeedSoftLimits& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline JointSpeedSoftLimits* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  JointSpeedSoftLimits* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const JointSpeedSoftLimits& from);
+  void MergeFrom(const JointSpeedSoftLimits& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(JointSpeedSoftLimits* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated float joint_speed_soft_limits = 2;
+  int joint_speed_soft_limits_size() const;
+  void clear_joint_speed_soft_limits();
+  static const int kJointSpeedSoftLimitsFieldNumber = 2;
+  float joint_speed_soft_limits(int index) const;
+  void set_joint_speed_soft_limits(int index, float value);
+  void add_joint_speed_soft_limits(float value);
+  const ::google::protobuf::RepeatedField< float >&
+      joint_speed_soft_limits() const;
+  ::google::protobuf::RepeatedField< float >*
+      mutable_joint_speed_soft_limits();
+
+  // .Kinova.Api.ControlConfig.ControlMode control_mode = 1;
+  void clear_control_mode();
+  static const int kControlModeFieldNumber = 1;
+  ::Kinova::Api::ControlConfig::ControlMode control_mode() const;
+  void set_control_mode(::Kinova::Api::ControlConfig::ControlMode value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.ControlConfig.JointSpeedSoftLimits)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedField< float > joint_speed_soft_limits_;
+  mutable int _joint_speed_soft_limits_cached_byte_size_;
+  int control_mode_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_ControlConfig_2eproto::TableStruct;
+  friend void ::protobuf_ControlConfig_2eproto::InitDefaultsJointSpeedSoftLimitsImpl();
+};
+// -------------------------------------------------------------------
+
+class JointAccelerationSoftLimits : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.ControlConfig.JointAccelerationSoftLimits) */ {
+ public:
+  JointAccelerationSoftLimits();
+  virtual ~JointAccelerationSoftLimits();
+
+  JointAccelerationSoftLimits(const JointAccelerationSoftLimits& from);
+
+  inline JointAccelerationSoftLimits& operator=(const JointAccelerationSoftLimits& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  JointAccelerationSoftLimits(JointAccelerationSoftLimits&& from) noexcept
+    : JointAccelerationSoftLimits() {
+    *this = ::std::move(from);
+  }
+
+  inline JointAccelerationSoftLimits& operator=(JointAccelerationSoftLimits&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const JointAccelerationSoftLimits& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const JointAccelerationSoftLimits* internal_default_instance() {
+    return reinterpret_cast<const JointAccelerationSoftLimits*>(
+               &_JointAccelerationSoftLimits_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    10;
+
+  void Swap(JointAccelerationSoftLimits* other);
+  friend void swap(JointAccelerationSoftLimits& a, JointAccelerationSoftLimits& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline JointAccelerationSoftLimits* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  JointAccelerationSoftLimits* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const JointAccelerationSoftLimits& from);
+  void MergeFrom(const JointAccelerationSoftLimits& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(JointAccelerationSoftLimits* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated float joint_acceleration_soft_limits = 2;
+  int joint_acceleration_soft_limits_size() const;
+  void clear_joint_acceleration_soft_limits();
+  static const int kJointAccelerationSoftLimitsFieldNumber = 2;
+  float joint_acceleration_soft_limits(int index) const;
+  void set_joint_acceleration_soft_limits(int index, float value);
+  void add_joint_acceleration_soft_limits(float value);
+  const ::google::protobuf::RepeatedField< float >&
+      joint_acceleration_soft_limits() const;
+  ::google::protobuf::RepeatedField< float >*
+      mutable_joint_acceleration_soft_limits();
+
+  // .Kinova.Api.ControlConfig.ControlMode control_mode = 1;
+  void clear_control_mode();
+  static const int kControlModeFieldNumber = 1;
+  ::Kinova::Api::ControlConfig::ControlMode control_mode() const;
+  void set_control_mode(::Kinova::Api::ControlConfig::ControlMode value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.ControlConfig.JointAccelerationSoftLimits)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedField< float > joint_acceleration_soft_limits_;
+  mutable int _joint_acceleration_soft_limits_cached_byte_size_;
+  int control_mode_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_ControlConfig_2eproto::TableStruct;
+  friend void ::protobuf_ControlConfig_2eproto::InitDefaultsJointAccelerationSoftLimitsImpl();
+};
+// -------------------------------------------------------------------
+
+class KinematicLimits : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.ControlConfig.KinematicLimits) */ {
+ public:
+  KinematicLimits();
+  virtual ~KinematicLimits();
+
+  KinematicLimits(const KinematicLimits& from);
+
+  inline KinematicLimits& operator=(const KinematicLimits& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  KinematicLimits(KinematicLimits&& from) noexcept
+    : KinematicLimits() {
+    *this = ::std::move(from);
+  }
+
+  inline KinematicLimits& operator=(KinematicLimits&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const KinematicLimits& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const KinematicLimits* internal_default_instance() {
+    return reinterpret_cast<const KinematicLimits*>(
+               &_KinematicLimits_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    11;
+
+  void Swap(KinematicLimits* other);
+  friend void swap(KinematicLimits& a, KinematicLimits& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline KinematicLimits* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  KinematicLimits* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const KinematicLimits& from);
+  void MergeFrom(const KinematicLimits& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(KinematicLimits* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated float joint_speed_limits = 4;
+  int joint_speed_limits_size() const;
+  void clear_joint_speed_limits();
+  static const int kJointSpeedLimitsFieldNumber = 4;
+  float joint_speed_limits(int index) const;
+  void set_joint_speed_limits(int index, float value);
+  void add_joint_speed_limits(float value);
+  const ::google::protobuf::RepeatedField< float >&
+      joint_speed_limits() const;
+  ::google::protobuf::RepeatedField< float >*
+      mutable_joint_speed_limits();
+
+  // repeated float joint_acceleration_limits = 5;
+  int joint_acceleration_limits_size() const;
+  void clear_joint_acceleration_limits();
+  static const int kJointAccelerationLimitsFieldNumber = 5;
+  float joint_acceleration_limits(int index) const;
+  void set_joint_acceleration_limits(int index, float value);
+  void add_joint_acceleration_limits(float value);
+  const ::google::protobuf::RepeatedField< float >&
+      joint_acceleration_limits() const;
+  ::google::protobuf::RepeatedField< float >*
+      mutable_joint_acceleration_limits();
+
+  // .Kinova.Api.ControlConfig.ControlMode control_mode = 1;
+  void clear_control_mode();
+  static const int kControlModeFieldNumber = 1;
+  ::Kinova::Api::ControlConfig::ControlMode control_mode() const;
+  void set_control_mode(::Kinova::Api::ControlConfig::ControlMode value);
+
+  // float twist_linear = 2;
+  void clear_twist_linear();
+  static const int kTwistLinearFieldNumber = 2;
+  float twist_linear() const;
+  void set_twist_linear(float value);
+
+  // float twist_angular = 3;
+  void clear_twist_angular();
+  static const int kTwistAngularFieldNumber = 3;
+  float twist_angular() const;
+  void set_twist_angular(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.ControlConfig.KinematicLimits)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedField< float > joint_speed_limits_;
+  mutable int _joint_speed_limits_cached_byte_size_;
+  ::google::protobuf::RepeatedField< float > joint_acceleration_limits_;
+  mutable int _joint_acceleration_limits_cached_byte_size_;
+  int control_mode_;
+  float twist_linear_;
+  float twist_angular_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_ControlConfig_2eproto::TableStruct;
+  friend void ::protobuf_ControlConfig_2eproto::InitDefaultsKinematicLimitsImpl();
+};
+// -------------------------------------------------------------------
+
+class KinematicLimitsList : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.ControlConfig.KinematicLimitsList) */ {
+ public:
+  KinematicLimitsList();
+  virtual ~KinematicLimitsList();
+
+  KinematicLimitsList(const KinematicLimitsList& from);
+
+  inline KinematicLimitsList& operator=(const KinematicLimitsList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  KinematicLimitsList(KinematicLimitsList&& from) noexcept
+    : KinematicLimitsList() {
+    *this = ::std::move(from);
+  }
+
+  inline KinematicLimitsList& operator=(KinematicLimitsList&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const KinematicLimitsList& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const KinematicLimitsList* internal_default_instance() {
+    return reinterpret_cast<const KinematicLimitsList*>(
+               &_KinematicLimitsList_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    12;
+
+  void Swap(KinematicLimitsList* other);
+  friend void swap(KinematicLimitsList& a, KinematicLimitsList& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline KinematicLimitsList* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  KinematicLimitsList* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const KinematicLimitsList& from);
+  void MergeFrom(const KinematicLimitsList& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(KinematicLimitsList* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .Kinova.Api.ControlConfig.KinematicLimits kinematic_limits_list = 1;
+  int kinematic_limits_list_size() const;
+  void clear_kinematic_limits_list();
+  static const int kKinematicLimitsListFieldNumber = 1;
+  const ::Kinova::Api::ControlConfig::KinematicLimits& kinematic_limits_list(int index) const;
+  ::Kinova::Api::ControlConfig::KinematicLimits* mutable_kinematic_limits_list(int index);
+  ::Kinova::Api::ControlConfig::KinematicLimits* add_kinematic_limits_list();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::ControlConfig::KinematicLimits >*
+      mutable_kinematic_limits_list();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::ControlConfig::KinematicLimits >&
+      kinematic_limits_list() const;
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.ControlConfig.KinematicLimitsList)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::ControlConfig::KinematicLimits > kinematic_limits_list_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_ControlConfig_2eproto::TableStruct;
+  friend void ::protobuf_ControlConfig_2eproto::InitDefaultsKinematicLimitsListImpl();
+};
+// -------------------------------------------------------------------
+
+class DesiredSpeeds : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.ControlConfig.DesiredSpeeds) */ {
+ public:
+  DesiredSpeeds();
+  virtual ~DesiredSpeeds();
+
+  DesiredSpeeds(const DesiredSpeeds& from);
+
+  inline DesiredSpeeds& operator=(const DesiredSpeeds& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  DesiredSpeeds(DesiredSpeeds&& from) noexcept
+    : DesiredSpeeds() {
+    *this = ::std::move(from);
+  }
+
+  inline DesiredSpeeds& operator=(DesiredSpeeds&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const DesiredSpeeds& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const DesiredSpeeds* internal_default_instance() {
+    return reinterpret_cast<const DesiredSpeeds*>(
+               &_DesiredSpeeds_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    13;
+
+  void Swap(DesiredSpeeds* other);
+  friend void swap(DesiredSpeeds& a, DesiredSpeeds& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline DesiredSpeeds* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  DesiredSpeeds* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const DesiredSpeeds& from);
+  void MergeFrom(const DesiredSpeeds& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(DesiredSpeeds* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated float joint_speed = 3;
+  int joint_speed_size() const;
+  void clear_joint_speed();
+  static const int kJointSpeedFieldNumber = 3;
+  float joint_speed(int index) const;
+  void set_joint_speed(int index, float value);
+  void add_joint_speed(float value);
+  const ::google::protobuf::RepeatedField< float >&
+      joint_speed() const;
+  ::google::protobuf::RepeatedField< float >*
+      mutable_joint_speed();
+
+  // float linear = 1;
+  void clear_linear();
+  static const int kLinearFieldNumber = 1;
+  float linear() const;
+  void set_linear(float value);
+
+  // float angular = 2;
+  void clear_angular();
+  static const int kAngularFieldNumber = 2;
+  float angular() const;
+  void set_angular(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.ControlConfig.DesiredSpeeds)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedField< float > joint_speed_;
+  mutable int _joint_speed_cached_byte_size_;
+  float linear_;
+  float angular_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_ControlConfig_2eproto::TableStruct;
+  friend void ::protobuf_ControlConfig_2eproto::InitDefaultsDesiredSpeedsImpl();
+};
+// -------------------------------------------------------------------
+
+class LinearTwist : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.ControlConfig.LinearTwist) */ {
+ public:
+  LinearTwist();
+  virtual ~LinearTwist();
+
+  LinearTwist(const LinearTwist& from);
+
+  inline LinearTwist& operator=(const LinearTwist& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  LinearTwist(LinearTwist&& from) noexcept
+    : LinearTwist() {
+    *this = ::std::move(from);
+  }
+
+  inline LinearTwist& operator=(LinearTwist&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const LinearTwist& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const LinearTwist* internal_default_instance() {
+    return reinterpret_cast<const LinearTwist*>(
+               &_LinearTwist_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    14;
+
+  void Swap(LinearTwist* other);
+  friend void swap(LinearTwist& a, LinearTwist& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline LinearTwist* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  LinearTwist* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const LinearTwist& from);
+  void MergeFrom(const LinearTwist& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(LinearTwist* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // float linear = 1;
+  void clear_linear();
+  static const int kLinearFieldNumber = 1;
+  float linear() const;
+  void set_linear(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.ControlConfig.LinearTwist)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  float linear_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_ControlConfig_2eproto::TableStruct;
+  friend void ::protobuf_ControlConfig_2eproto::InitDefaultsLinearTwistImpl();
+};
+// -------------------------------------------------------------------
+
+class AngularTwist : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.ControlConfig.AngularTwist) */ {
+ public:
+  AngularTwist();
+  virtual ~AngularTwist();
+
+  AngularTwist(const AngularTwist& from);
+
+  inline AngularTwist& operator=(const AngularTwist& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  AngularTwist(AngularTwist&& from) noexcept
+    : AngularTwist() {
+    *this = ::std::move(from);
+  }
+
+  inline AngularTwist& operator=(AngularTwist&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const AngularTwist& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const AngularTwist* internal_default_instance() {
+    return reinterpret_cast<const AngularTwist*>(
+               &_AngularTwist_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    15;
+
+  void Swap(AngularTwist* other);
+  friend void swap(AngularTwist& a, AngularTwist& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline AngularTwist* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  AngularTwist* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const AngularTwist& from);
+  void MergeFrom(const AngularTwist& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(AngularTwist* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // float angular = 1;
+  void clear_angular();
+  static const int kAngularFieldNumber = 1;
+  float angular() const;
+  void set_angular(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.ControlConfig.AngularTwist)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  float angular_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_ControlConfig_2eproto::TableStruct;
+  friend void ::protobuf_ControlConfig_2eproto::InitDefaultsAngularTwistImpl();
+};
+// -------------------------------------------------------------------
+
+class JointSpeeds : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.ControlConfig.JointSpeeds) */ {
+ public:
+  JointSpeeds();
+  virtual ~JointSpeeds();
+
+  JointSpeeds(const JointSpeeds& from);
+
+  inline JointSpeeds& operator=(const JointSpeeds& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  JointSpeeds(JointSpeeds&& from) noexcept
+    : JointSpeeds() {
+    *this = ::std::move(from);
+  }
+
+  inline JointSpeeds& operator=(JointSpeeds&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const JointSpeeds& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const JointSpeeds* internal_default_instance() {
+    return reinterpret_cast<const JointSpeeds*>(
+               &_JointSpeeds_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    16;
+
+  void Swap(JointSpeeds* other);
+  friend void swap(JointSpeeds& a, JointSpeeds& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline JointSpeeds* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  JointSpeeds* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const JointSpeeds& from);
+  void MergeFrom(const JointSpeeds& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(JointSpeeds* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated float joint_speed = 1;
+  int joint_speed_size() const;
+  void clear_joint_speed();
+  static const int kJointSpeedFieldNumber = 1;
+  float joint_speed(int index) const;
+  void set_joint_speed(int index, float value);
+  void add_joint_speed(float value);
+  const ::google::protobuf::RepeatedField< float >&
+      joint_speed() const;
+  ::google::protobuf::RepeatedField< float >*
+      mutable_joint_speed();
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.ControlConfig.JointSpeeds)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedField< float > joint_speed_;
+  mutable int _joint_speed_cached_byte_size_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_ControlConfig_2eproto::TableStruct;
+  friend void ::protobuf_ControlConfig_2eproto::InitDefaultsJointSpeedsImpl();
+};
+// -------------------------------------------------------------------
+
+class ControlModeInformation : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.ControlConfig.ControlModeInformation) */ {
+ public:
+  ControlModeInformation();
+  virtual ~ControlModeInformation();
+
+  ControlModeInformation(const ControlModeInformation& from);
+
+  inline ControlModeInformation& operator=(const ControlModeInformation& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ControlModeInformation(ControlModeInformation&& from) noexcept
+    : ControlModeInformation() {
+    *this = ::std::move(from);
+  }
+
+  inline ControlModeInformation& operator=(ControlModeInformation&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ControlModeInformation& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ControlModeInformation* internal_default_instance() {
+    return reinterpret_cast<const ControlModeInformation*>(
+               &_ControlModeInformation_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    17;
+
+  void Swap(ControlModeInformation* other);
+  friend void swap(ControlModeInformation& a, ControlModeInformation& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ControlModeInformation* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ControlModeInformation* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ControlModeInformation& from);
+  void MergeFrom(const ControlModeInformation& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ControlModeInformation* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.ControlConfig.ControlMode control_mode = 1;
+  void clear_control_mode();
+  static const int kControlModeFieldNumber = 1;
+  ::Kinova::Api::ControlConfig::ControlMode control_mode() const;
+  void set_control_mode(::Kinova::Api::ControlConfig::ControlMode value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.ControlConfig.ControlModeInformation)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  int control_mode_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_ControlConfig_2eproto::TableStruct;
+  friend void ::protobuf_ControlConfig_2eproto::InitDefaultsControlModeInformationImpl();
+};
+// -------------------------------------------------------------------
+
+class ControlModeNotification : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.ControlConfig.ControlModeNotification) */ {
+ public:
+  ControlModeNotification();
+  virtual ~ControlModeNotification();
+
+  ControlModeNotification(const ControlModeNotification& from);
+
+  inline ControlModeNotification& operator=(const ControlModeNotification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ControlModeNotification(ControlModeNotification&& from) noexcept
+    : ControlModeNotification() {
+    *this = ::std::move(from);
+  }
+
+  inline ControlModeNotification& operator=(ControlModeNotification&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ControlModeNotification& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ControlModeNotification* internal_default_instance() {
+    return reinterpret_cast<const ControlModeNotification*>(
+               &_ControlModeNotification_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    18;
+
+  void Swap(ControlModeNotification* other);
+  friend void swap(ControlModeNotification& a, ControlModeNotification& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ControlModeNotification* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ControlModeNotification* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ControlModeNotification& from);
+  void MergeFrom(const ControlModeNotification& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ControlModeNotification* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Common.Timestamp timestamp = 2;
+  bool has_timestamp() const;
+  void clear_timestamp();
+  static const int kTimestampFieldNumber = 2;
+  const ::Kinova::Api::Common::Timestamp& timestamp() const;
+  ::Kinova::Api::Common::Timestamp* release_timestamp();
+  ::Kinova::Api::Common::Timestamp* mutable_timestamp();
+  void set_allocated_timestamp(::Kinova::Api::Common::Timestamp* timestamp);
+
+  // .Kinova.Api.Common.UserProfileHandle user_handle = 3;
+  bool has_user_handle() const;
+  void clear_user_handle();
+  static const int kUserHandleFieldNumber = 3;
+  const ::Kinova::Api::Common::UserProfileHandle& user_handle() const;
+  ::Kinova::Api::Common::UserProfileHandle* release_user_handle();
+  ::Kinova::Api::Common::UserProfileHandle* mutable_user_handle();
+  void set_allocated_user_handle(::Kinova::Api::Common::UserProfileHandle* user_handle);
+
+  // .Kinova.Api.Common.Connection connection = 4;
+  bool has_connection() const;
+  void clear_connection();
+  static const int kConnectionFieldNumber = 4;
+  const ::Kinova::Api::Common::Connection& connection() const;
+  ::Kinova::Api::Common::Connection* release_connection();
+  ::Kinova::Api::Common::Connection* mutable_connection();
+  void set_allocated_connection(::Kinova::Api::Common::Connection* connection);
+
+  // .Kinova.Api.ControlConfig.ControlMode control_mode = 1;
+  void clear_control_mode();
+  static const int kControlModeFieldNumber = 1;
+  ::Kinova::Api::ControlConfig::ControlMode control_mode() const;
+  void set_control_mode(::Kinova::Api::ControlConfig::ControlMode value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.ControlConfig.ControlModeNotification)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::Common::Timestamp* timestamp_;
+  ::Kinova::Api::Common::UserProfileHandle* user_handle_;
+  ::Kinova::Api::Common::Connection* connection_;
+  int control_mode_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_ControlConfig_2eproto::TableStruct;
+  friend void ::protobuf_ControlConfig_2eproto::InitDefaultsControlModeNotificationImpl();
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// GravityVector
+
+// float x = 1;
+inline void GravityVector::clear_x() {
+  x_ = 0;
+}
+inline float GravityVector::x() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ControlConfig.GravityVector.x)
+  return x_;
+}
+inline void GravityVector::set_x(float value) {
+  
+  x_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ControlConfig.GravityVector.x)
+}
+
+// float y = 2;
+inline void GravityVector::clear_y() {
+  y_ = 0;
+}
+inline float GravityVector::y() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ControlConfig.GravityVector.y)
+  return y_;
+}
+inline void GravityVector::set_y(float value) {
+  
+  y_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ControlConfig.GravityVector.y)
+}
+
+// float z = 3;
+inline void GravityVector::clear_z() {
+  z_ = 0;
+}
+inline float GravityVector::z() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ControlConfig.GravityVector.z)
+  return z_;
+}
+inline void GravityVector::set_z(float value) {
+  
+  z_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ControlConfig.GravityVector.z)
+}
+
+// -------------------------------------------------------------------
+
+// Position
+
+// float x = 1;
+inline void Position::clear_x() {
+  x_ = 0;
+}
+inline float Position::x() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ControlConfig.Position.x)
+  return x_;
+}
+inline void Position::set_x(float value) {
+  
+  x_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ControlConfig.Position.x)
+}
+
+// float y = 2;
+inline void Position::clear_y() {
+  y_ = 0;
+}
+inline float Position::y() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ControlConfig.Position.y)
+  return y_;
+}
+inline void Position::set_y(float value) {
+  
+  y_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ControlConfig.Position.y)
+}
+
+// float z = 3;
+inline void Position::clear_z() {
+  z_ = 0;
+}
+inline float Position::z() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ControlConfig.Position.z)
+  return z_;
+}
+inline void Position::set_z(float value) {
+  
+  z_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ControlConfig.Position.z)
+}
+
+// -------------------------------------------------------------------
+
+// PayloadInformation
+
+// float payload_mass = 1;
+inline void PayloadInformation::clear_payload_mass() {
+  payload_mass_ = 0;
+}
+inline float PayloadInformation::payload_mass() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ControlConfig.PayloadInformation.payload_mass)
+  return payload_mass_;
+}
+inline void PayloadInformation::set_payload_mass(float value) {
+  
+  payload_mass_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ControlConfig.PayloadInformation.payload_mass)
+}
+
+// .Kinova.Api.ControlConfig.Position payload_mass_center = 2;
+inline bool PayloadInformation::has_payload_mass_center() const {
+  return this != internal_default_instance() && payload_mass_center_ != NULL;
+}
+inline void PayloadInformation::clear_payload_mass_center() {
+  if (GetArenaNoVirtual() == NULL && payload_mass_center_ != NULL) {
+    delete payload_mass_center_;
+  }
+  payload_mass_center_ = NULL;
+}
+inline const ::Kinova::Api::ControlConfig::Position& PayloadInformation::payload_mass_center() const {
+  const ::Kinova::Api::ControlConfig::Position* p = payload_mass_center_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.ControlConfig.PayloadInformation.payload_mass_center)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::ControlConfig::Position*>(
+      &::Kinova::Api::ControlConfig::_Position_default_instance_);
+}
+inline ::Kinova::Api::ControlConfig::Position* PayloadInformation::release_payload_mass_center() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.ControlConfig.PayloadInformation.payload_mass_center)
+  
+  ::Kinova::Api::ControlConfig::Position* temp = payload_mass_center_;
+  payload_mass_center_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::ControlConfig::Position* PayloadInformation::mutable_payload_mass_center() {
+  
+  if (payload_mass_center_ == NULL) {
+    payload_mass_center_ = new ::Kinova::Api::ControlConfig::Position;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.ControlConfig.PayloadInformation.payload_mass_center)
+  return payload_mass_center_;
+}
+inline void PayloadInformation::set_allocated_payload_mass_center(::Kinova::Api::ControlConfig::Position* payload_mass_center) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete payload_mass_center_;
+  }
+  if (payload_mass_center) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      payload_mass_center = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, payload_mass_center, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  payload_mass_center_ = payload_mass_center;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.ControlConfig.PayloadInformation.payload_mass_center)
+}
+
+// -------------------------------------------------------------------
+
+// CartesianTransform
+
+// float x = 1;
+inline void CartesianTransform::clear_x() {
+  x_ = 0;
+}
+inline float CartesianTransform::x() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ControlConfig.CartesianTransform.x)
+  return x_;
+}
+inline void CartesianTransform::set_x(float value) {
+  
+  x_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ControlConfig.CartesianTransform.x)
+}
+
+// float y = 2;
+inline void CartesianTransform::clear_y() {
+  y_ = 0;
+}
+inline float CartesianTransform::y() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ControlConfig.CartesianTransform.y)
+  return y_;
+}
+inline void CartesianTransform::set_y(float value) {
+  
+  y_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ControlConfig.CartesianTransform.y)
+}
+
+// float z = 3;
+inline void CartesianTransform::clear_z() {
+  z_ = 0;
+}
+inline float CartesianTransform::z() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ControlConfig.CartesianTransform.z)
+  return z_;
+}
+inline void CartesianTransform::set_z(float value) {
+  
+  z_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ControlConfig.CartesianTransform.z)
+}
+
+// float theta_x = 4;
+inline void CartesianTransform::clear_theta_x() {
+  theta_x_ = 0;
+}
+inline float CartesianTransform::theta_x() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ControlConfig.CartesianTransform.theta_x)
+  return theta_x_;
+}
+inline void CartesianTransform::set_theta_x(float value) {
+  
+  theta_x_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ControlConfig.CartesianTransform.theta_x)
+}
+
+// float theta_y = 5;
+inline void CartesianTransform::clear_theta_y() {
+  theta_y_ = 0;
+}
+inline float CartesianTransform::theta_y() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ControlConfig.CartesianTransform.theta_y)
+  return theta_y_;
+}
+inline void CartesianTransform::set_theta_y(float value) {
+  
+  theta_y_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ControlConfig.CartesianTransform.theta_y)
+}
+
+// float theta_z = 6;
+inline void CartesianTransform::clear_theta_z() {
+  theta_z_ = 0;
+}
+inline float CartesianTransform::theta_z() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ControlConfig.CartesianTransform.theta_z)
+  return theta_z_;
+}
+inline void CartesianTransform::set_theta_z(float value) {
+  
+  theta_z_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ControlConfig.CartesianTransform.theta_z)
+}
+
+// -------------------------------------------------------------------
+
+// ToolConfiguration
+
+// .Kinova.Api.ControlConfig.CartesianTransform tool_transform = 1;
+inline bool ToolConfiguration::has_tool_transform() const {
+  return this != internal_default_instance() && tool_transform_ != NULL;
+}
+inline void ToolConfiguration::clear_tool_transform() {
+  if (GetArenaNoVirtual() == NULL && tool_transform_ != NULL) {
+    delete tool_transform_;
+  }
+  tool_transform_ = NULL;
+}
+inline const ::Kinova::Api::ControlConfig::CartesianTransform& ToolConfiguration::tool_transform() const {
+  const ::Kinova::Api::ControlConfig::CartesianTransform* p = tool_transform_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.ControlConfig.ToolConfiguration.tool_transform)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::ControlConfig::CartesianTransform*>(
+      &::Kinova::Api::ControlConfig::_CartesianTransform_default_instance_);
+}
+inline ::Kinova::Api::ControlConfig::CartesianTransform* ToolConfiguration::release_tool_transform() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.ControlConfig.ToolConfiguration.tool_transform)
+  
+  ::Kinova::Api::ControlConfig::CartesianTransform* temp = tool_transform_;
+  tool_transform_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::ControlConfig::CartesianTransform* ToolConfiguration::mutable_tool_transform() {
+  
+  if (tool_transform_ == NULL) {
+    tool_transform_ = new ::Kinova::Api::ControlConfig::CartesianTransform;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.ControlConfig.ToolConfiguration.tool_transform)
+  return tool_transform_;
+}
+inline void ToolConfiguration::set_allocated_tool_transform(::Kinova::Api::ControlConfig::CartesianTransform* tool_transform) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete tool_transform_;
+  }
+  if (tool_transform) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      tool_transform = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, tool_transform, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  tool_transform_ = tool_transform;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.ControlConfig.ToolConfiguration.tool_transform)
+}
+
+// float tool_mass = 2;
+inline void ToolConfiguration::clear_tool_mass() {
+  tool_mass_ = 0;
+}
+inline float ToolConfiguration::tool_mass() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ControlConfig.ToolConfiguration.tool_mass)
+  return tool_mass_;
+}
+inline void ToolConfiguration::set_tool_mass(float value) {
+  
+  tool_mass_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ControlConfig.ToolConfiguration.tool_mass)
+}
+
+// .Kinova.Api.ControlConfig.Position tool_mass_center = 3;
+inline bool ToolConfiguration::has_tool_mass_center() const {
+  return this != internal_default_instance() && tool_mass_center_ != NULL;
+}
+inline void ToolConfiguration::clear_tool_mass_center() {
+  if (GetArenaNoVirtual() == NULL && tool_mass_center_ != NULL) {
+    delete tool_mass_center_;
+  }
+  tool_mass_center_ = NULL;
+}
+inline const ::Kinova::Api::ControlConfig::Position& ToolConfiguration::tool_mass_center() const {
+  const ::Kinova::Api::ControlConfig::Position* p = tool_mass_center_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.ControlConfig.ToolConfiguration.tool_mass_center)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::ControlConfig::Position*>(
+      &::Kinova::Api::ControlConfig::_Position_default_instance_);
+}
+inline ::Kinova::Api::ControlConfig::Position* ToolConfiguration::release_tool_mass_center() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.ControlConfig.ToolConfiguration.tool_mass_center)
+  
+  ::Kinova::Api::ControlConfig::Position* temp = tool_mass_center_;
+  tool_mass_center_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::ControlConfig::Position* ToolConfiguration::mutable_tool_mass_center() {
+  
+  if (tool_mass_center_ == NULL) {
+    tool_mass_center_ = new ::Kinova::Api::ControlConfig::Position;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.ControlConfig.ToolConfiguration.tool_mass_center)
+  return tool_mass_center_;
+}
+inline void ToolConfiguration::set_allocated_tool_mass_center(::Kinova::Api::ControlConfig::Position* tool_mass_center) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete tool_mass_center_;
+  }
+  if (tool_mass_center) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      tool_mass_center = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, tool_mass_center, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  tool_mass_center_ = tool_mass_center;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.ControlConfig.ToolConfiguration.tool_mass_center)
+}
+
+// -------------------------------------------------------------------
+
+// ControlConfigurationNotification
+
+// .Kinova.Api.ControlConfig.ControlConfigurationEvent event = 1;
+inline void ControlConfigurationNotification::clear_event() {
+  event_ = 0;
+}
+inline ::Kinova::Api::ControlConfig::ControlConfigurationEvent ControlConfigurationNotification::event() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ControlConfig.ControlConfigurationNotification.event)
+  return static_cast< ::Kinova::Api::ControlConfig::ControlConfigurationEvent >(event_);
+}
+inline void ControlConfigurationNotification::set_event(::Kinova::Api::ControlConfig::ControlConfigurationEvent value) {
+  
+  event_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ControlConfig.ControlConfigurationNotification.event)
+}
+
+// .Kinova.Api.Common.Timestamp timestamp = 2;
+inline bool ControlConfigurationNotification::has_timestamp() const {
+  return this != internal_default_instance() && timestamp_ != NULL;
+}
+inline const ::Kinova::Api::Common::Timestamp& ControlConfigurationNotification::timestamp() const {
+  const ::Kinova::Api::Common::Timestamp* p = timestamp_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.ControlConfig.ControlConfigurationNotification.timestamp)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::Timestamp*>(
+      &::Kinova::Api::Common::_Timestamp_default_instance_);
+}
+inline ::Kinova::Api::Common::Timestamp* ControlConfigurationNotification::release_timestamp() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.ControlConfig.ControlConfigurationNotification.timestamp)
+  
+  ::Kinova::Api::Common::Timestamp* temp = timestamp_;
+  timestamp_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::Timestamp* ControlConfigurationNotification::mutable_timestamp() {
+  
+  if (timestamp_ == NULL) {
+    timestamp_ = new ::Kinova::Api::Common::Timestamp;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.ControlConfig.ControlConfigurationNotification.timestamp)
+  return timestamp_;
+}
+inline void ControlConfigurationNotification::set_allocated_timestamp(::Kinova::Api::Common::Timestamp* timestamp) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(timestamp_);
+  }
+  if (timestamp) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      timestamp = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, timestamp, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  timestamp_ = timestamp;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.ControlConfig.ControlConfigurationNotification.timestamp)
+}
+
+// .Kinova.Api.Common.UserProfileHandle user_handle = 3;
+inline bool ControlConfigurationNotification::has_user_handle() const {
+  return this != internal_default_instance() && user_handle_ != NULL;
+}
+inline const ::Kinova::Api::Common::UserProfileHandle& ControlConfigurationNotification::user_handle() const {
+  const ::Kinova::Api::Common::UserProfileHandle* p = user_handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.ControlConfig.ControlConfigurationNotification.user_handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::UserProfileHandle*>(
+      &::Kinova::Api::Common::_UserProfileHandle_default_instance_);
+}
+inline ::Kinova::Api::Common::UserProfileHandle* ControlConfigurationNotification::release_user_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.ControlConfig.ControlConfigurationNotification.user_handle)
+  
+  ::Kinova::Api::Common::UserProfileHandle* temp = user_handle_;
+  user_handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::UserProfileHandle* ControlConfigurationNotification::mutable_user_handle() {
+  
+  if (user_handle_ == NULL) {
+    user_handle_ = new ::Kinova::Api::Common::UserProfileHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.ControlConfig.ControlConfigurationNotification.user_handle)
+  return user_handle_;
+}
+inline void ControlConfigurationNotification::set_allocated_user_handle(::Kinova::Api::Common::UserProfileHandle* user_handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(user_handle_);
+  }
+  if (user_handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      user_handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, user_handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  user_handle_ = user_handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.ControlConfig.ControlConfigurationNotification.user_handle)
+}
+
+// .Kinova.Api.Common.Connection connection = 4;
+inline bool ControlConfigurationNotification::has_connection() const {
+  return this != internal_default_instance() && connection_ != NULL;
+}
+inline const ::Kinova::Api::Common::Connection& ControlConfigurationNotification::connection() const {
+  const ::Kinova::Api::Common::Connection* p = connection_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.ControlConfig.ControlConfigurationNotification.connection)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::Connection*>(
+      &::Kinova::Api::Common::_Connection_default_instance_);
+}
+inline ::Kinova::Api::Common::Connection* ControlConfigurationNotification::release_connection() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.ControlConfig.ControlConfigurationNotification.connection)
+  
+  ::Kinova::Api::Common::Connection* temp = connection_;
+  connection_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::Connection* ControlConfigurationNotification::mutable_connection() {
+  
+  if (connection_ == NULL) {
+    connection_ = new ::Kinova::Api::Common::Connection;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.ControlConfig.ControlConfigurationNotification.connection)
+  return connection_;
+}
+inline void ControlConfigurationNotification::set_allocated_connection(::Kinova::Api::Common::Connection* connection) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(connection_);
+  }
+  if (connection) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      connection = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, connection, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  connection_ = connection;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.ControlConfig.ControlConfigurationNotification.connection)
+}
+
+// -------------------------------------------------------------------
+
+// CartesianReferenceFrameInfo
+
+// .Kinova.Api.Common.CartesianReferenceFrame reference_frame = 1;
+inline void CartesianReferenceFrameInfo::clear_reference_frame() {
+  reference_frame_ = 0;
+}
+inline ::Kinova::Api::Common::CartesianReferenceFrame CartesianReferenceFrameInfo::reference_frame() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ControlConfig.CartesianReferenceFrameInfo.reference_frame)
+  return static_cast< ::Kinova::Api::Common::CartesianReferenceFrame >(reference_frame_);
+}
+inline void CartesianReferenceFrameInfo::set_reference_frame(::Kinova::Api::Common::CartesianReferenceFrame value) {
+  
+  reference_frame_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ControlConfig.CartesianReferenceFrameInfo.reference_frame)
+}
+
+// -------------------------------------------------------------------
+
+// TwistLinearSoftLimit
+
+// .Kinova.Api.ControlConfig.ControlMode control_mode = 1;
+inline void TwistLinearSoftLimit::clear_control_mode() {
+  control_mode_ = 0;
+}
+inline ::Kinova::Api::ControlConfig::ControlMode TwistLinearSoftLimit::control_mode() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ControlConfig.TwistLinearSoftLimit.control_mode)
+  return static_cast< ::Kinova::Api::ControlConfig::ControlMode >(control_mode_);
+}
+inline void TwistLinearSoftLimit::set_control_mode(::Kinova::Api::ControlConfig::ControlMode value) {
+  
+  control_mode_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ControlConfig.TwistLinearSoftLimit.control_mode)
+}
+
+// float twist_linear_soft_limit = 2;
+inline void TwistLinearSoftLimit::clear_twist_linear_soft_limit() {
+  twist_linear_soft_limit_ = 0;
+}
+inline float TwistLinearSoftLimit::twist_linear_soft_limit() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ControlConfig.TwistLinearSoftLimit.twist_linear_soft_limit)
+  return twist_linear_soft_limit_;
+}
+inline void TwistLinearSoftLimit::set_twist_linear_soft_limit(float value) {
+  
+  twist_linear_soft_limit_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ControlConfig.TwistLinearSoftLimit.twist_linear_soft_limit)
+}
+
+// -------------------------------------------------------------------
+
+// TwistAngularSoftLimit
+
+// .Kinova.Api.ControlConfig.ControlMode control_mode = 1;
+inline void TwistAngularSoftLimit::clear_control_mode() {
+  control_mode_ = 0;
+}
+inline ::Kinova::Api::ControlConfig::ControlMode TwistAngularSoftLimit::control_mode() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ControlConfig.TwistAngularSoftLimit.control_mode)
+  return static_cast< ::Kinova::Api::ControlConfig::ControlMode >(control_mode_);
+}
+inline void TwistAngularSoftLimit::set_control_mode(::Kinova::Api::ControlConfig::ControlMode value) {
+  
+  control_mode_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ControlConfig.TwistAngularSoftLimit.control_mode)
+}
+
+// float twist_angular_soft_limit = 2;
+inline void TwistAngularSoftLimit::clear_twist_angular_soft_limit() {
+  twist_angular_soft_limit_ = 0;
+}
+inline float TwistAngularSoftLimit::twist_angular_soft_limit() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ControlConfig.TwistAngularSoftLimit.twist_angular_soft_limit)
+  return twist_angular_soft_limit_;
+}
+inline void TwistAngularSoftLimit::set_twist_angular_soft_limit(float value) {
+  
+  twist_angular_soft_limit_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ControlConfig.TwistAngularSoftLimit.twist_angular_soft_limit)
+}
+
+// -------------------------------------------------------------------
+
+// JointSpeedSoftLimits
+
+// .Kinova.Api.ControlConfig.ControlMode control_mode = 1;
+inline void JointSpeedSoftLimits::clear_control_mode() {
+  control_mode_ = 0;
+}
+inline ::Kinova::Api::ControlConfig::ControlMode JointSpeedSoftLimits::control_mode() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ControlConfig.JointSpeedSoftLimits.control_mode)
+  return static_cast< ::Kinova::Api::ControlConfig::ControlMode >(control_mode_);
+}
+inline void JointSpeedSoftLimits::set_control_mode(::Kinova::Api::ControlConfig::ControlMode value) {
+  
+  control_mode_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ControlConfig.JointSpeedSoftLimits.control_mode)
+}
+
+// repeated float joint_speed_soft_limits = 2;
+inline int JointSpeedSoftLimits::joint_speed_soft_limits_size() const {
+  return joint_speed_soft_limits_.size();
+}
+inline void JointSpeedSoftLimits::clear_joint_speed_soft_limits() {
+  joint_speed_soft_limits_.Clear();
+}
+inline float JointSpeedSoftLimits::joint_speed_soft_limits(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ControlConfig.JointSpeedSoftLimits.joint_speed_soft_limits)
+  return joint_speed_soft_limits_.Get(index);
+}
+inline void JointSpeedSoftLimits::set_joint_speed_soft_limits(int index, float value) {
+  joint_speed_soft_limits_.Set(index, value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.ControlConfig.JointSpeedSoftLimits.joint_speed_soft_limits)
+}
+inline void JointSpeedSoftLimits::add_joint_speed_soft_limits(float value) {
+  joint_speed_soft_limits_.Add(value);
+  // @@protoc_insertion_point(field_add:Kinova.Api.ControlConfig.JointSpeedSoftLimits.joint_speed_soft_limits)
+}
+inline const ::google::protobuf::RepeatedField< float >&
+JointSpeedSoftLimits::joint_speed_soft_limits() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.ControlConfig.JointSpeedSoftLimits.joint_speed_soft_limits)
+  return joint_speed_soft_limits_;
+}
+inline ::google::protobuf::RepeatedField< float >*
+JointSpeedSoftLimits::mutable_joint_speed_soft_limits() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.ControlConfig.JointSpeedSoftLimits.joint_speed_soft_limits)
+  return &joint_speed_soft_limits_;
+}
+
+// -------------------------------------------------------------------
+
+// JointAccelerationSoftLimits
+
+// .Kinova.Api.ControlConfig.ControlMode control_mode = 1;
+inline void JointAccelerationSoftLimits::clear_control_mode() {
+  control_mode_ = 0;
+}
+inline ::Kinova::Api::ControlConfig::ControlMode JointAccelerationSoftLimits::control_mode() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ControlConfig.JointAccelerationSoftLimits.control_mode)
+  return static_cast< ::Kinova::Api::ControlConfig::ControlMode >(control_mode_);
+}
+inline void JointAccelerationSoftLimits::set_control_mode(::Kinova::Api::ControlConfig::ControlMode value) {
+  
+  control_mode_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ControlConfig.JointAccelerationSoftLimits.control_mode)
+}
+
+// repeated float joint_acceleration_soft_limits = 2;
+inline int JointAccelerationSoftLimits::joint_acceleration_soft_limits_size() const {
+  return joint_acceleration_soft_limits_.size();
+}
+inline void JointAccelerationSoftLimits::clear_joint_acceleration_soft_limits() {
+  joint_acceleration_soft_limits_.Clear();
+}
+inline float JointAccelerationSoftLimits::joint_acceleration_soft_limits(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ControlConfig.JointAccelerationSoftLimits.joint_acceleration_soft_limits)
+  return joint_acceleration_soft_limits_.Get(index);
+}
+inline void JointAccelerationSoftLimits::set_joint_acceleration_soft_limits(int index, float value) {
+  joint_acceleration_soft_limits_.Set(index, value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.ControlConfig.JointAccelerationSoftLimits.joint_acceleration_soft_limits)
+}
+inline void JointAccelerationSoftLimits::add_joint_acceleration_soft_limits(float value) {
+  joint_acceleration_soft_limits_.Add(value);
+  // @@protoc_insertion_point(field_add:Kinova.Api.ControlConfig.JointAccelerationSoftLimits.joint_acceleration_soft_limits)
+}
+inline const ::google::protobuf::RepeatedField< float >&
+JointAccelerationSoftLimits::joint_acceleration_soft_limits() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.ControlConfig.JointAccelerationSoftLimits.joint_acceleration_soft_limits)
+  return joint_acceleration_soft_limits_;
+}
+inline ::google::protobuf::RepeatedField< float >*
+JointAccelerationSoftLimits::mutable_joint_acceleration_soft_limits() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.ControlConfig.JointAccelerationSoftLimits.joint_acceleration_soft_limits)
+  return &joint_acceleration_soft_limits_;
+}
+
+// -------------------------------------------------------------------
+
+// KinematicLimits
+
+// .Kinova.Api.ControlConfig.ControlMode control_mode = 1;
+inline void KinematicLimits::clear_control_mode() {
+  control_mode_ = 0;
+}
+inline ::Kinova::Api::ControlConfig::ControlMode KinematicLimits::control_mode() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ControlConfig.KinematicLimits.control_mode)
+  return static_cast< ::Kinova::Api::ControlConfig::ControlMode >(control_mode_);
+}
+inline void KinematicLimits::set_control_mode(::Kinova::Api::ControlConfig::ControlMode value) {
+  
+  control_mode_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ControlConfig.KinematicLimits.control_mode)
+}
+
+// float twist_linear = 2;
+inline void KinematicLimits::clear_twist_linear() {
+  twist_linear_ = 0;
+}
+inline float KinematicLimits::twist_linear() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ControlConfig.KinematicLimits.twist_linear)
+  return twist_linear_;
+}
+inline void KinematicLimits::set_twist_linear(float value) {
+  
+  twist_linear_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ControlConfig.KinematicLimits.twist_linear)
+}
+
+// float twist_angular = 3;
+inline void KinematicLimits::clear_twist_angular() {
+  twist_angular_ = 0;
+}
+inline float KinematicLimits::twist_angular() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ControlConfig.KinematicLimits.twist_angular)
+  return twist_angular_;
+}
+inline void KinematicLimits::set_twist_angular(float value) {
+  
+  twist_angular_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ControlConfig.KinematicLimits.twist_angular)
+}
+
+// repeated float joint_speed_limits = 4;
+inline int KinematicLimits::joint_speed_limits_size() const {
+  return joint_speed_limits_.size();
+}
+inline void KinematicLimits::clear_joint_speed_limits() {
+  joint_speed_limits_.Clear();
+}
+inline float KinematicLimits::joint_speed_limits(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ControlConfig.KinematicLimits.joint_speed_limits)
+  return joint_speed_limits_.Get(index);
+}
+inline void KinematicLimits::set_joint_speed_limits(int index, float value) {
+  joint_speed_limits_.Set(index, value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.ControlConfig.KinematicLimits.joint_speed_limits)
+}
+inline void KinematicLimits::add_joint_speed_limits(float value) {
+  joint_speed_limits_.Add(value);
+  // @@protoc_insertion_point(field_add:Kinova.Api.ControlConfig.KinematicLimits.joint_speed_limits)
+}
+inline const ::google::protobuf::RepeatedField< float >&
+KinematicLimits::joint_speed_limits() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.ControlConfig.KinematicLimits.joint_speed_limits)
+  return joint_speed_limits_;
+}
+inline ::google::protobuf::RepeatedField< float >*
+KinematicLimits::mutable_joint_speed_limits() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.ControlConfig.KinematicLimits.joint_speed_limits)
+  return &joint_speed_limits_;
+}
+
+// repeated float joint_acceleration_limits = 5;
+inline int KinematicLimits::joint_acceleration_limits_size() const {
+  return joint_acceleration_limits_.size();
+}
+inline void KinematicLimits::clear_joint_acceleration_limits() {
+  joint_acceleration_limits_.Clear();
+}
+inline float KinematicLimits::joint_acceleration_limits(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ControlConfig.KinematicLimits.joint_acceleration_limits)
+  return joint_acceleration_limits_.Get(index);
+}
+inline void KinematicLimits::set_joint_acceleration_limits(int index, float value) {
+  joint_acceleration_limits_.Set(index, value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.ControlConfig.KinematicLimits.joint_acceleration_limits)
+}
+inline void KinematicLimits::add_joint_acceleration_limits(float value) {
+  joint_acceleration_limits_.Add(value);
+  // @@protoc_insertion_point(field_add:Kinova.Api.ControlConfig.KinematicLimits.joint_acceleration_limits)
+}
+inline const ::google::protobuf::RepeatedField< float >&
+KinematicLimits::joint_acceleration_limits() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.ControlConfig.KinematicLimits.joint_acceleration_limits)
+  return joint_acceleration_limits_;
+}
+inline ::google::protobuf::RepeatedField< float >*
+KinematicLimits::mutable_joint_acceleration_limits() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.ControlConfig.KinematicLimits.joint_acceleration_limits)
+  return &joint_acceleration_limits_;
+}
+
+// -------------------------------------------------------------------
+
+// KinematicLimitsList
+
+// repeated .Kinova.Api.ControlConfig.KinematicLimits kinematic_limits_list = 1;
+inline int KinematicLimitsList::kinematic_limits_list_size() const {
+  return kinematic_limits_list_.size();
+}
+inline void KinematicLimitsList::clear_kinematic_limits_list() {
+  kinematic_limits_list_.Clear();
+}
+inline const ::Kinova::Api::ControlConfig::KinematicLimits& KinematicLimitsList::kinematic_limits_list(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ControlConfig.KinematicLimitsList.kinematic_limits_list)
+  return kinematic_limits_list_.Get(index);
+}
+inline ::Kinova::Api::ControlConfig::KinematicLimits* KinematicLimitsList::mutable_kinematic_limits_list(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.ControlConfig.KinematicLimitsList.kinematic_limits_list)
+  return kinematic_limits_list_.Mutable(index);
+}
+inline ::Kinova::Api::ControlConfig::KinematicLimits* KinematicLimitsList::add_kinematic_limits_list() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.ControlConfig.KinematicLimitsList.kinematic_limits_list)
+  return kinematic_limits_list_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::ControlConfig::KinematicLimits >*
+KinematicLimitsList::mutable_kinematic_limits_list() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.ControlConfig.KinematicLimitsList.kinematic_limits_list)
+  return &kinematic_limits_list_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::ControlConfig::KinematicLimits >&
+KinematicLimitsList::kinematic_limits_list() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.ControlConfig.KinematicLimitsList.kinematic_limits_list)
+  return kinematic_limits_list_;
+}
+
+// -------------------------------------------------------------------
+
+// DesiredSpeeds
+
+// float linear = 1;
+inline void DesiredSpeeds::clear_linear() {
+  linear_ = 0;
+}
+inline float DesiredSpeeds::linear() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ControlConfig.DesiredSpeeds.linear)
+  return linear_;
+}
+inline void DesiredSpeeds::set_linear(float value) {
+  
+  linear_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ControlConfig.DesiredSpeeds.linear)
+}
+
+// float angular = 2;
+inline void DesiredSpeeds::clear_angular() {
+  angular_ = 0;
+}
+inline float DesiredSpeeds::angular() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ControlConfig.DesiredSpeeds.angular)
+  return angular_;
+}
+inline void DesiredSpeeds::set_angular(float value) {
+  
+  angular_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ControlConfig.DesiredSpeeds.angular)
+}
+
+// repeated float joint_speed = 3;
+inline int DesiredSpeeds::joint_speed_size() const {
+  return joint_speed_.size();
+}
+inline void DesiredSpeeds::clear_joint_speed() {
+  joint_speed_.Clear();
+}
+inline float DesiredSpeeds::joint_speed(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ControlConfig.DesiredSpeeds.joint_speed)
+  return joint_speed_.Get(index);
+}
+inline void DesiredSpeeds::set_joint_speed(int index, float value) {
+  joint_speed_.Set(index, value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.ControlConfig.DesiredSpeeds.joint_speed)
+}
+inline void DesiredSpeeds::add_joint_speed(float value) {
+  joint_speed_.Add(value);
+  // @@protoc_insertion_point(field_add:Kinova.Api.ControlConfig.DesiredSpeeds.joint_speed)
+}
+inline const ::google::protobuf::RepeatedField< float >&
+DesiredSpeeds::joint_speed() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.ControlConfig.DesiredSpeeds.joint_speed)
+  return joint_speed_;
+}
+inline ::google::protobuf::RepeatedField< float >*
+DesiredSpeeds::mutable_joint_speed() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.ControlConfig.DesiredSpeeds.joint_speed)
+  return &joint_speed_;
+}
+
+// -------------------------------------------------------------------
+
+// LinearTwist
+
+// float linear = 1;
+inline void LinearTwist::clear_linear() {
+  linear_ = 0;
+}
+inline float LinearTwist::linear() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ControlConfig.LinearTwist.linear)
+  return linear_;
+}
+inline void LinearTwist::set_linear(float value) {
+  
+  linear_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ControlConfig.LinearTwist.linear)
+}
+
+// -------------------------------------------------------------------
+
+// AngularTwist
+
+// float angular = 1;
+inline void AngularTwist::clear_angular() {
+  angular_ = 0;
+}
+inline float AngularTwist::angular() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ControlConfig.AngularTwist.angular)
+  return angular_;
+}
+inline void AngularTwist::set_angular(float value) {
+  
+  angular_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ControlConfig.AngularTwist.angular)
+}
+
+// -------------------------------------------------------------------
+
+// JointSpeeds
+
+// repeated float joint_speed = 1;
+inline int JointSpeeds::joint_speed_size() const {
+  return joint_speed_.size();
+}
+inline void JointSpeeds::clear_joint_speed() {
+  joint_speed_.Clear();
+}
+inline float JointSpeeds::joint_speed(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ControlConfig.JointSpeeds.joint_speed)
+  return joint_speed_.Get(index);
+}
+inline void JointSpeeds::set_joint_speed(int index, float value) {
+  joint_speed_.Set(index, value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.ControlConfig.JointSpeeds.joint_speed)
+}
+inline void JointSpeeds::add_joint_speed(float value) {
+  joint_speed_.Add(value);
+  // @@protoc_insertion_point(field_add:Kinova.Api.ControlConfig.JointSpeeds.joint_speed)
+}
+inline const ::google::protobuf::RepeatedField< float >&
+JointSpeeds::joint_speed() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.ControlConfig.JointSpeeds.joint_speed)
+  return joint_speed_;
+}
+inline ::google::protobuf::RepeatedField< float >*
+JointSpeeds::mutable_joint_speed() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.ControlConfig.JointSpeeds.joint_speed)
+  return &joint_speed_;
+}
+
+// -------------------------------------------------------------------
+
+// ControlModeInformation
+
+// .Kinova.Api.ControlConfig.ControlMode control_mode = 1;
+inline void ControlModeInformation::clear_control_mode() {
+  control_mode_ = 0;
+}
+inline ::Kinova::Api::ControlConfig::ControlMode ControlModeInformation::control_mode() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ControlConfig.ControlModeInformation.control_mode)
+  return static_cast< ::Kinova::Api::ControlConfig::ControlMode >(control_mode_);
+}
+inline void ControlModeInformation::set_control_mode(::Kinova::Api::ControlConfig::ControlMode value) {
+  
+  control_mode_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ControlConfig.ControlModeInformation.control_mode)
+}
+
+// -------------------------------------------------------------------
+
+// ControlModeNotification
+
+// .Kinova.Api.ControlConfig.ControlMode control_mode = 1;
+inline void ControlModeNotification::clear_control_mode() {
+  control_mode_ = 0;
+}
+inline ::Kinova::Api::ControlConfig::ControlMode ControlModeNotification::control_mode() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ControlConfig.ControlModeNotification.control_mode)
+  return static_cast< ::Kinova::Api::ControlConfig::ControlMode >(control_mode_);
+}
+inline void ControlModeNotification::set_control_mode(::Kinova::Api::ControlConfig::ControlMode value) {
+  
+  control_mode_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ControlConfig.ControlModeNotification.control_mode)
+}
+
+// .Kinova.Api.Common.Timestamp timestamp = 2;
+inline bool ControlModeNotification::has_timestamp() const {
+  return this != internal_default_instance() && timestamp_ != NULL;
+}
+inline const ::Kinova::Api::Common::Timestamp& ControlModeNotification::timestamp() const {
+  const ::Kinova::Api::Common::Timestamp* p = timestamp_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.ControlConfig.ControlModeNotification.timestamp)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::Timestamp*>(
+      &::Kinova::Api::Common::_Timestamp_default_instance_);
+}
+inline ::Kinova::Api::Common::Timestamp* ControlModeNotification::release_timestamp() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.ControlConfig.ControlModeNotification.timestamp)
+  
+  ::Kinova::Api::Common::Timestamp* temp = timestamp_;
+  timestamp_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::Timestamp* ControlModeNotification::mutable_timestamp() {
+  
+  if (timestamp_ == NULL) {
+    timestamp_ = new ::Kinova::Api::Common::Timestamp;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.ControlConfig.ControlModeNotification.timestamp)
+  return timestamp_;
+}
+inline void ControlModeNotification::set_allocated_timestamp(::Kinova::Api::Common::Timestamp* timestamp) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(timestamp_);
+  }
+  if (timestamp) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      timestamp = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, timestamp, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  timestamp_ = timestamp;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.ControlConfig.ControlModeNotification.timestamp)
+}
+
+// .Kinova.Api.Common.UserProfileHandle user_handle = 3;
+inline bool ControlModeNotification::has_user_handle() const {
+  return this != internal_default_instance() && user_handle_ != NULL;
+}
+inline const ::Kinova::Api::Common::UserProfileHandle& ControlModeNotification::user_handle() const {
+  const ::Kinova::Api::Common::UserProfileHandle* p = user_handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.ControlConfig.ControlModeNotification.user_handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::UserProfileHandle*>(
+      &::Kinova::Api::Common::_UserProfileHandle_default_instance_);
+}
+inline ::Kinova::Api::Common::UserProfileHandle* ControlModeNotification::release_user_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.ControlConfig.ControlModeNotification.user_handle)
+  
+  ::Kinova::Api::Common::UserProfileHandle* temp = user_handle_;
+  user_handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::UserProfileHandle* ControlModeNotification::mutable_user_handle() {
+  
+  if (user_handle_ == NULL) {
+    user_handle_ = new ::Kinova::Api::Common::UserProfileHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.ControlConfig.ControlModeNotification.user_handle)
+  return user_handle_;
+}
+inline void ControlModeNotification::set_allocated_user_handle(::Kinova::Api::Common::UserProfileHandle* user_handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(user_handle_);
+  }
+  if (user_handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      user_handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, user_handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  user_handle_ = user_handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.ControlConfig.ControlModeNotification.user_handle)
+}
+
+// .Kinova.Api.Common.Connection connection = 4;
+inline bool ControlModeNotification::has_connection() const {
+  return this != internal_default_instance() && connection_ != NULL;
+}
+inline const ::Kinova::Api::Common::Connection& ControlModeNotification::connection() const {
+  const ::Kinova::Api::Common::Connection* p = connection_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.ControlConfig.ControlModeNotification.connection)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::Connection*>(
+      &::Kinova::Api::Common::_Connection_default_instance_);
+}
+inline ::Kinova::Api::Common::Connection* ControlModeNotification::release_connection() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.ControlConfig.ControlModeNotification.connection)
+  
+  ::Kinova::Api::Common::Connection* temp = connection_;
+  connection_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::Connection* ControlModeNotification::mutable_connection() {
+  
+  if (connection_ == NULL) {
+    connection_ = new ::Kinova::Api::Common::Connection;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.ControlConfig.ControlModeNotification.connection)
+  return connection_;
+}
+inline void ControlModeNotification::set_allocated_connection(::Kinova::Api::Common::Connection* connection) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(connection_);
+  }
+  if (connection) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      connection = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, connection, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  connection_ = connection;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.ControlConfig.ControlModeNotification.connection)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace ControlConfig
+}  // namespace Api
+}  // namespace Kinova
+
+namespace google {
+namespace protobuf {
+
+template <> struct is_proto_enum< ::Kinova::Api::ControlConfig::ServiceVersion> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::ControlConfig::ServiceVersion>() {
+  return ::Kinova::Api::ControlConfig::ServiceVersion_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::ControlConfig::ControlConfigurationEvent> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::ControlConfig::ControlConfigurationEvent>() {
+  return ::Kinova::Api::ControlConfig::ControlConfigurationEvent_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::ControlConfig::ControlMode> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::ControlConfig::ControlMode>() {
+  return ::Kinova::Api::ControlConfig::ControlMode_descriptor();
+}
+
+}  // namespace protobuf
+}  // namespace google
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_ControlConfig_2eproto__INCLUDED
diff --git a/kortex_api/include/messages/DeviceConfig.pb.h b/kortex_api/include/messages/DeviceConfig.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..596521d1e5dd739c3ecb31038a63175b017b7c94
--- /dev/null
+++ b/kortex_api/include/messages/DeviceConfig.pb.h
@@ -0,0 +1,4460 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: DeviceConfig.proto
+
+#ifndef PROTOBUF_DeviceConfig_2eproto__INCLUDED
+#define PROTOBUF_DeviceConfig_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 3005000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 3005001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "Common.pb.h"  // IWYU pragma: export
+// @@protoc_insertion_point(includes)
+
+namespace protobuf_DeviceConfig_2eproto {
+// Internal implementation detail -- do not use these members.
+struct TableStruct {
+  static const ::google::protobuf::internal::ParseTableField entries[];
+  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
+  static const ::google::protobuf::internal::ParseTable schema[25];
+  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
+  static const ::google::protobuf::internal::SerializationTable serialization_table[];
+  static const ::google::protobuf::uint32 offsets[];
+};
+void AddDescriptors();
+void InitDefaultsDeviceTypeImpl();
+void InitDefaultsDeviceType();
+void InitDefaultsRunModeImpl();
+void InitDefaultsRunMode();
+void InitDefaultsFirmwareVersionImpl();
+void InitDefaultsFirmwareVersion();
+void InitDefaultsBootloaderVersionImpl();
+void InitDefaultsBootloaderVersion();
+void InitDefaultsModelNumberImpl();
+void InitDefaultsModelNumber();
+void InitDefaultsPartNumberImpl();
+void InitDefaultsPartNumber();
+void InitDefaultsSerialNumberImpl();
+void InitDefaultsSerialNumber();
+void InitDefaultsMACAddressImpl();
+void InitDefaultsMACAddress();
+void InitDefaultsIPv4SettingsImpl();
+void InitDefaultsIPv4Settings();
+void InitDefaultsPartNumberRevisionImpl();
+void InitDefaultsPartNumberRevision();
+void InitDefaultsPowerOnSelfTestResultImpl();
+void InitDefaultsPowerOnSelfTestResult();
+void InitDefaultsRebootRqstImpl();
+void InitDefaultsRebootRqst();
+void InitDefaultsSafetyInformationImpl();
+void InitDefaultsSafetyInformation();
+void InitDefaultsSafetyInformationListImpl();
+void InitDefaultsSafetyInformationList();
+void InitDefaultsSafetyEnableImpl();
+void InitDefaultsSafetyEnable();
+void InitDefaultsSafetyThresholdImpl();
+void InitDefaultsSafetyThreshold();
+void InitDefaultsSafetyConfigurationImpl();
+void InitDefaultsSafetyConfiguration();
+void InitDefaultsSafetyConfigurationListImpl();
+void InitDefaultsSafetyConfigurationList();
+void InitDefaultsSafetyStatusImpl();
+void InitDefaultsSafetyStatus();
+void InitDefaultsCalibrationParameterImpl();
+void InitDefaultsCalibrationParameter();
+void InitDefaultsCalibrationImpl();
+void InitDefaultsCalibration();
+void InitDefaultsCalibrationElementImpl();
+void InitDefaultsCalibrationElement();
+void InitDefaultsCalibrationResultImpl();
+void InitDefaultsCalibrationResult();
+void InitDefaultsCapSenseConfigImpl();
+void InitDefaultsCapSenseConfig();
+void InitDefaultsCapSenseRegisterImpl();
+void InitDefaultsCapSenseRegister();
+inline void InitDefaults() {
+  InitDefaultsDeviceType();
+  InitDefaultsRunMode();
+  InitDefaultsFirmwareVersion();
+  InitDefaultsBootloaderVersion();
+  InitDefaultsModelNumber();
+  InitDefaultsPartNumber();
+  InitDefaultsSerialNumber();
+  InitDefaultsMACAddress();
+  InitDefaultsIPv4Settings();
+  InitDefaultsPartNumberRevision();
+  InitDefaultsPowerOnSelfTestResult();
+  InitDefaultsRebootRqst();
+  InitDefaultsSafetyInformation();
+  InitDefaultsSafetyInformationList();
+  InitDefaultsSafetyEnable();
+  InitDefaultsSafetyThreshold();
+  InitDefaultsSafetyConfiguration();
+  InitDefaultsSafetyConfigurationList();
+  InitDefaultsSafetyStatus();
+  InitDefaultsCalibrationParameter();
+  InitDefaultsCalibration();
+  InitDefaultsCalibrationElement();
+  InitDefaultsCalibrationResult();
+  InitDefaultsCapSenseConfig();
+  InitDefaultsCapSenseRegister();
+}
+}  // namespace protobuf_DeviceConfig_2eproto
+namespace Kinova {
+namespace Api {
+namespace DeviceConfig {
+class BootloaderVersion;
+class BootloaderVersionDefaultTypeInternal;
+extern BootloaderVersionDefaultTypeInternal _BootloaderVersion_default_instance_;
+class Calibration;
+class CalibrationDefaultTypeInternal;
+extern CalibrationDefaultTypeInternal _Calibration_default_instance_;
+class CalibrationElement;
+class CalibrationElementDefaultTypeInternal;
+extern CalibrationElementDefaultTypeInternal _CalibrationElement_default_instance_;
+class CalibrationParameter;
+class CalibrationParameterDefaultTypeInternal;
+extern CalibrationParameterDefaultTypeInternal _CalibrationParameter_default_instance_;
+class CalibrationResult;
+class CalibrationResultDefaultTypeInternal;
+extern CalibrationResultDefaultTypeInternal _CalibrationResult_default_instance_;
+class CapSenseConfig;
+class CapSenseConfigDefaultTypeInternal;
+extern CapSenseConfigDefaultTypeInternal _CapSenseConfig_default_instance_;
+class CapSenseRegister;
+class CapSenseRegisterDefaultTypeInternal;
+extern CapSenseRegisterDefaultTypeInternal _CapSenseRegister_default_instance_;
+class DeviceType;
+class DeviceTypeDefaultTypeInternal;
+extern DeviceTypeDefaultTypeInternal _DeviceType_default_instance_;
+class FirmwareVersion;
+class FirmwareVersionDefaultTypeInternal;
+extern FirmwareVersionDefaultTypeInternal _FirmwareVersion_default_instance_;
+class IPv4Settings;
+class IPv4SettingsDefaultTypeInternal;
+extern IPv4SettingsDefaultTypeInternal _IPv4Settings_default_instance_;
+class MACAddress;
+class MACAddressDefaultTypeInternal;
+extern MACAddressDefaultTypeInternal _MACAddress_default_instance_;
+class ModelNumber;
+class ModelNumberDefaultTypeInternal;
+extern ModelNumberDefaultTypeInternal _ModelNumber_default_instance_;
+class PartNumber;
+class PartNumberDefaultTypeInternal;
+extern PartNumberDefaultTypeInternal _PartNumber_default_instance_;
+class PartNumberRevision;
+class PartNumberRevisionDefaultTypeInternal;
+extern PartNumberRevisionDefaultTypeInternal _PartNumberRevision_default_instance_;
+class PowerOnSelfTestResult;
+class PowerOnSelfTestResultDefaultTypeInternal;
+extern PowerOnSelfTestResultDefaultTypeInternal _PowerOnSelfTestResult_default_instance_;
+class RebootRqst;
+class RebootRqstDefaultTypeInternal;
+extern RebootRqstDefaultTypeInternal _RebootRqst_default_instance_;
+class RunMode;
+class RunModeDefaultTypeInternal;
+extern RunModeDefaultTypeInternal _RunMode_default_instance_;
+class SafetyConfiguration;
+class SafetyConfigurationDefaultTypeInternal;
+extern SafetyConfigurationDefaultTypeInternal _SafetyConfiguration_default_instance_;
+class SafetyConfigurationList;
+class SafetyConfigurationListDefaultTypeInternal;
+extern SafetyConfigurationListDefaultTypeInternal _SafetyConfigurationList_default_instance_;
+class SafetyEnable;
+class SafetyEnableDefaultTypeInternal;
+extern SafetyEnableDefaultTypeInternal _SafetyEnable_default_instance_;
+class SafetyInformation;
+class SafetyInformationDefaultTypeInternal;
+extern SafetyInformationDefaultTypeInternal _SafetyInformation_default_instance_;
+class SafetyInformationList;
+class SafetyInformationListDefaultTypeInternal;
+extern SafetyInformationListDefaultTypeInternal _SafetyInformationList_default_instance_;
+class SafetyStatus;
+class SafetyStatusDefaultTypeInternal;
+extern SafetyStatusDefaultTypeInternal _SafetyStatus_default_instance_;
+class SafetyThreshold;
+class SafetyThresholdDefaultTypeInternal;
+extern SafetyThresholdDefaultTypeInternal _SafetyThreshold_default_instance_;
+class SerialNumber;
+class SerialNumberDefaultTypeInternal;
+extern SerialNumberDefaultTypeInternal _SerialNumber_default_instance_;
+}  // namespace DeviceConfig
+}  // namespace Api
+}  // namespace Kinova
+namespace Kinova {
+namespace Api {
+namespace DeviceConfig {
+
+enum ServiceVersion {
+  RESERVED_0 = 0,
+  CURRENT_VERSION = 1,
+  ServiceVersion_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  ServiceVersion_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool ServiceVersion_IsValid(int value);
+const ServiceVersion ServiceVersion_MIN = RESERVED_0;
+const ServiceVersion ServiceVersion_MAX = CURRENT_VERSION;
+const int ServiceVersion_ARRAYSIZE = ServiceVersion_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* ServiceVersion_descriptor();
+inline const ::std::string& ServiceVersion_Name(ServiceVersion value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    ServiceVersion_descriptor(), value);
+}
+inline bool ServiceVersion_Parse(
+    const ::std::string& name, ServiceVersion* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<ServiceVersion>(
+    ServiceVersion_descriptor(), name, value);
+}
+enum RunModes {
+  RUN_MODE = 0,
+  CALIBRATION_MODE = 1,
+  CONFIGURATION_MODE = 2,
+  DEBUG_MODE = 3,
+  TUNING_MODE = 4,
+  RunModes_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  RunModes_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool RunModes_IsValid(int value);
+const RunModes RunModes_MIN = RUN_MODE;
+const RunModes RunModes_MAX = TUNING_MODE;
+const int RunModes_ARRAYSIZE = RunModes_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* RunModes_descriptor();
+inline const ::std::string& RunModes_Name(RunModes value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    RunModes_descriptor(), value);
+}
+inline bool RunModes_Parse(
+    const ::std::string& name, RunModes* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<RunModes>(
+    RunModes_descriptor(), name, value);
+}
+enum CalibrationItem {
+  UNSPECIFIED_CALIBRATION_ITEM = 0,
+  COGGING = 1,
+  MAGNETIC = 2,
+  MOTOR = 3,
+  POSITION_RANGE = 4,
+  CalibrationItem_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  CalibrationItem_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool CalibrationItem_IsValid(int value);
+const CalibrationItem CalibrationItem_MIN = UNSPECIFIED_CALIBRATION_ITEM;
+const CalibrationItem CalibrationItem_MAX = POSITION_RANGE;
+const int CalibrationItem_ARRAYSIZE = CalibrationItem_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* CalibrationItem_descriptor();
+inline const ::std::string& CalibrationItem_Name(CalibrationItem value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    CalibrationItem_descriptor(), value);
+}
+inline bool CalibrationItem_Parse(
+    const ::std::string& name, CalibrationItem* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<CalibrationItem>(
+    CalibrationItem_descriptor(), name, value);
+}
+enum CalibrationStatus {
+  UNSPECIFIED_CALIBRATION_STATUS = 0,
+  NOT_CALIBRATED = 1,
+  IN_PROGRESS = 2,
+  CALIBRATED = 3,
+  IN_FAULT = 4,
+  CalibrationStatus_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  CalibrationStatus_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool CalibrationStatus_IsValid(int value);
+const CalibrationStatus CalibrationStatus_MIN = UNSPECIFIED_CALIBRATION_STATUS;
+const CalibrationStatus CalibrationStatus_MAX = IN_FAULT;
+const int CalibrationStatus_ARRAYSIZE = CalibrationStatus_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* CalibrationStatus_descriptor();
+inline const ::std::string& CalibrationStatus_Name(CalibrationStatus value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    CalibrationStatus_descriptor(), value);
+}
+inline bool CalibrationStatus_Parse(
+    const ::std::string& name, CalibrationStatus* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<CalibrationStatus>(
+    CalibrationStatus_descriptor(), name, value);
+}
+enum SafetyLimitType {
+  UNSPECIFIED_SAFETY_LIMIT_TYPE = 0,
+  MINIMAL_LIMIT = 1,
+  MAXIMAL_LIMIT = 2,
+  EVENT_LIMIT = 3,
+  SafetyLimitType_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  SafetyLimitType_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool SafetyLimitType_IsValid(int value);
+const SafetyLimitType SafetyLimitType_MIN = UNSPECIFIED_SAFETY_LIMIT_TYPE;
+const SafetyLimitType SafetyLimitType_MAX = EVENT_LIMIT;
+const int SafetyLimitType_ARRAYSIZE = SafetyLimitType_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* SafetyLimitType_descriptor();
+inline const ::std::string& SafetyLimitType_Name(SafetyLimitType value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    SafetyLimitType_descriptor(), value);
+}
+inline bool SafetyLimitType_Parse(
+    const ::std::string& name, SafetyLimitType* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<SafetyLimitType>(
+    SafetyLimitType_descriptor(), name, value);
+}
+enum CapSenseMode {
+  RESERVED = 0,
+  INACTIVE = 1,
+  ACTIVE_AUTO_THRESHOLD = 2,
+  ACTIVE_NOISE_ATT = 4,
+  ACTIVE_NORMAL = 5,
+  CONFIGURATION = 6,
+  CapSenseMode_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  CapSenseMode_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool CapSenseMode_IsValid(int value);
+const CapSenseMode CapSenseMode_MIN = RESERVED;
+const CapSenseMode CapSenseMode_MAX = CONFIGURATION;
+const int CapSenseMode_ARRAYSIZE = CapSenseMode_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* CapSenseMode_descriptor();
+inline const ::std::string& CapSenseMode_Name(CapSenseMode value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    CapSenseMode_descriptor(), value);
+}
+inline bool CapSenseMode_Parse(
+    const ::std::string& name, CapSenseMode* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<CapSenseMode>(
+    CapSenseMode_descriptor(), name, value);
+}
+// ===================================================================
+
+class DeviceType : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.DeviceConfig.DeviceType) */ {
+ public:
+  DeviceType();
+  virtual ~DeviceType();
+
+  DeviceType(const DeviceType& from);
+
+  inline DeviceType& operator=(const DeviceType& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  DeviceType(DeviceType&& from) noexcept
+    : DeviceType() {
+    *this = ::std::move(from);
+  }
+
+  inline DeviceType& operator=(DeviceType&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const DeviceType& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const DeviceType* internal_default_instance() {
+    return reinterpret_cast<const DeviceType*>(
+               &_DeviceType_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    0;
+
+  void Swap(DeviceType* other);
+  friend void swap(DeviceType& a, DeviceType& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline DeviceType* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  DeviceType* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const DeviceType& from);
+  void MergeFrom(const DeviceType& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(DeviceType* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Common.DeviceTypes device_type = 1;
+  void clear_device_type();
+  static const int kDeviceTypeFieldNumber = 1;
+  ::Kinova::Api::Common::DeviceTypes device_type() const;
+  void set_device_type(::Kinova::Api::Common::DeviceTypes value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.DeviceConfig.DeviceType)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  int device_type_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_DeviceConfig_2eproto::TableStruct;
+  friend void ::protobuf_DeviceConfig_2eproto::InitDefaultsDeviceTypeImpl();
+};
+// -------------------------------------------------------------------
+
+class RunMode : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.DeviceConfig.RunMode) */ {
+ public:
+  RunMode();
+  virtual ~RunMode();
+
+  RunMode(const RunMode& from);
+
+  inline RunMode& operator=(const RunMode& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  RunMode(RunMode&& from) noexcept
+    : RunMode() {
+    *this = ::std::move(from);
+  }
+
+  inline RunMode& operator=(RunMode&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const RunMode& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const RunMode* internal_default_instance() {
+    return reinterpret_cast<const RunMode*>(
+               &_RunMode_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    1;
+
+  void Swap(RunMode* other);
+  friend void swap(RunMode& a, RunMode& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline RunMode* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  RunMode* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const RunMode& from);
+  void MergeFrom(const RunMode& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(RunMode* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.DeviceConfig.RunModes run_mode = 1;
+  void clear_run_mode();
+  static const int kRunModeFieldNumber = 1;
+  ::Kinova::Api::DeviceConfig::RunModes run_mode() const;
+  void set_run_mode(::Kinova::Api::DeviceConfig::RunModes value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.DeviceConfig.RunMode)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  int run_mode_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_DeviceConfig_2eproto::TableStruct;
+  friend void ::protobuf_DeviceConfig_2eproto::InitDefaultsRunModeImpl();
+};
+// -------------------------------------------------------------------
+
+class FirmwareVersion : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.DeviceConfig.FirmwareVersion) */ {
+ public:
+  FirmwareVersion();
+  virtual ~FirmwareVersion();
+
+  FirmwareVersion(const FirmwareVersion& from);
+
+  inline FirmwareVersion& operator=(const FirmwareVersion& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  FirmwareVersion(FirmwareVersion&& from) noexcept
+    : FirmwareVersion() {
+    *this = ::std::move(from);
+  }
+
+  inline FirmwareVersion& operator=(FirmwareVersion&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const FirmwareVersion& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const FirmwareVersion* internal_default_instance() {
+    return reinterpret_cast<const FirmwareVersion*>(
+               &_FirmwareVersion_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    2;
+
+  void Swap(FirmwareVersion* other);
+  friend void swap(FirmwareVersion& a, FirmwareVersion& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline FirmwareVersion* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  FirmwareVersion* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const FirmwareVersion& from);
+  void MergeFrom(const FirmwareVersion& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(FirmwareVersion* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // uint32 firmware_version = 1;
+  void clear_firmware_version();
+  static const int kFirmwareVersionFieldNumber = 1;
+  ::google::protobuf::uint32 firmware_version() const;
+  void set_firmware_version(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.DeviceConfig.FirmwareVersion)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 firmware_version_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_DeviceConfig_2eproto::TableStruct;
+  friend void ::protobuf_DeviceConfig_2eproto::InitDefaultsFirmwareVersionImpl();
+};
+// -------------------------------------------------------------------
+
+class BootloaderVersion : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.DeviceConfig.BootloaderVersion) */ {
+ public:
+  BootloaderVersion();
+  virtual ~BootloaderVersion();
+
+  BootloaderVersion(const BootloaderVersion& from);
+
+  inline BootloaderVersion& operator=(const BootloaderVersion& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  BootloaderVersion(BootloaderVersion&& from) noexcept
+    : BootloaderVersion() {
+    *this = ::std::move(from);
+  }
+
+  inline BootloaderVersion& operator=(BootloaderVersion&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const BootloaderVersion& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const BootloaderVersion* internal_default_instance() {
+    return reinterpret_cast<const BootloaderVersion*>(
+               &_BootloaderVersion_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    3;
+
+  void Swap(BootloaderVersion* other);
+  friend void swap(BootloaderVersion& a, BootloaderVersion& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline BootloaderVersion* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  BootloaderVersion* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const BootloaderVersion& from);
+  void MergeFrom(const BootloaderVersion& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(BootloaderVersion* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // uint32 bootloader_version = 1;
+  void clear_bootloader_version();
+  static const int kBootloaderVersionFieldNumber = 1;
+  ::google::protobuf::uint32 bootloader_version() const;
+  void set_bootloader_version(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.DeviceConfig.BootloaderVersion)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 bootloader_version_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_DeviceConfig_2eproto::TableStruct;
+  friend void ::protobuf_DeviceConfig_2eproto::InitDefaultsBootloaderVersionImpl();
+};
+// -------------------------------------------------------------------
+
+class ModelNumber : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.DeviceConfig.ModelNumber) */ {
+ public:
+  ModelNumber();
+  virtual ~ModelNumber();
+
+  ModelNumber(const ModelNumber& from);
+
+  inline ModelNumber& operator=(const ModelNumber& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ModelNumber(ModelNumber&& from) noexcept
+    : ModelNumber() {
+    *this = ::std::move(from);
+  }
+
+  inline ModelNumber& operator=(ModelNumber&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ModelNumber& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ModelNumber* internal_default_instance() {
+    return reinterpret_cast<const ModelNumber*>(
+               &_ModelNumber_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    4;
+
+  void Swap(ModelNumber* other);
+  friend void swap(ModelNumber& a, ModelNumber& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ModelNumber* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ModelNumber* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ModelNumber& from);
+  void MergeFrom(const ModelNumber& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ModelNumber* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // string model_number = 1;
+  void clear_model_number();
+  static const int kModelNumberFieldNumber = 1;
+  const ::std::string& model_number() const;
+  void set_model_number(const ::std::string& value);
+  #if LANG_CXX11
+  void set_model_number(::std::string&& value);
+  #endif
+  void set_model_number(const char* value);
+  void set_model_number(const char* value, size_t size);
+  ::std::string* mutable_model_number();
+  ::std::string* release_model_number();
+  void set_allocated_model_number(::std::string* model_number);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.DeviceConfig.ModelNumber)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::internal::ArenaStringPtr model_number_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_DeviceConfig_2eproto::TableStruct;
+  friend void ::protobuf_DeviceConfig_2eproto::InitDefaultsModelNumberImpl();
+};
+// -------------------------------------------------------------------
+
+class PartNumber : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.DeviceConfig.PartNumber) */ {
+ public:
+  PartNumber();
+  virtual ~PartNumber();
+
+  PartNumber(const PartNumber& from);
+
+  inline PartNumber& operator=(const PartNumber& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  PartNumber(PartNumber&& from) noexcept
+    : PartNumber() {
+    *this = ::std::move(from);
+  }
+
+  inline PartNumber& operator=(PartNumber&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const PartNumber& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const PartNumber* internal_default_instance() {
+    return reinterpret_cast<const PartNumber*>(
+               &_PartNumber_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    5;
+
+  void Swap(PartNumber* other);
+  friend void swap(PartNumber& a, PartNumber& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline PartNumber* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  PartNumber* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const PartNumber& from);
+  void MergeFrom(const PartNumber& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(PartNumber* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // string part_number = 1;
+  void clear_part_number();
+  static const int kPartNumberFieldNumber = 1;
+  const ::std::string& part_number() const;
+  void set_part_number(const ::std::string& value);
+  #if LANG_CXX11
+  void set_part_number(::std::string&& value);
+  #endif
+  void set_part_number(const char* value);
+  void set_part_number(const char* value, size_t size);
+  ::std::string* mutable_part_number();
+  ::std::string* release_part_number();
+  void set_allocated_part_number(::std::string* part_number);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.DeviceConfig.PartNumber)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::internal::ArenaStringPtr part_number_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_DeviceConfig_2eproto::TableStruct;
+  friend void ::protobuf_DeviceConfig_2eproto::InitDefaultsPartNumberImpl();
+};
+// -------------------------------------------------------------------
+
+class SerialNumber : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.DeviceConfig.SerialNumber) */ {
+ public:
+  SerialNumber();
+  virtual ~SerialNumber();
+
+  SerialNumber(const SerialNumber& from);
+
+  inline SerialNumber& operator=(const SerialNumber& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  SerialNumber(SerialNumber&& from) noexcept
+    : SerialNumber() {
+    *this = ::std::move(from);
+  }
+
+  inline SerialNumber& operator=(SerialNumber&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SerialNumber& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const SerialNumber* internal_default_instance() {
+    return reinterpret_cast<const SerialNumber*>(
+               &_SerialNumber_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    6;
+
+  void Swap(SerialNumber* other);
+  friend void swap(SerialNumber& a, SerialNumber& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SerialNumber* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  SerialNumber* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const SerialNumber& from);
+  void MergeFrom(const SerialNumber& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(SerialNumber* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // string serial_number = 1;
+  void clear_serial_number();
+  static const int kSerialNumberFieldNumber = 1;
+  const ::std::string& serial_number() const;
+  void set_serial_number(const ::std::string& value);
+  #if LANG_CXX11
+  void set_serial_number(::std::string&& value);
+  #endif
+  void set_serial_number(const char* value);
+  void set_serial_number(const char* value, size_t size);
+  ::std::string* mutable_serial_number();
+  ::std::string* release_serial_number();
+  void set_allocated_serial_number(::std::string* serial_number);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.DeviceConfig.SerialNumber)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::internal::ArenaStringPtr serial_number_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_DeviceConfig_2eproto::TableStruct;
+  friend void ::protobuf_DeviceConfig_2eproto::InitDefaultsSerialNumberImpl();
+};
+// -------------------------------------------------------------------
+
+class MACAddress : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.DeviceConfig.MACAddress) */ {
+ public:
+  MACAddress();
+  virtual ~MACAddress();
+
+  MACAddress(const MACAddress& from);
+
+  inline MACAddress& operator=(const MACAddress& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  MACAddress(MACAddress&& from) noexcept
+    : MACAddress() {
+    *this = ::std::move(from);
+  }
+
+  inline MACAddress& operator=(MACAddress&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const MACAddress& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const MACAddress* internal_default_instance() {
+    return reinterpret_cast<const MACAddress*>(
+               &_MACAddress_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    7;
+
+  void Swap(MACAddress* other);
+  friend void swap(MACAddress& a, MACAddress& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline MACAddress* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  MACAddress* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const MACAddress& from);
+  void MergeFrom(const MACAddress& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(MACAddress* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // bytes mac_address = 1;
+  void clear_mac_address();
+  static const int kMacAddressFieldNumber = 1;
+  const ::std::string& mac_address() const;
+  void set_mac_address(const ::std::string& value);
+  #if LANG_CXX11
+  void set_mac_address(::std::string&& value);
+  #endif
+  void set_mac_address(const char* value);
+  void set_mac_address(const void* value, size_t size);
+  ::std::string* mutable_mac_address();
+  ::std::string* release_mac_address();
+  void set_allocated_mac_address(::std::string* mac_address);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.DeviceConfig.MACAddress)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::internal::ArenaStringPtr mac_address_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_DeviceConfig_2eproto::TableStruct;
+  friend void ::protobuf_DeviceConfig_2eproto::InitDefaultsMACAddressImpl();
+};
+// -------------------------------------------------------------------
+
+class IPv4Settings : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.DeviceConfig.IPv4Settings) */ {
+ public:
+  IPv4Settings();
+  virtual ~IPv4Settings();
+
+  IPv4Settings(const IPv4Settings& from);
+
+  inline IPv4Settings& operator=(const IPv4Settings& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  IPv4Settings(IPv4Settings&& from) noexcept
+    : IPv4Settings() {
+    *this = ::std::move(from);
+  }
+
+  inline IPv4Settings& operator=(IPv4Settings&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const IPv4Settings& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const IPv4Settings* internal_default_instance() {
+    return reinterpret_cast<const IPv4Settings*>(
+               &_IPv4Settings_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    8;
+
+  void Swap(IPv4Settings* other);
+  friend void swap(IPv4Settings& a, IPv4Settings& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline IPv4Settings* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  IPv4Settings* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const IPv4Settings& from);
+  void MergeFrom(const IPv4Settings& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(IPv4Settings* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // uint32 ipv4_address = 1;
+  void clear_ipv4_address();
+  static const int kIpv4AddressFieldNumber = 1;
+  ::google::protobuf::uint32 ipv4_address() const;
+  void set_ipv4_address(::google::protobuf::uint32 value);
+
+  // uint32 ipv4_subnet_mask = 2;
+  void clear_ipv4_subnet_mask();
+  static const int kIpv4SubnetMaskFieldNumber = 2;
+  ::google::protobuf::uint32 ipv4_subnet_mask() const;
+  void set_ipv4_subnet_mask(::google::protobuf::uint32 value);
+
+  // uint32 ipv4_default_gateway = 3;
+  void clear_ipv4_default_gateway();
+  static const int kIpv4DefaultGatewayFieldNumber = 3;
+  ::google::protobuf::uint32 ipv4_default_gateway() const;
+  void set_ipv4_default_gateway(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.DeviceConfig.IPv4Settings)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 ipv4_address_;
+  ::google::protobuf::uint32 ipv4_subnet_mask_;
+  ::google::protobuf::uint32 ipv4_default_gateway_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_DeviceConfig_2eproto::TableStruct;
+  friend void ::protobuf_DeviceConfig_2eproto::InitDefaultsIPv4SettingsImpl();
+};
+// -------------------------------------------------------------------
+
+class PartNumberRevision : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.DeviceConfig.PartNumberRevision) */ {
+ public:
+  PartNumberRevision();
+  virtual ~PartNumberRevision();
+
+  PartNumberRevision(const PartNumberRevision& from);
+
+  inline PartNumberRevision& operator=(const PartNumberRevision& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  PartNumberRevision(PartNumberRevision&& from) noexcept
+    : PartNumberRevision() {
+    *this = ::std::move(from);
+  }
+
+  inline PartNumberRevision& operator=(PartNumberRevision&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const PartNumberRevision& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const PartNumberRevision* internal_default_instance() {
+    return reinterpret_cast<const PartNumberRevision*>(
+               &_PartNumberRevision_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    9;
+
+  void Swap(PartNumberRevision* other);
+  friend void swap(PartNumberRevision& a, PartNumberRevision& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline PartNumberRevision* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  PartNumberRevision* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const PartNumberRevision& from);
+  void MergeFrom(const PartNumberRevision& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(PartNumberRevision* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // string part_number_revision = 1;
+  void clear_part_number_revision();
+  static const int kPartNumberRevisionFieldNumber = 1;
+  const ::std::string& part_number_revision() const;
+  void set_part_number_revision(const ::std::string& value);
+  #if LANG_CXX11
+  void set_part_number_revision(::std::string&& value);
+  #endif
+  void set_part_number_revision(const char* value);
+  void set_part_number_revision(const char* value, size_t size);
+  ::std::string* mutable_part_number_revision();
+  ::std::string* release_part_number_revision();
+  void set_allocated_part_number_revision(::std::string* part_number_revision);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.DeviceConfig.PartNumberRevision)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::internal::ArenaStringPtr part_number_revision_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_DeviceConfig_2eproto::TableStruct;
+  friend void ::protobuf_DeviceConfig_2eproto::InitDefaultsPartNumberRevisionImpl();
+};
+// -------------------------------------------------------------------
+
+class PowerOnSelfTestResult : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.DeviceConfig.PowerOnSelfTestResult) */ {
+ public:
+  PowerOnSelfTestResult();
+  virtual ~PowerOnSelfTestResult();
+
+  PowerOnSelfTestResult(const PowerOnSelfTestResult& from);
+
+  inline PowerOnSelfTestResult& operator=(const PowerOnSelfTestResult& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  PowerOnSelfTestResult(PowerOnSelfTestResult&& from) noexcept
+    : PowerOnSelfTestResult() {
+    *this = ::std::move(from);
+  }
+
+  inline PowerOnSelfTestResult& operator=(PowerOnSelfTestResult&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const PowerOnSelfTestResult& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const PowerOnSelfTestResult* internal_default_instance() {
+    return reinterpret_cast<const PowerOnSelfTestResult*>(
+               &_PowerOnSelfTestResult_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    10;
+
+  void Swap(PowerOnSelfTestResult* other);
+  friend void swap(PowerOnSelfTestResult& a, PowerOnSelfTestResult& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline PowerOnSelfTestResult* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  PowerOnSelfTestResult* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const PowerOnSelfTestResult& from);
+  void MergeFrom(const PowerOnSelfTestResult& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(PowerOnSelfTestResult* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // uint32 power_on_self_test_result = 1;
+  void clear_power_on_self_test_result();
+  static const int kPowerOnSelfTestResultFieldNumber = 1;
+  ::google::protobuf::uint32 power_on_self_test_result() const;
+  void set_power_on_self_test_result(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.DeviceConfig.PowerOnSelfTestResult)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 power_on_self_test_result_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_DeviceConfig_2eproto::TableStruct;
+  friend void ::protobuf_DeviceConfig_2eproto::InitDefaultsPowerOnSelfTestResultImpl();
+};
+// -------------------------------------------------------------------
+
+class RebootRqst : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.DeviceConfig.RebootRqst) */ {
+ public:
+  RebootRqst();
+  virtual ~RebootRqst();
+
+  RebootRqst(const RebootRqst& from);
+
+  inline RebootRqst& operator=(const RebootRqst& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  RebootRqst(RebootRqst&& from) noexcept
+    : RebootRqst() {
+    *this = ::std::move(from);
+  }
+
+  inline RebootRqst& operator=(RebootRqst&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const RebootRqst& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const RebootRqst* internal_default_instance() {
+    return reinterpret_cast<const RebootRqst*>(
+               &_RebootRqst_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    11;
+
+  void Swap(RebootRqst* other);
+  friend void swap(RebootRqst& a, RebootRqst& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline RebootRqst* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  RebootRqst* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const RebootRqst& from);
+  void MergeFrom(const RebootRqst& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(RebootRqst* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // uint32 delay = 1;
+  void clear_delay();
+  static const int kDelayFieldNumber = 1;
+  ::google::protobuf::uint32 delay() const;
+  void set_delay(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.DeviceConfig.RebootRqst)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 delay_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_DeviceConfig_2eproto::TableStruct;
+  friend void ::protobuf_DeviceConfig_2eproto::InitDefaultsRebootRqstImpl();
+};
+// -------------------------------------------------------------------
+
+class SafetyInformation : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.DeviceConfig.SafetyInformation) */ {
+ public:
+  SafetyInformation();
+  virtual ~SafetyInformation();
+
+  SafetyInformation(const SafetyInformation& from);
+
+  inline SafetyInformation& operator=(const SafetyInformation& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  SafetyInformation(SafetyInformation&& from) noexcept
+    : SafetyInformation() {
+    *this = ::std::move(from);
+  }
+
+  inline SafetyInformation& operator=(SafetyInformation&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SafetyInformation& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const SafetyInformation* internal_default_instance() {
+    return reinterpret_cast<const SafetyInformation*>(
+               &_SafetyInformation_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    12;
+
+  void Swap(SafetyInformation* other);
+  friend void swap(SafetyInformation& a, SafetyInformation& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SafetyInformation* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  SafetyInformation* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const SafetyInformation& from);
+  void MergeFrom(const SafetyInformation& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(SafetyInformation* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Common.SafetyHandle handle = 1;
+  bool has_handle() const;
+  void clear_handle();
+  static const int kHandleFieldNumber = 1;
+  const ::Kinova::Api::Common::SafetyHandle& handle() const;
+  ::Kinova::Api::Common::SafetyHandle* release_handle();
+  ::Kinova::Api::Common::SafetyHandle* mutable_handle();
+  void set_allocated_handle(::Kinova::Api::Common::SafetyHandle* handle);
+
+  // bool can_change_safety_state = 2;
+  void clear_can_change_safety_state();
+  static const int kCanChangeSafetyStateFieldNumber = 2;
+  bool can_change_safety_state() const;
+  void set_can_change_safety_state(bool value);
+
+  // bool has_warning_threshold = 3;
+  void clear_has_warning_threshold();
+  static const int kHasWarningThresholdFieldNumber = 3;
+  bool has_warning_threshold() const;
+  void set_has_warning_threshold(bool value);
+
+  // bool has_error_threshold = 4;
+  void clear_has_error_threshold();
+  static const int kHasErrorThresholdFieldNumber = 4;
+  bool has_error_threshold() const;
+  void set_has_error_threshold(bool value);
+
+  // .Kinova.Api.DeviceConfig.SafetyLimitType limit_type = 5;
+  void clear_limit_type();
+  static const int kLimitTypeFieldNumber = 5;
+  ::Kinova::Api::DeviceConfig::SafetyLimitType limit_type() const;
+  void set_limit_type(::Kinova::Api::DeviceConfig::SafetyLimitType value);
+
+  // float default_warning_threshold = 6;
+  void clear_default_warning_threshold();
+  static const int kDefaultWarningThresholdFieldNumber = 6;
+  float default_warning_threshold() const;
+  void set_default_warning_threshold(float value);
+
+  // float default_error_threshold = 7;
+  void clear_default_error_threshold();
+  static const int kDefaultErrorThresholdFieldNumber = 7;
+  float default_error_threshold() const;
+  void set_default_error_threshold(float value);
+
+  // float upper_hard_limit = 8;
+  void clear_upper_hard_limit();
+  static const int kUpperHardLimitFieldNumber = 8;
+  float upper_hard_limit() const;
+  void set_upper_hard_limit(float value);
+
+  // float lower_hard_limit = 9;
+  void clear_lower_hard_limit();
+  static const int kLowerHardLimitFieldNumber = 9;
+  float lower_hard_limit() const;
+  void set_lower_hard_limit(float value);
+
+  // .Kinova.Api.Common.SafetyStatusValue status = 11;
+  void clear_status();
+  static const int kStatusFieldNumber = 11;
+  ::Kinova::Api::Common::SafetyStatusValue status() const;
+  void set_status(::Kinova::Api::Common::SafetyStatusValue value);
+
+  // .Kinova.Api.Common.Unit unit = 12;
+  void clear_unit();
+  static const int kUnitFieldNumber = 12;
+  ::Kinova::Api::Common::Unit unit() const;
+  void set_unit(::Kinova::Api::Common::Unit value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.DeviceConfig.SafetyInformation)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::Common::SafetyHandle* handle_;
+  bool can_change_safety_state_;
+  bool has_warning_threshold_;
+  bool has_error_threshold_;
+  int limit_type_;
+  float default_warning_threshold_;
+  float default_error_threshold_;
+  float upper_hard_limit_;
+  float lower_hard_limit_;
+  int status_;
+  int unit_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_DeviceConfig_2eproto::TableStruct;
+  friend void ::protobuf_DeviceConfig_2eproto::InitDefaultsSafetyInformationImpl();
+};
+// -------------------------------------------------------------------
+
+class SafetyInformationList : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.DeviceConfig.SafetyInformationList) */ {
+ public:
+  SafetyInformationList();
+  virtual ~SafetyInformationList();
+
+  SafetyInformationList(const SafetyInformationList& from);
+
+  inline SafetyInformationList& operator=(const SafetyInformationList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  SafetyInformationList(SafetyInformationList&& from) noexcept
+    : SafetyInformationList() {
+    *this = ::std::move(from);
+  }
+
+  inline SafetyInformationList& operator=(SafetyInformationList&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SafetyInformationList& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const SafetyInformationList* internal_default_instance() {
+    return reinterpret_cast<const SafetyInformationList*>(
+               &_SafetyInformationList_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    13;
+
+  void Swap(SafetyInformationList* other);
+  friend void swap(SafetyInformationList& a, SafetyInformationList& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SafetyInformationList* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  SafetyInformationList* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const SafetyInformationList& from);
+  void MergeFrom(const SafetyInformationList& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(SafetyInformationList* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .Kinova.Api.DeviceConfig.SafetyInformation information = 1;
+  int information_size() const;
+  void clear_information();
+  static const int kInformationFieldNumber = 1;
+  const ::Kinova::Api::DeviceConfig::SafetyInformation& information(int index) const;
+  ::Kinova::Api::DeviceConfig::SafetyInformation* mutable_information(int index);
+  ::Kinova::Api::DeviceConfig::SafetyInformation* add_information();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::DeviceConfig::SafetyInformation >*
+      mutable_information();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::DeviceConfig::SafetyInformation >&
+      information() const;
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.DeviceConfig.SafetyInformationList)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::DeviceConfig::SafetyInformation > information_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_DeviceConfig_2eproto::TableStruct;
+  friend void ::protobuf_DeviceConfig_2eproto::InitDefaultsSafetyInformationListImpl();
+};
+// -------------------------------------------------------------------
+
+class SafetyEnable : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.DeviceConfig.SafetyEnable) */ {
+ public:
+  SafetyEnable();
+  virtual ~SafetyEnable();
+
+  SafetyEnable(const SafetyEnable& from);
+
+  inline SafetyEnable& operator=(const SafetyEnable& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  SafetyEnable(SafetyEnable&& from) noexcept
+    : SafetyEnable() {
+    *this = ::std::move(from);
+  }
+
+  inline SafetyEnable& operator=(SafetyEnable&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SafetyEnable& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const SafetyEnable* internal_default_instance() {
+    return reinterpret_cast<const SafetyEnable*>(
+               &_SafetyEnable_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    14;
+
+  void Swap(SafetyEnable* other);
+  friend void swap(SafetyEnable& a, SafetyEnable& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SafetyEnable* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  SafetyEnable* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const SafetyEnable& from);
+  void MergeFrom(const SafetyEnable& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(SafetyEnable* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Common.SafetyHandle handle = 1;
+  bool has_handle() const;
+  void clear_handle();
+  static const int kHandleFieldNumber = 1;
+  const ::Kinova::Api::Common::SafetyHandle& handle() const;
+  ::Kinova::Api::Common::SafetyHandle* release_handle();
+  ::Kinova::Api::Common::SafetyHandle* mutable_handle();
+  void set_allocated_handle(::Kinova::Api::Common::SafetyHandle* handle);
+
+  // bool enable = 2;
+  void clear_enable();
+  static const int kEnableFieldNumber = 2;
+  bool enable() const;
+  void set_enable(bool value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.DeviceConfig.SafetyEnable)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::Common::SafetyHandle* handle_;
+  bool enable_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_DeviceConfig_2eproto::TableStruct;
+  friend void ::protobuf_DeviceConfig_2eproto::InitDefaultsSafetyEnableImpl();
+};
+// -------------------------------------------------------------------
+
+class SafetyThreshold : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.DeviceConfig.SafetyThreshold) */ {
+ public:
+  SafetyThreshold();
+  virtual ~SafetyThreshold();
+
+  SafetyThreshold(const SafetyThreshold& from);
+
+  inline SafetyThreshold& operator=(const SafetyThreshold& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  SafetyThreshold(SafetyThreshold&& from) noexcept
+    : SafetyThreshold() {
+    *this = ::std::move(from);
+  }
+
+  inline SafetyThreshold& operator=(SafetyThreshold&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SafetyThreshold& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const SafetyThreshold* internal_default_instance() {
+    return reinterpret_cast<const SafetyThreshold*>(
+               &_SafetyThreshold_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    15;
+
+  void Swap(SafetyThreshold* other);
+  friend void swap(SafetyThreshold& a, SafetyThreshold& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SafetyThreshold* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  SafetyThreshold* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const SafetyThreshold& from);
+  void MergeFrom(const SafetyThreshold& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(SafetyThreshold* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Common.SafetyHandle handle = 1;
+  bool has_handle() const;
+  void clear_handle();
+  static const int kHandleFieldNumber = 1;
+  const ::Kinova::Api::Common::SafetyHandle& handle() const;
+  ::Kinova::Api::Common::SafetyHandle* release_handle();
+  ::Kinova::Api::Common::SafetyHandle* mutable_handle();
+  void set_allocated_handle(::Kinova::Api::Common::SafetyHandle* handle);
+
+  // float value = 2;
+  void clear_value();
+  static const int kValueFieldNumber = 2;
+  float value() const;
+  void set_value(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.DeviceConfig.SafetyThreshold)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::Common::SafetyHandle* handle_;
+  float value_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_DeviceConfig_2eproto::TableStruct;
+  friend void ::protobuf_DeviceConfig_2eproto::InitDefaultsSafetyThresholdImpl();
+};
+// -------------------------------------------------------------------
+
+class SafetyConfiguration : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.DeviceConfig.SafetyConfiguration) */ {
+ public:
+  SafetyConfiguration();
+  virtual ~SafetyConfiguration();
+
+  SafetyConfiguration(const SafetyConfiguration& from);
+
+  inline SafetyConfiguration& operator=(const SafetyConfiguration& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  SafetyConfiguration(SafetyConfiguration&& from) noexcept
+    : SafetyConfiguration() {
+    *this = ::std::move(from);
+  }
+
+  inline SafetyConfiguration& operator=(SafetyConfiguration&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SafetyConfiguration& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const SafetyConfiguration* internal_default_instance() {
+    return reinterpret_cast<const SafetyConfiguration*>(
+               &_SafetyConfiguration_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    16;
+
+  void Swap(SafetyConfiguration* other);
+  friend void swap(SafetyConfiguration& a, SafetyConfiguration& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SafetyConfiguration* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  SafetyConfiguration* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const SafetyConfiguration& from);
+  void MergeFrom(const SafetyConfiguration& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(SafetyConfiguration* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Common.SafetyHandle handle = 1;
+  bool has_handle() const;
+  void clear_handle();
+  static const int kHandleFieldNumber = 1;
+  const ::Kinova::Api::Common::SafetyHandle& handle() const;
+  ::Kinova::Api::Common::SafetyHandle* release_handle();
+  ::Kinova::Api::Common::SafetyHandle* mutable_handle();
+  void set_allocated_handle(::Kinova::Api::Common::SafetyHandle* handle);
+
+  // .Kinova.Api.DeviceConfig.SafetyEnable enable = 4;
+  bool has_enable() const;
+  void clear_enable();
+  static const int kEnableFieldNumber = 4;
+  const ::Kinova::Api::DeviceConfig::SafetyEnable& enable() const;
+  ::Kinova::Api::DeviceConfig::SafetyEnable* release_enable();
+  ::Kinova::Api::DeviceConfig::SafetyEnable* mutable_enable();
+  void set_allocated_enable(::Kinova::Api::DeviceConfig::SafetyEnable* enable);
+
+  // float error_threshold = 2;
+  void clear_error_threshold();
+  static const int kErrorThresholdFieldNumber = 2;
+  float error_threshold() const;
+  void set_error_threshold(float value);
+
+  // float warning_threshold = 3;
+  void clear_warning_threshold();
+  static const int kWarningThresholdFieldNumber = 3;
+  float warning_threshold() const;
+  void set_warning_threshold(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.DeviceConfig.SafetyConfiguration)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::Common::SafetyHandle* handle_;
+  ::Kinova::Api::DeviceConfig::SafetyEnable* enable_;
+  float error_threshold_;
+  float warning_threshold_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_DeviceConfig_2eproto::TableStruct;
+  friend void ::protobuf_DeviceConfig_2eproto::InitDefaultsSafetyConfigurationImpl();
+};
+// -------------------------------------------------------------------
+
+class SafetyConfigurationList : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.DeviceConfig.SafetyConfigurationList) */ {
+ public:
+  SafetyConfigurationList();
+  virtual ~SafetyConfigurationList();
+
+  SafetyConfigurationList(const SafetyConfigurationList& from);
+
+  inline SafetyConfigurationList& operator=(const SafetyConfigurationList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  SafetyConfigurationList(SafetyConfigurationList&& from) noexcept
+    : SafetyConfigurationList() {
+    *this = ::std::move(from);
+  }
+
+  inline SafetyConfigurationList& operator=(SafetyConfigurationList&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SafetyConfigurationList& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const SafetyConfigurationList* internal_default_instance() {
+    return reinterpret_cast<const SafetyConfigurationList*>(
+               &_SafetyConfigurationList_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    17;
+
+  void Swap(SafetyConfigurationList* other);
+  friend void swap(SafetyConfigurationList& a, SafetyConfigurationList& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SafetyConfigurationList* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  SafetyConfigurationList* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const SafetyConfigurationList& from);
+  void MergeFrom(const SafetyConfigurationList& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(SafetyConfigurationList* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .Kinova.Api.DeviceConfig.SafetyConfiguration configuration = 1;
+  int configuration_size() const;
+  void clear_configuration();
+  static const int kConfigurationFieldNumber = 1;
+  const ::Kinova::Api::DeviceConfig::SafetyConfiguration& configuration(int index) const;
+  ::Kinova::Api::DeviceConfig::SafetyConfiguration* mutable_configuration(int index);
+  ::Kinova::Api::DeviceConfig::SafetyConfiguration* add_configuration();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::DeviceConfig::SafetyConfiguration >*
+      mutable_configuration();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::DeviceConfig::SafetyConfiguration >&
+      configuration() const;
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.DeviceConfig.SafetyConfigurationList)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::DeviceConfig::SafetyConfiguration > configuration_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_DeviceConfig_2eproto::TableStruct;
+  friend void ::protobuf_DeviceConfig_2eproto::InitDefaultsSafetyConfigurationListImpl();
+};
+// -------------------------------------------------------------------
+
+class SafetyStatus : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.DeviceConfig.SafetyStatus) */ {
+ public:
+  SafetyStatus();
+  virtual ~SafetyStatus();
+
+  SafetyStatus(const SafetyStatus& from);
+
+  inline SafetyStatus& operator=(const SafetyStatus& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  SafetyStatus(SafetyStatus&& from) noexcept
+    : SafetyStatus() {
+    *this = ::std::move(from);
+  }
+
+  inline SafetyStatus& operator=(SafetyStatus&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SafetyStatus& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const SafetyStatus* internal_default_instance() {
+    return reinterpret_cast<const SafetyStatus*>(
+               &_SafetyStatus_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    18;
+
+  void Swap(SafetyStatus* other);
+  friend void swap(SafetyStatus& a, SafetyStatus& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SafetyStatus* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  SafetyStatus* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const SafetyStatus& from);
+  void MergeFrom(const SafetyStatus& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(SafetyStatus* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Common.SafetyStatusValue value = 1;
+  void clear_value();
+  static const int kValueFieldNumber = 1;
+  ::Kinova::Api::Common::SafetyStatusValue value() const;
+  void set_value(::Kinova::Api::Common::SafetyStatusValue value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.DeviceConfig.SafetyStatus)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  int value_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_DeviceConfig_2eproto::TableStruct;
+  friend void ::protobuf_DeviceConfig_2eproto::InitDefaultsSafetyStatusImpl();
+};
+// -------------------------------------------------------------------
+
+class CalibrationParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.DeviceConfig.CalibrationParameter) */ {
+ public:
+  CalibrationParameter();
+  virtual ~CalibrationParameter();
+
+  CalibrationParameter(const CalibrationParameter& from);
+
+  inline CalibrationParameter& operator=(const CalibrationParameter& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  CalibrationParameter(CalibrationParameter&& from) noexcept
+    : CalibrationParameter() {
+    *this = ::std::move(from);
+  }
+
+  inline CalibrationParameter& operator=(CalibrationParameter&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const CalibrationParameter& default_instance();
+
+  enum ValueCase {
+    kSignedIntValue = 2,
+    kUnsignedIntValue = 3,
+    kFloatValue = 4,
+    VALUE_NOT_SET = 0,
+  };
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const CalibrationParameter* internal_default_instance() {
+    return reinterpret_cast<const CalibrationParameter*>(
+               &_CalibrationParameter_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    19;
+
+  void Swap(CalibrationParameter* other);
+  friend void swap(CalibrationParameter& a, CalibrationParameter& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline CalibrationParameter* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  CalibrationParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const CalibrationParameter& from);
+  void MergeFrom(const CalibrationParameter& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(CalibrationParameter* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // uint32 calibration_parameter_identifier = 1;
+  void clear_calibration_parameter_identifier();
+  static const int kCalibrationParameterIdentifierFieldNumber = 1;
+  ::google::protobuf::uint32 calibration_parameter_identifier() const;
+  void set_calibration_parameter_identifier(::google::protobuf::uint32 value);
+
+  // int32 signedIntValue = 2;
+  private:
+  bool has_signedintvalue() const;
+  public:
+  void clear_signedintvalue();
+  static const int kSignedIntValueFieldNumber = 2;
+  ::google::protobuf::int32 signedintvalue() const;
+  void set_signedintvalue(::google::protobuf::int32 value);
+
+  // uint32 unsignedIntValue = 3;
+  private:
+  bool has_unsignedintvalue() const;
+  public:
+  void clear_unsignedintvalue();
+  static const int kUnsignedIntValueFieldNumber = 3;
+  ::google::protobuf::uint32 unsignedintvalue() const;
+  void set_unsignedintvalue(::google::protobuf::uint32 value);
+
+  // float floatValue = 4;
+  private:
+  bool has_floatvalue() const;
+  public:
+  void clear_floatvalue();
+  static const int kFloatValueFieldNumber = 4;
+  float floatvalue() const;
+  void set_floatvalue(float value);
+
+  ValueCase value_case() const;
+  // @@protoc_insertion_point(class_scope:Kinova.Api.DeviceConfig.CalibrationParameter)
+ private:
+  void set_has_signedintvalue();
+  void set_has_unsignedintvalue();
+  void set_has_floatvalue();
+
+  inline bool has_value() const;
+  void clear_value();
+  inline void clear_has_value();
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 calibration_parameter_identifier_;
+  union ValueUnion {
+    ValueUnion() {}
+    ::google::protobuf::int32 signedintvalue_;
+    ::google::protobuf::uint32 unsignedintvalue_;
+    float floatvalue_;
+  } value_;
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _oneof_case_[1];
+
+  friend struct ::protobuf_DeviceConfig_2eproto::TableStruct;
+  friend void ::protobuf_DeviceConfig_2eproto::InitDefaultsCalibrationParameterImpl();
+};
+// -------------------------------------------------------------------
+
+class Calibration : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.DeviceConfig.Calibration) */ {
+ public:
+  Calibration();
+  virtual ~Calibration();
+
+  Calibration(const Calibration& from);
+
+  inline Calibration& operator=(const Calibration& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Calibration(Calibration&& from) noexcept
+    : Calibration() {
+    *this = ::std::move(from);
+  }
+
+  inline Calibration& operator=(Calibration&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Calibration& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Calibration* internal_default_instance() {
+    return reinterpret_cast<const Calibration*>(
+               &_Calibration_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    20;
+
+  void Swap(Calibration* other);
+  friend void swap(Calibration& a, Calibration& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Calibration* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Calibration* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Calibration& from);
+  void MergeFrom(const Calibration& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Calibration* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .Kinova.Api.DeviceConfig.CalibrationParameter calibration_parameter = 2;
+  int calibration_parameter_size() const;
+  void clear_calibration_parameter();
+  static const int kCalibrationParameterFieldNumber = 2;
+  const ::Kinova::Api::DeviceConfig::CalibrationParameter& calibration_parameter(int index) const;
+  ::Kinova::Api::DeviceConfig::CalibrationParameter* mutable_calibration_parameter(int index);
+  ::Kinova::Api::DeviceConfig::CalibrationParameter* add_calibration_parameter();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::DeviceConfig::CalibrationParameter >*
+      mutable_calibration_parameter();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::DeviceConfig::CalibrationParameter >&
+      calibration_parameter() const;
+
+  // .Kinova.Api.DeviceConfig.CalibrationItem calibration_item = 1;
+  void clear_calibration_item();
+  static const int kCalibrationItemFieldNumber = 1;
+  ::Kinova::Api::DeviceConfig::CalibrationItem calibration_item() const;
+  void set_calibration_item(::Kinova::Api::DeviceConfig::CalibrationItem value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.DeviceConfig.Calibration)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::DeviceConfig::CalibrationParameter > calibration_parameter_;
+  int calibration_item_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_DeviceConfig_2eproto::TableStruct;
+  friend void ::protobuf_DeviceConfig_2eproto::InitDefaultsCalibrationImpl();
+};
+// -------------------------------------------------------------------
+
+class CalibrationElement : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.DeviceConfig.CalibrationElement) */ {
+ public:
+  CalibrationElement();
+  virtual ~CalibrationElement();
+
+  CalibrationElement(const CalibrationElement& from);
+
+  inline CalibrationElement& operator=(const CalibrationElement& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  CalibrationElement(CalibrationElement&& from) noexcept
+    : CalibrationElement() {
+    *this = ::std::move(from);
+  }
+
+  inline CalibrationElement& operator=(CalibrationElement&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const CalibrationElement& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const CalibrationElement* internal_default_instance() {
+    return reinterpret_cast<const CalibrationElement*>(
+               &_CalibrationElement_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    21;
+
+  void Swap(CalibrationElement* other);
+  friend void swap(CalibrationElement& a, CalibrationElement& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline CalibrationElement* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  CalibrationElement* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const CalibrationElement& from);
+  void MergeFrom(const CalibrationElement& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(CalibrationElement* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.DeviceConfig.CalibrationItem calibration_item = 1;
+  void clear_calibration_item();
+  static const int kCalibrationItemFieldNumber = 1;
+  ::Kinova::Api::DeviceConfig::CalibrationItem calibration_item() const;
+  void set_calibration_item(::Kinova::Api::DeviceConfig::CalibrationItem value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.DeviceConfig.CalibrationElement)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  int calibration_item_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_DeviceConfig_2eproto::TableStruct;
+  friend void ::protobuf_DeviceConfig_2eproto::InitDefaultsCalibrationElementImpl();
+};
+// -------------------------------------------------------------------
+
+class CalibrationResult : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.DeviceConfig.CalibrationResult) */ {
+ public:
+  CalibrationResult();
+  virtual ~CalibrationResult();
+
+  CalibrationResult(const CalibrationResult& from);
+
+  inline CalibrationResult& operator=(const CalibrationResult& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  CalibrationResult(CalibrationResult&& from) noexcept
+    : CalibrationResult() {
+    *this = ::std::move(from);
+  }
+
+  inline CalibrationResult& operator=(CalibrationResult&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const CalibrationResult& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const CalibrationResult* internal_default_instance() {
+    return reinterpret_cast<const CalibrationResult*>(
+               &_CalibrationResult_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    22;
+
+  void Swap(CalibrationResult* other);
+  friend void swap(CalibrationResult& a, CalibrationResult& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline CalibrationResult* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  CalibrationResult* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const CalibrationResult& from);
+  void MergeFrom(const CalibrationResult& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(CalibrationResult* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.DeviceConfig.CalibrationStatus calibration_status = 1;
+  void clear_calibration_status();
+  static const int kCalibrationStatusFieldNumber = 1;
+  ::Kinova::Api::DeviceConfig::CalibrationStatus calibration_status() const;
+  void set_calibration_status(::Kinova::Api::DeviceConfig::CalibrationStatus value);
+
+  // uint32 calibration_details = 2;
+  void clear_calibration_details();
+  static const int kCalibrationDetailsFieldNumber = 2;
+  ::google::protobuf::uint32 calibration_details() const;
+  void set_calibration_details(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.DeviceConfig.CalibrationResult)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  int calibration_status_;
+  ::google::protobuf::uint32 calibration_details_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_DeviceConfig_2eproto::TableStruct;
+  friend void ::protobuf_DeviceConfig_2eproto::InitDefaultsCalibrationResultImpl();
+};
+// -------------------------------------------------------------------
+
+class CapSenseConfig : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.DeviceConfig.CapSenseConfig) */ {
+ public:
+  CapSenseConfig();
+  virtual ~CapSenseConfig();
+
+  CapSenseConfig(const CapSenseConfig& from);
+
+  inline CapSenseConfig& operator=(const CapSenseConfig& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  CapSenseConfig(CapSenseConfig&& from) noexcept
+    : CapSenseConfig() {
+    *this = ::std::move(from);
+  }
+
+  inline CapSenseConfig& operator=(CapSenseConfig&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const CapSenseConfig& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const CapSenseConfig* internal_default_instance() {
+    return reinterpret_cast<const CapSenseConfig*>(
+               &_CapSenseConfig_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    23;
+
+  void Swap(CapSenseConfig* other);
+  friend void swap(CapSenseConfig& a, CapSenseConfig& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline CapSenseConfig* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  CapSenseConfig* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const CapSenseConfig& from);
+  void MergeFrom(const CapSenseConfig& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(CapSenseConfig* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.DeviceConfig.CapSenseMode mode = 1;
+  void clear_mode();
+  static const int kModeFieldNumber = 1;
+  ::Kinova::Api::DeviceConfig::CapSenseMode mode() const;
+  void set_mode(::Kinova::Api::DeviceConfig::CapSenseMode value);
+
+  // float threshold_a = 2;
+  void clear_threshold_a();
+  static const int kThresholdAFieldNumber = 2;
+  float threshold_a() const;
+  void set_threshold_a(float value);
+
+  // float threshold_b = 3;
+  void clear_threshold_b();
+  static const int kThresholdBFieldNumber = 3;
+  float threshold_b() const;
+  void set_threshold_b(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.DeviceConfig.CapSenseConfig)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  int mode_;
+  float threshold_a_;
+  float threshold_b_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_DeviceConfig_2eproto::TableStruct;
+  friend void ::protobuf_DeviceConfig_2eproto::InitDefaultsCapSenseConfigImpl();
+};
+// -------------------------------------------------------------------
+
+class CapSenseRegister : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.DeviceConfig.CapSenseRegister) */ {
+ public:
+  CapSenseRegister();
+  virtual ~CapSenseRegister();
+
+  CapSenseRegister(const CapSenseRegister& from);
+
+  inline CapSenseRegister& operator=(const CapSenseRegister& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  CapSenseRegister(CapSenseRegister&& from) noexcept
+    : CapSenseRegister() {
+    *this = ::std::move(from);
+  }
+
+  inline CapSenseRegister& operator=(CapSenseRegister&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const CapSenseRegister& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const CapSenseRegister* internal_default_instance() {
+    return reinterpret_cast<const CapSenseRegister*>(
+               &_CapSenseRegister_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    24;
+
+  void Swap(CapSenseRegister* other);
+  friend void swap(CapSenseRegister& a, CapSenseRegister& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline CapSenseRegister* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  CapSenseRegister* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const CapSenseRegister& from);
+  void MergeFrom(const CapSenseRegister& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(CapSenseRegister* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // uint32 address = 1;
+  void clear_address();
+  static const int kAddressFieldNumber = 1;
+  ::google::protobuf::uint32 address() const;
+  void set_address(::google::protobuf::uint32 value);
+
+  // uint32 value = 2;
+  void clear_value();
+  static const int kValueFieldNumber = 2;
+  ::google::protobuf::uint32 value() const;
+  void set_value(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.DeviceConfig.CapSenseRegister)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 address_;
+  ::google::protobuf::uint32 value_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_DeviceConfig_2eproto::TableStruct;
+  friend void ::protobuf_DeviceConfig_2eproto::InitDefaultsCapSenseRegisterImpl();
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// DeviceType
+
+// .Kinova.Api.Common.DeviceTypes device_type = 1;
+inline void DeviceType::clear_device_type() {
+  device_type_ = 0;
+}
+inline ::Kinova::Api::Common::DeviceTypes DeviceType::device_type() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.DeviceConfig.DeviceType.device_type)
+  return static_cast< ::Kinova::Api::Common::DeviceTypes >(device_type_);
+}
+inline void DeviceType::set_device_type(::Kinova::Api::Common::DeviceTypes value) {
+  
+  device_type_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.DeviceConfig.DeviceType.device_type)
+}
+
+// -------------------------------------------------------------------
+
+// RunMode
+
+// .Kinova.Api.DeviceConfig.RunModes run_mode = 1;
+inline void RunMode::clear_run_mode() {
+  run_mode_ = 0;
+}
+inline ::Kinova::Api::DeviceConfig::RunModes RunMode::run_mode() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.DeviceConfig.RunMode.run_mode)
+  return static_cast< ::Kinova::Api::DeviceConfig::RunModes >(run_mode_);
+}
+inline void RunMode::set_run_mode(::Kinova::Api::DeviceConfig::RunModes value) {
+  
+  run_mode_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.DeviceConfig.RunMode.run_mode)
+}
+
+// -------------------------------------------------------------------
+
+// FirmwareVersion
+
+// uint32 firmware_version = 1;
+inline void FirmwareVersion::clear_firmware_version() {
+  firmware_version_ = 0u;
+}
+inline ::google::protobuf::uint32 FirmwareVersion::firmware_version() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.DeviceConfig.FirmwareVersion.firmware_version)
+  return firmware_version_;
+}
+inline void FirmwareVersion::set_firmware_version(::google::protobuf::uint32 value) {
+  
+  firmware_version_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.DeviceConfig.FirmwareVersion.firmware_version)
+}
+
+// -------------------------------------------------------------------
+
+// BootloaderVersion
+
+// uint32 bootloader_version = 1;
+inline void BootloaderVersion::clear_bootloader_version() {
+  bootloader_version_ = 0u;
+}
+inline ::google::protobuf::uint32 BootloaderVersion::bootloader_version() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.DeviceConfig.BootloaderVersion.bootloader_version)
+  return bootloader_version_;
+}
+inline void BootloaderVersion::set_bootloader_version(::google::protobuf::uint32 value) {
+  
+  bootloader_version_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.DeviceConfig.BootloaderVersion.bootloader_version)
+}
+
+// -------------------------------------------------------------------
+
+// ModelNumber
+
+// string model_number = 1;
+inline void ModelNumber::clear_model_number() {
+  model_number_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& ModelNumber::model_number() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.DeviceConfig.ModelNumber.model_number)
+  return model_number_.GetNoArena();
+}
+inline void ModelNumber::set_model_number(const ::std::string& value) {
+  
+  model_number_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.DeviceConfig.ModelNumber.model_number)
+}
+#if LANG_CXX11
+inline void ModelNumber::set_model_number(::std::string&& value) {
+  
+  model_number_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:Kinova.Api.DeviceConfig.ModelNumber.model_number)
+}
+#endif
+inline void ModelNumber::set_model_number(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  model_number_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:Kinova.Api.DeviceConfig.ModelNumber.model_number)
+}
+inline void ModelNumber::set_model_number(const char* value, size_t size) {
+  
+  model_number_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:Kinova.Api.DeviceConfig.ModelNumber.model_number)
+}
+inline ::std::string* ModelNumber::mutable_model_number() {
+  
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.DeviceConfig.ModelNumber.model_number)
+  return model_number_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* ModelNumber::release_model_number() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.DeviceConfig.ModelNumber.model_number)
+  
+  return model_number_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void ModelNumber::set_allocated_model_number(::std::string* model_number) {
+  if (model_number != NULL) {
+    
+  } else {
+    
+  }
+  model_number_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), model_number);
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.DeviceConfig.ModelNumber.model_number)
+}
+
+// -------------------------------------------------------------------
+
+// PartNumber
+
+// string part_number = 1;
+inline void PartNumber::clear_part_number() {
+  part_number_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& PartNumber::part_number() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.DeviceConfig.PartNumber.part_number)
+  return part_number_.GetNoArena();
+}
+inline void PartNumber::set_part_number(const ::std::string& value) {
+  
+  part_number_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.DeviceConfig.PartNumber.part_number)
+}
+#if LANG_CXX11
+inline void PartNumber::set_part_number(::std::string&& value) {
+  
+  part_number_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:Kinova.Api.DeviceConfig.PartNumber.part_number)
+}
+#endif
+inline void PartNumber::set_part_number(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  part_number_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:Kinova.Api.DeviceConfig.PartNumber.part_number)
+}
+inline void PartNumber::set_part_number(const char* value, size_t size) {
+  
+  part_number_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:Kinova.Api.DeviceConfig.PartNumber.part_number)
+}
+inline ::std::string* PartNumber::mutable_part_number() {
+  
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.DeviceConfig.PartNumber.part_number)
+  return part_number_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* PartNumber::release_part_number() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.DeviceConfig.PartNumber.part_number)
+  
+  return part_number_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void PartNumber::set_allocated_part_number(::std::string* part_number) {
+  if (part_number != NULL) {
+    
+  } else {
+    
+  }
+  part_number_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), part_number);
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.DeviceConfig.PartNumber.part_number)
+}
+
+// -------------------------------------------------------------------
+
+// SerialNumber
+
+// string serial_number = 1;
+inline void SerialNumber::clear_serial_number() {
+  serial_number_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& SerialNumber::serial_number() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.DeviceConfig.SerialNumber.serial_number)
+  return serial_number_.GetNoArena();
+}
+inline void SerialNumber::set_serial_number(const ::std::string& value) {
+  
+  serial_number_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.DeviceConfig.SerialNumber.serial_number)
+}
+#if LANG_CXX11
+inline void SerialNumber::set_serial_number(::std::string&& value) {
+  
+  serial_number_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:Kinova.Api.DeviceConfig.SerialNumber.serial_number)
+}
+#endif
+inline void SerialNumber::set_serial_number(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  serial_number_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:Kinova.Api.DeviceConfig.SerialNumber.serial_number)
+}
+inline void SerialNumber::set_serial_number(const char* value, size_t size) {
+  
+  serial_number_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:Kinova.Api.DeviceConfig.SerialNumber.serial_number)
+}
+inline ::std::string* SerialNumber::mutable_serial_number() {
+  
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.DeviceConfig.SerialNumber.serial_number)
+  return serial_number_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* SerialNumber::release_serial_number() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.DeviceConfig.SerialNumber.serial_number)
+  
+  return serial_number_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void SerialNumber::set_allocated_serial_number(::std::string* serial_number) {
+  if (serial_number != NULL) {
+    
+  } else {
+    
+  }
+  serial_number_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), serial_number);
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.DeviceConfig.SerialNumber.serial_number)
+}
+
+// -------------------------------------------------------------------
+
+// MACAddress
+
+// bytes mac_address = 1;
+inline void MACAddress::clear_mac_address() {
+  mac_address_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& MACAddress::mac_address() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.DeviceConfig.MACAddress.mac_address)
+  return mac_address_.GetNoArena();
+}
+inline void MACAddress::set_mac_address(const ::std::string& value) {
+  
+  mac_address_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.DeviceConfig.MACAddress.mac_address)
+}
+#if LANG_CXX11
+inline void MACAddress::set_mac_address(::std::string&& value) {
+  
+  mac_address_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:Kinova.Api.DeviceConfig.MACAddress.mac_address)
+}
+#endif
+inline void MACAddress::set_mac_address(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  mac_address_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:Kinova.Api.DeviceConfig.MACAddress.mac_address)
+}
+inline void MACAddress::set_mac_address(const void* value, size_t size) {
+  
+  mac_address_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:Kinova.Api.DeviceConfig.MACAddress.mac_address)
+}
+inline ::std::string* MACAddress::mutable_mac_address() {
+  
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.DeviceConfig.MACAddress.mac_address)
+  return mac_address_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* MACAddress::release_mac_address() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.DeviceConfig.MACAddress.mac_address)
+  
+  return mac_address_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void MACAddress::set_allocated_mac_address(::std::string* mac_address) {
+  if (mac_address != NULL) {
+    
+  } else {
+    
+  }
+  mac_address_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), mac_address);
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.DeviceConfig.MACAddress.mac_address)
+}
+
+// -------------------------------------------------------------------
+
+// IPv4Settings
+
+// uint32 ipv4_address = 1;
+inline void IPv4Settings::clear_ipv4_address() {
+  ipv4_address_ = 0u;
+}
+inline ::google::protobuf::uint32 IPv4Settings::ipv4_address() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.DeviceConfig.IPv4Settings.ipv4_address)
+  return ipv4_address_;
+}
+inline void IPv4Settings::set_ipv4_address(::google::protobuf::uint32 value) {
+  
+  ipv4_address_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.DeviceConfig.IPv4Settings.ipv4_address)
+}
+
+// uint32 ipv4_subnet_mask = 2;
+inline void IPv4Settings::clear_ipv4_subnet_mask() {
+  ipv4_subnet_mask_ = 0u;
+}
+inline ::google::protobuf::uint32 IPv4Settings::ipv4_subnet_mask() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.DeviceConfig.IPv4Settings.ipv4_subnet_mask)
+  return ipv4_subnet_mask_;
+}
+inline void IPv4Settings::set_ipv4_subnet_mask(::google::protobuf::uint32 value) {
+  
+  ipv4_subnet_mask_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.DeviceConfig.IPv4Settings.ipv4_subnet_mask)
+}
+
+// uint32 ipv4_default_gateway = 3;
+inline void IPv4Settings::clear_ipv4_default_gateway() {
+  ipv4_default_gateway_ = 0u;
+}
+inline ::google::protobuf::uint32 IPv4Settings::ipv4_default_gateway() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.DeviceConfig.IPv4Settings.ipv4_default_gateway)
+  return ipv4_default_gateway_;
+}
+inline void IPv4Settings::set_ipv4_default_gateway(::google::protobuf::uint32 value) {
+  
+  ipv4_default_gateway_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.DeviceConfig.IPv4Settings.ipv4_default_gateway)
+}
+
+// -------------------------------------------------------------------
+
+// PartNumberRevision
+
+// string part_number_revision = 1;
+inline void PartNumberRevision::clear_part_number_revision() {
+  part_number_revision_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& PartNumberRevision::part_number_revision() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.DeviceConfig.PartNumberRevision.part_number_revision)
+  return part_number_revision_.GetNoArena();
+}
+inline void PartNumberRevision::set_part_number_revision(const ::std::string& value) {
+  
+  part_number_revision_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.DeviceConfig.PartNumberRevision.part_number_revision)
+}
+#if LANG_CXX11
+inline void PartNumberRevision::set_part_number_revision(::std::string&& value) {
+  
+  part_number_revision_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:Kinova.Api.DeviceConfig.PartNumberRevision.part_number_revision)
+}
+#endif
+inline void PartNumberRevision::set_part_number_revision(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  part_number_revision_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:Kinova.Api.DeviceConfig.PartNumberRevision.part_number_revision)
+}
+inline void PartNumberRevision::set_part_number_revision(const char* value, size_t size) {
+  
+  part_number_revision_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:Kinova.Api.DeviceConfig.PartNumberRevision.part_number_revision)
+}
+inline ::std::string* PartNumberRevision::mutable_part_number_revision() {
+  
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.DeviceConfig.PartNumberRevision.part_number_revision)
+  return part_number_revision_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* PartNumberRevision::release_part_number_revision() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.DeviceConfig.PartNumberRevision.part_number_revision)
+  
+  return part_number_revision_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void PartNumberRevision::set_allocated_part_number_revision(::std::string* part_number_revision) {
+  if (part_number_revision != NULL) {
+    
+  } else {
+    
+  }
+  part_number_revision_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), part_number_revision);
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.DeviceConfig.PartNumberRevision.part_number_revision)
+}
+
+// -------------------------------------------------------------------
+
+// PowerOnSelfTestResult
+
+// uint32 power_on_self_test_result = 1;
+inline void PowerOnSelfTestResult::clear_power_on_self_test_result() {
+  power_on_self_test_result_ = 0u;
+}
+inline ::google::protobuf::uint32 PowerOnSelfTestResult::power_on_self_test_result() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.DeviceConfig.PowerOnSelfTestResult.power_on_self_test_result)
+  return power_on_self_test_result_;
+}
+inline void PowerOnSelfTestResult::set_power_on_self_test_result(::google::protobuf::uint32 value) {
+  
+  power_on_self_test_result_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.DeviceConfig.PowerOnSelfTestResult.power_on_self_test_result)
+}
+
+// -------------------------------------------------------------------
+
+// RebootRqst
+
+// uint32 delay = 1;
+inline void RebootRqst::clear_delay() {
+  delay_ = 0u;
+}
+inline ::google::protobuf::uint32 RebootRqst::delay() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.DeviceConfig.RebootRqst.delay)
+  return delay_;
+}
+inline void RebootRqst::set_delay(::google::protobuf::uint32 value) {
+  
+  delay_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.DeviceConfig.RebootRqst.delay)
+}
+
+// -------------------------------------------------------------------
+
+// SafetyInformation
+
+// .Kinova.Api.Common.SafetyHandle handle = 1;
+inline bool SafetyInformation::has_handle() const {
+  return this != internal_default_instance() && handle_ != NULL;
+}
+inline const ::Kinova::Api::Common::SafetyHandle& SafetyInformation::handle() const {
+  const ::Kinova::Api::Common::SafetyHandle* p = handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.DeviceConfig.SafetyInformation.handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::SafetyHandle*>(
+      &::Kinova::Api::Common::_SafetyHandle_default_instance_);
+}
+inline ::Kinova::Api::Common::SafetyHandle* SafetyInformation::release_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.DeviceConfig.SafetyInformation.handle)
+  
+  ::Kinova::Api::Common::SafetyHandle* temp = handle_;
+  handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::SafetyHandle* SafetyInformation::mutable_handle() {
+  
+  if (handle_ == NULL) {
+    handle_ = new ::Kinova::Api::Common::SafetyHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.DeviceConfig.SafetyInformation.handle)
+  return handle_;
+}
+inline void SafetyInformation::set_allocated_handle(::Kinova::Api::Common::SafetyHandle* handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(handle_);
+  }
+  if (handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  handle_ = handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.DeviceConfig.SafetyInformation.handle)
+}
+
+// bool can_change_safety_state = 2;
+inline void SafetyInformation::clear_can_change_safety_state() {
+  can_change_safety_state_ = false;
+}
+inline bool SafetyInformation::can_change_safety_state() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.DeviceConfig.SafetyInformation.can_change_safety_state)
+  return can_change_safety_state_;
+}
+inline void SafetyInformation::set_can_change_safety_state(bool value) {
+  
+  can_change_safety_state_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.DeviceConfig.SafetyInformation.can_change_safety_state)
+}
+
+// bool has_warning_threshold = 3;
+inline void SafetyInformation::clear_has_warning_threshold() {
+  has_warning_threshold_ = false;
+}
+inline bool SafetyInformation::has_warning_threshold() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.DeviceConfig.SafetyInformation.has_warning_threshold)
+  return has_warning_threshold_;
+}
+inline void SafetyInformation::set_has_warning_threshold(bool value) {
+  
+  has_warning_threshold_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.DeviceConfig.SafetyInformation.has_warning_threshold)
+}
+
+// bool has_error_threshold = 4;
+inline void SafetyInformation::clear_has_error_threshold() {
+  has_error_threshold_ = false;
+}
+inline bool SafetyInformation::has_error_threshold() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.DeviceConfig.SafetyInformation.has_error_threshold)
+  return has_error_threshold_;
+}
+inline void SafetyInformation::set_has_error_threshold(bool value) {
+  
+  has_error_threshold_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.DeviceConfig.SafetyInformation.has_error_threshold)
+}
+
+// .Kinova.Api.DeviceConfig.SafetyLimitType limit_type = 5;
+inline void SafetyInformation::clear_limit_type() {
+  limit_type_ = 0;
+}
+inline ::Kinova::Api::DeviceConfig::SafetyLimitType SafetyInformation::limit_type() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.DeviceConfig.SafetyInformation.limit_type)
+  return static_cast< ::Kinova::Api::DeviceConfig::SafetyLimitType >(limit_type_);
+}
+inline void SafetyInformation::set_limit_type(::Kinova::Api::DeviceConfig::SafetyLimitType value) {
+  
+  limit_type_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.DeviceConfig.SafetyInformation.limit_type)
+}
+
+// float default_warning_threshold = 6;
+inline void SafetyInformation::clear_default_warning_threshold() {
+  default_warning_threshold_ = 0;
+}
+inline float SafetyInformation::default_warning_threshold() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.DeviceConfig.SafetyInformation.default_warning_threshold)
+  return default_warning_threshold_;
+}
+inline void SafetyInformation::set_default_warning_threshold(float value) {
+  
+  default_warning_threshold_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.DeviceConfig.SafetyInformation.default_warning_threshold)
+}
+
+// float default_error_threshold = 7;
+inline void SafetyInformation::clear_default_error_threshold() {
+  default_error_threshold_ = 0;
+}
+inline float SafetyInformation::default_error_threshold() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.DeviceConfig.SafetyInformation.default_error_threshold)
+  return default_error_threshold_;
+}
+inline void SafetyInformation::set_default_error_threshold(float value) {
+  
+  default_error_threshold_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.DeviceConfig.SafetyInformation.default_error_threshold)
+}
+
+// float upper_hard_limit = 8;
+inline void SafetyInformation::clear_upper_hard_limit() {
+  upper_hard_limit_ = 0;
+}
+inline float SafetyInformation::upper_hard_limit() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.DeviceConfig.SafetyInformation.upper_hard_limit)
+  return upper_hard_limit_;
+}
+inline void SafetyInformation::set_upper_hard_limit(float value) {
+  
+  upper_hard_limit_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.DeviceConfig.SafetyInformation.upper_hard_limit)
+}
+
+// float lower_hard_limit = 9;
+inline void SafetyInformation::clear_lower_hard_limit() {
+  lower_hard_limit_ = 0;
+}
+inline float SafetyInformation::lower_hard_limit() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.DeviceConfig.SafetyInformation.lower_hard_limit)
+  return lower_hard_limit_;
+}
+inline void SafetyInformation::set_lower_hard_limit(float value) {
+  
+  lower_hard_limit_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.DeviceConfig.SafetyInformation.lower_hard_limit)
+}
+
+// .Kinova.Api.Common.SafetyStatusValue status = 11;
+inline void SafetyInformation::clear_status() {
+  status_ = 0;
+}
+inline ::Kinova::Api::Common::SafetyStatusValue SafetyInformation::status() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.DeviceConfig.SafetyInformation.status)
+  return static_cast< ::Kinova::Api::Common::SafetyStatusValue >(status_);
+}
+inline void SafetyInformation::set_status(::Kinova::Api::Common::SafetyStatusValue value) {
+  
+  status_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.DeviceConfig.SafetyInformation.status)
+}
+
+// .Kinova.Api.Common.Unit unit = 12;
+inline void SafetyInformation::clear_unit() {
+  unit_ = 0;
+}
+inline ::Kinova::Api::Common::Unit SafetyInformation::unit() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.DeviceConfig.SafetyInformation.unit)
+  return static_cast< ::Kinova::Api::Common::Unit >(unit_);
+}
+inline void SafetyInformation::set_unit(::Kinova::Api::Common::Unit value) {
+  
+  unit_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.DeviceConfig.SafetyInformation.unit)
+}
+
+// -------------------------------------------------------------------
+
+// SafetyInformationList
+
+// repeated .Kinova.Api.DeviceConfig.SafetyInformation information = 1;
+inline int SafetyInformationList::information_size() const {
+  return information_.size();
+}
+inline void SafetyInformationList::clear_information() {
+  information_.Clear();
+}
+inline const ::Kinova::Api::DeviceConfig::SafetyInformation& SafetyInformationList::information(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.DeviceConfig.SafetyInformationList.information)
+  return information_.Get(index);
+}
+inline ::Kinova::Api::DeviceConfig::SafetyInformation* SafetyInformationList::mutable_information(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.DeviceConfig.SafetyInformationList.information)
+  return information_.Mutable(index);
+}
+inline ::Kinova::Api::DeviceConfig::SafetyInformation* SafetyInformationList::add_information() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.DeviceConfig.SafetyInformationList.information)
+  return information_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::DeviceConfig::SafetyInformation >*
+SafetyInformationList::mutable_information() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.DeviceConfig.SafetyInformationList.information)
+  return &information_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::DeviceConfig::SafetyInformation >&
+SafetyInformationList::information() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.DeviceConfig.SafetyInformationList.information)
+  return information_;
+}
+
+// -------------------------------------------------------------------
+
+// SafetyEnable
+
+// .Kinova.Api.Common.SafetyHandle handle = 1;
+inline bool SafetyEnable::has_handle() const {
+  return this != internal_default_instance() && handle_ != NULL;
+}
+inline const ::Kinova::Api::Common::SafetyHandle& SafetyEnable::handle() const {
+  const ::Kinova::Api::Common::SafetyHandle* p = handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.DeviceConfig.SafetyEnable.handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::SafetyHandle*>(
+      &::Kinova::Api::Common::_SafetyHandle_default_instance_);
+}
+inline ::Kinova::Api::Common::SafetyHandle* SafetyEnable::release_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.DeviceConfig.SafetyEnable.handle)
+  
+  ::Kinova::Api::Common::SafetyHandle* temp = handle_;
+  handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::SafetyHandle* SafetyEnable::mutable_handle() {
+  
+  if (handle_ == NULL) {
+    handle_ = new ::Kinova::Api::Common::SafetyHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.DeviceConfig.SafetyEnable.handle)
+  return handle_;
+}
+inline void SafetyEnable::set_allocated_handle(::Kinova::Api::Common::SafetyHandle* handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(handle_);
+  }
+  if (handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  handle_ = handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.DeviceConfig.SafetyEnable.handle)
+}
+
+// bool enable = 2;
+inline void SafetyEnable::clear_enable() {
+  enable_ = false;
+}
+inline bool SafetyEnable::enable() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.DeviceConfig.SafetyEnable.enable)
+  return enable_;
+}
+inline void SafetyEnable::set_enable(bool value) {
+  
+  enable_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.DeviceConfig.SafetyEnable.enable)
+}
+
+// -------------------------------------------------------------------
+
+// SafetyThreshold
+
+// .Kinova.Api.Common.SafetyHandle handle = 1;
+inline bool SafetyThreshold::has_handle() const {
+  return this != internal_default_instance() && handle_ != NULL;
+}
+inline const ::Kinova::Api::Common::SafetyHandle& SafetyThreshold::handle() const {
+  const ::Kinova::Api::Common::SafetyHandle* p = handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.DeviceConfig.SafetyThreshold.handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::SafetyHandle*>(
+      &::Kinova::Api::Common::_SafetyHandle_default_instance_);
+}
+inline ::Kinova::Api::Common::SafetyHandle* SafetyThreshold::release_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.DeviceConfig.SafetyThreshold.handle)
+  
+  ::Kinova::Api::Common::SafetyHandle* temp = handle_;
+  handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::SafetyHandle* SafetyThreshold::mutable_handle() {
+  
+  if (handle_ == NULL) {
+    handle_ = new ::Kinova::Api::Common::SafetyHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.DeviceConfig.SafetyThreshold.handle)
+  return handle_;
+}
+inline void SafetyThreshold::set_allocated_handle(::Kinova::Api::Common::SafetyHandle* handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(handle_);
+  }
+  if (handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  handle_ = handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.DeviceConfig.SafetyThreshold.handle)
+}
+
+// float value = 2;
+inline void SafetyThreshold::clear_value() {
+  value_ = 0;
+}
+inline float SafetyThreshold::value() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.DeviceConfig.SafetyThreshold.value)
+  return value_;
+}
+inline void SafetyThreshold::set_value(float value) {
+  
+  value_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.DeviceConfig.SafetyThreshold.value)
+}
+
+// -------------------------------------------------------------------
+
+// SafetyConfiguration
+
+// .Kinova.Api.Common.SafetyHandle handle = 1;
+inline bool SafetyConfiguration::has_handle() const {
+  return this != internal_default_instance() && handle_ != NULL;
+}
+inline const ::Kinova::Api::Common::SafetyHandle& SafetyConfiguration::handle() const {
+  const ::Kinova::Api::Common::SafetyHandle* p = handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.DeviceConfig.SafetyConfiguration.handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::SafetyHandle*>(
+      &::Kinova::Api::Common::_SafetyHandle_default_instance_);
+}
+inline ::Kinova::Api::Common::SafetyHandle* SafetyConfiguration::release_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.DeviceConfig.SafetyConfiguration.handle)
+  
+  ::Kinova::Api::Common::SafetyHandle* temp = handle_;
+  handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::SafetyHandle* SafetyConfiguration::mutable_handle() {
+  
+  if (handle_ == NULL) {
+    handle_ = new ::Kinova::Api::Common::SafetyHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.DeviceConfig.SafetyConfiguration.handle)
+  return handle_;
+}
+inline void SafetyConfiguration::set_allocated_handle(::Kinova::Api::Common::SafetyHandle* handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(handle_);
+  }
+  if (handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  handle_ = handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.DeviceConfig.SafetyConfiguration.handle)
+}
+
+// float error_threshold = 2;
+inline void SafetyConfiguration::clear_error_threshold() {
+  error_threshold_ = 0;
+}
+inline float SafetyConfiguration::error_threshold() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.DeviceConfig.SafetyConfiguration.error_threshold)
+  return error_threshold_;
+}
+inline void SafetyConfiguration::set_error_threshold(float value) {
+  
+  error_threshold_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.DeviceConfig.SafetyConfiguration.error_threshold)
+}
+
+// float warning_threshold = 3;
+inline void SafetyConfiguration::clear_warning_threshold() {
+  warning_threshold_ = 0;
+}
+inline float SafetyConfiguration::warning_threshold() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.DeviceConfig.SafetyConfiguration.warning_threshold)
+  return warning_threshold_;
+}
+inline void SafetyConfiguration::set_warning_threshold(float value) {
+  
+  warning_threshold_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.DeviceConfig.SafetyConfiguration.warning_threshold)
+}
+
+// .Kinova.Api.DeviceConfig.SafetyEnable enable = 4;
+inline bool SafetyConfiguration::has_enable() const {
+  return this != internal_default_instance() && enable_ != NULL;
+}
+inline void SafetyConfiguration::clear_enable() {
+  if (GetArenaNoVirtual() == NULL && enable_ != NULL) {
+    delete enable_;
+  }
+  enable_ = NULL;
+}
+inline const ::Kinova::Api::DeviceConfig::SafetyEnable& SafetyConfiguration::enable() const {
+  const ::Kinova::Api::DeviceConfig::SafetyEnable* p = enable_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.DeviceConfig.SafetyConfiguration.enable)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::DeviceConfig::SafetyEnable*>(
+      &::Kinova::Api::DeviceConfig::_SafetyEnable_default_instance_);
+}
+inline ::Kinova::Api::DeviceConfig::SafetyEnable* SafetyConfiguration::release_enable() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.DeviceConfig.SafetyConfiguration.enable)
+  
+  ::Kinova::Api::DeviceConfig::SafetyEnable* temp = enable_;
+  enable_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::DeviceConfig::SafetyEnable* SafetyConfiguration::mutable_enable() {
+  
+  if (enable_ == NULL) {
+    enable_ = new ::Kinova::Api::DeviceConfig::SafetyEnable;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.DeviceConfig.SafetyConfiguration.enable)
+  return enable_;
+}
+inline void SafetyConfiguration::set_allocated_enable(::Kinova::Api::DeviceConfig::SafetyEnable* enable) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete enable_;
+  }
+  if (enable) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      enable = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, enable, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  enable_ = enable;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.DeviceConfig.SafetyConfiguration.enable)
+}
+
+// -------------------------------------------------------------------
+
+// SafetyConfigurationList
+
+// repeated .Kinova.Api.DeviceConfig.SafetyConfiguration configuration = 1;
+inline int SafetyConfigurationList::configuration_size() const {
+  return configuration_.size();
+}
+inline void SafetyConfigurationList::clear_configuration() {
+  configuration_.Clear();
+}
+inline const ::Kinova::Api::DeviceConfig::SafetyConfiguration& SafetyConfigurationList::configuration(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.DeviceConfig.SafetyConfigurationList.configuration)
+  return configuration_.Get(index);
+}
+inline ::Kinova::Api::DeviceConfig::SafetyConfiguration* SafetyConfigurationList::mutable_configuration(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.DeviceConfig.SafetyConfigurationList.configuration)
+  return configuration_.Mutable(index);
+}
+inline ::Kinova::Api::DeviceConfig::SafetyConfiguration* SafetyConfigurationList::add_configuration() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.DeviceConfig.SafetyConfigurationList.configuration)
+  return configuration_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::DeviceConfig::SafetyConfiguration >*
+SafetyConfigurationList::mutable_configuration() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.DeviceConfig.SafetyConfigurationList.configuration)
+  return &configuration_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::DeviceConfig::SafetyConfiguration >&
+SafetyConfigurationList::configuration() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.DeviceConfig.SafetyConfigurationList.configuration)
+  return configuration_;
+}
+
+// -------------------------------------------------------------------
+
+// SafetyStatus
+
+// .Kinova.Api.Common.SafetyStatusValue value = 1;
+inline void SafetyStatus::clear_value() {
+  value_ = 0;
+}
+inline ::Kinova::Api::Common::SafetyStatusValue SafetyStatus::value() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.DeviceConfig.SafetyStatus.value)
+  return static_cast< ::Kinova::Api::Common::SafetyStatusValue >(value_);
+}
+inline void SafetyStatus::set_value(::Kinova::Api::Common::SafetyStatusValue value) {
+  
+  value_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.DeviceConfig.SafetyStatus.value)
+}
+
+// -------------------------------------------------------------------
+
+// CalibrationParameter
+
+// uint32 calibration_parameter_identifier = 1;
+inline void CalibrationParameter::clear_calibration_parameter_identifier() {
+  calibration_parameter_identifier_ = 0u;
+}
+inline ::google::protobuf::uint32 CalibrationParameter::calibration_parameter_identifier() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.DeviceConfig.CalibrationParameter.calibration_parameter_identifier)
+  return calibration_parameter_identifier_;
+}
+inline void CalibrationParameter::set_calibration_parameter_identifier(::google::protobuf::uint32 value) {
+  
+  calibration_parameter_identifier_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.DeviceConfig.CalibrationParameter.calibration_parameter_identifier)
+}
+
+// int32 signedIntValue = 2;
+inline bool CalibrationParameter::has_signedintvalue() const {
+  return value_case() == kSignedIntValue;
+}
+inline void CalibrationParameter::set_has_signedintvalue() {
+  _oneof_case_[0] = kSignedIntValue;
+}
+inline void CalibrationParameter::clear_signedintvalue() {
+  if (has_signedintvalue()) {
+    value_.signedintvalue_ = 0;
+    clear_has_value();
+  }
+}
+inline ::google::protobuf::int32 CalibrationParameter::signedintvalue() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.DeviceConfig.CalibrationParameter.signedIntValue)
+  if (has_signedintvalue()) {
+    return value_.signedintvalue_;
+  }
+  return 0;
+}
+inline void CalibrationParameter::set_signedintvalue(::google::protobuf::int32 value) {
+  if (!has_signedintvalue()) {
+    clear_value();
+    set_has_signedintvalue();
+  }
+  value_.signedintvalue_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.DeviceConfig.CalibrationParameter.signedIntValue)
+}
+
+// uint32 unsignedIntValue = 3;
+inline bool CalibrationParameter::has_unsignedintvalue() const {
+  return value_case() == kUnsignedIntValue;
+}
+inline void CalibrationParameter::set_has_unsignedintvalue() {
+  _oneof_case_[0] = kUnsignedIntValue;
+}
+inline void CalibrationParameter::clear_unsignedintvalue() {
+  if (has_unsignedintvalue()) {
+    value_.unsignedintvalue_ = 0u;
+    clear_has_value();
+  }
+}
+inline ::google::protobuf::uint32 CalibrationParameter::unsignedintvalue() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.DeviceConfig.CalibrationParameter.unsignedIntValue)
+  if (has_unsignedintvalue()) {
+    return value_.unsignedintvalue_;
+  }
+  return 0u;
+}
+inline void CalibrationParameter::set_unsignedintvalue(::google::protobuf::uint32 value) {
+  if (!has_unsignedintvalue()) {
+    clear_value();
+    set_has_unsignedintvalue();
+  }
+  value_.unsignedintvalue_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.DeviceConfig.CalibrationParameter.unsignedIntValue)
+}
+
+// float floatValue = 4;
+inline bool CalibrationParameter::has_floatvalue() const {
+  return value_case() == kFloatValue;
+}
+inline void CalibrationParameter::set_has_floatvalue() {
+  _oneof_case_[0] = kFloatValue;
+}
+inline void CalibrationParameter::clear_floatvalue() {
+  if (has_floatvalue()) {
+    value_.floatvalue_ = 0;
+    clear_has_value();
+  }
+}
+inline float CalibrationParameter::floatvalue() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.DeviceConfig.CalibrationParameter.floatValue)
+  if (has_floatvalue()) {
+    return value_.floatvalue_;
+  }
+  return 0;
+}
+inline void CalibrationParameter::set_floatvalue(float value) {
+  if (!has_floatvalue()) {
+    clear_value();
+    set_has_floatvalue();
+  }
+  value_.floatvalue_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.DeviceConfig.CalibrationParameter.floatValue)
+}
+
+inline bool CalibrationParameter::has_value() const {
+  return value_case() != VALUE_NOT_SET;
+}
+inline void CalibrationParameter::clear_has_value() {
+  _oneof_case_[0] = VALUE_NOT_SET;
+}
+inline CalibrationParameter::ValueCase CalibrationParameter::value_case() const {
+  return CalibrationParameter::ValueCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// Calibration
+
+// .Kinova.Api.DeviceConfig.CalibrationItem calibration_item = 1;
+inline void Calibration::clear_calibration_item() {
+  calibration_item_ = 0;
+}
+inline ::Kinova::Api::DeviceConfig::CalibrationItem Calibration::calibration_item() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.DeviceConfig.Calibration.calibration_item)
+  return static_cast< ::Kinova::Api::DeviceConfig::CalibrationItem >(calibration_item_);
+}
+inline void Calibration::set_calibration_item(::Kinova::Api::DeviceConfig::CalibrationItem value) {
+  
+  calibration_item_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.DeviceConfig.Calibration.calibration_item)
+}
+
+// repeated .Kinova.Api.DeviceConfig.CalibrationParameter calibration_parameter = 2;
+inline int Calibration::calibration_parameter_size() const {
+  return calibration_parameter_.size();
+}
+inline void Calibration::clear_calibration_parameter() {
+  calibration_parameter_.Clear();
+}
+inline const ::Kinova::Api::DeviceConfig::CalibrationParameter& Calibration::calibration_parameter(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.DeviceConfig.Calibration.calibration_parameter)
+  return calibration_parameter_.Get(index);
+}
+inline ::Kinova::Api::DeviceConfig::CalibrationParameter* Calibration::mutable_calibration_parameter(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.DeviceConfig.Calibration.calibration_parameter)
+  return calibration_parameter_.Mutable(index);
+}
+inline ::Kinova::Api::DeviceConfig::CalibrationParameter* Calibration::add_calibration_parameter() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.DeviceConfig.Calibration.calibration_parameter)
+  return calibration_parameter_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::DeviceConfig::CalibrationParameter >*
+Calibration::mutable_calibration_parameter() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.DeviceConfig.Calibration.calibration_parameter)
+  return &calibration_parameter_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::DeviceConfig::CalibrationParameter >&
+Calibration::calibration_parameter() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.DeviceConfig.Calibration.calibration_parameter)
+  return calibration_parameter_;
+}
+
+// -------------------------------------------------------------------
+
+// CalibrationElement
+
+// .Kinova.Api.DeviceConfig.CalibrationItem calibration_item = 1;
+inline void CalibrationElement::clear_calibration_item() {
+  calibration_item_ = 0;
+}
+inline ::Kinova::Api::DeviceConfig::CalibrationItem CalibrationElement::calibration_item() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.DeviceConfig.CalibrationElement.calibration_item)
+  return static_cast< ::Kinova::Api::DeviceConfig::CalibrationItem >(calibration_item_);
+}
+inline void CalibrationElement::set_calibration_item(::Kinova::Api::DeviceConfig::CalibrationItem value) {
+  
+  calibration_item_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.DeviceConfig.CalibrationElement.calibration_item)
+}
+
+// -------------------------------------------------------------------
+
+// CalibrationResult
+
+// .Kinova.Api.DeviceConfig.CalibrationStatus calibration_status = 1;
+inline void CalibrationResult::clear_calibration_status() {
+  calibration_status_ = 0;
+}
+inline ::Kinova::Api::DeviceConfig::CalibrationStatus CalibrationResult::calibration_status() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.DeviceConfig.CalibrationResult.calibration_status)
+  return static_cast< ::Kinova::Api::DeviceConfig::CalibrationStatus >(calibration_status_);
+}
+inline void CalibrationResult::set_calibration_status(::Kinova::Api::DeviceConfig::CalibrationStatus value) {
+  
+  calibration_status_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.DeviceConfig.CalibrationResult.calibration_status)
+}
+
+// uint32 calibration_details = 2;
+inline void CalibrationResult::clear_calibration_details() {
+  calibration_details_ = 0u;
+}
+inline ::google::protobuf::uint32 CalibrationResult::calibration_details() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.DeviceConfig.CalibrationResult.calibration_details)
+  return calibration_details_;
+}
+inline void CalibrationResult::set_calibration_details(::google::protobuf::uint32 value) {
+  
+  calibration_details_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.DeviceConfig.CalibrationResult.calibration_details)
+}
+
+// -------------------------------------------------------------------
+
+// CapSenseConfig
+
+// .Kinova.Api.DeviceConfig.CapSenseMode mode = 1;
+inline void CapSenseConfig::clear_mode() {
+  mode_ = 0;
+}
+inline ::Kinova::Api::DeviceConfig::CapSenseMode CapSenseConfig::mode() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.DeviceConfig.CapSenseConfig.mode)
+  return static_cast< ::Kinova::Api::DeviceConfig::CapSenseMode >(mode_);
+}
+inline void CapSenseConfig::set_mode(::Kinova::Api::DeviceConfig::CapSenseMode value) {
+  
+  mode_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.DeviceConfig.CapSenseConfig.mode)
+}
+
+// float threshold_a = 2;
+inline void CapSenseConfig::clear_threshold_a() {
+  threshold_a_ = 0;
+}
+inline float CapSenseConfig::threshold_a() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.DeviceConfig.CapSenseConfig.threshold_a)
+  return threshold_a_;
+}
+inline void CapSenseConfig::set_threshold_a(float value) {
+  
+  threshold_a_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.DeviceConfig.CapSenseConfig.threshold_a)
+}
+
+// float threshold_b = 3;
+inline void CapSenseConfig::clear_threshold_b() {
+  threshold_b_ = 0;
+}
+inline float CapSenseConfig::threshold_b() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.DeviceConfig.CapSenseConfig.threshold_b)
+  return threshold_b_;
+}
+inline void CapSenseConfig::set_threshold_b(float value) {
+  
+  threshold_b_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.DeviceConfig.CapSenseConfig.threshold_b)
+}
+
+// -------------------------------------------------------------------
+
+// CapSenseRegister
+
+// uint32 address = 1;
+inline void CapSenseRegister::clear_address() {
+  address_ = 0u;
+}
+inline ::google::protobuf::uint32 CapSenseRegister::address() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.DeviceConfig.CapSenseRegister.address)
+  return address_;
+}
+inline void CapSenseRegister::set_address(::google::protobuf::uint32 value) {
+  
+  address_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.DeviceConfig.CapSenseRegister.address)
+}
+
+// uint32 value = 2;
+inline void CapSenseRegister::clear_value() {
+  value_ = 0u;
+}
+inline ::google::protobuf::uint32 CapSenseRegister::value() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.DeviceConfig.CapSenseRegister.value)
+  return value_;
+}
+inline void CapSenseRegister::set_value(::google::protobuf::uint32 value) {
+  
+  value_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.DeviceConfig.CapSenseRegister.value)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace DeviceConfig
+}  // namespace Api
+}  // namespace Kinova
+
+namespace google {
+namespace protobuf {
+
+template <> struct is_proto_enum< ::Kinova::Api::DeviceConfig::ServiceVersion> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::DeviceConfig::ServiceVersion>() {
+  return ::Kinova::Api::DeviceConfig::ServiceVersion_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::DeviceConfig::RunModes> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::DeviceConfig::RunModes>() {
+  return ::Kinova::Api::DeviceConfig::RunModes_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::DeviceConfig::CalibrationItem> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::DeviceConfig::CalibrationItem>() {
+  return ::Kinova::Api::DeviceConfig::CalibrationItem_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::DeviceConfig::CalibrationStatus> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::DeviceConfig::CalibrationStatus>() {
+  return ::Kinova::Api::DeviceConfig::CalibrationStatus_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::DeviceConfig::SafetyLimitType> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::DeviceConfig::SafetyLimitType>() {
+  return ::Kinova::Api::DeviceConfig::SafetyLimitType_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::DeviceConfig::CapSenseMode> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::DeviceConfig::CapSenseMode>() {
+  return ::Kinova::Api::DeviceConfig::CapSenseMode_descriptor();
+}
+
+}  // namespace protobuf
+}  // namespace google
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_DeviceConfig_2eproto__INCLUDED
diff --git a/kortex_api/include/messages/DeviceManager.pb.h b/kortex_api/include/messages/DeviceManager.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..128aa6ed27b9be6a06f8cb0b80f9ecd39e9ae271
--- /dev/null
+++ b/kortex_api/include/messages/DeviceManager.pb.h
@@ -0,0 +1,254 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: DeviceManager.proto
+
+#ifndef PROTOBUF_DeviceManager_2eproto__INCLUDED
+#define PROTOBUF_DeviceManager_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 3005000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 3005001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "Common.pb.h"  // IWYU pragma: export
+// @@protoc_insertion_point(includes)
+
+namespace protobuf_DeviceManager_2eproto {
+// Internal implementation detail -- do not use these members.
+struct TableStruct {
+  static const ::google::protobuf::internal::ParseTableField entries[];
+  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
+  static const ::google::protobuf::internal::ParseTable schema[1];
+  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
+  static const ::google::protobuf::internal::SerializationTable serialization_table[];
+  static const ::google::protobuf::uint32 offsets[];
+};
+void AddDescriptors();
+void InitDefaultsDeviceHandlesImpl();
+void InitDefaultsDeviceHandles();
+inline void InitDefaults() {
+  InitDefaultsDeviceHandles();
+}
+}  // namespace protobuf_DeviceManager_2eproto
+namespace Kinova {
+namespace Api {
+namespace DeviceManager {
+class DeviceHandles;
+class DeviceHandlesDefaultTypeInternal;
+extern DeviceHandlesDefaultTypeInternal _DeviceHandles_default_instance_;
+}  // namespace DeviceManager
+}  // namespace Api
+}  // namespace Kinova
+namespace Kinova {
+namespace Api {
+namespace DeviceManager {
+
+enum ServiceVersion {
+  RESERVED_0 = 0,
+  CURRENT_VERSION = 1,
+  ServiceVersion_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  ServiceVersion_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool ServiceVersion_IsValid(int value);
+const ServiceVersion ServiceVersion_MIN = RESERVED_0;
+const ServiceVersion ServiceVersion_MAX = CURRENT_VERSION;
+const int ServiceVersion_ARRAYSIZE = ServiceVersion_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* ServiceVersion_descriptor();
+inline const ::std::string& ServiceVersion_Name(ServiceVersion value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    ServiceVersion_descriptor(), value);
+}
+inline bool ServiceVersion_Parse(
+    const ::std::string& name, ServiceVersion* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<ServiceVersion>(
+    ServiceVersion_descriptor(), name, value);
+}
+// ===================================================================
+
+class DeviceHandles : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.DeviceManager.DeviceHandles) */ {
+ public:
+  DeviceHandles();
+  virtual ~DeviceHandles();
+
+  DeviceHandles(const DeviceHandles& from);
+
+  inline DeviceHandles& operator=(const DeviceHandles& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  DeviceHandles(DeviceHandles&& from) noexcept
+    : DeviceHandles() {
+    *this = ::std::move(from);
+  }
+
+  inline DeviceHandles& operator=(DeviceHandles&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const DeviceHandles& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const DeviceHandles* internal_default_instance() {
+    return reinterpret_cast<const DeviceHandles*>(
+               &_DeviceHandles_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    0;
+
+  void Swap(DeviceHandles* other);
+  friend void swap(DeviceHandles& a, DeviceHandles& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline DeviceHandles* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  DeviceHandles* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const DeviceHandles& from);
+  void MergeFrom(const DeviceHandles& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(DeviceHandles* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .Kinova.Api.Common.DeviceHandle device_handle = 1;
+  int device_handle_size() const;
+  void clear_device_handle();
+  static const int kDeviceHandleFieldNumber = 1;
+  const ::Kinova::Api::Common::DeviceHandle& device_handle(int index) const;
+  ::Kinova::Api::Common::DeviceHandle* mutable_device_handle(int index);
+  ::Kinova::Api::Common::DeviceHandle* add_device_handle();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Common::DeviceHandle >*
+      mutable_device_handle();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Common::DeviceHandle >&
+      device_handle() const;
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.DeviceManager.DeviceHandles)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Common::DeviceHandle > device_handle_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_DeviceManager_2eproto::TableStruct;
+  friend void ::protobuf_DeviceManager_2eproto::InitDefaultsDeviceHandlesImpl();
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// DeviceHandles
+
+// repeated .Kinova.Api.Common.DeviceHandle device_handle = 1;
+inline int DeviceHandles::device_handle_size() const {
+  return device_handle_.size();
+}
+inline const ::Kinova::Api::Common::DeviceHandle& DeviceHandles::device_handle(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.DeviceManager.DeviceHandles.device_handle)
+  return device_handle_.Get(index);
+}
+inline ::Kinova::Api::Common::DeviceHandle* DeviceHandles::mutable_device_handle(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.DeviceManager.DeviceHandles.device_handle)
+  return device_handle_.Mutable(index);
+}
+inline ::Kinova::Api::Common::DeviceHandle* DeviceHandles::add_device_handle() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.DeviceManager.DeviceHandles.device_handle)
+  return device_handle_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Common::DeviceHandle >*
+DeviceHandles::mutable_device_handle() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.DeviceManager.DeviceHandles.device_handle)
+  return &device_handle_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Common::DeviceHandle >&
+DeviceHandles::device_handle() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.DeviceManager.DeviceHandles.device_handle)
+  return device_handle_;
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace DeviceManager
+}  // namespace Api
+}  // namespace Kinova
+
+namespace google {
+namespace protobuf {
+
+template <> struct is_proto_enum< ::Kinova::Api::DeviceManager::ServiceVersion> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::DeviceManager::ServiceVersion>() {
+  return ::Kinova::Api::DeviceManager::ServiceVersion_descriptor();
+}
+
+}  // namespace protobuf
+}  // namespace google
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_DeviceManager_2eproto__INCLUDED
diff --git a/kortex_api/include/messages/Errors.pb.h b/kortex_api/include/messages/Errors.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..2c1e99790d039d6660475dd4f8eb4289bc133b7e
--- /dev/null
+++ b/kortex_api/include/messages/Errors.pb.h
@@ -0,0 +1,237 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: Errors.proto
+
+#ifndef PROTOBUF_Errors_2eproto__INCLUDED
+#define PROTOBUF_Errors_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 3005000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 3005001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+// @@protoc_insertion_point(includes)
+
+namespace protobuf_Errors_2eproto {
+// Internal implementation detail -- do not use these members.
+struct TableStruct {
+  static const ::google::protobuf::internal::ParseTableField entries[];
+  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
+  static const ::google::protobuf::internal::ParseTable schema[1];
+  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
+  static const ::google::protobuf::internal::SerializationTable serialization_table[];
+  static const ::google::protobuf::uint32 offsets[];
+};
+void AddDescriptors();
+inline void InitDefaults() {
+}
+}  // namespace protobuf_Errors_2eproto
+namespace Kinova {
+namespace Api {
+}  // namespace Api
+}  // namespace Kinova
+namespace Kinova {
+namespace Api {
+
+enum ErrorCodes {
+  ERROR_NONE = 0,
+  ERROR_PROTOCOL_SERVER = 1,
+  ERROR_PROTOCOL_CLIENT = 2,
+  ERROR_DEVICE = 3,
+  ERROR_INTERNAL = 4,
+  ErrorCodes_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  ErrorCodes_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool ErrorCodes_IsValid(int value);
+const ErrorCodes ErrorCodes_MIN = ERROR_NONE;
+const ErrorCodes ErrorCodes_MAX = ERROR_INTERNAL;
+const int ErrorCodes_ARRAYSIZE = ErrorCodes_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* ErrorCodes_descriptor();
+inline const ::std::string& ErrorCodes_Name(ErrorCodes value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    ErrorCodes_descriptor(), value);
+}
+inline bool ErrorCodes_Parse(
+    const ::std::string& name, ErrorCodes* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<ErrorCodes>(
+    ErrorCodes_descriptor(), name, value);
+}
+enum SubErrorCodes {
+  SUB_ERROR_NONE = 0,
+  METHOD_FAILED = 1,
+  UNIMPLEMENTED = 2,
+  INVALID_PARAM = 3,
+  UNSUPPORTED_SERVICE = 4,
+  UNSUPPORTED_METHOD = 5,
+  TOO_LARGE_ENCODED_FRAME_BUFFER = 6,
+  FRAME_ENCODING_ERR = 7,
+  FRAME_DECODING_ERR = 8,
+  INCOMPATIBLE_HEADER_VERSION = 9,
+  UNSUPPORTED_FRAME_TYPE = 10,
+  UNREGISTERED_NOTIFICATION_RECEIVED = 11,
+  INVALID_SESSION = 12,
+  PAYLOAD_DECODING_ERR = 13,
+  UNREGISTERED_FRAME_RECEIVED = 14,
+  INVALID_PASSWORD = 15,
+  USER_NOT_FOUND = 16,
+  ENTITY_NOT_FOUND = 17,
+  ROBOT_MOVEMENT_IN_PROGRESS = 18,
+  ROBOT_NOT_MOVING = 19,
+  NO_MORE_STORAGE_SPACE = 20,
+  ROBOT_NOT_READY = 21,
+  ROBOT_IN_FAULT = 22,
+  ROBOT_IN_MAINTENANCE = 23,
+  ROBOT_IN_UPDATE_MODE = 24,
+  ROBOT_IN_EMERGENCY_STOP = 25,
+  SINGLE_LEVEL_SERVOING = 26,
+  LOW_LEVEL_SERVOING = 27,
+  MAPPING_GROUP_NON_ROOT = 28,
+  MAPPING_INVALID_GROUP = 29,
+  MAPPING_INVALID_MAP = 30,
+  MAP_GROUP_INVALID_MAP = 31,
+  MAP_GROUP_INVALID_PARENT = 32,
+  MAP_GROUP_INVALID_CHILD = 33,
+  MAP_GROUP_INVALID_MOVE = 34,
+  MAP_IN_USE = 35,
+  WIFI_CONNECT_ERROR = 36,
+  UNSUPPORTED_NETWORK_TYPE = 37,
+  TOO_LARGE_ENCODED_PAYLOAD_BUFFER = 38,
+  UPDATE_PERMISSION_DENIED = 39,
+  DELETE_PERMISSION_DENIED = 40,
+  DATABASE_ERROR = 41,
+  UNSUPPORTED_OPTION = 42,
+  UNSUPPORTED_RESOLUTION = 43,
+  UNSUPPORTED_FRAME_RATE = 44,
+  UNSUPPORTED_BIT_RATE = 45,
+  UNSUPPORTED_ACTION = 46,
+  UNSUPPORTED_FOCUS_ACTION = 47,
+  VALUE_IS_ABOVE_MAXIMUM = 48,
+  VALUE_IS_BELOW_MINIMUM = 49,
+  DEVICE_DISCONNECTED = 50,
+  DEVICE_NOT_READY = 51,
+  INVALID_DEVICE = 52,
+  SAFETY_THRESHOLD_REACHED = 53,
+  INVALID_USER_SESSION_ACCESS = 54,
+  CONTROL_MANUAL_STOP = 55,
+  CONTROL_OUTSIDE_WORKSPACE = 56,
+  CONTROL_ACTUATOR_COUNT_MISMATCH = 57,
+  CONTROL_INVALID_DURATION = 58,
+  CONTROL_INVALID_SPEED = 59,
+  CONTROL_LARGE_SPEED = 60,
+  CONTROL_INVALID_ACCELERATION = 61,
+  CONTROL_INVALID_TIME_STEP = 62,
+  CONTROL_LARGE_SIZE = 63,
+  CONTROL_WRONG_MODE = 64,
+  CONTROL_JOINT_POSITION_LIMIT = 65,
+  CONTROL_NO_FILE_IN_MEMORY = 66,
+  CONTROL_INDEX_OUT_OF_TRAJECTORY = 67,
+  CONTROL_ALREADY_RUNNING = 68,
+  CONTROL_WRONG_STARTING_POINT = 69,
+  CONTROL_CARTESIAN_CANNOT_START = 70,
+  CONTROL_UNDEFINED_CONSTRAINT = 71,
+  CONTROL_UNINITIALIZED = 72,
+  CONTROL_NO_ACTION = 73,
+  CONTROL_UNDEFINED = 74,
+  WRONG_SERVOING_MODE = 75,
+  CONTROL_WRONG_STARTING_SPEED = 76,
+  USERNAME_LENGTH_EXCEEDED = 100,
+  FIRSTNAME_LENGTH_EXCEEDED = 101,
+  LASTNAME_LENGTH_EXCEEDED = 102,
+  PASSWORD_LENGTH_EXCEEDED = 103,
+  USERNAME_ALREADY_EXISTS = 104,
+  USERNAME_EMPTY = 105,
+  PASSWORD_NOT_CHANGED = 106,
+  MAXIMUM_USER_PROFILES_USED = 107,
+  ROUTER_UNVAILABLE = 108,
+  ADDRESS_NOT_IN_VALID_RANGE = 120,
+  ADDRESS_NOT_CONFIGURABLE = 121,
+  SESSION_NOT_IN_CONTROL = 130,
+  METHOD_TIMEOUT = 131,
+  UNSUPPORTED_ROBOT_CONFIGURATION = 132,
+  NVRAM_READ_FAIL = 133,
+  NVRAM_WRITE_FAIL = 134,
+  NETWORK_NO_ADDRESS_ASSIGNED = 135,
+  READ_PERMISSION_DENIED = 136,
+  CONTROLLER_INVALID_MAPPING = 137,
+  ACTION_IN_USE = 138,
+  SEND_FAILED = 139,
+  CONTROL_WAYPOINT_TRAJECTORY_ABORTED = 140,
+  CONTROL_PERMISSION_DENIED = 141,
+  SubErrorCodes_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  SubErrorCodes_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool SubErrorCodes_IsValid(int value);
+const SubErrorCodes SubErrorCodes_MIN = SUB_ERROR_NONE;
+const SubErrorCodes SubErrorCodes_MAX = CONTROL_PERMISSION_DENIED;
+const int SubErrorCodes_ARRAYSIZE = SubErrorCodes_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* SubErrorCodes_descriptor();
+inline const ::std::string& SubErrorCodes_Name(SubErrorCodes value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    SubErrorCodes_descriptor(), value);
+}
+inline bool SubErrorCodes_Parse(
+    const ::std::string& name, SubErrorCodes* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<SubErrorCodes>(
+    SubErrorCodes_descriptor(), name, value);
+}
+// ===================================================================
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace Api
+}  // namespace Kinova
+
+namespace google {
+namespace protobuf {
+
+template <> struct is_proto_enum< ::Kinova::Api::ErrorCodes> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::ErrorCodes>() {
+  return ::Kinova::Api::ErrorCodes_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::SubErrorCodes> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::SubErrorCodes>() {
+  return ::Kinova::Api::SubErrorCodes_descriptor();
+}
+
+}  // namespace protobuf
+}  // namespace google
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_Errors_2eproto__INCLUDED
diff --git a/kortex_api/include/messages/Frame.pb.h b/kortex_api/include/messages/Frame.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..b8ce4800b23c979eac0dc77b46ff32f0530b6e26
--- /dev/null
+++ b/kortex_api/include/messages/Frame.pb.h
@@ -0,0 +1,771 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: Frame.proto
+
+#ifndef PROTOBUF_Frame_2eproto__INCLUDED
+#define PROTOBUF_Frame_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 3005000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 3005001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "Errors.pb.h"  // IWYU pragma: export
+// @@protoc_insertion_point(includes)
+
+namespace protobuf_Frame_2eproto {
+// Internal implementation detail -- do not use these members.
+struct TableStruct {
+  static const ::google::protobuf::internal::ParseTableField entries[];
+  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
+  static const ::google::protobuf::internal::ParseTable schema[3];
+  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
+  static const ::google::protobuf::internal::SerializationTable serialization_table[];
+  static const ::google::protobuf::uint32 offsets[];
+};
+void AddDescriptors();
+void InitDefaultsFrameImpl();
+void InitDefaultsFrame();
+void InitDefaultsHeaderImpl();
+void InitDefaultsHeader();
+void InitDefaultsErrorImpl();
+void InitDefaultsError();
+inline void InitDefaults() {
+  InitDefaultsFrame();
+  InitDefaultsHeader();
+  InitDefaultsError();
+}
+}  // namespace protobuf_Frame_2eproto
+namespace Kinova {
+namespace Api {
+class Error;
+class ErrorDefaultTypeInternal;
+extern ErrorDefaultTypeInternal _Error_default_instance_;
+class Frame;
+class FrameDefaultTypeInternal;
+extern FrameDefaultTypeInternal _Frame_default_instance_;
+class Header;
+class HeaderDefaultTypeInternal;
+extern HeaderDefaultTypeInternal _Header_default_instance_;
+}  // namespace Api
+}  // namespace Kinova
+namespace Kinova {
+namespace Api {
+
+enum HeaderVersion {
+  RESERVED_0 = 0,
+  CURRENT_VERSION = 1,
+  HeaderVersion_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  HeaderVersion_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool HeaderVersion_IsValid(int value);
+const HeaderVersion HeaderVersion_MIN = RESERVED_0;
+const HeaderVersion HeaderVersion_MAX = CURRENT_VERSION;
+const int HeaderVersion_ARRAYSIZE = HeaderVersion_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* HeaderVersion_descriptor();
+inline const ::std::string& HeaderVersion_Name(HeaderVersion value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    HeaderVersion_descriptor(), value);
+}
+inline bool HeaderVersion_Parse(
+    const ::std::string& name, HeaderVersion* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<HeaderVersion>(
+    HeaderVersion_descriptor(), name, value);
+}
+enum FrameTypes {
+  RESERVED = 0,
+  MSG_FRAME_REQUEST = 1,
+  MSG_FRAME_RAW = 2,
+  MSG_FRAME_RESPONSE = 3,
+  MSG_FRAME_NOTIFICATION = 5,
+  MSG_FRAME_PING = 7,
+  MSG_FRAME_PONG = 8,
+  FrameTypes_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  FrameTypes_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool FrameTypes_IsValid(int value);
+const FrameTypes FrameTypes_MIN = RESERVED;
+const FrameTypes FrameTypes_MAX = MSG_FRAME_PONG;
+const int FrameTypes_ARRAYSIZE = FrameTypes_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* FrameTypes_descriptor();
+inline const ::std::string& FrameTypes_Name(FrameTypes value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    FrameTypes_descriptor(), value);
+}
+inline bool FrameTypes_Parse(
+    const ::std::string& name, FrameTypes* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<FrameTypes>(
+    FrameTypes_descriptor(), name, value);
+}
+// ===================================================================
+
+class Frame : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Frame) */ {
+ public:
+  Frame();
+  virtual ~Frame();
+
+  Frame(const Frame& from);
+
+  inline Frame& operator=(const Frame& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Frame(Frame&& from) noexcept
+    : Frame() {
+    *this = ::std::move(from);
+  }
+
+  inline Frame& operator=(Frame&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Frame& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Frame* internal_default_instance() {
+    return reinterpret_cast<const Frame*>(
+               &_Frame_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    0;
+
+  void Swap(Frame* other);
+  friend void swap(Frame& a, Frame& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Frame* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Frame* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Frame& from);
+  void MergeFrom(const Frame& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Frame* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // bytes payload = 2;
+  void clear_payload();
+  static const int kPayloadFieldNumber = 2;
+  const ::std::string& payload() const;
+  void set_payload(const ::std::string& value);
+  #if LANG_CXX11
+  void set_payload(::std::string&& value);
+  #endif
+  void set_payload(const char* value);
+  void set_payload(const void* value, size_t size);
+  ::std::string* mutable_payload();
+  ::std::string* release_payload();
+  void set_allocated_payload(::std::string* payload);
+
+  // .Kinova.Api.Header header = 1;
+  bool has_header() const;
+  void clear_header();
+  static const int kHeaderFieldNumber = 1;
+  const ::Kinova::Api::Header& header() const;
+  ::Kinova::Api::Header* release_header();
+  ::Kinova::Api::Header* mutable_header();
+  void set_allocated_header(::Kinova::Api::Header* header);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Frame)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::internal::ArenaStringPtr payload_;
+  ::Kinova::Api::Header* header_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Frame_2eproto::TableStruct;
+  friend void ::protobuf_Frame_2eproto::InitDefaultsFrameImpl();
+};
+// -------------------------------------------------------------------
+
+class Header : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Header) */ {
+ public:
+  Header();
+  virtual ~Header();
+
+  Header(const Header& from);
+
+  inline Header& operator=(const Header& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Header(Header&& from) noexcept
+    : Header() {
+    *this = ::std::move(from);
+  }
+
+  inline Header& operator=(Header&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Header& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Header* internal_default_instance() {
+    return reinterpret_cast<const Header*>(
+               &_Header_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    1;
+
+  void Swap(Header* other);
+  friend void swap(Header& a, Header& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Header* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Header* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Header& from);
+  void MergeFrom(const Header& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Header* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // fixed32 frame_info = 1;
+  void clear_frame_info();
+  static const int kFrameInfoFieldNumber = 1;
+  ::google::protobuf::uint32 frame_info() const;
+  void set_frame_info(::google::protobuf::uint32 value);
+
+  // fixed32 message_info = 2;
+  void clear_message_info();
+  static const int kMessageInfoFieldNumber = 2;
+  ::google::protobuf::uint32 message_info() const;
+  void set_message_info(::google::protobuf::uint32 value);
+
+  // fixed32 service_info = 3;
+  void clear_service_info();
+  static const int kServiceInfoFieldNumber = 3;
+  ::google::protobuf::uint32 service_info() const;
+  void set_service_info(::google::protobuf::uint32 value);
+
+  // fixed32 payload_info = 4;
+  void clear_payload_info();
+  static const int kPayloadInfoFieldNumber = 4;
+  ::google::protobuf::uint32 payload_info() const;
+  void set_payload_info(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Header)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 frame_info_;
+  ::google::protobuf::uint32 message_info_;
+  ::google::protobuf::uint32 service_info_;
+  ::google::protobuf::uint32 payload_info_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Frame_2eproto::TableStruct;
+  friend void ::protobuf_Frame_2eproto::InitDefaultsHeaderImpl();
+};
+// -------------------------------------------------------------------
+
+class Error : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Error) */ {
+ public:
+  Error();
+  virtual ~Error();
+
+  Error(const Error& from);
+
+  inline Error& operator=(const Error& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Error(Error&& from) noexcept
+    : Error() {
+    *this = ::std::move(from);
+  }
+
+  inline Error& operator=(Error&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Error& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Error* internal_default_instance() {
+    return reinterpret_cast<const Error*>(
+               &_Error_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    2;
+
+  void Swap(Error* other);
+  friend void swap(Error& a, Error& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Error* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Error* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Error& from);
+  void MergeFrom(const Error& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Error* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // string error_sub_string = 3;
+  void clear_error_sub_string();
+  static const int kErrorSubStringFieldNumber = 3;
+  const ::std::string& error_sub_string() const;
+  void set_error_sub_string(const ::std::string& value);
+  #if LANG_CXX11
+  void set_error_sub_string(::std::string&& value);
+  #endif
+  void set_error_sub_string(const char* value);
+  void set_error_sub_string(const char* value, size_t size);
+  ::std::string* mutable_error_sub_string();
+  ::std::string* release_error_sub_string();
+  void set_allocated_error_sub_string(::std::string* error_sub_string);
+
+  // .Kinova.Api.ErrorCodes error_code = 1;
+  void clear_error_code();
+  static const int kErrorCodeFieldNumber = 1;
+  ::Kinova::Api::ErrorCodes error_code() const;
+  void set_error_code(::Kinova::Api::ErrorCodes value);
+
+  // uint32 error_sub_code = 2;
+  void clear_error_sub_code();
+  static const int kErrorSubCodeFieldNumber = 2;
+  ::google::protobuf::uint32 error_sub_code() const;
+  void set_error_sub_code(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Error)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::internal::ArenaStringPtr error_sub_string_;
+  int error_code_;
+  ::google::protobuf::uint32 error_sub_code_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Frame_2eproto::TableStruct;
+  friend void ::protobuf_Frame_2eproto::InitDefaultsErrorImpl();
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// Frame
+
+// .Kinova.Api.Header header = 1;
+inline bool Frame::has_header() const {
+  return this != internal_default_instance() && header_ != NULL;
+}
+inline void Frame::clear_header() {
+  if (GetArenaNoVirtual() == NULL && header_ != NULL) {
+    delete header_;
+  }
+  header_ = NULL;
+}
+inline const ::Kinova::Api::Header& Frame::header() const {
+  const ::Kinova::Api::Header* p = header_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Frame.header)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Header*>(
+      &::Kinova::Api::_Header_default_instance_);
+}
+inline ::Kinova::Api::Header* Frame::release_header() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Frame.header)
+  
+  ::Kinova::Api::Header* temp = header_;
+  header_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Header* Frame::mutable_header() {
+  
+  if (header_ == NULL) {
+    header_ = new ::Kinova::Api::Header;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Frame.header)
+  return header_;
+}
+inline void Frame::set_allocated_header(::Kinova::Api::Header* header) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete header_;
+  }
+  if (header) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      header = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, header, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  header_ = header;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Frame.header)
+}
+
+// bytes payload = 2;
+inline void Frame::clear_payload() {
+  payload_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& Frame::payload() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Frame.payload)
+  return payload_.GetNoArena();
+}
+inline void Frame::set_payload(const ::std::string& value) {
+  
+  payload_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.Frame.payload)
+}
+#if LANG_CXX11
+inline void Frame::set_payload(::std::string&& value) {
+  
+  payload_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:Kinova.Api.Frame.payload)
+}
+#endif
+inline void Frame::set_payload(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  payload_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:Kinova.Api.Frame.payload)
+}
+inline void Frame::set_payload(const void* value, size_t size) {
+  
+  payload_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:Kinova.Api.Frame.payload)
+}
+inline ::std::string* Frame::mutable_payload() {
+  
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Frame.payload)
+  return payload_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* Frame::release_payload() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Frame.payload)
+  
+  return payload_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void Frame::set_allocated_payload(::std::string* payload) {
+  if (payload != NULL) {
+    
+  } else {
+    
+  }
+  payload_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), payload);
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Frame.payload)
+}
+
+// -------------------------------------------------------------------
+
+// Header
+
+// fixed32 frame_info = 1;
+inline void Header::clear_frame_info() {
+  frame_info_ = 0u;
+}
+inline ::google::protobuf::uint32 Header::frame_info() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Header.frame_info)
+  return frame_info_;
+}
+inline void Header::set_frame_info(::google::protobuf::uint32 value) {
+  
+  frame_info_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Header.frame_info)
+}
+
+// fixed32 message_info = 2;
+inline void Header::clear_message_info() {
+  message_info_ = 0u;
+}
+inline ::google::protobuf::uint32 Header::message_info() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Header.message_info)
+  return message_info_;
+}
+inline void Header::set_message_info(::google::protobuf::uint32 value) {
+  
+  message_info_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Header.message_info)
+}
+
+// fixed32 service_info = 3;
+inline void Header::clear_service_info() {
+  service_info_ = 0u;
+}
+inline ::google::protobuf::uint32 Header::service_info() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Header.service_info)
+  return service_info_;
+}
+inline void Header::set_service_info(::google::protobuf::uint32 value) {
+  
+  service_info_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Header.service_info)
+}
+
+// fixed32 payload_info = 4;
+inline void Header::clear_payload_info() {
+  payload_info_ = 0u;
+}
+inline ::google::protobuf::uint32 Header::payload_info() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Header.payload_info)
+  return payload_info_;
+}
+inline void Header::set_payload_info(::google::protobuf::uint32 value) {
+  
+  payload_info_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Header.payload_info)
+}
+
+// -------------------------------------------------------------------
+
+// Error
+
+// .Kinova.Api.ErrorCodes error_code = 1;
+inline void Error::clear_error_code() {
+  error_code_ = 0;
+}
+inline ::Kinova::Api::ErrorCodes Error::error_code() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Error.error_code)
+  return static_cast< ::Kinova::Api::ErrorCodes >(error_code_);
+}
+inline void Error::set_error_code(::Kinova::Api::ErrorCodes value) {
+  
+  error_code_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Error.error_code)
+}
+
+// uint32 error_sub_code = 2;
+inline void Error::clear_error_sub_code() {
+  error_sub_code_ = 0u;
+}
+inline ::google::protobuf::uint32 Error::error_sub_code() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Error.error_sub_code)
+  return error_sub_code_;
+}
+inline void Error::set_error_sub_code(::google::protobuf::uint32 value) {
+  
+  error_sub_code_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Error.error_sub_code)
+}
+
+// string error_sub_string = 3;
+inline void Error::clear_error_sub_string() {
+  error_sub_string_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& Error::error_sub_string() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Error.error_sub_string)
+  return error_sub_string_.GetNoArena();
+}
+inline void Error::set_error_sub_string(const ::std::string& value) {
+  
+  error_sub_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.Error.error_sub_string)
+}
+#if LANG_CXX11
+inline void Error::set_error_sub_string(::std::string&& value) {
+  
+  error_sub_string_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:Kinova.Api.Error.error_sub_string)
+}
+#endif
+inline void Error::set_error_sub_string(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  error_sub_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:Kinova.Api.Error.error_sub_string)
+}
+inline void Error::set_error_sub_string(const char* value, size_t size) {
+  
+  error_sub_string_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:Kinova.Api.Error.error_sub_string)
+}
+inline ::std::string* Error::mutable_error_sub_string() {
+  
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Error.error_sub_string)
+  return error_sub_string_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* Error::release_error_sub_string() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Error.error_sub_string)
+  
+  return error_sub_string_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void Error::set_allocated_error_sub_string(::std::string* error_sub_string) {
+  if (error_sub_string != NULL) {
+    
+  } else {
+    
+  }
+  error_sub_string_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), error_sub_string);
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Error.error_sub_string)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace Api
+}  // namespace Kinova
+
+namespace google {
+namespace protobuf {
+
+template <> struct is_proto_enum< ::Kinova::Api::HeaderVersion> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::HeaderVersion>() {
+  return ::Kinova::Api::HeaderVersion_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::FrameTypes> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::FrameTypes>() {
+  return ::Kinova::Api::FrameTypes_descriptor();
+}
+
+}  // namespace protobuf
+}  // namespace google
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_Frame_2eproto__INCLUDED
diff --git a/kortex_api/include/messages/GripperConfig.pb.h b/kortex_api/include/messages/GripperConfig.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..31957e75480ba2a77d14227fe3238c25c57b9a3d
--- /dev/null
+++ b/kortex_api/include/messages/GripperConfig.pb.h
@@ -0,0 +1,152 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: GripperConfig.proto
+
+#ifndef PROTOBUF_GripperConfig_2eproto__INCLUDED
+#define PROTOBUF_GripperConfig_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 3005000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 3005001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include "Common.pb.h"  // IWYU pragma: export
+// @@protoc_insertion_point(includes)
+
+namespace protobuf_GripperConfig_2eproto {
+// Internal implementation detail -- do not use these members.
+struct TableStruct {
+  static const ::google::protobuf::internal::ParseTableField entries[];
+  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
+  static const ::google::protobuf::internal::ParseTable schema[1];
+  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
+  static const ::google::protobuf::internal::SerializationTable serialization_table[];
+  static const ::google::protobuf::uint32 offsets[];
+};
+void AddDescriptors();
+inline void InitDefaults() {
+}
+}  // namespace protobuf_GripperConfig_2eproto
+namespace Kinova {
+namespace Api {
+namespace GripperConfig {
+}  // namespace GripperConfig
+}  // namespace Api
+}  // namespace Kinova
+namespace Kinova {
+namespace Api {
+namespace GripperConfig {
+
+enum SafetyIdentifier {
+  UNSPECIFIED_ACTUATOR_SAFETY_IDENTIFIER = 0,
+  MAXIMUM_MOTOR_CURRENT = 1,
+  MAXIMUM_VOLTAGE = 2,
+  MINIMUM_VOLTAGE = 4,
+  MAXIMUM_MOTOR_TEMPERATURE = 8,
+  MAXIMUM_CORE_TEMPERATURE = 16,
+  NON_VOLATILE_MEMORY_CORRUPTED = 32,
+  EMERGENCY_LINE_ASSERTED = 64,
+  COMMUNICATION_TICK_LOST = 128,
+  WATCHDOG_TRIGGERED = 256,
+  SafetyIdentifier_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  SafetyIdentifier_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool SafetyIdentifier_IsValid(int value);
+const SafetyIdentifier SafetyIdentifier_MIN = UNSPECIFIED_ACTUATOR_SAFETY_IDENTIFIER;
+const SafetyIdentifier SafetyIdentifier_MAX = WATCHDOG_TRIGGERED;
+const int SafetyIdentifier_ARRAYSIZE = SafetyIdentifier_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* SafetyIdentifier_descriptor();
+inline const ::std::string& SafetyIdentifier_Name(SafetyIdentifier value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    SafetyIdentifier_descriptor(), value);
+}
+inline bool SafetyIdentifier_Parse(
+    const ::std::string& name, SafetyIdentifier* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<SafetyIdentifier>(
+    SafetyIdentifier_descriptor(), name, value);
+}
+enum RobotiqGripperStatusFlags {
+  UNSPECIFIED_ROBOTIQ_STATUS = 0,
+  ROBOTIQ_STAT_INITIALIZED = 1,
+  ROBOTIQ_STAT_OBJECT_DETECTED = 2,
+  ROBOTIQ_STAT_POS_REACHED = 4,
+  ROBOTIQ_STAT_STOPPED = 8,
+  RobotiqGripperStatusFlags_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  RobotiqGripperStatusFlags_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool RobotiqGripperStatusFlags_IsValid(int value);
+const RobotiqGripperStatusFlags RobotiqGripperStatusFlags_MIN = UNSPECIFIED_ROBOTIQ_STATUS;
+const RobotiqGripperStatusFlags RobotiqGripperStatusFlags_MAX = ROBOTIQ_STAT_STOPPED;
+const int RobotiqGripperStatusFlags_ARRAYSIZE = RobotiqGripperStatusFlags_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* RobotiqGripperStatusFlags_descriptor();
+inline const ::std::string& RobotiqGripperStatusFlags_Name(RobotiqGripperStatusFlags value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    RobotiqGripperStatusFlags_descriptor(), value);
+}
+inline bool RobotiqGripperStatusFlags_Parse(
+    const ::std::string& name, RobotiqGripperStatusFlags* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<RobotiqGripperStatusFlags>(
+    RobotiqGripperStatusFlags_descriptor(), name, value);
+}
+// ===================================================================
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace GripperConfig
+}  // namespace Api
+}  // namespace Kinova
+
+namespace google {
+namespace protobuf {
+
+template <> struct is_proto_enum< ::Kinova::Api::GripperConfig::SafetyIdentifier> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::GripperConfig::SafetyIdentifier>() {
+  return ::Kinova::Api::GripperConfig::SafetyIdentifier_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::GripperConfig::RobotiqGripperStatusFlags> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::GripperConfig::RobotiqGripperStatusFlags>() {
+  return ::Kinova::Api::GripperConfig::RobotiqGripperStatusFlags_descriptor();
+}
+
+}  // namespace protobuf
+}  // namespace google
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_GripperConfig_2eproto__INCLUDED
diff --git a/kortex_api/include/messages/GripperCyclic.pb.h b/kortex_api/include/messages/GripperCyclic.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..7ad2073a5523868cd667fbf308a09c22d8ac7750
--- /dev/null
+++ b/kortex_api/include/messages/GripperCyclic.pb.h
@@ -0,0 +1,116 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: GripperCyclic.proto
+
+#ifndef PROTOBUF_GripperCyclic_2eproto__INCLUDED
+#define PROTOBUF_GripperCyclic_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 3005000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 3005001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include "Common.pb.h"  // IWYU pragma: export
+#include "GripperCyclicMessage.pb.h"  // IWYU pragma: export
+// @@protoc_insertion_point(includes)
+
+namespace protobuf_GripperCyclic_2eproto {
+// Internal implementation detail -- do not use these members.
+struct TableStruct {
+  static const ::google::protobuf::internal::ParseTableField entries[];
+  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
+  static const ::google::protobuf::internal::ParseTable schema[1];
+  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
+  static const ::google::protobuf::internal::SerializationTable serialization_table[];
+  static const ::google::protobuf::uint32 offsets[];
+};
+void AddDescriptors();
+inline void InitDefaults() {
+}
+}  // namespace protobuf_GripperCyclic_2eproto
+namespace Kinova {
+namespace Api {
+namespace GripperCyclic {
+}  // namespace GripperCyclic
+}  // namespace Api
+}  // namespace Kinova
+namespace Kinova {
+namespace Api {
+namespace GripperCyclic {
+
+enum ServiceVersion {
+  RESERVED_0 = 0,
+  CURRENT_VERSION = 1,
+  ServiceVersion_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  ServiceVersion_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool ServiceVersion_IsValid(int value);
+const ServiceVersion ServiceVersion_MIN = RESERVED_0;
+const ServiceVersion ServiceVersion_MAX = CURRENT_VERSION;
+const int ServiceVersion_ARRAYSIZE = ServiceVersion_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* ServiceVersion_descriptor();
+inline const ::std::string& ServiceVersion_Name(ServiceVersion value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    ServiceVersion_descriptor(), value);
+}
+inline bool ServiceVersion_Parse(
+    const ::std::string& name, ServiceVersion* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<ServiceVersion>(
+    ServiceVersion_descriptor(), name, value);
+}
+// ===================================================================
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace GripperCyclic
+}  // namespace Api
+}  // namespace Kinova
+
+namespace google {
+namespace protobuf {
+
+template <> struct is_proto_enum< ::Kinova::Api::GripperCyclic::ServiceVersion> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::GripperCyclic::ServiceVersion>() {
+  return ::Kinova::Api::GripperCyclic::ServiceVersion_descriptor();
+}
+
+}  // namespace protobuf
+}  // namespace google
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_GripperCyclic_2eproto__INCLUDED
diff --git a/kortex_api/include/messages/GripperCyclicMessage.pb.h b/kortex_api/include/messages/GripperCyclicMessage.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..1ca5663af03eea6083f99cb71317ed2d9529a93d
--- /dev/null
+++ b/kortex_api/include/messages/GripperCyclicMessage.pb.h
@@ -0,0 +1,1866 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: GripperCyclicMessage.proto
+
+#ifndef PROTOBUF_GripperCyclicMessage_2eproto__INCLUDED
+#define PROTOBUF_GripperCyclicMessage_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 3005000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 3005001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+#include "Common.pb.h"  // IWYU pragma: export
+// @@protoc_insertion_point(includes)
+
+namespace protobuf_GripperCyclicMessage_2eproto {
+// Internal implementation detail -- do not use these members.
+struct TableStruct {
+  static const ::google::protobuf::internal::ParseTableField entries[];
+  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
+  static const ::google::protobuf::internal::ParseTable schema[7];
+  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
+  static const ::google::protobuf::internal::SerializationTable serialization_table[];
+  static const ::google::protobuf::uint32 offsets[];
+};
+void AddDescriptors();
+void InitDefaultsMessageIdImpl();
+void InitDefaultsMessageId();
+void InitDefaultsMotorCommandImpl();
+void InitDefaultsMotorCommand();
+void InitDefaultsCommandImpl();
+void InitDefaultsCommand();
+void InitDefaultsMotorFeedbackImpl();
+void InitDefaultsMotorFeedback();
+void InitDefaultsFeedbackImpl();
+void InitDefaultsFeedback();
+void InitDefaultsCustomDataUnitImpl();
+void InitDefaultsCustomDataUnit();
+void InitDefaultsCustomDataImpl();
+void InitDefaultsCustomData();
+inline void InitDefaults() {
+  InitDefaultsMessageId();
+  InitDefaultsMotorCommand();
+  InitDefaultsCommand();
+  InitDefaultsMotorFeedback();
+  InitDefaultsFeedback();
+  InitDefaultsCustomDataUnit();
+  InitDefaultsCustomData();
+}
+}  // namespace protobuf_GripperCyclicMessage_2eproto
+namespace Kinova {
+namespace Api {
+namespace GripperCyclic {
+class Command;
+class CommandDefaultTypeInternal;
+extern CommandDefaultTypeInternal _Command_default_instance_;
+class CustomData;
+class CustomDataDefaultTypeInternal;
+extern CustomDataDefaultTypeInternal _CustomData_default_instance_;
+class CustomDataUnit;
+class CustomDataUnitDefaultTypeInternal;
+extern CustomDataUnitDefaultTypeInternal _CustomDataUnit_default_instance_;
+class Feedback;
+class FeedbackDefaultTypeInternal;
+extern FeedbackDefaultTypeInternal _Feedback_default_instance_;
+class MessageId;
+class MessageIdDefaultTypeInternal;
+extern MessageIdDefaultTypeInternal _MessageId_default_instance_;
+class MotorCommand;
+class MotorCommandDefaultTypeInternal;
+extern MotorCommandDefaultTypeInternal _MotorCommand_default_instance_;
+class MotorFeedback;
+class MotorFeedbackDefaultTypeInternal;
+extern MotorFeedbackDefaultTypeInternal _MotorFeedback_default_instance_;
+}  // namespace GripperCyclic
+}  // namespace Api
+}  // namespace Kinova
+namespace Kinova {
+namespace Api {
+namespace GripperCyclic {
+
+// ===================================================================
+
+class MessageId : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.GripperCyclic.MessageId) */ {
+ public:
+  MessageId();
+  virtual ~MessageId();
+
+  MessageId(const MessageId& from);
+
+  inline MessageId& operator=(const MessageId& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  MessageId(MessageId&& from) noexcept
+    : MessageId() {
+    *this = ::std::move(from);
+  }
+
+  inline MessageId& operator=(MessageId&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const MessageId& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const MessageId* internal_default_instance() {
+    return reinterpret_cast<const MessageId*>(
+               &_MessageId_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    0;
+
+  void Swap(MessageId* other);
+  friend void swap(MessageId& a, MessageId& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline MessageId* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  MessageId* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const MessageId& from);
+  void MergeFrom(const MessageId& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(MessageId* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // fixed32 identifier = 1;
+  void clear_identifier();
+  static const int kIdentifierFieldNumber = 1;
+  ::google::protobuf::uint32 identifier() const;
+  void set_identifier(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.GripperCyclic.MessageId)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 identifier_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_GripperCyclicMessage_2eproto::TableStruct;
+  friend void ::protobuf_GripperCyclicMessage_2eproto::InitDefaultsMessageIdImpl();
+};
+// -------------------------------------------------------------------
+
+class MotorCommand : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.GripperCyclic.MotorCommand) */ {
+ public:
+  MotorCommand();
+  virtual ~MotorCommand();
+
+  MotorCommand(const MotorCommand& from);
+
+  inline MotorCommand& operator=(const MotorCommand& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  MotorCommand(MotorCommand&& from) noexcept
+    : MotorCommand() {
+    *this = ::std::move(from);
+  }
+
+  inline MotorCommand& operator=(MotorCommand&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const MotorCommand& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const MotorCommand* internal_default_instance() {
+    return reinterpret_cast<const MotorCommand*>(
+               &_MotorCommand_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    1;
+
+  void Swap(MotorCommand* other);
+  friend void swap(MotorCommand& a, MotorCommand& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline MotorCommand* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  MotorCommand* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const MotorCommand& from);
+  void MergeFrom(const MotorCommand& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(MotorCommand* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // fixed32 motor_id = 1;
+  void clear_motor_id();
+  static const int kMotorIdFieldNumber = 1;
+  ::google::protobuf::uint32 motor_id() const;
+  void set_motor_id(::google::protobuf::uint32 value);
+
+  // float position = 3;
+  void clear_position();
+  static const int kPositionFieldNumber = 3;
+  float position() const;
+  void set_position(float value);
+
+  // float velocity = 4;
+  void clear_velocity();
+  static const int kVelocityFieldNumber = 4;
+  float velocity() const;
+  void set_velocity(float value);
+
+  // float force = 5;
+  void clear_force();
+  static const int kForceFieldNumber = 5;
+  float force() const;
+  void set_force(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.GripperCyclic.MotorCommand)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 motor_id_;
+  float position_;
+  float velocity_;
+  float force_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_GripperCyclicMessage_2eproto::TableStruct;
+  friend void ::protobuf_GripperCyclicMessage_2eproto::InitDefaultsMotorCommandImpl();
+};
+// -------------------------------------------------------------------
+
+class Command : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.GripperCyclic.Command) */ {
+ public:
+  Command();
+  virtual ~Command();
+
+  Command(const Command& from);
+
+  inline Command& operator=(const Command& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Command(Command&& from) noexcept
+    : Command() {
+    *this = ::std::move(from);
+  }
+
+  inline Command& operator=(Command&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Command& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Command* internal_default_instance() {
+    return reinterpret_cast<const Command*>(
+               &_Command_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    2;
+
+  void Swap(Command* other);
+  friend void swap(Command& a, Command& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Command* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Command* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Command& from);
+  void MergeFrom(const Command& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Command* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .Kinova.Api.GripperCyclic.MotorCommand motor_cmd = 3;
+  int motor_cmd_size() const;
+  void clear_motor_cmd();
+  static const int kMotorCmdFieldNumber = 3;
+  const ::Kinova::Api::GripperCyclic::MotorCommand& motor_cmd(int index) const;
+  ::Kinova::Api::GripperCyclic::MotorCommand* mutable_motor_cmd(int index);
+  ::Kinova::Api::GripperCyclic::MotorCommand* add_motor_cmd();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::GripperCyclic::MotorCommand >*
+      mutable_motor_cmd();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::GripperCyclic::MotorCommand >&
+      motor_cmd() const;
+
+  // .Kinova.Api.GripperCyclic.MessageId command_id = 1;
+  bool has_command_id() const;
+  void clear_command_id();
+  static const int kCommandIdFieldNumber = 1;
+  const ::Kinova::Api::GripperCyclic::MessageId& command_id() const;
+  ::Kinova::Api::GripperCyclic::MessageId* release_command_id();
+  ::Kinova::Api::GripperCyclic::MessageId* mutable_command_id();
+  void set_allocated_command_id(::Kinova::Api::GripperCyclic::MessageId* command_id);
+
+  // fixed32 flags = 2;
+  void clear_flags();
+  static const int kFlagsFieldNumber = 2;
+  ::google::protobuf::uint32 flags() const;
+  void set_flags(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.GripperCyclic.Command)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::GripperCyclic::MotorCommand > motor_cmd_;
+  ::Kinova::Api::GripperCyclic::MessageId* command_id_;
+  ::google::protobuf::uint32 flags_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_GripperCyclicMessage_2eproto::TableStruct;
+  friend void ::protobuf_GripperCyclicMessage_2eproto::InitDefaultsCommandImpl();
+};
+// -------------------------------------------------------------------
+
+class MotorFeedback : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.GripperCyclic.MotorFeedback) */ {
+ public:
+  MotorFeedback();
+  virtual ~MotorFeedback();
+
+  MotorFeedback(const MotorFeedback& from);
+
+  inline MotorFeedback& operator=(const MotorFeedback& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  MotorFeedback(MotorFeedback&& from) noexcept
+    : MotorFeedback() {
+    *this = ::std::move(from);
+  }
+
+  inline MotorFeedback& operator=(MotorFeedback&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const MotorFeedback& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const MotorFeedback* internal_default_instance() {
+    return reinterpret_cast<const MotorFeedback*>(
+               &_MotorFeedback_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    3;
+
+  void Swap(MotorFeedback* other);
+  friend void swap(MotorFeedback& a, MotorFeedback& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline MotorFeedback* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  MotorFeedback* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const MotorFeedback& from);
+  void MergeFrom(const MotorFeedback& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(MotorFeedback* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // fixed32 motor_id = 1;
+  void clear_motor_id();
+  static const int kMotorIdFieldNumber = 1;
+  ::google::protobuf::uint32 motor_id() const;
+  void set_motor_id(::google::protobuf::uint32 value);
+
+  // float position = 4;
+  void clear_position();
+  static const int kPositionFieldNumber = 4;
+  float position() const;
+  void set_position(float value);
+
+  // float velocity = 5;
+  void clear_velocity();
+  static const int kVelocityFieldNumber = 5;
+  float velocity() const;
+  void set_velocity(float value);
+
+  // float current_motor = 7;
+  void clear_current_motor();
+  static const int kCurrentMotorFieldNumber = 7;
+  float current_motor() const;
+  void set_current_motor(float value);
+
+  // float voltage = 8;
+  void clear_voltage();
+  static const int kVoltageFieldNumber = 8;
+  float voltage() const;
+  void set_voltage(float value);
+
+  // float temperature_motor = 10;
+  void clear_temperature_motor();
+  static const int kTemperatureMotorFieldNumber = 10;
+  float temperature_motor() const;
+  void set_temperature_motor(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.GripperCyclic.MotorFeedback)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 motor_id_;
+  float position_;
+  float velocity_;
+  float current_motor_;
+  float voltage_;
+  float temperature_motor_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_GripperCyclicMessage_2eproto::TableStruct;
+  friend void ::protobuf_GripperCyclicMessage_2eproto::InitDefaultsMotorFeedbackImpl();
+};
+// -------------------------------------------------------------------
+
+class Feedback : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.GripperCyclic.Feedback) */ {
+ public:
+  Feedback();
+  virtual ~Feedback();
+
+  Feedback(const Feedback& from);
+
+  inline Feedback& operator=(const Feedback& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Feedback(Feedback&& from) noexcept
+    : Feedback() {
+    *this = ::std::move(from);
+  }
+
+  inline Feedback& operator=(Feedback&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Feedback& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Feedback* internal_default_instance() {
+    return reinterpret_cast<const Feedback*>(
+               &_Feedback_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    4;
+
+  void Swap(Feedback* other);
+  friend void swap(Feedback& a, Feedback& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Feedback* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Feedback* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Feedback& from);
+  void MergeFrom(const Feedback& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Feedback* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .Kinova.Api.GripperCyclic.MotorFeedback motor = 7;
+  int motor_size() const;
+  void clear_motor();
+  static const int kMotorFieldNumber = 7;
+  const ::Kinova::Api::GripperCyclic::MotorFeedback& motor(int index) const;
+  ::Kinova::Api::GripperCyclic::MotorFeedback* mutable_motor(int index);
+  ::Kinova::Api::GripperCyclic::MotorFeedback* add_motor();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::GripperCyclic::MotorFeedback >*
+      mutable_motor();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::GripperCyclic::MotorFeedback >&
+      motor() const;
+
+  // .Kinova.Api.GripperCyclic.MessageId feedback_id = 1;
+  bool has_feedback_id() const;
+  void clear_feedback_id();
+  static const int kFeedbackIdFieldNumber = 1;
+  const ::Kinova::Api::GripperCyclic::MessageId& feedback_id() const;
+  ::Kinova::Api::GripperCyclic::MessageId* release_feedback_id();
+  ::Kinova::Api::GripperCyclic::MessageId* mutable_feedback_id();
+  void set_allocated_feedback_id(::Kinova::Api::GripperCyclic::MessageId* feedback_id);
+
+  // fixed32 status_flags = 2;
+  void clear_status_flags();
+  static const int kStatusFlagsFieldNumber = 2;
+  ::google::protobuf::uint32 status_flags() const;
+  void set_status_flags(::google::protobuf::uint32 value);
+
+  // fixed32 fault_bank_a = 3;
+  void clear_fault_bank_a();
+  static const int kFaultBankAFieldNumber = 3;
+  ::google::protobuf::uint32 fault_bank_a() const;
+  void set_fault_bank_a(::google::protobuf::uint32 value);
+
+  // fixed32 fault_bank_b = 4;
+  void clear_fault_bank_b();
+  static const int kFaultBankBFieldNumber = 4;
+  ::google::protobuf::uint32 fault_bank_b() const;
+  void set_fault_bank_b(::google::protobuf::uint32 value);
+
+  // fixed32 warning_bank_a = 5;
+  void clear_warning_bank_a();
+  static const int kWarningBankAFieldNumber = 5;
+  ::google::protobuf::uint32 warning_bank_a() const;
+  void set_warning_bank_a(::google::protobuf::uint32 value);
+
+  // fixed32 warning_bank_b = 6;
+  void clear_warning_bank_b();
+  static const int kWarningBankBFieldNumber = 6;
+  ::google::protobuf::uint32 warning_bank_b() const;
+  void set_warning_bank_b(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.GripperCyclic.Feedback)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::GripperCyclic::MotorFeedback > motor_;
+  ::Kinova::Api::GripperCyclic::MessageId* feedback_id_;
+  ::google::protobuf::uint32 status_flags_;
+  ::google::protobuf::uint32 fault_bank_a_;
+  ::google::protobuf::uint32 fault_bank_b_;
+  ::google::protobuf::uint32 warning_bank_a_;
+  ::google::protobuf::uint32 warning_bank_b_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_GripperCyclicMessage_2eproto::TableStruct;
+  friend void ::protobuf_GripperCyclicMessage_2eproto::InitDefaultsFeedbackImpl();
+};
+// -------------------------------------------------------------------
+
+class CustomDataUnit : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.GripperCyclic.CustomDataUnit) */ {
+ public:
+  CustomDataUnit();
+  virtual ~CustomDataUnit();
+
+  CustomDataUnit(const CustomDataUnit& from);
+
+  inline CustomDataUnit& operator=(const CustomDataUnit& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  CustomDataUnit(CustomDataUnit&& from) noexcept
+    : CustomDataUnit() {
+    *this = ::std::move(from);
+  }
+
+  inline CustomDataUnit& operator=(CustomDataUnit&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const CustomDataUnit& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const CustomDataUnit* internal_default_instance() {
+    return reinterpret_cast<const CustomDataUnit*>(
+               &_CustomDataUnit_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    5;
+
+  void Swap(CustomDataUnit* other);
+  friend void swap(CustomDataUnit& a, CustomDataUnit& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline CustomDataUnit* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  CustomDataUnit* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const CustomDataUnit& from);
+  void MergeFrom(const CustomDataUnit& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(CustomDataUnit* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // fixed32 custom_data_0 = 1;
+  void clear_custom_data_0();
+  static const int kCustomData0FieldNumber = 1;
+  ::google::protobuf::uint32 custom_data_0() const;
+  void set_custom_data_0(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_1 = 2;
+  void clear_custom_data_1();
+  static const int kCustomData1FieldNumber = 2;
+  ::google::protobuf::uint32 custom_data_1() const;
+  void set_custom_data_1(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_2 = 3;
+  void clear_custom_data_2();
+  static const int kCustomData2FieldNumber = 3;
+  ::google::protobuf::uint32 custom_data_2() const;
+  void set_custom_data_2(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_3 = 4;
+  void clear_custom_data_3();
+  static const int kCustomData3FieldNumber = 4;
+  ::google::protobuf::uint32 custom_data_3() const;
+  void set_custom_data_3(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_4 = 5;
+  void clear_custom_data_4();
+  static const int kCustomData4FieldNumber = 5;
+  ::google::protobuf::uint32 custom_data_4() const;
+  void set_custom_data_4(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_5 = 6;
+  void clear_custom_data_5();
+  static const int kCustomData5FieldNumber = 6;
+  ::google::protobuf::uint32 custom_data_5() const;
+  void set_custom_data_5(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_6 = 7;
+  void clear_custom_data_6();
+  static const int kCustomData6FieldNumber = 7;
+  ::google::protobuf::uint32 custom_data_6() const;
+  void set_custom_data_6(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_7 = 8;
+  void clear_custom_data_7();
+  static const int kCustomData7FieldNumber = 8;
+  ::google::protobuf::uint32 custom_data_7() const;
+  void set_custom_data_7(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_8 = 9;
+  void clear_custom_data_8();
+  static const int kCustomData8FieldNumber = 9;
+  ::google::protobuf::uint32 custom_data_8() const;
+  void set_custom_data_8(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_9 = 10;
+  void clear_custom_data_9();
+  static const int kCustomData9FieldNumber = 10;
+  ::google::protobuf::uint32 custom_data_9() const;
+  void set_custom_data_9(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_10 = 11;
+  void clear_custom_data_10();
+  static const int kCustomData10FieldNumber = 11;
+  ::google::protobuf::uint32 custom_data_10() const;
+  void set_custom_data_10(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_11 = 12;
+  void clear_custom_data_11();
+  static const int kCustomData11FieldNumber = 12;
+  ::google::protobuf::uint32 custom_data_11() const;
+  void set_custom_data_11(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_12 = 13;
+  void clear_custom_data_12();
+  static const int kCustomData12FieldNumber = 13;
+  ::google::protobuf::uint32 custom_data_12() const;
+  void set_custom_data_12(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_13 = 14;
+  void clear_custom_data_13();
+  static const int kCustomData13FieldNumber = 14;
+  ::google::protobuf::uint32 custom_data_13() const;
+  void set_custom_data_13(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_14 = 15;
+  void clear_custom_data_14();
+  static const int kCustomData14FieldNumber = 15;
+  ::google::protobuf::uint32 custom_data_14() const;
+  void set_custom_data_14(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_15 = 16;
+  void clear_custom_data_15();
+  static const int kCustomData15FieldNumber = 16;
+  ::google::protobuf::uint32 custom_data_15() const;
+  void set_custom_data_15(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.GripperCyclic.CustomDataUnit)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 custom_data_0_;
+  ::google::protobuf::uint32 custom_data_1_;
+  ::google::protobuf::uint32 custom_data_2_;
+  ::google::protobuf::uint32 custom_data_3_;
+  ::google::protobuf::uint32 custom_data_4_;
+  ::google::protobuf::uint32 custom_data_5_;
+  ::google::protobuf::uint32 custom_data_6_;
+  ::google::protobuf::uint32 custom_data_7_;
+  ::google::protobuf::uint32 custom_data_8_;
+  ::google::protobuf::uint32 custom_data_9_;
+  ::google::protobuf::uint32 custom_data_10_;
+  ::google::protobuf::uint32 custom_data_11_;
+  ::google::protobuf::uint32 custom_data_12_;
+  ::google::protobuf::uint32 custom_data_13_;
+  ::google::protobuf::uint32 custom_data_14_;
+  ::google::protobuf::uint32 custom_data_15_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_GripperCyclicMessage_2eproto::TableStruct;
+  friend void ::protobuf_GripperCyclicMessage_2eproto::InitDefaultsCustomDataUnitImpl();
+};
+// -------------------------------------------------------------------
+
+class CustomData : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.GripperCyclic.CustomData) */ {
+ public:
+  CustomData();
+  virtual ~CustomData();
+
+  CustomData(const CustomData& from);
+
+  inline CustomData& operator=(const CustomData& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  CustomData(CustomData&& from) noexcept
+    : CustomData() {
+    *this = ::std::move(from);
+  }
+
+  inline CustomData& operator=(CustomData&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const CustomData& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const CustomData* internal_default_instance() {
+    return reinterpret_cast<const CustomData*>(
+               &_CustomData_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    6;
+
+  void Swap(CustomData* other);
+  friend void swap(CustomData& a, CustomData& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline CustomData* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  CustomData* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const CustomData& from);
+  void MergeFrom(const CustomData& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(CustomData* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .Kinova.Api.GripperCyclic.CustomDataUnit motor_custom_data = 3;
+  int motor_custom_data_size() const;
+  void clear_motor_custom_data();
+  static const int kMotorCustomDataFieldNumber = 3;
+  const ::Kinova::Api::GripperCyclic::CustomDataUnit& motor_custom_data(int index) const;
+  ::Kinova::Api::GripperCyclic::CustomDataUnit* mutable_motor_custom_data(int index);
+  ::Kinova::Api::GripperCyclic::CustomDataUnit* add_motor_custom_data();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::GripperCyclic::CustomDataUnit >*
+      mutable_motor_custom_data();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::GripperCyclic::CustomDataUnit >&
+      motor_custom_data() const;
+
+  // .Kinova.Api.GripperCyclic.MessageId custom_data_id = 1;
+  bool has_custom_data_id() const;
+  void clear_custom_data_id();
+  static const int kCustomDataIdFieldNumber = 1;
+  const ::Kinova::Api::GripperCyclic::MessageId& custom_data_id() const;
+  ::Kinova::Api::GripperCyclic::MessageId* release_custom_data_id();
+  ::Kinova::Api::GripperCyclic::MessageId* mutable_custom_data_id();
+  void set_allocated_custom_data_id(::Kinova::Api::GripperCyclic::MessageId* custom_data_id);
+
+  // .Kinova.Api.GripperCyclic.CustomDataUnit gripper_custom_data = 2;
+  bool has_gripper_custom_data() const;
+  void clear_gripper_custom_data();
+  static const int kGripperCustomDataFieldNumber = 2;
+  const ::Kinova::Api::GripperCyclic::CustomDataUnit& gripper_custom_data() const;
+  ::Kinova::Api::GripperCyclic::CustomDataUnit* release_gripper_custom_data();
+  ::Kinova::Api::GripperCyclic::CustomDataUnit* mutable_gripper_custom_data();
+  void set_allocated_gripper_custom_data(::Kinova::Api::GripperCyclic::CustomDataUnit* gripper_custom_data);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.GripperCyclic.CustomData)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::GripperCyclic::CustomDataUnit > motor_custom_data_;
+  ::Kinova::Api::GripperCyclic::MessageId* custom_data_id_;
+  ::Kinova::Api::GripperCyclic::CustomDataUnit* gripper_custom_data_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_GripperCyclicMessage_2eproto::TableStruct;
+  friend void ::protobuf_GripperCyclicMessage_2eproto::InitDefaultsCustomDataImpl();
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// MessageId
+
+// fixed32 identifier = 1;
+inline void MessageId::clear_identifier() {
+  identifier_ = 0u;
+}
+inline ::google::protobuf::uint32 MessageId::identifier() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.GripperCyclic.MessageId.identifier)
+  return identifier_;
+}
+inline void MessageId::set_identifier(::google::protobuf::uint32 value) {
+  
+  identifier_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.GripperCyclic.MessageId.identifier)
+}
+
+// -------------------------------------------------------------------
+
+// MotorCommand
+
+// fixed32 motor_id = 1;
+inline void MotorCommand::clear_motor_id() {
+  motor_id_ = 0u;
+}
+inline ::google::protobuf::uint32 MotorCommand::motor_id() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.GripperCyclic.MotorCommand.motor_id)
+  return motor_id_;
+}
+inline void MotorCommand::set_motor_id(::google::protobuf::uint32 value) {
+  
+  motor_id_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.GripperCyclic.MotorCommand.motor_id)
+}
+
+// float position = 3;
+inline void MotorCommand::clear_position() {
+  position_ = 0;
+}
+inline float MotorCommand::position() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.GripperCyclic.MotorCommand.position)
+  return position_;
+}
+inline void MotorCommand::set_position(float value) {
+  
+  position_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.GripperCyclic.MotorCommand.position)
+}
+
+// float velocity = 4;
+inline void MotorCommand::clear_velocity() {
+  velocity_ = 0;
+}
+inline float MotorCommand::velocity() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.GripperCyclic.MotorCommand.velocity)
+  return velocity_;
+}
+inline void MotorCommand::set_velocity(float value) {
+  
+  velocity_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.GripperCyclic.MotorCommand.velocity)
+}
+
+// float force = 5;
+inline void MotorCommand::clear_force() {
+  force_ = 0;
+}
+inline float MotorCommand::force() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.GripperCyclic.MotorCommand.force)
+  return force_;
+}
+inline void MotorCommand::set_force(float value) {
+  
+  force_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.GripperCyclic.MotorCommand.force)
+}
+
+// -------------------------------------------------------------------
+
+// Command
+
+// .Kinova.Api.GripperCyclic.MessageId command_id = 1;
+inline bool Command::has_command_id() const {
+  return this != internal_default_instance() && command_id_ != NULL;
+}
+inline void Command::clear_command_id() {
+  if (GetArenaNoVirtual() == NULL && command_id_ != NULL) {
+    delete command_id_;
+  }
+  command_id_ = NULL;
+}
+inline const ::Kinova::Api::GripperCyclic::MessageId& Command::command_id() const {
+  const ::Kinova::Api::GripperCyclic::MessageId* p = command_id_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.GripperCyclic.Command.command_id)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::GripperCyclic::MessageId*>(
+      &::Kinova::Api::GripperCyclic::_MessageId_default_instance_);
+}
+inline ::Kinova::Api::GripperCyclic::MessageId* Command::release_command_id() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.GripperCyclic.Command.command_id)
+  
+  ::Kinova::Api::GripperCyclic::MessageId* temp = command_id_;
+  command_id_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::GripperCyclic::MessageId* Command::mutable_command_id() {
+  
+  if (command_id_ == NULL) {
+    command_id_ = new ::Kinova::Api::GripperCyclic::MessageId;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.GripperCyclic.Command.command_id)
+  return command_id_;
+}
+inline void Command::set_allocated_command_id(::Kinova::Api::GripperCyclic::MessageId* command_id) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete command_id_;
+  }
+  if (command_id) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      command_id = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, command_id, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  command_id_ = command_id;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.GripperCyclic.Command.command_id)
+}
+
+// fixed32 flags = 2;
+inline void Command::clear_flags() {
+  flags_ = 0u;
+}
+inline ::google::protobuf::uint32 Command::flags() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.GripperCyclic.Command.flags)
+  return flags_;
+}
+inline void Command::set_flags(::google::protobuf::uint32 value) {
+  
+  flags_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.GripperCyclic.Command.flags)
+}
+
+// repeated .Kinova.Api.GripperCyclic.MotorCommand motor_cmd = 3;
+inline int Command::motor_cmd_size() const {
+  return motor_cmd_.size();
+}
+inline void Command::clear_motor_cmd() {
+  motor_cmd_.Clear();
+}
+inline const ::Kinova::Api::GripperCyclic::MotorCommand& Command::motor_cmd(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.GripperCyclic.Command.motor_cmd)
+  return motor_cmd_.Get(index);
+}
+inline ::Kinova::Api::GripperCyclic::MotorCommand* Command::mutable_motor_cmd(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.GripperCyclic.Command.motor_cmd)
+  return motor_cmd_.Mutable(index);
+}
+inline ::Kinova::Api::GripperCyclic::MotorCommand* Command::add_motor_cmd() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.GripperCyclic.Command.motor_cmd)
+  return motor_cmd_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::GripperCyclic::MotorCommand >*
+Command::mutable_motor_cmd() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.GripperCyclic.Command.motor_cmd)
+  return &motor_cmd_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::GripperCyclic::MotorCommand >&
+Command::motor_cmd() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.GripperCyclic.Command.motor_cmd)
+  return motor_cmd_;
+}
+
+// -------------------------------------------------------------------
+
+// MotorFeedback
+
+// fixed32 motor_id = 1;
+inline void MotorFeedback::clear_motor_id() {
+  motor_id_ = 0u;
+}
+inline ::google::protobuf::uint32 MotorFeedback::motor_id() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.GripperCyclic.MotorFeedback.motor_id)
+  return motor_id_;
+}
+inline void MotorFeedback::set_motor_id(::google::protobuf::uint32 value) {
+  
+  motor_id_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.GripperCyclic.MotorFeedback.motor_id)
+}
+
+// float position = 4;
+inline void MotorFeedback::clear_position() {
+  position_ = 0;
+}
+inline float MotorFeedback::position() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.GripperCyclic.MotorFeedback.position)
+  return position_;
+}
+inline void MotorFeedback::set_position(float value) {
+  
+  position_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.GripperCyclic.MotorFeedback.position)
+}
+
+// float velocity = 5;
+inline void MotorFeedback::clear_velocity() {
+  velocity_ = 0;
+}
+inline float MotorFeedback::velocity() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.GripperCyclic.MotorFeedback.velocity)
+  return velocity_;
+}
+inline void MotorFeedback::set_velocity(float value) {
+  
+  velocity_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.GripperCyclic.MotorFeedback.velocity)
+}
+
+// float current_motor = 7;
+inline void MotorFeedback::clear_current_motor() {
+  current_motor_ = 0;
+}
+inline float MotorFeedback::current_motor() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.GripperCyclic.MotorFeedback.current_motor)
+  return current_motor_;
+}
+inline void MotorFeedback::set_current_motor(float value) {
+  
+  current_motor_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.GripperCyclic.MotorFeedback.current_motor)
+}
+
+// float voltage = 8;
+inline void MotorFeedback::clear_voltage() {
+  voltage_ = 0;
+}
+inline float MotorFeedback::voltage() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.GripperCyclic.MotorFeedback.voltage)
+  return voltage_;
+}
+inline void MotorFeedback::set_voltage(float value) {
+  
+  voltage_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.GripperCyclic.MotorFeedback.voltage)
+}
+
+// float temperature_motor = 10;
+inline void MotorFeedback::clear_temperature_motor() {
+  temperature_motor_ = 0;
+}
+inline float MotorFeedback::temperature_motor() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.GripperCyclic.MotorFeedback.temperature_motor)
+  return temperature_motor_;
+}
+inline void MotorFeedback::set_temperature_motor(float value) {
+  
+  temperature_motor_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.GripperCyclic.MotorFeedback.temperature_motor)
+}
+
+// -------------------------------------------------------------------
+
+// Feedback
+
+// .Kinova.Api.GripperCyclic.MessageId feedback_id = 1;
+inline bool Feedback::has_feedback_id() const {
+  return this != internal_default_instance() && feedback_id_ != NULL;
+}
+inline void Feedback::clear_feedback_id() {
+  if (GetArenaNoVirtual() == NULL && feedback_id_ != NULL) {
+    delete feedback_id_;
+  }
+  feedback_id_ = NULL;
+}
+inline const ::Kinova::Api::GripperCyclic::MessageId& Feedback::feedback_id() const {
+  const ::Kinova::Api::GripperCyclic::MessageId* p = feedback_id_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.GripperCyclic.Feedback.feedback_id)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::GripperCyclic::MessageId*>(
+      &::Kinova::Api::GripperCyclic::_MessageId_default_instance_);
+}
+inline ::Kinova::Api::GripperCyclic::MessageId* Feedback::release_feedback_id() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.GripperCyclic.Feedback.feedback_id)
+  
+  ::Kinova::Api::GripperCyclic::MessageId* temp = feedback_id_;
+  feedback_id_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::GripperCyclic::MessageId* Feedback::mutable_feedback_id() {
+  
+  if (feedback_id_ == NULL) {
+    feedback_id_ = new ::Kinova::Api::GripperCyclic::MessageId;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.GripperCyclic.Feedback.feedback_id)
+  return feedback_id_;
+}
+inline void Feedback::set_allocated_feedback_id(::Kinova::Api::GripperCyclic::MessageId* feedback_id) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete feedback_id_;
+  }
+  if (feedback_id) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      feedback_id = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, feedback_id, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  feedback_id_ = feedback_id;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.GripperCyclic.Feedback.feedback_id)
+}
+
+// fixed32 status_flags = 2;
+inline void Feedback::clear_status_flags() {
+  status_flags_ = 0u;
+}
+inline ::google::protobuf::uint32 Feedback::status_flags() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.GripperCyclic.Feedback.status_flags)
+  return status_flags_;
+}
+inline void Feedback::set_status_flags(::google::protobuf::uint32 value) {
+  
+  status_flags_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.GripperCyclic.Feedback.status_flags)
+}
+
+// fixed32 fault_bank_a = 3;
+inline void Feedback::clear_fault_bank_a() {
+  fault_bank_a_ = 0u;
+}
+inline ::google::protobuf::uint32 Feedback::fault_bank_a() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.GripperCyclic.Feedback.fault_bank_a)
+  return fault_bank_a_;
+}
+inline void Feedback::set_fault_bank_a(::google::protobuf::uint32 value) {
+  
+  fault_bank_a_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.GripperCyclic.Feedback.fault_bank_a)
+}
+
+// fixed32 fault_bank_b = 4;
+inline void Feedback::clear_fault_bank_b() {
+  fault_bank_b_ = 0u;
+}
+inline ::google::protobuf::uint32 Feedback::fault_bank_b() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.GripperCyclic.Feedback.fault_bank_b)
+  return fault_bank_b_;
+}
+inline void Feedback::set_fault_bank_b(::google::protobuf::uint32 value) {
+  
+  fault_bank_b_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.GripperCyclic.Feedback.fault_bank_b)
+}
+
+// fixed32 warning_bank_a = 5;
+inline void Feedback::clear_warning_bank_a() {
+  warning_bank_a_ = 0u;
+}
+inline ::google::protobuf::uint32 Feedback::warning_bank_a() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.GripperCyclic.Feedback.warning_bank_a)
+  return warning_bank_a_;
+}
+inline void Feedback::set_warning_bank_a(::google::protobuf::uint32 value) {
+  
+  warning_bank_a_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.GripperCyclic.Feedback.warning_bank_a)
+}
+
+// fixed32 warning_bank_b = 6;
+inline void Feedback::clear_warning_bank_b() {
+  warning_bank_b_ = 0u;
+}
+inline ::google::protobuf::uint32 Feedback::warning_bank_b() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.GripperCyclic.Feedback.warning_bank_b)
+  return warning_bank_b_;
+}
+inline void Feedback::set_warning_bank_b(::google::protobuf::uint32 value) {
+  
+  warning_bank_b_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.GripperCyclic.Feedback.warning_bank_b)
+}
+
+// repeated .Kinova.Api.GripperCyclic.MotorFeedback motor = 7;
+inline int Feedback::motor_size() const {
+  return motor_.size();
+}
+inline void Feedback::clear_motor() {
+  motor_.Clear();
+}
+inline const ::Kinova::Api::GripperCyclic::MotorFeedback& Feedback::motor(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.GripperCyclic.Feedback.motor)
+  return motor_.Get(index);
+}
+inline ::Kinova::Api::GripperCyclic::MotorFeedback* Feedback::mutable_motor(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.GripperCyclic.Feedback.motor)
+  return motor_.Mutable(index);
+}
+inline ::Kinova::Api::GripperCyclic::MotorFeedback* Feedback::add_motor() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.GripperCyclic.Feedback.motor)
+  return motor_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::GripperCyclic::MotorFeedback >*
+Feedback::mutable_motor() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.GripperCyclic.Feedback.motor)
+  return &motor_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::GripperCyclic::MotorFeedback >&
+Feedback::motor() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.GripperCyclic.Feedback.motor)
+  return motor_;
+}
+
+// -------------------------------------------------------------------
+
+// CustomDataUnit
+
+// fixed32 custom_data_0 = 1;
+inline void CustomDataUnit::clear_custom_data_0() {
+  custom_data_0_ = 0u;
+}
+inline ::google::protobuf::uint32 CustomDataUnit::custom_data_0() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.GripperCyclic.CustomDataUnit.custom_data_0)
+  return custom_data_0_;
+}
+inline void CustomDataUnit::set_custom_data_0(::google::protobuf::uint32 value) {
+  
+  custom_data_0_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.GripperCyclic.CustomDataUnit.custom_data_0)
+}
+
+// fixed32 custom_data_1 = 2;
+inline void CustomDataUnit::clear_custom_data_1() {
+  custom_data_1_ = 0u;
+}
+inline ::google::protobuf::uint32 CustomDataUnit::custom_data_1() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.GripperCyclic.CustomDataUnit.custom_data_1)
+  return custom_data_1_;
+}
+inline void CustomDataUnit::set_custom_data_1(::google::protobuf::uint32 value) {
+  
+  custom_data_1_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.GripperCyclic.CustomDataUnit.custom_data_1)
+}
+
+// fixed32 custom_data_2 = 3;
+inline void CustomDataUnit::clear_custom_data_2() {
+  custom_data_2_ = 0u;
+}
+inline ::google::protobuf::uint32 CustomDataUnit::custom_data_2() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.GripperCyclic.CustomDataUnit.custom_data_2)
+  return custom_data_2_;
+}
+inline void CustomDataUnit::set_custom_data_2(::google::protobuf::uint32 value) {
+  
+  custom_data_2_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.GripperCyclic.CustomDataUnit.custom_data_2)
+}
+
+// fixed32 custom_data_3 = 4;
+inline void CustomDataUnit::clear_custom_data_3() {
+  custom_data_3_ = 0u;
+}
+inline ::google::protobuf::uint32 CustomDataUnit::custom_data_3() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.GripperCyclic.CustomDataUnit.custom_data_3)
+  return custom_data_3_;
+}
+inline void CustomDataUnit::set_custom_data_3(::google::protobuf::uint32 value) {
+  
+  custom_data_3_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.GripperCyclic.CustomDataUnit.custom_data_3)
+}
+
+// fixed32 custom_data_4 = 5;
+inline void CustomDataUnit::clear_custom_data_4() {
+  custom_data_4_ = 0u;
+}
+inline ::google::protobuf::uint32 CustomDataUnit::custom_data_4() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.GripperCyclic.CustomDataUnit.custom_data_4)
+  return custom_data_4_;
+}
+inline void CustomDataUnit::set_custom_data_4(::google::protobuf::uint32 value) {
+  
+  custom_data_4_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.GripperCyclic.CustomDataUnit.custom_data_4)
+}
+
+// fixed32 custom_data_5 = 6;
+inline void CustomDataUnit::clear_custom_data_5() {
+  custom_data_5_ = 0u;
+}
+inline ::google::protobuf::uint32 CustomDataUnit::custom_data_5() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.GripperCyclic.CustomDataUnit.custom_data_5)
+  return custom_data_5_;
+}
+inline void CustomDataUnit::set_custom_data_5(::google::protobuf::uint32 value) {
+  
+  custom_data_5_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.GripperCyclic.CustomDataUnit.custom_data_5)
+}
+
+// fixed32 custom_data_6 = 7;
+inline void CustomDataUnit::clear_custom_data_6() {
+  custom_data_6_ = 0u;
+}
+inline ::google::protobuf::uint32 CustomDataUnit::custom_data_6() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.GripperCyclic.CustomDataUnit.custom_data_6)
+  return custom_data_6_;
+}
+inline void CustomDataUnit::set_custom_data_6(::google::protobuf::uint32 value) {
+  
+  custom_data_6_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.GripperCyclic.CustomDataUnit.custom_data_6)
+}
+
+// fixed32 custom_data_7 = 8;
+inline void CustomDataUnit::clear_custom_data_7() {
+  custom_data_7_ = 0u;
+}
+inline ::google::protobuf::uint32 CustomDataUnit::custom_data_7() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.GripperCyclic.CustomDataUnit.custom_data_7)
+  return custom_data_7_;
+}
+inline void CustomDataUnit::set_custom_data_7(::google::protobuf::uint32 value) {
+  
+  custom_data_7_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.GripperCyclic.CustomDataUnit.custom_data_7)
+}
+
+// fixed32 custom_data_8 = 9;
+inline void CustomDataUnit::clear_custom_data_8() {
+  custom_data_8_ = 0u;
+}
+inline ::google::protobuf::uint32 CustomDataUnit::custom_data_8() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.GripperCyclic.CustomDataUnit.custom_data_8)
+  return custom_data_8_;
+}
+inline void CustomDataUnit::set_custom_data_8(::google::protobuf::uint32 value) {
+  
+  custom_data_8_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.GripperCyclic.CustomDataUnit.custom_data_8)
+}
+
+// fixed32 custom_data_9 = 10;
+inline void CustomDataUnit::clear_custom_data_9() {
+  custom_data_9_ = 0u;
+}
+inline ::google::protobuf::uint32 CustomDataUnit::custom_data_9() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.GripperCyclic.CustomDataUnit.custom_data_9)
+  return custom_data_9_;
+}
+inline void CustomDataUnit::set_custom_data_9(::google::protobuf::uint32 value) {
+  
+  custom_data_9_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.GripperCyclic.CustomDataUnit.custom_data_9)
+}
+
+// fixed32 custom_data_10 = 11;
+inline void CustomDataUnit::clear_custom_data_10() {
+  custom_data_10_ = 0u;
+}
+inline ::google::protobuf::uint32 CustomDataUnit::custom_data_10() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.GripperCyclic.CustomDataUnit.custom_data_10)
+  return custom_data_10_;
+}
+inline void CustomDataUnit::set_custom_data_10(::google::protobuf::uint32 value) {
+  
+  custom_data_10_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.GripperCyclic.CustomDataUnit.custom_data_10)
+}
+
+// fixed32 custom_data_11 = 12;
+inline void CustomDataUnit::clear_custom_data_11() {
+  custom_data_11_ = 0u;
+}
+inline ::google::protobuf::uint32 CustomDataUnit::custom_data_11() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.GripperCyclic.CustomDataUnit.custom_data_11)
+  return custom_data_11_;
+}
+inline void CustomDataUnit::set_custom_data_11(::google::protobuf::uint32 value) {
+  
+  custom_data_11_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.GripperCyclic.CustomDataUnit.custom_data_11)
+}
+
+// fixed32 custom_data_12 = 13;
+inline void CustomDataUnit::clear_custom_data_12() {
+  custom_data_12_ = 0u;
+}
+inline ::google::protobuf::uint32 CustomDataUnit::custom_data_12() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.GripperCyclic.CustomDataUnit.custom_data_12)
+  return custom_data_12_;
+}
+inline void CustomDataUnit::set_custom_data_12(::google::protobuf::uint32 value) {
+  
+  custom_data_12_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.GripperCyclic.CustomDataUnit.custom_data_12)
+}
+
+// fixed32 custom_data_13 = 14;
+inline void CustomDataUnit::clear_custom_data_13() {
+  custom_data_13_ = 0u;
+}
+inline ::google::protobuf::uint32 CustomDataUnit::custom_data_13() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.GripperCyclic.CustomDataUnit.custom_data_13)
+  return custom_data_13_;
+}
+inline void CustomDataUnit::set_custom_data_13(::google::protobuf::uint32 value) {
+  
+  custom_data_13_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.GripperCyclic.CustomDataUnit.custom_data_13)
+}
+
+// fixed32 custom_data_14 = 15;
+inline void CustomDataUnit::clear_custom_data_14() {
+  custom_data_14_ = 0u;
+}
+inline ::google::protobuf::uint32 CustomDataUnit::custom_data_14() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.GripperCyclic.CustomDataUnit.custom_data_14)
+  return custom_data_14_;
+}
+inline void CustomDataUnit::set_custom_data_14(::google::protobuf::uint32 value) {
+  
+  custom_data_14_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.GripperCyclic.CustomDataUnit.custom_data_14)
+}
+
+// fixed32 custom_data_15 = 16;
+inline void CustomDataUnit::clear_custom_data_15() {
+  custom_data_15_ = 0u;
+}
+inline ::google::protobuf::uint32 CustomDataUnit::custom_data_15() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.GripperCyclic.CustomDataUnit.custom_data_15)
+  return custom_data_15_;
+}
+inline void CustomDataUnit::set_custom_data_15(::google::protobuf::uint32 value) {
+  
+  custom_data_15_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.GripperCyclic.CustomDataUnit.custom_data_15)
+}
+
+// -------------------------------------------------------------------
+
+// CustomData
+
+// .Kinova.Api.GripperCyclic.MessageId custom_data_id = 1;
+inline bool CustomData::has_custom_data_id() const {
+  return this != internal_default_instance() && custom_data_id_ != NULL;
+}
+inline void CustomData::clear_custom_data_id() {
+  if (GetArenaNoVirtual() == NULL && custom_data_id_ != NULL) {
+    delete custom_data_id_;
+  }
+  custom_data_id_ = NULL;
+}
+inline const ::Kinova::Api::GripperCyclic::MessageId& CustomData::custom_data_id() const {
+  const ::Kinova::Api::GripperCyclic::MessageId* p = custom_data_id_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.GripperCyclic.CustomData.custom_data_id)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::GripperCyclic::MessageId*>(
+      &::Kinova::Api::GripperCyclic::_MessageId_default_instance_);
+}
+inline ::Kinova::Api::GripperCyclic::MessageId* CustomData::release_custom_data_id() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.GripperCyclic.CustomData.custom_data_id)
+  
+  ::Kinova::Api::GripperCyclic::MessageId* temp = custom_data_id_;
+  custom_data_id_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::GripperCyclic::MessageId* CustomData::mutable_custom_data_id() {
+  
+  if (custom_data_id_ == NULL) {
+    custom_data_id_ = new ::Kinova::Api::GripperCyclic::MessageId;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.GripperCyclic.CustomData.custom_data_id)
+  return custom_data_id_;
+}
+inline void CustomData::set_allocated_custom_data_id(::Kinova::Api::GripperCyclic::MessageId* custom_data_id) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete custom_data_id_;
+  }
+  if (custom_data_id) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      custom_data_id = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, custom_data_id, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  custom_data_id_ = custom_data_id;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.GripperCyclic.CustomData.custom_data_id)
+}
+
+// .Kinova.Api.GripperCyclic.CustomDataUnit gripper_custom_data = 2;
+inline bool CustomData::has_gripper_custom_data() const {
+  return this != internal_default_instance() && gripper_custom_data_ != NULL;
+}
+inline void CustomData::clear_gripper_custom_data() {
+  if (GetArenaNoVirtual() == NULL && gripper_custom_data_ != NULL) {
+    delete gripper_custom_data_;
+  }
+  gripper_custom_data_ = NULL;
+}
+inline const ::Kinova::Api::GripperCyclic::CustomDataUnit& CustomData::gripper_custom_data() const {
+  const ::Kinova::Api::GripperCyclic::CustomDataUnit* p = gripper_custom_data_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.GripperCyclic.CustomData.gripper_custom_data)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::GripperCyclic::CustomDataUnit*>(
+      &::Kinova::Api::GripperCyclic::_CustomDataUnit_default_instance_);
+}
+inline ::Kinova::Api::GripperCyclic::CustomDataUnit* CustomData::release_gripper_custom_data() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.GripperCyclic.CustomData.gripper_custom_data)
+  
+  ::Kinova::Api::GripperCyclic::CustomDataUnit* temp = gripper_custom_data_;
+  gripper_custom_data_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::GripperCyclic::CustomDataUnit* CustomData::mutable_gripper_custom_data() {
+  
+  if (gripper_custom_data_ == NULL) {
+    gripper_custom_data_ = new ::Kinova::Api::GripperCyclic::CustomDataUnit;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.GripperCyclic.CustomData.gripper_custom_data)
+  return gripper_custom_data_;
+}
+inline void CustomData::set_allocated_gripper_custom_data(::Kinova::Api::GripperCyclic::CustomDataUnit* gripper_custom_data) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete gripper_custom_data_;
+  }
+  if (gripper_custom_data) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      gripper_custom_data = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, gripper_custom_data, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  gripper_custom_data_ = gripper_custom_data;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.GripperCyclic.CustomData.gripper_custom_data)
+}
+
+// repeated .Kinova.Api.GripperCyclic.CustomDataUnit motor_custom_data = 3;
+inline int CustomData::motor_custom_data_size() const {
+  return motor_custom_data_.size();
+}
+inline void CustomData::clear_motor_custom_data() {
+  motor_custom_data_.Clear();
+}
+inline const ::Kinova::Api::GripperCyclic::CustomDataUnit& CustomData::motor_custom_data(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.GripperCyclic.CustomData.motor_custom_data)
+  return motor_custom_data_.Get(index);
+}
+inline ::Kinova::Api::GripperCyclic::CustomDataUnit* CustomData::mutable_motor_custom_data(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.GripperCyclic.CustomData.motor_custom_data)
+  return motor_custom_data_.Mutable(index);
+}
+inline ::Kinova::Api::GripperCyclic::CustomDataUnit* CustomData::add_motor_custom_data() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.GripperCyclic.CustomData.motor_custom_data)
+  return motor_custom_data_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::GripperCyclic::CustomDataUnit >*
+CustomData::mutable_motor_custom_data() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.GripperCyclic.CustomData.motor_custom_data)
+  return &motor_custom_data_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::GripperCyclic::CustomDataUnit >&
+CustomData::motor_custom_data() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.GripperCyclic.CustomData.motor_custom_data)
+  return motor_custom_data_;
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace GripperCyclic
+}  // namespace Api
+}  // namespace Kinova
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_GripperCyclicMessage_2eproto__INCLUDED
diff --git a/kortex_api/include/messages/InterconnectConfig.pb.h b/kortex_api/include/messages/InterconnectConfig.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..f9abccbdd033a46422b7a4a00807b650b26f6fa5
--- /dev/null
+++ b/kortex_api/include/messages/InterconnectConfig.pb.h
@@ -0,0 +1,2662 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: InterconnectConfig.proto
+
+#ifndef PROTOBUF_InterconnectConfig_2eproto__INCLUDED
+#define PROTOBUF_InterconnectConfig_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 3005000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 3005001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "Common.pb.h"  // IWYU pragma: export
+// @@protoc_insertion_point(includes)
+
+namespace protobuf_InterconnectConfig_2eproto {
+// Internal implementation detail -- do not use these members.
+struct TableStruct {
+  static const ::google::protobuf::internal::ParseTableField entries[];
+  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
+  static const ::google::protobuf::internal::ParseTable schema[12];
+  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
+  static const ::google::protobuf::internal::SerializationTable serialization_table[];
+  static const ::google::protobuf::uint32 offsets[];
+};
+void AddDescriptors();
+void InitDefaultsEthernetDeviceIdentificationImpl();
+void InitDefaultsEthernetDeviceIdentification();
+void InitDefaultsEthernetConfigurationImpl();
+void InitDefaultsEthernetConfiguration();
+void InitDefaultsGPIOIdentificationImpl();
+void InitDefaultsGPIOIdentification();
+void InitDefaultsGPIOConfigurationImpl();
+void InitDefaultsGPIOConfiguration();
+void InitDefaultsGPIOStateImpl();
+void InitDefaultsGPIOState();
+void InitDefaultsI2CDeviceIdentificationImpl();
+void InitDefaultsI2CDeviceIdentification();
+void InitDefaultsI2CConfigurationImpl();
+void InitDefaultsI2CConfiguration();
+void InitDefaultsI2CReadParameterImpl();
+void InitDefaultsI2CReadParameter();
+void InitDefaultsI2CReadRegisterParameterImpl();
+void InitDefaultsI2CReadRegisterParameter();
+void InitDefaultsI2CWriteParameterImpl();
+void InitDefaultsI2CWriteParameter();
+void InitDefaultsI2CWriteRegisterParameterImpl();
+void InitDefaultsI2CWriteRegisterParameter();
+void InitDefaultsI2CDataImpl();
+void InitDefaultsI2CData();
+inline void InitDefaults() {
+  InitDefaultsEthernetDeviceIdentification();
+  InitDefaultsEthernetConfiguration();
+  InitDefaultsGPIOIdentification();
+  InitDefaultsGPIOConfiguration();
+  InitDefaultsGPIOState();
+  InitDefaultsI2CDeviceIdentification();
+  InitDefaultsI2CConfiguration();
+  InitDefaultsI2CReadParameter();
+  InitDefaultsI2CReadRegisterParameter();
+  InitDefaultsI2CWriteParameter();
+  InitDefaultsI2CWriteRegisterParameter();
+  InitDefaultsI2CData();
+}
+}  // namespace protobuf_InterconnectConfig_2eproto
+namespace Kinova {
+namespace Api {
+namespace InterconnectConfig {
+class EthernetConfiguration;
+class EthernetConfigurationDefaultTypeInternal;
+extern EthernetConfigurationDefaultTypeInternal _EthernetConfiguration_default_instance_;
+class EthernetDeviceIdentification;
+class EthernetDeviceIdentificationDefaultTypeInternal;
+extern EthernetDeviceIdentificationDefaultTypeInternal _EthernetDeviceIdentification_default_instance_;
+class GPIOConfiguration;
+class GPIOConfigurationDefaultTypeInternal;
+extern GPIOConfigurationDefaultTypeInternal _GPIOConfiguration_default_instance_;
+class GPIOIdentification;
+class GPIOIdentificationDefaultTypeInternal;
+extern GPIOIdentificationDefaultTypeInternal _GPIOIdentification_default_instance_;
+class GPIOState;
+class GPIOStateDefaultTypeInternal;
+extern GPIOStateDefaultTypeInternal _GPIOState_default_instance_;
+class I2CConfiguration;
+class I2CConfigurationDefaultTypeInternal;
+extern I2CConfigurationDefaultTypeInternal _I2CConfiguration_default_instance_;
+class I2CData;
+class I2CDataDefaultTypeInternal;
+extern I2CDataDefaultTypeInternal _I2CData_default_instance_;
+class I2CDeviceIdentification;
+class I2CDeviceIdentificationDefaultTypeInternal;
+extern I2CDeviceIdentificationDefaultTypeInternal _I2CDeviceIdentification_default_instance_;
+class I2CReadParameter;
+class I2CReadParameterDefaultTypeInternal;
+extern I2CReadParameterDefaultTypeInternal _I2CReadParameter_default_instance_;
+class I2CReadRegisterParameter;
+class I2CReadRegisterParameterDefaultTypeInternal;
+extern I2CReadRegisterParameterDefaultTypeInternal _I2CReadRegisterParameter_default_instance_;
+class I2CWriteParameter;
+class I2CWriteParameterDefaultTypeInternal;
+extern I2CWriteParameterDefaultTypeInternal _I2CWriteParameter_default_instance_;
+class I2CWriteRegisterParameter;
+class I2CWriteRegisterParameterDefaultTypeInternal;
+extern I2CWriteRegisterParameterDefaultTypeInternal _I2CWriteRegisterParameter_default_instance_;
+}  // namespace InterconnectConfig
+}  // namespace Api
+}  // namespace Kinova
+namespace Kinova {
+namespace Api {
+namespace InterconnectConfig {
+
+enum ServiceVersion {
+  RESERVED_0 = 0,
+  CURRENT_VERSION = 1,
+  ServiceVersion_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  ServiceVersion_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool ServiceVersion_IsValid(int value);
+const ServiceVersion ServiceVersion_MIN = RESERVED_0;
+const ServiceVersion ServiceVersion_MAX = CURRENT_VERSION;
+const int ServiceVersion_ARRAYSIZE = ServiceVersion_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* ServiceVersion_descriptor();
+inline const ::std::string& ServiceVersion_Name(ServiceVersion value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    ServiceVersion_descriptor(), value);
+}
+inline bool ServiceVersion_Parse(
+    const ::std::string& name, ServiceVersion* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<ServiceVersion>(
+    ServiceVersion_descriptor(), name, value);
+}
+enum SafetyIdentifier {
+  UNSPECIFIED_INTERCONNECT_SAFETY_IDENTIFIER = 0,
+  MAXIMUM_MOTOR_CURRENT = 1,
+  MAXIMUM_VOLTAGE = 2,
+  MINIMUM_VOLTAGE = 4,
+  MAXIMUM_MOTOR_TEMPERATURE = 8,
+  MAXIMUM_CORE_TEMPERATURE = 16,
+  NON_VOLATILE_MEMORY_CORRUPTED = 32,
+  EMERGENCY_LINE_ASSERTED = 64,
+  COMMUNICATION_TICK_LOST = 128,
+  WATCHDOG_TRIGGERED = 256,
+  SafetyIdentifier_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  SafetyIdentifier_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool SafetyIdentifier_IsValid(int value);
+const SafetyIdentifier SafetyIdentifier_MIN = UNSPECIFIED_INTERCONNECT_SAFETY_IDENTIFIER;
+const SafetyIdentifier SafetyIdentifier_MAX = WATCHDOG_TRIGGERED;
+const int SafetyIdentifier_ARRAYSIZE = SafetyIdentifier_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* SafetyIdentifier_descriptor();
+inline const ::std::string& SafetyIdentifier_Name(SafetyIdentifier value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    SafetyIdentifier_descriptor(), value);
+}
+inline bool SafetyIdentifier_Parse(
+    const ::std::string& name, SafetyIdentifier* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<SafetyIdentifier>(
+    SafetyIdentifier_descriptor(), name, value);
+}
+enum UARTPortId {
+  UART_PORT_UNSPECIFIED = 0,
+  UART_PORT_EXPANSION = 1,
+  UARTPortId_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  UARTPortId_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool UARTPortId_IsValid(int value);
+const UARTPortId UARTPortId_MIN = UART_PORT_UNSPECIFIED;
+const UARTPortId UARTPortId_MAX = UART_PORT_EXPANSION;
+const int UARTPortId_ARRAYSIZE = UARTPortId_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* UARTPortId_descriptor();
+inline const ::std::string& UARTPortId_Name(UARTPortId value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    UARTPortId_descriptor(), value);
+}
+inline bool UARTPortId_Parse(
+    const ::std::string& name, UARTPortId* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<UARTPortId>(
+    UARTPortId_descriptor(), name, value);
+}
+enum EthernetDevice {
+  ETHERNET_DEVICE_UNSPECIFIED = 0,
+  ETHERNET_DEVICE_EXPANSION = 1,
+  EthernetDevice_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  EthernetDevice_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool EthernetDevice_IsValid(int value);
+const EthernetDevice EthernetDevice_MIN = ETHERNET_DEVICE_UNSPECIFIED;
+const EthernetDevice EthernetDevice_MAX = ETHERNET_DEVICE_EXPANSION;
+const int EthernetDevice_ARRAYSIZE = EthernetDevice_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* EthernetDevice_descriptor();
+inline const ::std::string& EthernetDevice_Name(EthernetDevice value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    EthernetDevice_descriptor(), value);
+}
+inline bool EthernetDevice_Parse(
+    const ::std::string& name, EthernetDevice* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<EthernetDevice>(
+    EthernetDevice_descriptor(), name, value);
+}
+enum EthernetSpeed {
+  ETHERNET_SPEED_UNSPECIFIED = 0,
+  ETHERNET_SPEED_10M = 1,
+  ETHERNET_SPEED_100M = 2,
+  EthernetSpeed_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  EthernetSpeed_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool EthernetSpeed_IsValid(int value);
+const EthernetSpeed EthernetSpeed_MIN = ETHERNET_SPEED_UNSPECIFIED;
+const EthernetSpeed EthernetSpeed_MAX = ETHERNET_SPEED_100M;
+const int EthernetSpeed_ARRAYSIZE = EthernetSpeed_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* EthernetSpeed_descriptor();
+inline const ::std::string& EthernetSpeed_Name(EthernetSpeed value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    EthernetSpeed_descriptor(), value);
+}
+inline bool EthernetSpeed_Parse(
+    const ::std::string& name, EthernetSpeed* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<EthernetSpeed>(
+    EthernetSpeed_descriptor(), name, value);
+}
+enum EthernetDuplex {
+  ETHERNET_DUPLEX_UNSPECIFIED = 0,
+  ETHERNET_DUPLEX_HALF = 1,
+  ETHERNET_DUPLEX_FULL = 2,
+  EthernetDuplex_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  EthernetDuplex_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool EthernetDuplex_IsValid(int value);
+const EthernetDuplex EthernetDuplex_MIN = ETHERNET_DUPLEX_UNSPECIFIED;
+const EthernetDuplex EthernetDuplex_MAX = ETHERNET_DUPLEX_FULL;
+const int EthernetDuplex_ARRAYSIZE = EthernetDuplex_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* EthernetDuplex_descriptor();
+inline const ::std::string& EthernetDuplex_Name(EthernetDuplex value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    EthernetDuplex_descriptor(), value);
+}
+inline bool EthernetDuplex_Parse(
+    const ::std::string& name, EthernetDuplex* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<EthernetDuplex>(
+    EthernetDuplex_descriptor(), name, value);
+}
+enum GPIOIdentifier {
+  GPIO_IDENTIFIER_UNSPECIFIED = 0,
+  GPIO_IDENTIFIER_1 = 1,
+  GPIO_IDENTIFIER_2 = 2,
+  GPIO_IDENTIFIER_3 = 3,
+  GPIO_IDENTIFIER_4 = 4,
+  GPIOIdentifier_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  GPIOIdentifier_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool GPIOIdentifier_IsValid(int value);
+const GPIOIdentifier GPIOIdentifier_MIN = GPIO_IDENTIFIER_UNSPECIFIED;
+const GPIOIdentifier GPIOIdentifier_MAX = GPIO_IDENTIFIER_4;
+const int GPIOIdentifier_ARRAYSIZE = GPIOIdentifier_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* GPIOIdentifier_descriptor();
+inline const ::std::string& GPIOIdentifier_Name(GPIOIdentifier value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    GPIOIdentifier_descriptor(), value);
+}
+inline bool GPIOIdentifier_Parse(
+    const ::std::string& name, GPIOIdentifier* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<GPIOIdentifier>(
+    GPIOIdentifier_descriptor(), name, value);
+}
+enum GPIOMode {
+  GPIO_MODE_UNSPECIFIED = 0,
+  GPIO_MODE_INPUT_FLOATING = 1,
+  GPIO_MODE_OUTPUT_PUSH_PULL = 2,
+  GPIO_MODE_OUTPUT_OPEN_DRAIN = 3,
+  GPIOMode_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  GPIOMode_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool GPIOMode_IsValid(int value);
+const GPIOMode GPIOMode_MIN = GPIO_MODE_UNSPECIFIED;
+const GPIOMode GPIOMode_MAX = GPIO_MODE_OUTPUT_OPEN_DRAIN;
+const int GPIOMode_ARRAYSIZE = GPIOMode_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* GPIOMode_descriptor();
+inline const ::std::string& GPIOMode_Name(GPIOMode value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    GPIOMode_descriptor(), value);
+}
+inline bool GPIOMode_Parse(
+    const ::std::string& name, GPIOMode* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<GPIOMode>(
+    GPIOMode_descriptor(), name, value);
+}
+enum GPIOPull {
+  GPIO_PULL_UNSPECIFIED = 0,
+  GPIO_PULL_NONE = 1,
+  GPIO_PULL_UP = 2,
+  GPIO_PULL_DOWN = 3,
+  GPIOPull_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  GPIOPull_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool GPIOPull_IsValid(int value);
+const GPIOPull GPIOPull_MIN = GPIO_PULL_UNSPECIFIED;
+const GPIOPull GPIOPull_MAX = GPIO_PULL_DOWN;
+const int GPIOPull_ARRAYSIZE = GPIOPull_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* GPIOPull_descriptor();
+inline const ::std::string& GPIOPull_Name(GPIOPull value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    GPIOPull_descriptor(), value);
+}
+inline bool GPIOPull_Parse(
+    const ::std::string& name, GPIOPull* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<GPIOPull>(
+    GPIOPull_descriptor(), name, value);
+}
+enum GPIOValue {
+  GPIO_VALUE_UNSPECIFIED = 0,
+  GPIO_VALUE_LOW = 1,
+  GPIO_VALUE_HIGH = 2,
+  GPIOValue_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  GPIOValue_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool GPIOValue_IsValid(int value);
+const GPIOValue GPIOValue_MIN = GPIO_VALUE_UNSPECIFIED;
+const GPIOValue GPIOValue_MAX = GPIO_VALUE_HIGH;
+const int GPIOValue_ARRAYSIZE = GPIOValue_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* GPIOValue_descriptor();
+inline const ::std::string& GPIOValue_Name(GPIOValue value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    GPIOValue_descriptor(), value);
+}
+inline bool GPIOValue_Parse(
+    const ::std::string& name, GPIOValue* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<GPIOValue>(
+    GPIOValue_descriptor(), name, value);
+}
+enum I2CDevice {
+  I2C_DEVICE_UNSPECIFIED = 0,
+  I2C_DEVICE_EXPANSION = 1,
+  I2CDevice_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  I2CDevice_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool I2CDevice_IsValid(int value);
+const I2CDevice I2CDevice_MIN = I2C_DEVICE_UNSPECIFIED;
+const I2CDevice I2CDevice_MAX = I2C_DEVICE_EXPANSION;
+const int I2CDevice_ARRAYSIZE = I2CDevice_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* I2CDevice_descriptor();
+inline const ::std::string& I2CDevice_Name(I2CDevice value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    I2CDevice_descriptor(), value);
+}
+inline bool I2CDevice_Parse(
+    const ::std::string& name, I2CDevice* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<I2CDevice>(
+    I2CDevice_descriptor(), name, value);
+}
+enum I2CMode {
+  I2C_MODE_UNSPECIFIED = 0,
+  I2C_MODE_STANDARD = 1,
+  I2C_MODE_FAST = 2,
+  I2C_MODE_FAST_PLUS = 3,
+  I2CMode_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  I2CMode_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool I2CMode_IsValid(int value);
+const I2CMode I2CMode_MIN = I2C_MODE_UNSPECIFIED;
+const I2CMode I2CMode_MAX = I2C_MODE_FAST_PLUS;
+const int I2CMode_ARRAYSIZE = I2CMode_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* I2CMode_descriptor();
+inline const ::std::string& I2CMode_Name(I2CMode value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    I2CMode_descriptor(), value);
+}
+inline bool I2CMode_Parse(
+    const ::std::string& name, I2CMode* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<I2CMode>(
+    I2CMode_descriptor(), name, value);
+}
+enum I2CDeviceAddressing {
+  I2C_DEVICE_ADDRESSING_UNSPECIFIED = 0,
+  I2C_DEVICE_ADDRESSING_7_BITS = 1,
+  I2C_DEVICE_ADDRESSING_10_BITS = 2,
+  I2CDeviceAddressing_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  I2CDeviceAddressing_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool I2CDeviceAddressing_IsValid(int value);
+const I2CDeviceAddressing I2CDeviceAddressing_MIN = I2C_DEVICE_ADDRESSING_UNSPECIFIED;
+const I2CDeviceAddressing I2CDeviceAddressing_MAX = I2C_DEVICE_ADDRESSING_10_BITS;
+const int I2CDeviceAddressing_ARRAYSIZE = I2CDeviceAddressing_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* I2CDeviceAddressing_descriptor();
+inline const ::std::string& I2CDeviceAddressing_Name(I2CDeviceAddressing value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    I2CDeviceAddressing_descriptor(), value);
+}
+inline bool I2CDeviceAddressing_Parse(
+    const ::std::string& name, I2CDeviceAddressing* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<I2CDeviceAddressing>(
+    I2CDeviceAddressing_descriptor(), name, value);
+}
+enum I2CRegisterAddressSize {
+  I2C_REGISTER_ADDRESS_SIZE_UNSPECIFIED = 0,
+  I2C_REGISTER_ADDRESS_SIZE_8_BITS = 1,
+  I2C_REGISTER_ADDRESS_SIZE_16_BITS = 2,
+  I2CRegisterAddressSize_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  I2CRegisterAddressSize_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool I2CRegisterAddressSize_IsValid(int value);
+const I2CRegisterAddressSize I2CRegisterAddressSize_MIN = I2C_REGISTER_ADDRESS_SIZE_UNSPECIFIED;
+const I2CRegisterAddressSize I2CRegisterAddressSize_MAX = I2C_REGISTER_ADDRESS_SIZE_16_BITS;
+const int I2CRegisterAddressSize_ARRAYSIZE = I2CRegisterAddressSize_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* I2CRegisterAddressSize_descriptor();
+inline const ::std::string& I2CRegisterAddressSize_Name(I2CRegisterAddressSize value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    I2CRegisterAddressSize_descriptor(), value);
+}
+inline bool I2CRegisterAddressSize_Parse(
+    const ::std::string& name, I2CRegisterAddressSize* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<I2CRegisterAddressSize>(
+    I2CRegisterAddressSize_descriptor(), name, value);
+}
+// ===================================================================
+
+class EthernetDeviceIdentification : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.InterconnectConfig.EthernetDeviceIdentification) */ {
+ public:
+  EthernetDeviceIdentification();
+  virtual ~EthernetDeviceIdentification();
+
+  EthernetDeviceIdentification(const EthernetDeviceIdentification& from);
+
+  inline EthernetDeviceIdentification& operator=(const EthernetDeviceIdentification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  EthernetDeviceIdentification(EthernetDeviceIdentification&& from) noexcept
+    : EthernetDeviceIdentification() {
+    *this = ::std::move(from);
+  }
+
+  inline EthernetDeviceIdentification& operator=(EthernetDeviceIdentification&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const EthernetDeviceIdentification& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const EthernetDeviceIdentification* internal_default_instance() {
+    return reinterpret_cast<const EthernetDeviceIdentification*>(
+               &_EthernetDeviceIdentification_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    0;
+
+  void Swap(EthernetDeviceIdentification* other);
+  friend void swap(EthernetDeviceIdentification& a, EthernetDeviceIdentification& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline EthernetDeviceIdentification* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  EthernetDeviceIdentification* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const EthernetDeviceIdentification& from);
+  void MergeFrom(const EthernetDeviceIdentification& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(EthernetDeviceIdentification* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.InterconnectConfig.EthernetDevice device = 1;
+  void clear_device();
+  static const int kDeviceFieldNumber = 1;
+  ::Kinova::Api::InterconnectConfig::EthernetDevice device() const;
+  void set_device(::Kinova::Api::InterconnectConfig::EthernetDevice value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.InterconnectConfig.EthernetDeviceIdentification)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  int device_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_InterconnectConfig_2eproto::TableStruct;
+  friend void ::protobuf_InterconnectConfig_2eproto::InitDefaultsEthernetDeviceIdentificationImpl();
+};
+// -------------------------------------------------------------------
+
+class EthernetConfiguration : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.InterconnectConfig.EthernetConfiguration) */ {
+ public:
+  EthernetConfiguration();
+  virtual ~EthernetConfiguration();
+
+  EthernetConfiguration(const EthernetConfiguration& from);
+
+  inline EthernetConfiguration& operator=(const EthernetConfiguration& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  EthernetConfiguration(EthernetConfiguration&& from) noexcept
+    : EthernetConfiguration() {
+    *this = ::std::move(from);
+  }
+
+  inline EthernetConfiguration& operator=(EthernetConfiguration&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const EthernetConfiguration& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const EthernetConfiguration* internal_default_instance() {
+    return reinterpret_cast<const EthernetConfiguration*>(
+               &_EthernetConfiguration_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    1;
+
+  void Swap(EthernetConfiguration* other);
+  friend void swap(EthernetConfiguration& a, EthernetConfiguration& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline EthernetConfiguration* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  EthernetConfiguration* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const EthernetConfiguration& from);
+  void MergeFrom(const EthernetConfiguration& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(EthernetConfiguration* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.InterconnectConfig.EthernetDevice device = 1;
+  void clear_device();
+  static const int kDeviceFieldNumber = 1;
+  ::Kinova::Api::InterconnectConfig::EthernetDevice device() const;
+  void set_device(::Kinova::Api::InterconnectConfig::EthernetDevice value);
+
+  // bool enabled = 2;
+  void clear_enabled();
+  static const int kEnabledFieldNumber = 2;
+  bool enabled() const;
+  void set_enabled(bool value);
+
+  // .Kinova.Api.InterconnectConfig.EthernetSpeed speed = 3;
+  void clear_speed();
+  static const int kSpeedFieldNumber = 3;
+  ::Kinova::Api::InterconnectConfig::EthernetSpeed speed() const;
+  void set_speed(::Kinova::Api::InterconnectConfig::EthernetSpeed value);
+
+  // .Kinova.Api.InterconnectConfig.EthernetDuplex duplex = 4;
+  void clear_duplex();
+  static const int kDuplexFieldNumber = 4;
+  ::Kinova::Api::InterconnectConfig::EthernetDuplex duplex() const;
+  void set_duplex(::Kinova::Api::InterconnectConfig::EthernetDuplex value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.InterconnectConfig.EthernetConfiguration)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  int device_;
+  bool enabled_;
+  int speed_;
+  int duplex_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_InterconnectConfig_2eproto::TableStruct;
+  friend void ::protobuf_InterconnectConfig_2eproto::InitDefaultsEthernetConfigurationImpl();
+};
+// -------------------------------------------------------------------
+
+class GPIOIdentification : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.InterconnectConfig.GPIOIdentification) */ {
+ public:
+  GPIOIdentification();
+  virtual ~GPIOIdentification();
+
+  GPIOIdentification(const GPIOIdentification& from);
+
+  inline GPIOIdentification& operator=(const GPIOIdentification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  GPIOIdentification(GPIOIdentification&& from) noexcept
+    : GPIOIdentification() {
+    *this = ::std::move(from);
+  }
+
+  inline GPIOIdentification& operator=(GPIOIdentification&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const GPIOIdentification& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const GPIOIdentification* internal_default_instance() {
+    return reinterpret_cast<const GPIOIdentification*>(
+               &_GPIOIdentification_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    2;
+
+  void Swap(GPIOIdentification* other);
+  friend void swap(GPIOIdentification& a, GPIOIdentification& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline GPIOIdentification* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  GPIOIdentification* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const GPIOIdentification& from);
+  void MergeFrom(const GPIOIdentification& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(GPIOIdentification* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.InterconnectConfig.GPIOIdentifier identifier = 1;
+  void clear_identifier();
+  static const int kIdentifierFieldNumber = 1;
+  ::Kinova::Api::InterconnectConfig::GPIOIdentifier identifier() const;
+  void set_identifier(::Kinova::Api::InterconnectConfig::GPIOIdentifier value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.InterconnectConfig.GPIOIdentification)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  int identifier_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_InterconnectConfig_2eproto::TableStruct;
+  friend void ::protobuf_InterconnectConfig_2eproto::InitDefaultsGPIOIdentificationImpl();
+};
+// -------------------------------------------------------------------
+
+class GPIOConfiguration : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.InterconnectConfig.GPIOConfiguration) */ {
+ public:
+  GPIOConfiguration();
+  virtual ~GPIOConfiguration();
+
+  GPIOConfiguration(const GPIOConfiguration& from);
+
+  inline GPIOConfiguration& operator=(const GPIOConfiguration& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  GPIOConfiguration(GPIOConfiguration&& from) noexcept
+    : GPIOConfiguration() {
+    *this = ::std::move(from);
+  }
+
+  inline GPIOConfiguration& operator=(GPIOConfiguration&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const GPIOConfiguration& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const GPIOConfiguration* internal_default_instance() {
+    return reinterpret_cast<const GPIOConfiguration*>(
+               &_GPIOConfiguration_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    3;
+
+  void Swap(GPIOConfiguration* other);
+  friend void swap(GPIOConfiguration& a, GPIOConfiguration& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline GPIOConfiguration* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  GPIOConfiguration* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const GPIOConfiguration& from);
+  void MergeFrom(const GPIOConfiguration& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(GPIOConfiguration* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.InterconnectConfig.GPIOIdentifier identifier = 1;
+  void clear_identifier();
+  static const int kIdentifierFieldNumber = 1;
+  ::Kinova::Api::InterconnectConfig::GPIOIdentifier identifier() const;
+  void set_identifier(::Kinova::Api::InterconnectConfig::GPIOIdentifier value);
+
+  // .Kinova.Api.InterconnectConfig.GPIOMode mode = 2;
+  void clear_mode();
+  static const int kModeFieldNumber = 2;
+  ::Kinova::Api::InterconnectConfig::GPIOMode mode() const;
+  void set_mode(::Kinova::Api::InterconnectConfig::GPIOMode value);
+
+  // .Kinova.Api.InterconnectConfig.GPIOPull pull = 3;
+  void clear_pull();
+  static const int kPullFieldNumber = 3;
+  ::Kinova::Api::InterconnectConfig::GPIOPull pull() const;
+  void set_pull(::Kinova::Api::InterconnectConfig::GPIOPull value);
+
+  // .Kinova.Api.InterconnectConfig.GPIOValue default_value = 4;
+  void clear_default_value();
+  static const int kDefaultValueFieldNumber = 4;
+  ::Kinova::Api::InterconnectConfig::GPIOValue default_value() const;
+  void set_default_value(::Kinova::Api::InterconnectConfig::GPIOValue value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.InterconnectConfig.GPIOConfiguration)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  int identifier_;
+  int mode_;
+  int pull_;
+  int default_value_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_InterconnectConfig_2eproto::TableStruct;
+  friend void ::protobuf_InterconnectConfig_2eproto::InitDefaultsGPIOConfigurationImpl();
+};
+// -------------------------------------------------------------------
+
+class GPIOState : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.InterconnectConfig.GPIOState) */ {
+ public:
+  GPIOState();
+  virtual ~GPIOState();
+
+  GPIOState(const GPIOState& from);
+
+  inline GPIOState& operator=(const GPIOState& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  GPIOState(GPIOState&& from) noexcept
+    : GPIOState() {
+    *this = ::std::move(from);
+  }
+
+  inline GPIOState& operator=(GPIOState&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const GPIOState& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const GPIOState* internal_default_instance() {
+    return reinterpret_cast<const GPIOState*>(
+               &_GPIOState_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    4;
+
+  void Swap(GPIOState* other);
+  friend void swap(GPIOState& a, GPIOState& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline GPIOState* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  GPIOState* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const GPIOState& from);
+  void MergeFrom(const GPIOState& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(GPIOState* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.InterconnectConfig.GPIOIdentifier identifier = 1;
+  void clear_identifier();
+  static const int kIdentifierFieldNumber = 1;
+  ::Kinova::Api::InterconnectConfig::GPIOIdentifier identifier() const;
+  void set_identifier(::Kinova::Api::InterconnectConfig::GPIOIdentifier value);
+
+  // .Kinova.Api.InterconnectConfig.GPIOValue value = 2;
+  void clear_value();
+  static const int kValueFieldNumber = 2;
+  ::Kinova::Api::InterconnectConfig::GPIOValue value() const;
+  void set_value(::Kinova::Api::InterconnectConfig::GPIOValue value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.InterconnectConfig.GPIOState)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  int identifier_;
+  int value_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_InterconnectConfig_2eproto::TableStruct;
+  friend void ::protobuf_InterconnectConfig_2eproto::InitDefaultsGPIOStateImpl();
+};
+// -------------------------------------------------------------------
+
+class I2CDeviceIdentification : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.InterconnectConfig.I2CDeviceIdentification) */ {
+ public:
+  I2CDeviceIdentification();
+  virtual ~I2CDeviceIdentification();
+
+  I2CDeviceIdentification(const I2CDeviceIdentification& from);
+
+  inline I2CDeviceIdentification& operator=(const I2CDeviceIdentification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  I2CDeviceIdentification(I2CDeviceIdentification&& from) noexcept
+    : I2CDeviceIdentification() {
+    *this = ::std::move(from);
+  }
+
+  inline I2CDeviceIdentification& operator=(I2CDeviceIdentification&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const I2CDeviceIdentification& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const I2CDeviceIdentification* internal_default_instance() {
+    return reinterpret_cast<const I2CDeviceIdentification*>(
+               &_I2CDeviceIdentification_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    5;
+
+  void Swap(I2CDeviceIdentification* other);
+  friend void swap(I2CDeviceIdentification& a, I2CDeviceIdentification& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline I2CDeviceIdentification* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  I2CDeviceIdentification* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const I2CDeviceIdentification& from);
+  void MergeFrom(const I2CDeviceIdentification& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(I2CDeviceIdentification* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.InterconnectConfig.I2CDevice device = 1;
+  void clear_device();
+  static const int kDeviceFieldNumber = 1;
+  ::Kinova::Api::InterconnectConfig::I2CDevice device() const;
+  void set_device(::Kinova::Api::InterconnectConfig::I2CDevice value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.InterconnectConfig.I2CDeviceIdentification)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  int device_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_InterconnectConfig_2eproto::TableStruct;
+  friend void ::protobuf_InterconnectConfig_2eproto::InitDefaultsI2CDeviceIdentificationImpl();
+};
+// -------------------------------------------------------------------
+
+class I2CConfiguration : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.InterconnectConfig.I2CConfiguration) */ {
+ public:
+  I2CConfiguration();
+  virtual ~I2CConfiguration();
+
+  I2CConfiguration(const I2CConfiguration& from);
+
+  inline I2CConfiguration& operator=(const I2CConfiguration& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  I2CConfiguration(I2CConfiguration&& from) noexcept
+    : I2CConfiguration() {
+    *this = ::std::move(from);
+  }
+
+  inline I2CConfiguration& operator=(I2CConfiguration&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const I2CConfiguration& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const I2CConfiguration* internal_default_instance() {
+    return reinterpret_cast<const I2CConfiguration*>(
+               &_I2CConfiguration_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    6;
+
+  void Swap(I2CConfiguration* other);
+  friend void swap(I2CConfiguration& a, I2CConfiguration& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline I2CConfiguration* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  I2CConfiguration* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const I2CConfiguration& from);
+  void MergeFrom(const I2CConfiguration& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(I2CConfiguration* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.InterconnectConfig.I2CDevice device = 1;
+  void clear_device();
+  static const int kDeviceFieldNumber = 1;
+  ::Kinova::Api::InterconnectConfig::I2CDevice device() const;
+  void set_device(::Kinova::Api::InterconnectConfig::I2CDevice value);
+
+  // bool enabled = 2;
+  void clear_enabled();
+  static const int kEnabledFieldNumber = 2;
+  bool enabled() const;
+  void set_enabled(bool value);
+
+  // .Kinova.Api.InterconnectConfig.I2CMode mode = 3;
+  void clear_mode();
+  static const int kModeFieldNumber = 3;
+  ::Kinova::Api::InterconnectConfig::I2CMode mode() const;
+  void set_mode(::Kinova::Api::InterconnectConfig::I2CMode value);
+
+  // .Kinova.Api.InterconnectConfig.I2CDeviceAddressing addressing = 4;
+  void clear_addressing();
+  static const int kAddressingFieldNumber = 4;
+  ::Kinova::Api::InterconnectConfig::I2CDeviceAddressing addressing() const;
+  void set_addressing(::Kinova::Api::InterconnectConfig::I2CDeviceAddressing value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.InterconnectConfig.I2CConfiguration)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  int device_;
+  bool enabled_;
+  int mode_;
+  int addressing_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_InterconnectConfig_2eproto::TableStruct;
+  friend void ::protobuf_InterconnectConfig_2eproto::InitDefaultsI2CConfigurationImpl();
+};
+// -------------------------------------------------------------------
+
+class I2CReadParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.InterconnectConfig.I2CReadParameter) */ {
+ public:
+  I2CReadParameter();
+  virtual ~I2CReadParameter();
+
+  I2CReadParameter(const I2CReadParameter& from);
+
+  inline I2CReadParameter& operator=(const I2CReadParameter& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  I2CReadParameter(I2CReadParameter&& from) noexcept
+    : I2CReadParameter() {
+    *this = ::std::move(from);
+  }
+
+  inline I2CReadParameter& operator=(I2CReadParameter&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const I2CReadParameter& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const I2CReadParameter* internal_default_instance() {
+    return reinterpret_cast<const I2CReadParameter*>(
+               &_I2CReadParameter_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    7;
+
+  void Swap(I2CReadParameter* other);
+  friend void swap(I2CReadParameter& a, I2CReadParameter& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline I2CReadParameter* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  I2CReadParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const I2CReadParameter& from);
+  void MergeFrom(const I2CReadParameter& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(I2CReadParameter* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.InterconnectConfig.I2CDevice device = 1;
+  void clear_device();
+  static const int kDeviceFieldNumber = 1;
+  ::Kinova::Api::InterconnectConfig::I2CDevice device() const;
+  void set_device(::Kinova::Api::InterconnectConfig::I2CDevice value);
+
+  // fixed32 device_address = 2;
+  void clear_device_address();
+  static const int kDeviceAddressFieldNumber = 2;
+  ::google::protobuf::uint32 device_address() const;
+  void set_device_address(::google::protobuf::uint32 value);
+
+  // fixed32 size = 5;
+  void clear_size();
+  static const int kSizeFieldNumber = 5;
+  ::google::protobuf::uint32 size() const;
+  void set_size(::google::protobuf::uint32 value);
+
+  // fixed32 timeout = 6;
+  void clear_timeout();
+  static const int kTimeoutFieldNumber = 6;
+  ::google::protobuf::uint32 timeout() const;
+  void set_timeout(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.InterconnectConfig.I2CReadParameter)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  int device_;
+  ::google::protobuf::uint32 device_address_;
+  ::google::protobuf::uint32 size_;
+  ::google::protobuf::uint32 timeout_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_InterconnectConfig_2eproto::TableStruct;
+  friend void ::protobuf_InterconnectConfig_2eproto::InitDefaultsI2CReadParameterImpl();
+};
+// -------------------------------------------------------------------
+
+class I2CReadRegisterParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.InterconnectConfig.I2CReadRegisterParameter) */ {
+ public:
+  I2CReadRegisterParameter();
+  virtual ~I2CReadRegisterParameter();
+
+  I2CReadRegisterParameter(const I2CReadRegisterParameter& from);
+
+  inline I2CReadRegisterParameter& operator=(const I2CReadRegisterParameter& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  I2CReadRegisterParameter(I2CReadRegisterParameter&& from) noexcept
+    : I2CReadRegisterParameter() {
+    *this = ::std::move(from);
+  }
+
+  inline I2CReadRegisterParameter& operator=(I2CReadRegisterParameter&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const I2CReadRegisterParameter& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const I2CReadRegisterParameter* internal_default_instance() {
+    return reinterpret_cast<const I2CReadRegisterParameter*>(
+               &_I2CReadRegisterParameter_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    8;
+
+  void Swap(I2CReadRegisterParameter* other);
+  friend void swap(I2CReadRegisterParameter& a, I2CReadRegisterParameter& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline I2CReadRegisterParameter* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  I2CReadRegisterParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const I2CReadRegisterParameter& from);
+  void MergeFrom(const I2CReadRegisterParameter& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(I2CReadRegisterParameter* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.InterconnectConfig.I2CDevice device = 1;
+  void clear_device();
+  static const int kDeviceFieldNumber = 1;
+  ::Kinova::Api::InterconnectConfig::I2CDevice device() const;
+  void set_device(::Kinova::Api::InterconnectConfig::I2CDevice value);
+
+  // fixed32 device_address = 2;
+  void clear_device_address();
+  static const int kDeviceAddressFieldNumber = 2;
+  ::google::protobuf::uint32 device_address() const;
+  void set_device_address(::google::protobuf::uint32 value);
+
+  // fixed32 register_address = 3;
+  void clear_register_address();
+  static const int kRegisterAddressFieldNumber = 3;
+  ::google::protobuf::uint32 register_address() const;
+  void set_register_address(::google::protobuf::uint32 value);
+
+  // .Kinova.Api.InterconnectConfig.I2CRegisterAddressSize register_address_size = 4;
+  void clear_register_address_size();
+  static const int kRegisterAddressSizeFieldNumber = 4;
+  ::Kinova::Api::InterconnectConfig::I2CRegisterAddressSize register_address_size() const;
+  void set_register_address_size(::Kinova::Api::InterconnectConfig::I2CRegisterAddressSize value);
+
+  // fixed32 size = 5;
+  void clear_size();
+  static const int kSizeFieldNumber = 5;
+  ::google::protobuf::uint32 size() const;
+  void set_size(::google::protobuf::uint32 value);
+
+  // fixed32 timeout = 6;
+  void clear_timeout();
+  static const int kTimeoutFieldNumber = 6;
+  ::google::protobuf::uint32 timeout() const;
+  void set_timeout(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.InterconnectConfig.I2CReadRegisterParameter)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  int device_;
+  ::google::protobuf::uint32 device_address_;
+  ::google::protobuf::uint32 register_address_;
+  int register_address_size_;
+  ::google::protobuf::uint32 size_;
+  ::google::protobuf::uint32 timeout_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_InterconnectConfig_2eproto::TableStruct;
+  friend void ::protobuf_InterconnectConfig_2eproto::InitDefaultsI2CReadRegisterParameterImpl();
+};
+// -------------------------------------------------------------------
+
+class I2CWriteParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.InterconnectConfig.I2CWriteParameter) */ {
+ public:
+  I2CWriteParameter();
+  virtual ~I2CWriteParameter();
+
+  I2CWriteParameter(const I2CWriteParameter& from);
+
+  inline I2CWriteParameter& operator=(const I2CWriteParameter& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  I2CWriteParameter(I2CWriteParameter&& from) noexcept
+    : I2CWriteParameter() {
+    *this = ::std::move(from);
+  }
+
+  inline I2CWriteParameter& operator=(I2CWriteParameter&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const I2CWriteParameter& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const I2CWriteParameter* internal_default_instance() {
+    return reinterpret_cast<const I2CWriteParameter*>(
+               &_I2CWriteParameter_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    9;
+
+  void Swap(I2CWriteParameter* other);
+  friend void swap(I2CWriteParameter& a, I2CWriteParameter& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline I2CWriteParameter* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  I2CWriteParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const I2CWriteParameter& from);
+  void MergeFrom(const I2CWriteParameter& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(I2CWriteParameter* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.InterconnectConfig.I2CData data = 6;
+  bool has_data() const;
+  void clear_data();
+  static const int kDataFieldNumber = 6;
+  const ::Kinova::Api::InterconnectConfig::I2CData& data() const;
+  ::Kinova::Api::InterconnectConfig::I2CData* release_data();
+  ::Kinova::Api::InterconnectConfig::I2CData* mutable_data();
+  void set_allocated_data(::Kinova::Api::InterconnectConfig::I2CData* data);
+
+  // .Kinova.Api.InterconnectConfig.I2CDevice device = 1;
+  void clear_device();
+  static const int kDeviceFieldNumber = 1;
+  ::Kinova::Api::InterconnectConfig::I2CDevice device() const;
+  void set_device(::Kinova::Api::InterconnectConfig::I2CDevice value);
+
+  // fixed32 device_address = 2;
+  void clear_device_address();
+  static const int kDeviceAddressFieldNumber = 2;
+  ::google::protobuf::uint32 device_address() const;
+  void set_device_address(::google::protobuf::uint32 value);
+
+  // fixed32 timeout = 5;
+  void clear_timeout();
+  static const int kTimeoutFieldNumber = 5;
+  ::google::protobuf::uint32 timeout() const;
+  void set_timeout(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.InterconnectConfig.I2CWriteParameter)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::InterconnectConfig::I2CData* data_;
+  int device_;
+  ::google::protobuf::uint32 device_address_;
+  ::google::protobuf::uint32 timeout_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_InterconnectConfig_2eproto::TableStruct;
+  friend void ::protobuf_InterconnectConfig_2eproto::InitDefaultsI2CWriteParameterImpl();
+};
+// -------------------------------------------------------------------
+
+class I2CWriteRegisterParameter : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.InterconnectConfig.I2CWriteRegisterParameter) */ {
+ public:
+  I2CWriteRegisterParameter();
+  virtual ~I2CWriteRegisterParameter();
+
+  I2CWriteRegisterParameter(const I2CWriteRegisterParameter& from);
+
+  inline I2CWriteRegisterParameter& operator=(const I2CWriteRegisterParameter& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  I2CWriteRegisterParameter(I2CWriteRegisterParameter&& from) noexcept
+    : I2CWriteRegisterParameter() {
+    *this = ::std::move(from);
+  }
+
+  inline I2CWriteRegisterParameter& operator=(I2CWriteRegisterParameter&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const I2CWriteRegisterParameter& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const I2CWriteRegisterParameter* internal_default_instance() {
+    return reinterpret_cast<const I2CWriteRegisterParameter*>(
+               &_I2CWriteRegisterParameter_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    10;
+
+  void Swap(I2CWriteRegisterParameter* other);
+  friend void swap(I2CWriteRegisterParameter& a, I2CWriteRegisterParameter& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline I2CWriteRegisterParameter* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  I2CWriteRegisterParameter* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const I2CWriteRegisterParameter& from);
+  void MergeFrom(const I2CWriteRegisterParameter& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(I2CWriteRegisterParameter* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.InterconnectConfig.I2CData data = 6;
+  bool has_data() const;
+  void clear_data();
+  static const int kDataFieldNumber = 6;
+  const ::Kinova::Api::InterconnectConfig::I2CData& data() const;
+  ::Kinova::Api::InterconnectConfig::I2CData* release_data();
+  ::Kinova::Api::InterconnectConfig::I2CData* mutable_data();
+  void set_allocated_data(::Kinova::Api::InterconnectConfig::I2CData* data);
+
+  // .Kinova.Api.InterconnectConfig.I2CDevice device = 1;
+  void clear_device();
+  static const int kDeviceFieldNumber = 1;
+  ::Kinova::Api::InterconnectConfig::I2CDevice device() const;
+  void set_device(::Kinova::Api::InterconnectConfig::I2CDevice value);
+
+  // fixed32 device_address = 2;
+  void clear_device_address();
+  static const int kDeviceAddressFieldNumber = 2;
+  ::google::protobuf::uint32 device_address() const;
+  void set_device_address(::google::protobuf::uint32 value);
+
+  // fixed32 register_address = 3;
+  void clear_register_address();
+  static const int kRegisterAddressFieldNumber = 3;
+  ::google::protobuf::uint32 register_address() const;
+  void set_register_address(::google::protobuf::uint32 value);
+
+  // .Kinova.Api.InterconnectConfig.I2CRegisterAddressSize register_address_size = 4;
+  void clear_register_address_size();
+  static const int kRegisterAddressSizeFieldNumber = 4;
+  ::Kinova::Api::InterconnectConfig::I2CRegisterAddressSize register_address_size() const;
+  void set_register_address_size(::Kinova::Api::InterconnectConfig::I2CRegisterAddressSize value);
+
+  // fixed32 timeout = 5;
+  void clear_timeout();
+  static const int kTimeoutFieldNumber = 5;
+  ::google::protobuf::uint32 timeout() const;
+  void set_timeout(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.InterconnectConfig.I2CWriteRegisterParameter)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::InterconnectConfig::I2CData* data_;
+  int device_;
+  ::google::protobuf::uint32 device_address_;
+  ::google::protobuf::uint32 register_address_;
+  int register_address_size_;
+  ::google::protobuf::uint32 timeout_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_InterconnectConfig_2eproto::TableStruct;
+  friend void ::protobuf_InterconnectConfig_2eproto::InitDefaultsI2CWriteRegisterParameterImpl();
+};
+// -------------------------------------------------------------------
+
+class I2CData : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.InterconnectConfig.I2CData) */ {
+ public:
+  I2CData();
+  virtual ~I2CData();
+
+  I2CData(const I2CData& from);
+
+  inline I2CData& operator=(const I2CData& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  I2CData(I2CData&& from) noexcept
+    : I2CData() {
+    *this = ::std::move(from);
+  }
+
+  inline I2CData& operator=(I2CData&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const I2CData& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const I2CData* internal_default_instance() {
+    return reinterpret_cast<const I2CData*>(
+               &_I2CData_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    11;
+
+  void Swap(I2CData* other);
+  friend void swap(I2CData& a, I2CData& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline I2CData* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  I2CData* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const I2CData& from);
+  void MergeFrom(const I2CData& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(I2CData* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // bytes data = 1;
+  void clear_data();
+  static const int kDataFieldNumber = 1;
+  const ::std::string& data() const;
+  void set_data(const ::std::string& value);
+  #if LANG_CXX11
+  void set_data(::std::string&& value);
+  #endif
+  void set_data(const char* value);
+  void set_data(const void* value, size_t size);
+  ::std::string* mutable_data();
+  ::std::string* release_data();
+  void set_allocated_data(::std::string* data);
+
+  // fixed32 size = 2;
+  void clear_size();
+  static const int kSizeFieldNumber = 2;
+  ::google::protobuf::uint32 size() const;
+  void set_size(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.InterconnectConfig.I2CData)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::internal::ArenaStringPtr data_;
+  ::google::protobuf::uint32 size_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_InterconnectConfig_2eproto::TableStruct;
+  friend void ::protobuf_InterconnectConfig_2eproto::InitDefaultsI2CDataImpl();
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// EthernetDeviceIdentification
+
+// .Kinova.Api.InterconnectConfig.EthernetDevice device = 1;
+inline void EthernetDeviceIdentification::clear_device() {
+  device_ = 0;
+}
+inline ::Kinova::Api::InterconnectConfig::EthernetDevice EthernetDeviceIdentification::device() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectConfig.EthernetDeviceIdentification.device)
+  return static_cast< ::Kinova::Api::InterconnectConfig::EthernetDevice >(device_);
+}
+inline void EthernetDeviceIdentification::set_device(::Kinova::Api::InterconnectConfig::EthernetDevice value) {
+  
+  device_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectConfig.EthernetDeviceIdentification.device)
+}
+
+// -------------------------------------------------------------------
+
+// EthernetConfiguration
+
+// .Kinova.Api.InterconnectConfig.EthernetDevice device = 1;
+inline void EthernetConfiguration::clear_device() {
+  device_ = 0;
+}
+inline ::Kinova::Api::InterconnectConfig::EthernetDevice EthernetConfiguration::device() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectConfig.EthernetConfiguration.device)
+  return static_cast< ::Kinova::Api::InterconnectConfig::EthernetDevice >(device_);
+}
+inline void EthernetConfiguration::set_device(::Kinova::Api::InterconnectConfig::EthernetDevice value) {
+  
+  device_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectConfig.EthernetConfiguration.device)
+}
+
+// bool enabled = 2;
+inline void EthernetConfiguration::clear_enabled() {
+  enabled_ = false;
+}
+inline bool EthernetConfiguration::enabled() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectConfig.EthernetConfiguration.enabled)
+  return enabled_;
+}
+inline void EthernetConfiguration::set_enabled(bool value) {
+  
+  enabled_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectConfig.EthernetConfiguration.enabled)
+}
+
+// .Kinova.Api.InterconnectConfig.EthernetSpeed speed = 3;
+inline void EthernetConfiguration::clear_speed() {
+  speed_ = 0;
+}
+inline ::Kinova::Api::InterconnectConfig::EthernetSpeed EthernetConfiguration::speed() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectConfig.EthernetConfiguration.speed)
+  return static_cast< ::Kinova::Api::InterconnectConfig::EthernetSpeed >(speed_);
+}
+inline void EthernetConfiguration::set_speed(::Kinova::Api::InterconnectConfig::EthernetSpeed value) {
+  
+  speed_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectConfig.EthernetConfiguration.speed)
+}
+
+// .Kinova.Api.InterconnectConfig.EthernetDuplex duplex = 4;
+inline void EthernetConfiguration::clear_duplex() {
+  duplex_ = 0;
+}
+inline ::Kinova::Api::InterconnectConfig::EthernetDuplex EthernetConfiguration::duplex() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectConfig.EthernetConfiguration.duplex)
+  return static_cast< ::Kinova::Api::InterconnectConfig::EthernetDuplex >(duplex_);
+}
+inline void EthernetConfiguration::set_duplex(::Kinova::Api::InterconnectConfig::EthernetDuplex value) {
+  
+  duplex_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectConfig.EthernetConfiguration.duplex)
+}
+
+// -------------------------------------------------------------------
+
+// GPIOIdentification
+
+// .Kinova.Api.InterconnectConfig.GPIOIdentifier identifier = 1;
+inline void GPIOIdentification::clear_identifier() {
+  identifier_ = 0;
+}
+inline ::Kinova::Api::InterconnectConfig::GPIOIdentifier GPIOIdentification::identifier() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectConfig.GPIOIdentification.identifier)
+  return static_cast< ::Kinova::Api::InterconnectConfig::GPIOIdentifier >(identifier_);
+}
+inline void GPIOIdentification::set_identifier(::Kinova::Api::InterconnectConfig::GPIOIdentifier value) {
+  
+  identifier_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectConfig.GPIOIdentification.identifier)
+}
+
+// -------------------------------------------------------------------
+
+// GPIOConfiguration
+
+// .Kinova.Api.InterconnectConfig.GPIOIdentifier identifier = 1;
+inline void GPIOConfiguration::clear_identifier() {
+  identifier_ = 0;
+}
+inline ::Kinova::Api::InterconnectConfig::GPIOIdentifier GPIOConfiguration::identifier() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectConfig.GPIOConfiguration.identifier)
+  return static_cast< ::Kinova::Api::InterconnectConfig::GPIOIdentifier >(identifier_);
+}
+inline void GPIOConfiguration::set_identifier(::Kinova::Api::InterconnectConfig::GPIOIdentifier value) {
+  
+  identifier_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectConfig.GPIOConfiguration.identifier)
+}
+
+// .Kinova.Api.InterconnectConfig.GPIOMode mode = 2;
+inline void GPIOConfiguration::clear_mode() {
+  mode_ = 0;
+}
+inline ::Kinova::Api::InterconnectConfig::GPIOMode GPIOConfiguration::mode() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectConfig.GPIOConfiguration.mode)
+  return static_cast< ::Kinova::Api::InterconnectConfig::GPIOMode >(mode_);
+}
+inline void GPIOConfiguration::set_mode(::Kinova::Api::InterconnectConfig::GPIOMode value) {
+  
+  mode_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectConfig.GPIOConfiguration.mode)
+}
+
+// .Kinova.Api.InterconnectConfig.GPIOPull pull = 3;
+inline void GPIOConfiguration::clear_pull() {
+  pull_ = 0;
+}
+inline ::Kinova::Api::InterconnectConfig::GPIOPull GPIOConfiguration::pull() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectConfig.GPIOConfiguration.pull)
+  return static_cast< ::Kinova::Api::InterconnectConfig::GPIOPull >(pull_);
+}
+inline void GPIOConfiguration::set_pull(::Kinova::Api::InterconnectConfig::GPIOPull value) {
+  
+  pull_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectConfig.GPIOConfiguration.pull)
+}
+
+// .Kinova.Api.InterconnectConfig.GPIOValue default_value = 4;
+inline void GPIOConfiguration::clear_default_value() {
+  default_value_ = 0;
+}
+inline ::Kinova::Api::InterconnectConfig::GPIOValue GPIOConfiguration::default_value() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectConfig.GPIOConfiguration.default_value)
+  return static_cast< ::Kinova::Api::InterconnectConfig::GPIOValue >(default_value_);
+}
+inline void GPIOConfiguration::set_default_value(::Kinova::Api::InterconnectConfig::GPIOValue value) {
+  
+  default_value_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectConfig.GPIOConfiguration.default_value)
+}
+
+// -------------------------------------------------------------------
+
+// GPIOState
+
+// .Kinova.Api.InterconnectConfig.GPIOIdentifier identifier = 1;
+inline void GPIOState::clear_identifier() {
+  identifier_ = 0;
+}
+inline ::Kinova::Api::InterconnectConfig::GPIOIdentifier GPIOState::identifier() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectConfig.GPIOState.identifier)
+  return static_cast< ::Kinova::Api::InterconnectConfig::GPIOIdentifier >(identifier_);
+}
+inline void GPIOState::set_identifier(::Kinova::Api::InterconnectConfig::GPIOIdentifier value) {
+  
+  identifier_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectConfig.GPIOState.identifier)
+}
+
+// .Kinova.Api.InterconnectConfig.GPIOValue value = 2;
+inline void GPIOState::clear_value() {
+  value_ = 0;
+}
+inline ::Kinova::Api::InterconnectConfig::GPIOValue GPIOState::value() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectConfig.GPIOState.value)
+  return static_cast< ::Kinova::Api::InterconnectConfig::GPIOValue >(value_);
+}
+inline void GPIOState::set_value(::Kinova::Api::InterconnectConfig::GPIOValue value) {
+  
+  value_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectConfig.GPIOState.value)
+}
+
+// -------------------------------------------------------------------
+
+// I2CDeviceIdentification
+
+// .Kinova.Api.InterconnectConfig.I2CDevice device = 1;
+inline void I2CDeviceIdentification::clear_device() {
+  device_ = 0;
+}
+inline ::Kinova::Api::InterconnectConfig::I2CDevice I2CDeviceIdentification::device() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectConfig.I2CDeviceIdentification.device)
+  return static_cast< ::Kinova::Api::InterconnectConfig::I2CDevice >(device_);
+}
+inline void I2CDeviceIdentification::set_device(::Kinova::Api::InterconnectConfig::I2CDevice value) {
+  
+  device_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectConfig.I2CDeviceIdentification.device)
+}
+
+// -------------------------------------------------------------------
+
+// I2CConfiguration
+
+// .Kinova.Api.InterconnectConfig.I2CDevice device = 1;
+inline void I2CConfiguration::clear_device() {
+  device_ = 0;
+}
+inline ::Kinova::Api::InterconnectConfig::I2CDevice I2CConfiguration::device() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectConfig.I2CConfiguration.device)
+  return static_cast< ::Kinova::Api::InterconnectConfig::I2CDevice >(device_);
+}
+inline void I2CConfiguration::set_device(::Kinova::Api::InterconnectConfig::I2CDevice value) {
+  
+  device_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectConfig.I2CConfiguration.device)
+}
+
+// bool enabled = 2;
+inline void I2CConfiguration::clear_enabled() {
+  enabled_ = false;
+}
+inline bool I2CConfiguration::enabled() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectConfig.I2CConfiguration.enabled)
+  return enabled_;
+}
+inline void I2CConfiguration::set_enabled(bool value) {
+  
+  enabled_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectConfig.I2CConfiguration.enabled)
+}
+
+// .Kinova.Api.InterconnectConfig.I2CMode mode = 3;
+inline void I2CConfiguration::clear_mode() {
+  mode_ = 0;
+}
+inline ::Kinova::Api::InterconnectConfig::I2CMode I2CConfiguration::mode() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectConfig.I2CConfiguration.mode)
+  return static_cast< ::Kinova::Api::InterconnectConfig::I2CMode >(mode_);
+}
+inline void I2CConfiguration::set_mode(::Kinova::Api::InterconnectConfig::I2CMode value) {
+  
+  mode_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectConfig.I2CConfiguration.mode)
+}
+
+// .Kinova.Api.InterconnectConfig.I2CDeviceAddressing addressing = 4;
+inline void I2CConfiguration::clear_addressing() {
+  addressing_ = 0;
+}
+inline ::Kinova::Api::InterconnectConfig::I2CDeviceAddressing I2CConfiguration::addressing() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectConfig.I2CConfiguration.addressing)
+  return static_cast< ::Kinova::Api::InterconnectConfig::I2CDeviceAddressing >(addressing_);
+}
+inline void I2CConfiguration::set_addressing(::Kinova::Api::InterconnectConfig::I2CDeviceAddressing value) {
+  
+  addressing_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectConfig.I2CConfiguration.addressing)
+}
+
+// -------------------------------------------------------------------
+
+// I2CReadParameter
+
+// .Kinova.Api.InterconnectConfig.I2CDevice device = 1;
+inline void I2CReadParameter::clear_device() {
+  device_ = 0;
+}
+inline ::Kinova::Api::InterconnectConfig::I2CDevice I2CReadParameter::device() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectConfig.I2CReadParameter.device)
+  return static_cast< ::Kinova::Api::InterconnectConfig::I2CDevice >(device_);
+}
+inline void I2CReadParameter::set_device(::Kinova::Api::InterconnectConfig::I2CDevice value) {
+  
+  device_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectConfig.I2CReadParameter.device)
+}
+
+// fixed32 device_address = 2;
+inline void I2CReadParameter::clear_device_address() {
+  device_address_ = 0u;
+}
+inline ::google::protobuf::uint32 I2CReadParameter::device_address() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectConfig.I2CReadParameter.device_address)
+  return device_address_;
+}
+inline void I2CReadParameter::set_device_address(::google::protobuf::uint32 value) {
+  
+  device_address_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectConfig.I2CReadParameter.device_address)
+}
+
+// fixed32 size = 5;
+inline void I2CReadParameter::clear_size() {
+  size_ = 0u;
+}
+inline ::google::protobuf::uint32 I2CReadParameter::size() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectConfig.I2CReadParameter.size)
+  return size_;
+}
+inline void I2CReadParameter::set_size(::google::protobuf::uint32 value) {
+  
+  size_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectConfig.I2CReadParameter.size)
+}
+
+// fixed32 timeout = 6;
+inline void I2CReadParameter::clear_timeout() {
+  timeout_ = 0u;
+}
+inline ::google::protobuf::uint32 I2CReadParameter::timeout() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectConfig.I2CReadParameter.timeout)
+  return timeout_;
+}
+inline void I2CReadParameter::set_timeout(::google::protobuf::uint32 value) {
+  
+  timeout_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectConfig.I2CReadParameter.timeout)
+}
+
+// -------------------------------------------------------------------
+
+// I2CReadRegisterParameter
+
+// .Kinova.Api.InterconnectConfig.I2CDevice device = 1;
+inline void I2CReadRegisterParameter::clear_device() {
+  device_ = 0;
+}
+inline ::Kinova::Api::InterconnectConfig::I2CDevice I2CReadRegisterParameter::device() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectConfig.I2CReadRegisterParameter.device)
+  return static_cast< ::Kinova::Api::InterconnectConfig::I2CDevice >(device_);
+}
+inline void I2CReadRegisterParameter::set_device(::Kinova::Api::InterconnectConfig::I2CDevice value) {
+  
+  device_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectConfig.I2CReadRegisterParameter.device)
+}
+
+// fixed32 device_address = 2;
+inline void I2CReadRegisterParameter::clear_device_address() {
+  device_address_ = 0u;
+}
+inline ::google::protobuf::uint32 I2CReadRegisterParameter::device_address() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectConfig.I2CReadRegisterParameter.device_address)
+  return device_address_;
+}
+inline void I2CReadRegisterParameter::set_device_address(::google::protobuf::uint32 value) {
+  
+  device_address_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectConfig.I2CReadRegisterParameter.device_address)
+}
+
+// fixed32 register_address = 3;
+inline void I2CReadRegisterParameter::clear_register_address() {
+  register_address_ = 0u;
+}
+inline ::google::protobuf::uint32 I2CReadRegisterParameter::register_address() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectConfig.I2CReadRegisterParameter.register_address)
+  return register_address_;
+}
+inline void I2CReadRegisterParameter::set_register_address(::google::protobuf::uint32 value) {
+  
+  register_address_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectConfig.I2CReadRegisterParameter.register_address)
+}
+
+// .Kinova.Api.InterconnectConfig.I2CRegisterAddressSize register_address_size = 4;
+inline void I2CReadRegisterParameter::clear_register_address_size() {
+  register_address_size_ = 0;
+}
+inline ::Kinova::Api::InterconnectConfig::I2CRegisterAddressSize I2CReadRegisterParameter::register_address_size() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectConfig.I2CReadRegisterParameter.register_address_size)
+  return static_cast< ::Kinova::Api::InterconnectConfig::I2CRegisterAddressSize >(register_address_size_);
+}
+inline void I2CReadRegisterParameter::set_register_address_size(::Kinova::Api::InterconnectConfig::I2CRegisterAddressSize value) {
+  
+  register_address_size_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectConfig.I2CReadRegisterParameter.register_address_size)
+}
+
+// fixed32 size = 5;
+inline void I2CReadRegisterParameter::clear_size() {
+  size_ = 0u;
+}
+inline ::google::protobuf::uint32 I2CReadRegisterParameter::size() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectConfig.I2CReadRegisterParameter.size)
+  return size_;
+}
+inline void I2CReadRegisterParameter::set_size(::google::protobuf::uint32 value) {
+  
+  size_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectConfig.I2CReadRegisterParameter.size)
+}
+
+// fixed32 timeout = 6;
+inline void I2CReadRegisterParameter::clear_timeout() {
+  timeout_ = 0u;
+}
+inline ::google::protobuf::uint32 I2CReadRegisterParameter::timeout() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectConfig.I2CReadRegisterParameter.timeout)
+  return timeout_;
+}
+inline void I2CReadRegisterParameter::set_timeout(::google::protobuf::uint32 value) {
+  
+  timeout_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectConfig.I2CReadRegisterParameter.timeout)
+}
+
+// -------------------------------------------------------------------
+
+// I2CWriteParameter
+
+// .Kinova.Api.InterconnectConfig.I2CDevice device = 1;
+inline void I2CWriteParameter::clear_device() {
+  device_ = 0;
+}
+inline ::Kinova::Api::InterconnectConfig::I2CDevice I2CWriteParameter::device() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectConfig.I2CWriteParameter.device)
+  return static_cast< ::Kinova::Api::InterconnectConfig::I2CDevice >(device_);
+}
+inline void I2CWriteParameter::set_device(::Kinova::Api::InterconnectConfig::I2CDevice value) {
+  
+  device_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectConfig.I2CWriteParameter.device)
+}
+
+// fixed32 device_address = 2;
+inline void I2CWriteParameter::clear_device_address() {
+  device_address_ = 0u;
+}
+inline ::google::protobuf::uint32 I2CWriteParameter::device_address() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectConfig.I2CWriteParameter.device_address)
+  return device_address_;
+}
+inline void I2CWriteParameter::set_device_address(::google::protobuf::uint32 value) {
+  
+  device_address_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectConfig.I2CWriteParameter.device_address)
+}
+
+// fixed32 timeout = 5;
+inline void I2CWriteParameter::clear_timeout() {
+  timeout_ = 0u;
+}
+inline ::google::protobuf::uint32 I2CWriteParameter::timeout() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectConfig.I2CWriteParameter.timeout)
+  return timeout_;
+}
+inline void I2CWriteParameter::set_timeout(::google::protobuf::uint32 value) {
+  
+  timeout_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectConfig.I2CWriteParameter.timeout)
+}
+
+// .Kinova.Api.InterconnectConfig.I2CData data = 6;
+inline bool I2CWriteParameter::has_data() const {
+  return this != internal_default_instance() && data_ != NULL;
+}
+inline void I2CWriteParameter::clear_data() {
+  if (GetArenaNoVirtual() == NULL && data_ != NULL) {
+    delete data_;
+  }
+  data_ = NULL;
+}
+inline const ::Kinova::Api::InterconnectConfig::I2CData& I2CWriteParameter::data() const {
+  const ::Kinova::Api::InterconnectConfig::I2CData* p = data_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectConfig.I2CWriteParameter.data)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::InterconnectConfig::I2CData*>(
+      &::Kinova::Api::InterconnectConfig::_I2CData_default_instance_);
+}
+inline ::Kinova::Api::InterconnectConfig::I2CData* I2CWriteParameter::release_data() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.InterconnectConfig.I2CWriteParameter.data)
+  
+  ::Kinova::Api::InterconnectConfig::I2CData* temp = data_;
+  data_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::InterconnectConfig::I2CData* I2CWriteParameter::mutable_data() {
+  
+  if (data_ == NULL) {
+    data_ = new ::Kinova::Api::InterconnectConfig::I2CData;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.InterconnectConfig.I2CWriteParameter.data)
+  return data_;
+}
+inline void I2CWriteParameter::set_allocated_data(::Kinova::Api::InterconnectConfig::I2CData* data) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete data_;
+  }
+  if (data) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      data = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, data, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  data_ = data;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.InterconnectConfig.I2CWriteParameter.data)
+}
+
+// -------------------------------------------------------------------
+
+// I2CWriteRegisterParameter
+
+// .Kinova.Api.InterconnectConfig.I2CDevice device = 1;
+inline void I2CWriteRegisterParameter::clear_device() {
+  device_ = 0;
+}
+inline ::Kinova::Api::InterconnectConfig::I2CDevice I2CWriteRegisterParameter::device() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectConfig.I2CWriteRegisterParameter.device)
+  return static_cast< ::Kinova::Api::InterconnectConfig::I2CDevice >(device_);
+}
+inline void I2CWriteRegisterParameter::set_device(::Kinova::Api::InterconnectConfig::I2CDevice value) {
+  
+  device_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectConfig.I2CWriteRegisterParameter.device)
+}
+
+// fixed32 device_address = 2;
+inline void I2CWriteRegisterParameter::clear_device_address() {
+  device_address_ = 0u;
+}
+inline ::google::protobuf::uint32 I2CWriteRegisterParameter::device_address() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectConfig.I2CWriteRegisterParameter.device_address)
+  return device_address_;
+}
+inline void I2CWriteRegisterParameter::set_device_address(::google::protobuf::uint32 value) {
+  
+  device_address_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectConfig.I2CWriteRegisterParameter.device_address)
+}
+
+// fixed32 register_address = 3;
+inline void I2CWriteRegisterParameter::clear_register_address() {
+  register_address_ = 0u;
+}
+inline ::google::protobuf::uint32 I2CWriteRegisterParameter::register_address() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectConfig.I2CWriteRegisterParameter.register_address)
+  return register_address_;
+}
+inline void I2CWriteRegisterParameter::set_register_address(::google::protobuf::uint32 value) {
+  
+  register_address_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectConfig.I2CWriteRegisterParameter.register_address)
+}
+
+// .Kinova.Api.InterconnectConfig.I2CRegisterAddressSize register_address_size = 4;
+inline void I2CWriteRegisterParameter::clear_register_address_size() {
+  register_address_size_ = 0;
+}
+inline ::Kinova::Api::InterconnectConfig::I2CRegisterAddressSize I2CWriteRegisterParameter::register_address_size() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectConfig.I2CWriteRegisterParameter.register_address_size)
+  return static_cast< ::Kinova::Api::InterconnectConfig::I2CRegisterAddressSize >(register_address_size_);
+}
+inline void I2CWriteRegisterParameter::set_register_address_size(::Kinova::Api::InterconnectConfig::I2CRegisterAddressSize value) {
+  
+  register_address_size_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectConfig.I2CWriteRegisterParameter.register_address_size)
+}
+
+// fixed32 timeout = 5;
+inline void I2CWriteRegisterParameter::clear_timeout() {
+  timeout_ = 0u;
+}
+inline ::google::protobuf::uint32 I2CWriteRegisterParameter::timeout() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectConfig.I2CWriteRegisterParameter.timeout)
+  return timeout_;
+}
+inline void I2CWriteRegisterParameter::set_timeout(::google::protobuf::uint32 value) {
+  
+  timeout_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectConfig.I2CWriteRegisterParameter.timeout)
+}
+
+// .Kinova.Api.InterconnectConfig.I2CData data = 6;
+inline bool I2CWriteRegisterParameter::has_data() const {
+  return this != internal_default_instance() && data_ != NULL;
+}
+inline void I2CWriteRegisterParameter::clear_data() {
+  if (GetArenaNoVirtual() == NULL && data_ != NULL) {
+    delete data_;
+  }
+  data_ = NULL;
+}
+inline const ::Kinova::Api::InterconnectConfig::I2CData& I2CWriteRegisterParameter::data() const {
+  const ::Kinova::Api::InterconnectConfig::I2CData* p = data_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectConfig.I2CWriteRegisterParameter.data)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::InterconnectConfig::I2CData*>(
+      &::Kinova::Api::InterconnectConfig::_I2CData_default_instance_);
+}
+inline ::Kinova::Api::InterconnectConfig::I2CData* I2CWriteRegisterParameter::release_data() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.InterconnectConfig.I2CWriteRegisterParameter.data)
+  
+  ::Kinova::Api::InterconnectConfig::I2CData* temp = data_;
+  data_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::InterconnectConfig::I2CData* I2CWriteRegisterParameter::mutable_data() {
+  
+  if (data_ == NULL) {
+    data_ = new ::Kinova::Api::InterconnectConfig::I2CData;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.InterconnectConfig.I2CWriteRegisterParameter.data)
+  return data_;
+}
+inline void I2CWriteRegisterParameter::set_allocated_data(::Kinova::Api::InterconnectConfig::I2CData* data) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete data_;
+  }
+  if (data) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      data = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, data, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  data_ = data;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.InterconnectConfig.I2CWriteRegisterParameter.data)
+}
+
+// -------------------------------------------------------------------
+
+// I2CData
+
+// bytes data = 1;
+inline void I2CData::clear_data() {
+  data_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& I2CData::data() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectConfig.I2CData.data)
+  return data_.GetNoArena();
+}
+inline void I2CData::set_data(const ::std::string& value) {
+  
+  data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectConfig.I2CData.data)
+}
+#if LANG_CXX11
+inline void I2CData::set_data(::std::string&& value) {
+  
+  data_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:Kinova.Api.InterconnectConfig.I2CData.data)
+}
+#endif
+inline void I2CData::set_data(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:Kinova.Api.InterconnectConfig.I2CData.data)
+}
+inline void I2CData::set_data(const void* value, size_t size) {
+  
+  data_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:Kinova.Api.InterconnectConfig.I2CData.data)
+}
+inline ::std::string* I2CData::mutable_data() {
+  
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.InterconnectConfig.I2CData.data)
+  return data_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* I2CData::release_data() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.InterconnectConfig.I2CData.data)
+  
+  return data_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void I2CData::set_allocated_data(::std::string* data) {
+  if (data != NULL) {
+    
+  } else {
+    
+  }
+  data_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), data);
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.InterconnectConfig.I2CData.data)
+}
+
+// fixed32 size = 2;
+inline void I2CData::clear_size() {
+  size_ = 0u;
+}
+inline ::google::protobuf::uint32 I2CData::size() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectConfig.I2CData.size)
+  return size_;
+}
+inline void I2CData::set_size(::google::protobuf::uint32 value) {
+  
+  size_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectConfig.I2CData.size)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace InterconnectConfig
+}  // namespace Api
+}  // namespace Kinova
+
+namespace google {
+namespace protobuf {
+
+template <> struct is_proto_enum< ::Kinova::Api::InterconnectConfig::ServiceVersion> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::InterconnectConfig::ServiceVersion>() {
+  return ::Kinova::Api::InterconnectConfig::ServiceVersion_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::InterconnectConfig::SafetyIdentifier> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::InterconnectConfig::SafetyIdentifier>() {
+  return ::Kinova::Api::InterconnectConfig::SafetyIdentifier_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::InterconnectConfig::UARTPortId> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::InterconnectConfig::UARTPortId>() {
+  return ::Kinova::Api::InterconnectConfig::UARTPortId_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::InterconnectConfig::EthernetDevice> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::InterconnectConfig::EthernetDevice>() {
+  return ::Kinova::Api::InterconnectConfig::EthernetDevice_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::InterconnectConfig::EthernetSpeed> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::InterconnectConfig::EthernetSpeed>() {
+  return ::Kinova::Api::InterconnectConfig::EthernetSpeed_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::InterconnectConfig::EthernetDuplex> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::InterconnectConfig::EthernetDuplex>() {
+  return ::Kinova::Api::InterconnectConfig::EthernetDuplex_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::InterconnectConfig::GPIOIdentifier> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::InterconnectConfig::GPIOIdentifier>() {
+  return ::Kinova::Api::InterconnectConfig::GPIOIdentifier_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::InterconnectConfig::GPIOMode> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::InterconnectConfig::GPIOMode>() {
+  return ::Kinova::Api::InterconnectConfig::GPIOMode_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::InterconnectConfig::GPIOPull> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::InterconnectConfig::GPIOPull>() {
+  return ::Kinova::Api::InterconnectConfig::GPIOPull_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::InterconnectConfig::GPIOValue> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::InterconnectConfig::GPIOValue>() {
+  return ::Kinova::Api::InterconnectConfig::GPIOValue_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::InterconnectConfig::I2CDevice> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::InterconnectConfig::I2CDevice>() {
+  return ::Kinova::Api::InterconnectConfig::I2CDevice_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::InterconnectConfig::I2CMode> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::InterconnectConfig::I2CMode>() {
+  return ::Kinova::Api::InterconnectConfig::I2CMode_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::InterconnectConfig::I2CDeviceAddressing> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::InterconnectConfig::I2CDeviceAddressing>() {
+  return ::Kinova::Api::InterconnectConfig::I2CDeviceAddressing_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::InterconnectConfig::I2CRegisterAddressSize> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::InterconnectConfig::I2CRegisterAddressSize>() {
+  return ::Kinova::Api::InterconnectConfig::I2CRegisterAddressSize_descriptor();
+}
+
+}  // namespace protobuf
+}  // namespace google
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_InterconnectConfig_2eproto__INCLUDED
diff --git a/kortex_api/include/messages/InterconnectCyclic.pb.h b/kortex_api/include/messages/InterconnectCyclic.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..2c253fe52acb798f27590e9118c204910edfabf5
--- /dev/null
+++ b/kortex_api/include/messages/InterconnectCyclic.pb.h
@@ -0,0 +1,116 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: InterconnectCyclic.proto
+
+#ifndef PROTOBUF_InterconnectCyclic_2eproto__INCLUDED
+#define PROTOBUF_InterconnectCyclic_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 3005000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 3005001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include "Common.pb.h"  // IWYU pragma: export
+#include "InterconnectCyclicMessage.pb.h"  // IWYU pragma: export
+// @@protoc_insertion_point(includes)
+
+namespace protobuf_InterconnectCyclic_2eproto {
+// Internal implementation detail -- do not use these members.
+struct TableStruct {
+  static const ::google::protobuf::internal::ParseTableField entries[];
+  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
+  static const ::google::protobuf::internal::ParseTable schema[1];
+  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
+  static const ::google::protobuf::internal::SerializationTable serialization_table[];
+  static const ::google::protobuf::uint32 offsets[];
+};
+void AddDescriptors();
+inline void InitDefaults() {
+}
+}  // namespace protobuf_InterconnectCyclic_2eproto
+namespace Kinova {
+namespace Api {
+namespace InterconnectCyclic {
+}  // namespace InterconnectCyclic
+}  // namespace Api
+}  // namespace Kinova
+namespace Kinova {
+namespace Api {
+namespace InterconnectCyclic {
+
+enum ServiceVersion {
+  RESERVED_0 = 0,
+  CURRENT_VERSION = 1,
+  ServiceVersion_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  ServiceVersion_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool ServiceVersion_IsValid(int value);
+const ServiceVersion ServiceVersion_MIN = RESERVED_0;
+const ServiceVersion ServiceVersion_MAX = CURRENT_VERSION;
+const int ServiceVersion_ARRAYSIZE = ServiceVersion_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* ServiceVersion_descriptor();
+inline const ::std::string& ServiceVersion_Name(ServiceVersion value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    ServiceVersion_descriptor(), value);
+}
+inline bool ServiceVersion_Parse(
+    const ::std::string& name, ServiceVersion* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<ServiceVersion>(
+    ServiceVersion_descriptor(), name, value);
+}
+// ===================================================================
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace InterconnectCyclic
+}  // namespace Api
+}  // namespace Kinova
+
+namespace google {
+namespace protobuf {
+
+template <> struct is_proto_enum< ::Kinova::Api::InterconnectCyclic::ServiceVersion> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::InterconnectCyclic::ServiceVersion>() {
+  return ::Kinova::Api::InterconnectCyclic::ServiceVersion_descriptor();
+}
+
+}  // namespace protobuf
+}  // namespace google
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_InterconnectCyclic_2eproto__INCLUDED
diff --git a/kortex_api/include/messages/InterconnectCyclicMessage.pb.h b/kortex_api/include/messages/InterconnectCyclicMessage.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..acc9800ab9cd1181d0e458ef296b34b5e913ce8d
--- /dev/null
+++ b/kortex_api/include/messages/InterconnectCyclicMessage.pb.h
@@ -0,0 +1,1552 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: InterconnectCyclicMessage.proto
+
+#ifndef PROTOBUF_InterconnectCyclicMessage_2eproto__INCLUDED
+#define PROTOBUF_InterconnectCyclicMessage_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 3005000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 3005001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+#include "Common.pb.h"  // IWYU pragma: export
+#include "GripperCyclicMessage.pb.h"  // IWYU pragma: export
+// @@protoc_insertion_point(includes)
+
+namespace protobuf_InterconnectCyclicMessage_2eproto {
+// Internal implementation detail -- do not use these members.
+struct TableStruct {
+  static const ::google::protobuf::internal::ParseTableField entries[];
+  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
+  static const ::google::protobuf::internal::ParseTable schema[4];
+  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
+  static const ::google::protobuf::internal::SerializationTable serialization_table[];
+  static const ::google::protobuf::uint32 offsets[];
+};
+void AddDescriptors();
+void InitDefaultsMessageIdImpl();
+void InitDefaultsMessageId();
+void InitDefaultsCommandImpl();
+void InitDefaultsCommand();
+void InitDefaultsFeedbackImpl();
+void InitDefaultsFeedback();
+void InitDefaultsCustomDataImpl();
+void InitDefaultsCustomData();
+inline void InitDefaults() {
+  InitDefaultsMessageId();
+  InitDefaultsCommand();
+  InitDefaultsFeedback();
+  InitDefaultsCustomData();
+}
+}  // namespace protobuf_InterconnectCyclicMessage_2eproto
+namespace Kinova {
+namespace Api {
+namespace InterconnectCyclic {
+class Command;
+class CommandDefaultTypeInternal;
+extern CommandDefaultTypeInternal _Command_default_instance_;
+class CustomData;
+class CustomDataDefaultTypeInternal;
+extern CustomDataDefaultTypeInternal _CustomData_default_instance_;
+class Feedback;
+class FeedbackDefaultTypeInternal;
+extern FeedbackDefaultTypeInternal _Feedback_default_instance_;
+class MessageId;
+class MessageIdDefaultTypeInternal;
+extern MessageIdDefaultTypeInternal _MessageId_default_instance_;
+}  // namespace InterconnectCyclic
+}  // namespace Api
+}  // namespace Kinova
+namespace Kinova {
+namespace Api {
+namespace InterconnectCyclic {
+
+// ===================================================================
+
+class MessageId : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.InterconnectCyclic.MessageId) */ {
+ public:
+  MessageId();
+  virtual ~MessageId();
+
+  MessageId(const MessageId& from);
+
+  inline MessageId& operator=(const MessageId& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  MessageId(MessageId&& from) noexcept
+    : MessageId() {
+    *this = ::std::move(from);
+  }
+
+  inline MessageId& operator=(MessageId&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const MessageId& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const MessageId* internal_default_instance() {
+    return reinterpret_cast<const MessageId*>(
+               &_MessageId_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    0;
+
+  void Swap(MessageId* other);
+  friend void swap(MessageId& a, MessageId& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline MessageId* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  MessageId* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const MessageId& from);
+  void MergeFrom(const MessageId& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(MessageId* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // fixed32 identifier = 1;
+  void clear_identifier();
+  static const int kIdentifierFieldNumber = 1;
+  ::google::protobuf::uint32 identifier() const;
+  void set_identifier(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.InterconnectCyclic.MessageId)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 identifier_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_InterconnectCyclicMessage_2eproto::TableStruct;
+  friend void ::protobuf_InterconnectCyclicMessage_2eproto::InitDefaultsMessageIdImpl();
+};
+// -------------------------------------------------------------------
+
+class Command : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.InterconnectCyclic.Command) */ {
+ public:
+  Command();
+  virtual ~Command();
+
+  Command(const Command& from);
+
+  inline Command& operator=(const Command& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Command(Command&& from) noexcept
+    : Command() {
+    *this = ::std::move(from);
+  }
+
+  inline Command& operator=(Command&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Command& default_instance();
+
+  enum ToolCommandCase {
+    kGripperCommand = 3,
+    TOOL_COMMAND_NOT_SET = 0,
+  };
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Command* internal_default_instance() {
+    return reinterpret_cast<const Command*>(
+               &_Command_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    1;
+
+  void Swap(Command* other);
+  friend void swap(Command& a, Command& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Command* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Command* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Command& from);
+  void MergeFrom(const Command& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Command* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.InterconnectCyclic.MessageId command_id = 1;
+  bool has_command_id() const;
+  void clear_command_id();
+  static const int kCommandIdFieldNumber = 1;
+  const ::Kinova::Api::InterconnectCyclic::MessageId& command_id() const;
+  ::Kinova::Api::InterconnectCyclic::MessageId* release_command_id();
+  ::Kinova::Api::InterconnectCyclic::MessageId* mutable_command_id();
+  void set_allocated_command_id(::Kinova::Api::InterconnectCyclic::MessageId* command_id);
+
+  // fixed32 flags = 2;
+  void clear_flags();
+  static const int kFlagsFieldNumber = 2;
+  ::google::protobuf::uint32 flags() const;
+  void set_flags(::google::protobuf::uint32 value);
+
+  // .Kinova.Api.GripperCyclic.Command gripper_command = 3;
+  bool has_gripper_command() const;
+  void clear_gripper_command();
+  static const int kGripperCommandFieldNumber = 3;
+  const ::Kinova::Api::GripperCyclic::Command& gripper_command() const;
+  ::Kinova::Api::GripperCyclic::Command* release_gripper_command();
+  ::Kinova::Api::GripperCyclic::Command* mutable_gripper_command();
+  void set_allocated_gripper_command(::Kinova::Api::GripperCyclic::Command* gripper_command);
+
+  ToolCommandCase tool_command_case() const;
+  // @@protoc_insertion_point(class_scope:Kinova.Api.InterconnectCyclic.Command)
+ private:
+  void set_has_gripper_command();
+
+  inline bool has_tool_command() const;
+  void clear_tool_command();
+  inline void clear_has_tool_command();
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::InterconnectCyclic::MessageId* command_id_;
+  ::google::protobuf::uint32 flags_;
+  union ToolCommandUnion {
+    ToolCommandUnion() {}
+    ::Kinova::Api::GripperCyclic::Command* gripper_command_;
+  } tool_command_;
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _oneof_case_[1];
+
+  friend struct ::protobuf_InterconnectCyclicMessage_2eproto::TableStruct;
+  friend void ::protobuf_InterconnectCyclicMessage_2eproto::InitDefaultsCommandImpl();
+};
+// -------------------------------------------------------------------
+
+class Feedback : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.InterconnectCyclic.Feedback) */ {
+ public:
+  Feedback();
+  virtual ~Feedback();
+
+  Feedback(const Feedback& from);
+
+  inline Feedback& operator=(const Feedback& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Feedback(Feedback&& from) noexcept
+    : Feedback() {
+    *this = ::std::move(from);
+  }
+
+  inline Feedback& operator=(Feedback&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Feedback& default_instance();
+
+  enum ToolFeedbackCase {
+    kGripperFeedback = 18,
+    TOOL_FEEDBACK_NOT_SET = 0,
+  };
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Feedback* internal_default_instance() {
+    return reinterpret_cast<const Feedback*>(
+               &_Feedback_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    2;
+
+  void Swap(Feedback* other);
+  friend void swap(Feedback& a, Feedback& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Feedback* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Feedback* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Feedback& from);
+  void MergeFrom(const Feedback& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Feedback* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.InterconnectCyclic.MessageId feedback_id = 1;
+  bool has_feedback_id() const;
+  void clear_feedback_id();
+  static const int kFeedbackIdFieldNumber = 1;
+  const ::Kinova::Api::InterconnectCyclic::MessageId& feedback_id() const;
+  ::Kinova::Api::InterconnectCyclic::MessageId* release_feedback_id();
+  ::Kinova::Api::InterconnectCyclic::MessageId* mutable_feedback_id();
+  void set_allocated_feedback_id(::Kinova::Api::InterconnectCyclic::MessageId* feedback_id);
+
+  // fixed32 status_flags = 2;
+  void clear_status_flags();
+  static const int kStatusFlagsFieldNumber = 2;
+  ::google::protobuf::uint32 status_flags() const;
+  void set_status_flags(::google::protobuf::uint32 value);
+
+  // fixed32 jitter_comm = 3;
+  void clear_jitter_comm();
+  static const int kJitterCommFieldNumber = 3;
+  ::google::protobuf::uint32 jitter_comm() const;
+  void set_jitter_comm(::google::protobuf::uint32 value);
+
+  // float imu_acceleration_x = 4;
+  void clear_imu_acceleration_x();
+  static const int kImuAccelerationXFieldNumber = 4;
+  float imu_acceleration_x() const;
+  void set_imu_acceleration_x(float value);
+
+  // float imu_acceleration_y = 5;
+  void clear_imu_acceleration_y();
+  static const int kImuAccelerationYFieldNumber = 5;
+  float imu_acceleration_y() const;
+  void set_imu_acceleration_y(float value);
+
+  // float imu_acceleration_z = 6;
+  void clear_imu_acceleration_z();
+  static const int kImuAccelerationZFieldNumber = 6;
+  float imu_acceleration_z() const;
+  void set_imu_acceleration_z(float value);
+
+  // float imu_angular_velocity_x = 7;
+  void clear_imu_angular_velocity_x();
+  static const int kImuAngularVelocityXFieldNumber = 7;
+  float imu_angular_velocity_x() const;
+  void set_imu_angular_velocity_x(float value);
+
+  // float imu_angular_velocity_y = 8;
+  void clear_imu_angular_velocity_y();
+  static const int kImuAngularVelocityYFieldNumber = 8;
+  float imu_angular_velocity_y() const;
+  void set_imu_angular_velocity_y(float value);
+
+  // float imu_angular_velocity_z = 9;
+  void clear_imu_angular_velocity_z();
+  static const int kImuAngularVelocityZFieldNumber = 9;
+  float imu_angular_velocity_z() const;
+  void set_imu_angular_velocity_z(float value);
+
+  // float voltage = 10;
+  void clear_voltage();
+  static const int kVoltageFieldNumber = 10;
+  float voltage() const;
+  void set_voltage(float value);
+
+  // float temperature_core = 11;
+  void clear_temperature_core();
+  static const int kTemperatureCoreFieldNumber = 11;
+  float temperature_core() const;
+  void set_temperature_core(float value);
+
+  // fixed32 fault_bank_a = 12;
+  void clear_fault_bank_a();
+  static const int kFaultBankAFieldNumber = 12;
+  ::google::protobuf::uint32 fault_bank_a() const;
+  void set_fault_bank_a(::google::protobuf::uint32 value);
+
+  // fixed32 fault_bank_b = 13;
+  void clear_fault_bank_b();
+  static const int kFaultBankBFieldNumber = 13;
+  ::google::protobuf::uint32 fault_bank_b() const;
+  void set_fault_bank_b(::google::protobuf::uint32 value);
+
+  // fixed32 warning_bank_a = 14;
+  void clear_warning_bank_a();
+  static const int kWarningBankAFieldNumber = 14;
+  ::google::protobuf::uint32 warning_bank_a() const;
+  void set_warning_bank_a(::google::protobuf::uint32 value);
+
+  // fixed32 warning_bank_b = 15;
+  void clear_warning_bank_b();
+  static const int kWarningBankBFieldNumber = 15;
+  ::google::protobuf::uint32 warning_bank_b() const;
+  void set_warning_bank_b(::google::protobuf::uint32 value);
+
+  // .Kinova.Api.GripperCyclic.Feedback gripper_feedback = 18;
+  bool has_gripper_feedback() const;
+  void clear_gripper_feedback();
+  static const int kGripperFeedbackFieldNumber = 18;
+  const ::Kinova::Api::GripperCyclic::Feedback& gripper_feedback() const;
+  ::Kinova::Api::GripperCyclic::Feedback* release_gripper_feedback();
+  ::Kinova::Api::GripperCyclic::Feedback* mutable_gripper_feedback();
+  void set_allocated_gripper_feedback(::Kinova::Api::GripperCyclic::Feedback* gripper_feedback);
+
+  ToolFeedbackCase tool_feedback_case() const;
+  // @@protoc_insertion_point(class_scope:Kinova.Api.InterconnectCyclic.Feedback)
+ private:
+  void set_has_gripper_feedback();
+
+  inline bool has_tool_feedback() const;
+  void clear_tool_feedback();
+  inline void clear_has_tool_feedback();
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::InterconnectCyclic::MessageId* feedback_id_;
+  ::google::protobuf::uint32 status_flags_;
+  ::google::protobuf::uint32 jitter_comm_;
+  float imu_acceleration_x_;
+  float imu_acceleration_y_;
+  float imu_acceleration_z_;
+  float imu_angular_velocity_x_;
+  float imu_angular_velocity_y_;
+  float imu_angular_velocity_z_;
+  float voltage_;
+  float temperature_core_;
+  ::google::protobuf::uint32 fault_bank_a_;
+  ::google::protobuf::uint32 fault_bank_b_;
+  ::google::protobuf::uint32 warning_bank_a_;
+  ::google::protobuf::uint32 warning_bank_b_;
+  union ToolFeedbackUnion {
+    ToolFeedbackUnion() {}
+    ::Kinova::Api::GripperCyclic::Feedback* gripper_feedback_;
+  } tool_feedback_;
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _oneof_case_[1];
+
+  friend struct ::protobuf_InterconnectCyclicMessage_2eproto::TableStruct;
+  friend void ::protobuf_InterconnectCyclicMessage_2eproto::InitDefaultsFeedbackImpl();
+};
+// -------------------------------------------------------------------
+
+class CustomData : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.InterconnectCyclic.CustomData) */ {
+ public:
+  CustomData();
+  virtual ~CustomData();
+
+  CustomData(const CustomData& from);
+
+  inline CustomData& operator=(const CustomData& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  CustomData(CustomData&& from) noexcept
+    : CustomData() {
+    *this = ::std::move(from);
+  }
+
+  inline CustomData& operator=(CustomData&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const CustomData& default_instance();
+
+  enum ToolCustomDataCase {
+    kGripperCustomData = 18,
+    TOOL_CUSTOMDATA_NOT_SET = 0,
+  };
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const CustomData* internal_default_instance() {
+    return reinterpret_cast<const CustomData*>(
+               &_CustomData_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    3;
+
+  void Swap(CustomData* other);
+  friend void swap(CustomData& a, CustomData& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline CustomData* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  CustomData* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const CustomData& from);
+  void MergeFrom(const CustomData& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(CustomData* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.InterconnectCyclic.MessageId custom_data_id = 1;
+  bool has_custom_data_id() const;
+  void clear_custom_data_id();
+  static const int kCustomDataIdFieldNumber = 1;
+  const ::Kinova::Api::InterconnectCyclic::MessageId& custom_data_id() const;
+  ::Kinova::Api::InterconnectCyclic::MessageId* release_custom_data_id();
+  ::Kinova::Api::InterconnectCyclic::MessageId* mutable_custom_data_id();
+  void set_allocated_custom_data_id(::Kinova::Api::InterconnectCyclic::MessageId* custom_data_id);
+
+  // fixed32 custom_data_0 = 2;
+  void clear_custom_data_0();
+  static const int kCustomData0FieldNumber = 2;
+  ::google::protobuf::uint32 custom_data_0() const;
+  void set_custom_data_0(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_1 = 3;
+  void clear_custom_data_1();
+  static const int kCustomData1FieldNumber = 3;
+  ::google::protobuf::uint32 custom_data_1() const;
+  void set_custom_data_1(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_2 = 4;
+  void clear_custom_data_2();
+  static const int kCustomData2FieldNumber = 4;
+  ::google::protobuf::uint32 custom_data_2() const;
+  void set_custom_data_2(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_3 = 5;
+  void clear_custom_data_3();
+  static const int kCustomData3FieldNumber = 5;
+  ::google::protobuf::uint32 custom_data_3() const;
+  void set_custom_data_3(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_4 = 6;
+  void clear_custom_data_4();
+  static const int kCustomData4FieldNumber = 6;
+  ::google::protobuf::uint32 custom_data_4() const;
+  void set_custom_data_4(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_5 = 7;
+  void clear_custom_data_5();
+  static const int kCustomData5FieldNumber = 7;
+  ::google::protobuf::uint32 custom_data_5() const;
+  void set_custom_data_5(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_6 = 8;
+  void clear_custom_data_6();
+  static const int kCustomData6FieldNumber = 8;
+  ::google::protobuf::uint32 custom_data_6() const;
+  void set_custom_data_6(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_7 = 9;
+  void clear_custom_data_7();
+  static const int kCustomData7FieldNumber = 9;
+  ::google::protobuf::uint32 custom_data_7() const;
+  void set_custom_data_7(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_8 = 10;
+  void clear_custom_data_8();
+  static const int kCustomData8FieldNumber = 10;
+  ::google::protobuf::uint32 custom_data_8() const;
+  void set_custom_data_8(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_9 = 11;
+  void clear_custom_data_9();
+  static const int kCustomData9FieldNumber = 11;
+  ::google::protobuf::uint32 custom_data_9() const;
+  void set_custom_data_9(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_10 = 12;
+  void clear_custom_data_10();
+  static const int kCustomData10FieldNumber = 12;
+  ::google::protobuf::uint32 custom_data_10() const;
+  void set_custom_data_10(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_11 = 13;
+  void clear_custom_data_11();
+  static const int kCustomData11FieldNumber = 13;
+  ::google::protobuf::uint32 custom_data_11() const;
+  void set_custom_data_11(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_12 = 14;
+  void clear_custom_data_12();
+  static const int kCustomData12FieldNumber = 14;
+  ::google::protobuf::uint32 custom_data_12() const;
+  void set_custom_data_12(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_13 = 15;
+  void clear_custom_data_13();
+  static const int kCustomData13FieldNumber = 15;
+  ::google::protobuf::uint32 custom_data_13() const;
+  void set_custom_data_13(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_14 = 16;
+  void clear_custom_data_14();
+  static const int kCustomData14FieldNumber = 16;
+  ::google::protobuf::uint32 custom_data_14() const;
+  void set_custom_data_14(::google::protobuf::uint32 value);
+
+  // fixed32 custom_data_15 = 17;
+  void clear_custom_data_15();
+  static const int kCustomData15FieldNumber = 17;
+  ::google::protobuf::uint32 custom_data_15() const;
+  void set_custom_data_15(::google::protobuf::uint32 value);
+
+  // .Kinova.Api.GripperCyclic.CustomData gripper_custom_data = 18;
+  bool has_gripper_custom_data() const;
+  void clear_gripper_custom_data();
+  static const int kGripperCustomDataFieldNumber = 18;
+  const ::Kinova::Api::GripperCyclic::CustomData& gripper_custom_data() const;
+  ::Kinova::Api::GripperCyclic::CustomData* release_gripper_custom_data();
+  ::Kinova::Api::GripperCyclic::CustomData* mutable_gripper_custom_data();
+  void set_allocated_gripper_custom_data(::Kinova::Api::GripperCyclic::CustomData* gripper_custom_data);
+
+  ToolCustomDataCase tool_customData_case() const;
+  // @@protoc_insertion_point(class_scope:Kinova.Api.InterconnectCyclic.CustomData)
+ private:
+  void set_has_gripper_custom_data();
+
+  inline bool has_tool_customData() const;
+  void clear_tool_customData();
+  inline void clear_has_tool_customData();
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::InterconnectCyclic::MessageId* custom_data_id_;
+  ::google::protobuf::uint32 custom_data_0_;
+  ::google::protobuf::uint32 custom_data_1_;
+  ::google::protobuf::uint32 custom_data_2_;
+  ::google::protobuf::uint32 custom_data_3_;
+  ::google::protobuf::uint32 custom_data_4_;
+  ::google::protobuf::uint32 custom_data_5_;
+  ::google::protobuf::uint32 custom_data_6_;
+  ::google::protobuf::uint32 custom_data_7_;
+  ::google::protobuf::uint32 custom_data_8_;
+  ::google::protobuf::uint32 custom_data_9_;
+  ::google::protobuf::uint32 custom_data_10_;
+  ::google::protobuf::uint32 custom_data_11_;
+  ::google::protobuf::uint32 custom_data_12_;
+  ::google::protobuf::uint32 custom_data_13_;
+  ::google::protobuf::uint32 custom_data_14_;
+  ::google::protobuf::uint32 custom_data_15_;
+  union ToolCustomDataUnion {
+    ToolCustomDataUnion() {}
+    ::Kinova::Api::GripperCyclic::CustomData* gripper_custom_data_;
+  } tool_customData_;
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _oneof_case_[1];
+
+  friend struct ::protobuf_InterconnectCyclicMessage_2eproto::TableStruct;
+  friend void ::protobuf_InterconnectCyclicMessage_2eproto::InitDefaultsCustomDataImpl();
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// MessageId
+
+// fixed32 identifier = 1;
+inline void MessageId::clear_identifier() {
+  identifier_ = 0u;
+}
+inline ::google::protobuf::uint32 MessageId::identifier() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectCyclic.MessageId.identifier)
+  return identifier_;
+}
+inline void MessageId::set_identifier(::google::protobuf::uint32 value) {
+  
+  identifier_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectCyclic.MessageId.identifier)
+}
+
+// -------------------------------------------------------------------
+
+// Command
+
+// .Kinova.Api.InterconnectCyclic.MessageId command_id = 1;
+inline bool Command::has_command_id() const {
+  return this != internal_default_instance() && command_id_ != NULL;
+}
+inline void Command::clear_command_id() {
+  if (GetArenaNoVirtual() == NULL && command_id_ != NULL) {
+    delete command_id_;
+  }
+  command_id_ = NULL;
+}
+inline const ::Kinova::Api::InterconnectCyclic::MessageId& Command::command_id() const {
+  const ::Kinova::Api::InterconnectCyclic::MessageId* p = command_id_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectCyclic.Command.command_id)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::InterconnectCyclic::MessageId*>(
+      &::Kinova::Api::InterconnectCyclic::_MessageId_default_instance_);
+}
+inline ::Kinova::Api::InterconnectCyclic::MessageId* Command::release_command_id() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.InterconnectCyclic.Command.command_id)
+  
+  ::Kinova::Api::InterconnectCyclic::MessageId* temp = command_id_;
+  command_id_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::InterconnectCyclic::MessageId* Command::mutable_command_id() {
+  
+  if (command_id_ == NULL) {
+    command_id_ = new ::Kinova::Api::InterconnectCyclic::MessageId;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.InterconnectCyclic.Command.command_id)
+  return command_id_;
+}
+inline void Command::set_allocated_command_id(::Kinova::Api::InterconnectCyclic::MessageId* command_id) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete command_id_;
+  }
+  if (command_id) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      command_id = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, command_id, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  command_id_ = command_id;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.InterconnectCyclic.Command.command_id)
+}
+
+// fixed32 flags = 2;
+inline void Command::clear_flags() {
+  flags_ = 0u;
+}
+inline ::google::protobuf::uint32 Command::flags() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectCyclic.Command.flags)
+  return flags_;
+}
+inline void Command::set_flags(::google::protobuf::uint32 value) {
+  
+  flags_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectCyclic.Command.flags)
+}
+
+// .Kinova.Api.GripperCyclic.Command gripper_command = 3;
+inline bool Command::has_gripper_command() const {
+  return tool_command_case() == kGripperCommand;
+}
+inline void Command::set_has_gripper_command() {
+  _oneof_case_[0] = kGripperCommand;
+}
+inline ::Kinova::Api::GripperCyclic::Command* Command::release_gripper_command() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.InterconnectCyclic.Command.gripper_command)
+  if (has_gripper_command()) {
+    clear_has_tool_command();
+      ::Kinova::Api::GripperCyclic::Command* temp = tool_command_.gripper_command_;
+    tool_command_.gripper_command_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline const ::Kinova::Api::GripperCyclic::Command& Command::gripper_command() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectCyclic.Command.gripper_command)
+  return has_gripper_command()
+      ? *tool_command_.gripper_command_
+      : *reinterpret_cast< ::Kinova::Api::GripperCyclic::Command*>(&::Kinova::Api::GripperCyclic::_Command_default_instance_);
+}
+inline ::Kinova::Api::GripperCyclic::Command* Command::mutable_gripper_command() {
+  if (!has_gripper_command()) {
+    clear_tool_command();
+    set_has_gripper_command();
+    tool_command_.gripper_command_ = new ::Kinova::Api::GripperCyclic::Command;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.InterconnectCyclic.Command.gripper_command)
+  return tool_command_.gripper_command_;
+}
+
+inline bool Command::has_tool_command() const {
+  return tool_command_case() != TOOL_COMMAND_NOT_SET;
+}
+inline void Command::clear_has_tool_command() {
+  _oneof_case_[0] = TOOL_COMMAND_NOT_SET;
+}
+inline Command::ToolCommandCase Command::tool_command_case() const {
+  return Command::ToolCommandCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// Feedback
+
+// .Kinova.Api.InterconnectCyclic.MessageId feedback_id = 1;
+inline bool Feedback::has_feedback_id() const {
+  return this != internal_default_instance() && feedback_id_ != NULL;
+}
+inline void Feedback::clear_feedback_id() {
+  if (GetArenaNoVirtual() == NULL && feedback_id_ != NULL) {
+    delete feedback_id_;
+  }
+  feedback_id_ = NULL;
+}
+inline const ::Kinova::Api::InterconnectCyclic::MessageId& Feedback::feedback_id() const {
+  const ::Kinova::Api::InterconnectCyclic::MessageId* p = feedback_id_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectCyclic.Feedback.feedback_id)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::InterconnectCyclic::MessageId*>(
+      &::Kinova::Api::InterconnectCyclic::_MessageId_default_instance_);
+}
+inline ::Kinova::Api::InterconnectCyclic::MessageId* Feedback::release_feedback_id() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.InterconnectCyclic.Feedback.feedback_id)
+  
+  ::Kinova::Api::InterconnectCyclic::MessageId* temp = feedback_id_;
+  feedback_id_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::InterconnectCyclic::MessageId* Feedback::mutable_feedback_id() {
+  
+  if (feedback_id_ == NULL) {
+    feedback_id_ = new ::Kinova::Api::InterconnectCyclic::MessageId;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.InterconnectCyclic.Feedback.feedback_id)
+  return feedback_id_;
+}
+inline void Feedback::set_allocated_feedback_id(::Kinova::Api::InterconnectCyclic::MessageId* feedback_id) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete feedback_id_;
+  }
+  if (feedback_id) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      feedback_id = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, feedback_id, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  feedback_id_ = feedback_id;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.InterconnectCyclic.Feedback.feedback_id)
+}
+
+// fixed32 status_flags = 2;
+inline void Feedback::clear_status_flags() {
+  status_flags_ = 0u;
+}
+inline ::google::protobuf::uint32 Feedback::status_flags() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectCyclic.Feedback.status_flags)
+  return status_flags_;
+}
+inline void Feedback::set_status_flags(::google::protobuf::uint32 value) {
+  
+  status_flags_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectCyclic.Feedback.status_flags)
+}
+
+// fixed32 jitter_comm = 3;
+inline void Feedback::clear_jitter_comm() {
+  jitter_comm_ = 0u;
+}
+inline ::google::protobuf::uint32 Feedback::jitter_comm() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectCyclic.Feedback.jitter_comm)
+  return jitter_comm_;
+}
+inline void Feedback::set_jitter_comm(::google::protobuf::uint32 value) {
+  
+  jitter_comm_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectCyclic.Feedback.jitter_comm)
+}
+
+// float imu_acceleration_x = 4;
+inline void Feedback::clear_imu_acceleration_x() {
+  imu_acceleration_x_ = 0;
+}
+inline float Feedback::imu_acceleration_x() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectCyclic.Feedback.imu_acceleration_x)
+  return imu_acceleration_x_;
+}
+inline void Feedback::set_imu_acceleration_x(float value) {
+  
+  imu_acceleration_x_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectCyclic.Feedback.imu_acceleration_x)
+}
+
+// float imu_acceleration_y = 5;
+inline void Feedback::clear_imu_acceleration_y() {
+  imu_acceleration_y_ = 0;
+}
+inline float Feedback::imu_acceleration_y() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectCyclic.Feedback.imu_acceleration_y)
+  return imu_acceleration_y_;
+}
+inline void Feedback::set_imu_acceleration_y(float value) {
+  
+  imu_acceleration_y_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectCyclic.Feedback.imu_acceleration_y)
+}
+
+// float imu_acceleration_z = 6;
+inline void Feedback::clear_imu_acceleration_z() {
+  imu_acceleration_z_ = 0;
+}
+inline float Feedback::imu_acceleration_z() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectCyclic.Feedback.imu_acceleration_z)
+  return imu_acceleration_z_;
+}
+inline void Feedback::set_imu_acceleration_z(float value) {
+  
+  imu_acceleration_z_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectCyclic.Feedback.imu_acceleration_z)
+}
+
+// float imu_angular_velocity_x = 7;
+inline void Feedback::clear_imu_angular_velocity_x() {
+  imu_angular_velocity_x_ = 0;
+}
+inline float Feedback::imu_angular_velocity_x() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectCyclic.Feedback.imu_angular_velocity_x)
+  return imu_angular_velocity_x_;
+}
+inline void Feedback::set_imu_angular_velocity_x(float value) {
+  
+  imu_angular_velocity_x_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectCyclic.Feedback.imu_angular_velocity_x)
+}
+
+// float imu_angular_velocity_y = 8;
+inline void Feedback::clear_imu_angular_velocity_y() {
+  imu_angular_velocity_y_ = 0;
+}
+inline float Feedback::imu_angular_velocity_y() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectCyclic.Feedback.imu_angular_velocity_y)
+  return imu_angular_velocity_y_;
+}
+inline void Feedback::set_imu_angular_velocity_y(float value) {
+  
+  imu_angular_velocity_y_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectCyclic.Feedback.imu_angular_velocity_y)
+}
+
+// float imu_angular_velocity_z = 9;
+inline void Feedback::clear_imu_angular_velocity_z() {
+  imu_angular_velocity_z_ = 0;
+}
+inline float Feedback::imu_angular_velocity_z() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectCyclic.Feedback.imu_angular_velocity_z)
+  return imu_angular_velocity_z_;
+}
+inline void Feedback::set_imu_angular_velocity_z(float value) {
+  
+  imu_angular_velocity_z_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectCyclic.Feedback.imu_angular_velocity_z)
+}
+
+// float voltage = 10;
+inline void Feedback::clear_voltage() {
+  voltage_ = 0;
+}
+inline float Feedback::voltage() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectCyclic.Feedback.voltage)
+  return voltage_;
+}
+inline void Feedback::set_voltage(float value) {
+  
+  voltage_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectCyclic.Feedback.voltage)
+}
+
+// float temperature_core = 11;
+inline void Feedback::clear_temperature_core() {
+  temperature_core_ = 0;
+}
+inline float Feedback::temperature_core() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectCyclic.Feedback.temperature_core)
+  return temperature_core_;
+}
+inline void Feedback::set_temperature_core(float value) {
+  
+  temperature_core_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectCyclic.Feedback.temperature_core)
+}
+
+// fixed32 fault_bank_a = 12;
+inline void Feedback::clear_fault_bank_a() {
+  fault_bank_a_ = 0u;
+}
+inline ::google::protobuf::uint32 Feedback::fault_bank_a() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectCyclic.Feedback.fault_bank_a)
+  return fault_bank_a_;
+}
+inline void Feedback::set_fault_bank_a(::google::protobuf::uint32 value) {
+  
+  fault_bank_a_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectCyclic.Feedback.fault_bank_a)
+}
+
+// fixed32 fault_bank_b = 13;
+inline void Feedback::clear_fault_bank_b() {
+  fault_bank_b_ = 0u;
+}
+inline ::google::protobuf::uint32 Feedback::fault_bank_b() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectCyclic.Feedback.fault_bank_b)
+  return fault_bank_b_;
+}
+inline void Feedback::set_fault_bank_b(::google::protobuf::uint32 value) {
+  
+  fault_bank_b_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectCyclic.Feedback.fault_bank_b)
+}
+
+// fixed32 warning_bank_a = 14;
+inline void Feedback::clear_warning_bank_a() {
+  warning_bank_a_ = 0u;
+}
+inline ::google::protobuf::uint32 Feedback::warning_bank_a() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectCyclic.Feedback.warning_bank_a)
+  return warning_bank_a_;
+}
+inline void Feedback::set_warning_bank_a(::google::protobuf::uint32 value) {
+  
+  warning_bank_a_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectCyclic.Feedback.warning_bank_a)
+}
+
+// fixed32 warning_bank_b = 15;
+inline void Feedback::clear_warning_bank_b() {
+  warning_bank_b_ = 0u;
+}
+inline ::google::protobuf::uint32 Feedback::warning_bank_b() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectCyclic.Feedback.warning_bank_b)
+  return warning_bank_b_;
+}
+inline void Feedback::set_warning_bank_b(::google::protobuf::uint32 value) {
+  
+  warning_bank_b_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectCyclic.Feedback.warning_bank_b)
+}
+
+// .Kinova.Api.GripperCyclic.Feedback gripper_feedback = 18;
+inline bool Feedback::has_gripper_feedback() const {
+  return tool_feedback_case() == kGripperFeedback;
+}
+inline void Feedback::set_has_gripper_feedback() {
+  _oneof_case_[0] = kGripperFeedback;
+}
+inline ::Kinova::Api::GripperCyclic::Feedback* Feedback::release_gripper_feedback() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.InterconnectCyclic.Feedback.gripper_feedback)
+  if (has_gripper_feedback()) {
+    clear_has_tool_feedback();
+      ::Kinova::Api::GripperCyclic::Feedback* temp = tool_feedback_.gripper_feedback_;
+    tool_feedback_.gripper_feedback_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline const ::Kinova::Api::GripperCyclic::Feedback& Feedback::gripper_feedback() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectCyclic.Feedback.gripper_feedback)
+  return has_gripper_feedback()
+      ? *tool_feedback_.gripper_feedback_
+      : *reinterpret_cast< ::Kinova::Api::GripperCyclic::Feedback*>(&::Kinova::Api::GripperCyclic::_Feedback_default_instance_);
+}
+inline ::Kinova::Api::GripperCyclic::Feedback* Feedback::mutable_gripper_feedback() {
+  if (!has_gripper_feedback()) {
+    clear_tool_feedback();
+    set_has_gripper_feedback();
+    tool_feedback_.gripper_feedback_ = new ::Kinova::Api::GripperCyclic::Feedback;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.InterconnectCyclic.Feedback.gripper_feedback)
+  return tool_feedback_.gripper_feedback_;
+}
+
+inline bool Feedback::has_tool_feedback() const {
+  return tool_feedback_case() != TOOL_FEEDBACK_NOT_SET;
+}
+inline void Feedback::clear_has_tool_feedback() {
+  _oneof_case_[0] = TOOL_FEEDBACK_NOT_SET;
+}
+inline Feedback::ToolFeedbackCase Feedback::tool_feedback_case() const {
+  return Feedback::ToolFeedbackCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// CustomData
+
+// .Kinova.Api.InterconnectCyclic.MessageId custom_data_id = 1;
+inline bool CustomData::has_custom_data_id() const {
+  return this != internal_default_instance() && custom_data_id_ != NULL;
+}
+inline void CustomData::clear_custom_data_id() {
+  if (GetArenaNoVirtual() == NULL && custom_data_id_ != NULL) {
+    delete custom_data_id_;
+  }
+  custom_data_id_ = NULL;
+}
+inline const ::Kinova::Api::InterconnectCyclic::MessageId& CustomData::custom_data_id() const {
+  const ::Kinova::Api::InterconnectCyclic::MessageId* p = custom_data_id_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectCyclic.CustomData.custom_data_id)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::InterconnectCyclic::MessageId*>(
+      &::Kinova::Api::InterconnectCyclic::_MessageId_default_instance_);
+}
+inline ::Kinova::Api::InterconnectCyclic::MessageId* CustomData::release_custom_data_id() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.InterconnectCyclic.CustomData.custom_data_id)
+  
+  ::Kinova::Api::InterconnectCyclic::MessageId* temp = custom_data_id_;
+  custom_data_id_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::InterconnectCyclic::MessageId* CustomData::mutable_custom_data_id() {
+  
+  if (custom_data_id_ == NULL) {
+    custom_data_id_ = new ::Kinova::Api::InterconnectCyclic::MessageId;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.InterconnectCyclic.CustomData.custom_data_id)
+  return custom_data_id_;
+}
+inline void CustomData::set_allocated_custom_data_id(::Kinova::Api::InterconnectCyclic::MessageId* custom_data_id) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete custom_data_id_;
+  }
+  if (custom_data_id) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      custom_data_id = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, custom_data_id, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  custom_data_id_ = custom_data_id;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.InterconnectCyclic.CustomData.custom_data_id)
+}
+
+// fixed32 custom_data_0 = 2;
+inline void CustomData::clear_custom_data_0() {
+  custom_data_0_ = 0u;
+}
+inline ::google::protobuf::uint32 CustomData::custom_data_0() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectCyclic.CustomData.custom_data_0)
+  return custom_data_0_;
+}
+inline void CustomData::set_custom_data_0(::google::protobuf::uint32 value) {
+  
+  custom_data_0_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectCyclic.CustomData.custom_data_0)
+}
+
+// fixed32 custom_data_1 = 3;
+inline void CustomData::clear_custom_data_1() {
+  custom_data_1_ = 0u;
+}
+inline ::google::protobuf::uint32 CustomData::custom_data_1() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectCyclic.CustomData.custom_data_1)
+  return custom_data_1_;
+}
+inline void CustomData::set_custom_data_1(::google::protobuf::uint32 value) {
+  
+  custom_data_1_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectCyclic.CustomData.custom_data_1)
+}
+
+// fixed32 custom_data_2 = 4;
+inline void CustomData::clear_custom_data_2() {
+  custom_data_2_ = 0u;
+}
+inline ::google::protobuf::uint32 CustomData::custom_data_2() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectCyclic.CustomData.custom_data_2)
+  return custom_data_2_;
+}
+inline void CustomData::set_custom_data_2(::google::protobuf::uint32 value) {
+  
+  custom_data_2_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectCyclic.CustomData.custom_data_2)
+}
+
+// fixed32 custom_data_3 = 5;
+inline void CustomData::clear_custom_data_3() {
+  custom_data_3_ = 0u;
+}
+inline ::google::protobuf::uint32 CustomData::custom_data_3() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectCyclic.CustomData.custom_data_3)
+  return custom_data_3_;
+}
+inline void CustomData::set_custom_data_3(::google::protobuf::uint32 value) {
+  
+  custom_data_3_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectCyclic.CustomData.custom_data_3)
+}
+
+// fixed32 custom_data_4 = 6;
+inline void CustomData::clear_custom_data_4() {
+  custom_data_4_ = 0u;
+}
+inline ::google::protobuf::uint32 CustomData::custom_data_4() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectCyclic.CustomData.custom_data_4)
+  return custom_data_4_;
+}
+inline void CustomData::set_custom_data_4(::google::protobuf::uint32 value) {
+  
+  custom_data_4_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectCyclic.CustomData.custom_data_4)
+}
+
+// fixed32 custom_data_5 = 7;
+inline void CustomData::clear_custom_data_5() {
+  custom_data_5_ = 0u;
+}
+inline ::google::protobuf::uint32 CustomData::custom_data_5() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectCyclic.CustomData.custom_data_5)
+  return custom_data_5_;
+}
+inline void CustomData::set_custom_data_5(::google::protobuf::uint32 value) {
+  
+  custom_data_5_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectCyclic.CustomData.custom_data_5)
+}
+
+// fixed32 custom_data_6 = 8;
+inline void CustomData::clear_custom_data_6() {
+  custom_data_6_ = 0u;
+}
+inline ::google::protobuf::uint32 CustomData::custom_data_6() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectCyclic.CustomData.custom_data_6)
+  return custom_data_6_;
+}
+inline void CustomData::set_custom_data_6(::google::protobuf::uint32 value) {
+  
+  custom_data_6_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectCyclic.CustomData.custom_data_6)
+}
+
+// fixed32 custom_data_7 = 9;
+inline void CustomData::clear_custom_data_7() {
+  custom_data_7_ = 0u;
+}
+inline ::google::protobuf::uint32 CustomData::custom_data_7() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectCyclic.CustomData.custom_data_7)
+  return custom_data_7_;
+}
+inline void CustomData::set_custom_data_7(::google::protobuf::uint32 value) {
+  
+  custom_data_7_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectCyclic.CustomData.custom_data_7)
+}
+
+// fixed32 custom_data_8 = 10;
+inline void CustomData::clear_custom_data_8() {
+  custom_data_8_ = 0u;
+}
+inline ::google::protobuf::uint32 CustomData::custom_data_8() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectCyclic.CustomData.custom_data_8)
+  return custom_data_8_;
+}
+inline void CustomData::set_custom_data_8(::google::protobuf::uint32 value) {
+  
+  custom_data_8_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectCyclic.CustomData.custom_data_8)
+}
+
+// fixed32 custom_data_9 = 11;
+inline void CustomData::clear_custom_data_9() {
+  custom_data_9_ = 0u;
+}
+inline ::google::protobuf::uint32 CustomData::custom_data_9() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectCyclic.CustomData.custom_data_9)
+  return custom_data_9_;
+}
+inline void CustomData::set_custom_data_9(::google::protobuf::uint32 value) {
+  
+  custom_data_9_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectCyclic.CustomData.custom_data_9)
+}
+
+// fixed32 custom_data_10 = 12;
+inline void CustomData::clear_custom_data_10() {
+  custom_data_10_ = 0u;
+}
+inline ::google::protobuf::uint32 CustomData::custom_data_10() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectCyclic.CustomData.custom_data_10)
+  return custom_data_10_;
+}
+inline void CustomData::set_custom_data_10(::google::protobuf::uint32 value) {
+  
+  custom_data_10_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectCyclic.CustomData.custom_data_10)
+}
+
+// fixed32 custom_data_11 = 13;
+inline void CustomData::clear_custom_data_11() {
+  custom_data_11_ = 0u;
+}
+inline ::google::protobuf::uint32 CustomData::custom_data_11() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectCyclic.CustomData.custom_data_11)
+  return custom_data_11_;
+}
+inline void CustomData::set_custom_data_11(::google::protobuf::uint32 value) {
+  
+  custom_data_11_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectCyclic.CustomData.custom_data_11)
+}
+
+// fixed32 custom_data_12 = 14;
+inline void CustomData::clear_custom_data_12() {
+  custom_data_12_ = 0u;
+}
+inline ::google::protobuf::uint32 CustomData::custom_data_12() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectCyclic.CustomData.custom_data_12)
+  return custom_data_12_;
+}
+inline void CustomData::set_custom_data_12(::google::protobuf::uint32 value) {
+  
+  custom_data_12_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectCyclic.CustomData.custom_data_12)
+}
+
+// fixed32 custom_data_13 = 15;
+inline void CustomData::clear_custom_data_13() {
+  custom_data_13_ = 0u;
+}
+inline ::google::protobuf::uint32 CustomData::custom_data_13() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectCyclic.CustomData.custom_data_13)
+  return custom_data_13_;
+}
+inline void CustomData::set_custom_data_13(::google::protobuf::uint32 value) {
+  
+  custom_data_13_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectCyclic.CustomData.custom_data_13)
+}
+
+// fixed32 custom_data_14 = 16;
+inline void CustomData::clear_custom_data_14() {
+  custom_data_14_ = 0u;
+}
+inline ::google::protobuf::uint32 CustomData::custom_data_14() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectCyclic.CustomData.custom_data_14)
+  return custom_data_14_;
+}
+inline void CustomData::set_custom_data_14(::google::protobuf::uint32 value) {
+  
+  custom_data_14_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectCyclic.CustomData.custom_data_14)
+}
+
+// fixed32 custom_data_15 = 17;
+inline void CustomData::clear_custom_data_15() {
+  custom_data_15_ = 0u;
+}
+inline ::google::protobuf::uint32 CustomData::custom_data_15() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectCyclic.CustomData.custom_data_15)
+  return custom_data_15_;
+}
+inline void CustomData::set_custom_data_15(::google::protobuf::uint32 value) {
+  
+  custom_data_15_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.InterconnectCyclic.CustomData.custom_data_15)
+}
+
+// .Kinova.Api.GripperCyclic.CustomData gripper_custom_data = 18;
+inline bool CustomData::has_gripper_custom_data() const {
+  return tool_customData_case() == kGripperCustomData;
+}
+inline void CustomData::set_has_gripper_custom_data() {
+  _oneof_case_[0] = kGripperCustomData;
+}
+inline ::Kinova::Api::GripperCyclic::CustomData* CustomData::release_gripper_custom_data() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.InterconnectCyclic.CustomData.gripper_custom_data)
+  if (has_gripper_custom_data()) {
+    clear_has_tool_customData();
+      ::Kinova::Api::GripperCyclic::CustomData* temp = tool_customData_.gripper_custom_data_;
+    tool_customData_.gripper_custom_data_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline const ::Kinova::Api::GripperCyclic::CustomData& CustomData::gripper_custom_data() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.InterconnectCyclic.CustomData.gripper_custom_data)
+  return has_gripper_custom_data()
+      ? *tool_customData_.gripper_custom_data_
+      : *reinterpret_cast< ::Kinova::Api::GripperCyclic::CustomData*>(&::Kinova::Api::GripperCyclic::_CustomData_default_instance_);
+}
+inline ::Kinova::Api::GripperCyclic::CustomData* CustomData::mutable_gripper_custom_data() {
+  if (!has_gripper_custom_data()) {
+    clear_tool_customData();
+    set_has_gripper_custom_data();
+    tool_customData_.gripper_custom_data_ = new ::Kinova::Api::GripperCyclic::CustomData;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.InterconnectCyclic.CustomData.gripper_custom_data)
+  return tool_customData_.gripper_custom_data_;
+}
+
+inline bool CustomData::has_tool_customData() const {
+  return tool_customData_case() != TOOL_CUSTOMDATA_NOT_SET;
+}
+inline void CustomData::clear_has_tool_customData() {
+  _oneof_case_[0] = TOOL_CUSTOMDATA_NOT_SET;
+}
+inline CustomData::ToolCustomDataCase CustomData::tool_customData_case() const {
+  return CustomData::ToolCustomDataCase(_oneof_case_[0]);
+}
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace InterconnectCyclic
+}  // namespace Api
+}  // namespace Kinova
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_InterconnectCyclicMessage_2eproto__INCLUDED
diff --git a/kortex_api/include/messages/ProductConfiguration.pb.h b/kortex_api/include/messages/ProductConfiguration.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..16e761d766a99e447740ba3e57eff3323b633507
--- /dev/null
+++ b/kortex_api/include/messages/ProductConfiguration.pb.h
@@ -0,0 +1,983 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: ProductConfiguration.proto
+
+#ifndef PROTOBUF_ProductConfiguration_2eproto__INCLUDED
+#define PROTOBUF_ProductConfiguration_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 3005000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 3005001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "Common.pb.h"  // IWYU pragma: export
+// @@protoc_insertion_point(includes)
+
+namespace protobuf_ProductConfiguration_2eproto {
+// Internal implementation detail -- do not use these members.
+struct TableStruct {
+  static const ::google::protobuf::internal::ParseTableField entries[];
+  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
+  static const ::google::protobuf::internal::ParseTable schema[2];
+  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
+  static const ::google::protobuf::internal::SerializationTable serialization_table[];
+  static const ::google::protobuf::uint32 offsets[];
+};
+void AddDescriptors();
+void InitDefaultsCompleteProductConfigurationImpl();
+void InitDefaultsCompleteProductConfiguration();
+void InitDefaultsProductConfigurationEndEffectorTypeImpl();
+void InitDefaultsProductConfigurationEndEffectorType();
+inline void InitDefaults() {
+  InitDefaultsCompleteProductConfiguration();
+  InitDefaultsProductConfigurationEndEffectorType();
+}
+}  // namespace protobuf_ProductConfiguration_2eproto
+namespace Kinova {
+namespace Api {
+namespace ProductConfiguration {
+class CompleteProductConfiguration;
+class CompleteProductConfigurationDefaultTypeInternal;
+extern CompleteProductConfigurationDefaultTypeInternal _CompleteProductConfiguration_default_instance_;
+class ProductConfigurationEndEffectorType;
+class ProductConfigurationEndEffectorTypeDefaultTypeInternal;
+extern ProductConfigurationEndEffectorTypeDefaultTypeInternal _ProductConfigurationEndEffectorType_default_instance_;
+}  // namespace ProductConfiguration
+}  // namespace Api
+}  // namespace Kinova
+namespace Kinova {
+namespace Api {
+namespace ProductConfiguration {
+
+enum ModelId {
+  MODEL_ID_UNSPECIFIED = 0,
+  MODEL_ID_L53 = 1,
+  MODEL_ID_L31 = 2,
+  ModelId_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  ModelId_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool ModelId_IsValid(int value);
+const ModelId ModelId_MIN = MODEL_ID_UNSPECIFIED;
+const ModelId ModelId_MAX = MODEL_ID_L31;
+const int ModelId_ARRAYSIZE = ModelId_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* ModelId_descriptor();
+inline const ::std::string& ModelId_Name(ModelId value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    ModelId_descriptor(), value);
+}
+inline bool ModelId_Parse(
+    const ::std::string& name, ModelId* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<ModelId>(
+    ModelId_descriptor(), name, value);
+}
+enum BaseType {
+  BASE_TYPE_UNSPECIFIED = 0,
+  BASE_TYPE_L53_QUICK_CONNECT = 1,
+  BASE_TYPE_L53_FIXED = 2,
+  BASE_TYPE_L31_FIXED = 3,
+  BaseType_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  BaseType_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool BaseType_IsValid(int value);
+const BaseType BaseType_MIN = BASE_TYPE_UNSPECIFIED;
+const BaseType BaseType_MAX = BASE_TYPE_L31_FIXED;
+const int BaseType_ARRAYSIZE = BaseType_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* BaseType_descriptor();
+inline const ::std::string& BaseType_Name(BaseType value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    BaseType_descriptor(), value);
+}
+inline bool BaseType_Parse(
+    const ::std::string& name, BaseType* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<BaseType>(
+    BaseType_descriptor(), name, value);
+}
+enum EndEffectorType {
+  END_EFFECTOR_TYPE_UNSPECIFIED = 0,
+  END_EFFECTOR_TYPE_NOT_INSTALLED = 1,
+  END_EFFECTOR_TYPE_L31_GRIPPER_2F = 2,
+  END_EFFECTOR_TYPE_ROBOTIQ_2F_85 = 3,
+  END_EFFECTOR_TYPE_ROBOTIQ_2F_140 = 4,
+  EndEffectorType_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  EndEffectorType_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool EndEffectorType_IsValid(int value);
+const EndEffectorType EndEffectorType_MIN = END_EFFECTOR_TYPE_UNSPECIFIED;
+const EndEffectorType EndEffectorType_MAX = END_EFFECTOR_TYPE_ROBOTIQ_2F_140;
+const int EndEffectorType_ARRAYSIZE = EndEffectorType_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* EndEffectorType_descriptor();
+inline const ::std::string& EndEffectorType_Name(EndEffectorType value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    EndEffectorType_descriptor(), value);
+}
+inline bool EndEffectorType_Parse(
+    const ::std::string& name, EndEffectorType* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<EndEffectorType>(
+    EndEffectorType_descriptor(), name, value);
+}
+enum VisionModuleType {
+  VISION_MODULE_TYPE_UNSPECIFIED = 0,
+  VISION_MODULE_TYPE_NOT_INSTALLED = 1,
+  VISION_MODULE_TYPE_L53_2D3D = 2,
+  VISION_MODULE_TYPE_L53_2D = 3,
+  VISION_MODULE_TYPE_EOD = 4,
+  VisionModuleType_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  VisionModuleType_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool VisionModuleType_IsValid(int value);
+const VisionModuleType VisionModuleType_MIN = VISION_MODULE_TYPE_UNSPECIFIED;
+const VisionModuleType VisionModuleType_MAX = VISION_MODULE_TYPE_EOD;
+const int VisionModuleType_ARRAYSIZE = VisionModuleType_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* VisionModuleType_descriptor();
+inline const ::std::string& VisionModuleType_Name(VisionModuleType value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    VisionModuleType_descriptor(), value);
+}
+inline bool VisionModuleType_Parse(
+    const ::std::string& name, VisionModuleType* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<VisionModuleType>(
+    VisionModuleType_descriptor(), name, value);
+}
+enum InterfaceModuleType {
+  INTERFACE_MODULE_TYPE_UNSPECIFIED = 0,
+  INTERFACE_MODULE_TYPE_NOT_INSTALLED = 1,
+  INTERFACE_MODULE_TYPE_L53 = 2,
+  INTERFACE_MODULE_TYPE_L31 = 3,
+  InterfaceModuleType_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  InterfaceModuleType_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool InterfaceModuleType_IsValid(int value);
+const InterfaceModuleType InterfaceModuleType_MIN = INTERFACE_MODULE_TYPE_UNSPECIFIED;
+const InterfaceModuleType InterfaceModuleType_MAX = INTERFACE_MODULE_TYPE_L31;
+const int InterfaceModuleType_ARRAYSIZE = InterfaceModuleType_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* InterfaceModuleType_descriptor();
+inline const ::std::string& InterfaceModuleType_Name(InterfaceModuleType value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    InterfaceModuleType_descriptor(), value);
+}
+inline bool InterfaceModuleType_Parse(
+    const ::std::string& name, InterfaceModuleType* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<InterfaceModuleType>(
+    InterfaceModuleType_descriptor(), name, value);
+}
+enum ArmLaterality {
+  ARM_LATERALITY_UNSPECIFIED = 0,
+  ARM_LATERALITY_NOT_APPLICABLE = 1,
+  ARM_LATERALITY_LEFT = 2,
+  ARM_LATERALITY_RIGHT = 3,
+  ArmLaterality_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  ArmLaterality_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool ArmLaterality_IsValid(int value);
+const ArmLaterality ArmLaterality_MIN = ARM_LATERALITY_UNSPECIFIED;
+const ArmLaterality ArmLaterality_MAX = ARM_LATERALITY_RIGHT;
+const int ArmLaterality_ARRAYSIZE = ArmLaterality_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* ArmLaterality_descriptor();
+inline const ::std::string& ArmLaterality_Name(ArmLaterality value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    ArmLaterality_descriptor(), value);
+}
+inline bool ArmLaterality_Parse(
+    const ::std::string& name, ArmLaterality* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<ArmLaterality>(
+    ArmLaterality_descriptor(), name, value);
+}
+enum WristType {
+  WRIST_TYPE_UNSPECIFIED = 0,
+  WRIST_TYPE_NOT_APPLICABLE = 1,
+  WRIST_TYPE_SPHERICAL = 2,
+  WRIST_TYPE_CURVED = 3,
+  WristType_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  WristType_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool WristType_IsValid(int value);
+const WristType WristType_MIN = WRIST_TYPE_UNSPECIFIED;
+const WristType WristType_MAX = WRIST_TYPE_CURVED;
+const int WristType_ARRAYSIZE = WristType_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* WristType_descriptor();
+inline const ::std::string& WristType_Name(WristType value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    WristType_descriptor(), value);
+}
+inline bool WristType_Parse(
+    const ::std::string& name, WristType* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<WristType>(
+    WristType_descriptor(), name, value);
+}
+enum BrakeType {
+  BRAKE_TYPE_UNSPECIFIED = 0,
+  BRAKE_TYPE_NOT_INSTALLED = 1,
+  BrakeType_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  BrakeType_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool BrakeType_IsValid(int value);
+const BrakeType BrakeType_MIN = BRAKE_TYPE_UNSPECIFIED;
+const BrakeType BrakeType_MAX = BRAKE_TYPE_NOT_INSTALLED;
+const int BrakeType_ARRAYSIZE = BrakeType_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* BrakeType_descriptor();
+inline const ::std::string& BrakeType_Name(BrakeType value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    BrakeType_descriptor(), value);
+}
+inline bool BrakeType_Parse(
+    const ::std::string& name, BrakeType* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<BrakeType>(
+    BrakeType_descriptor(), name, value);
+}
+// ===================================================================
+
+class CompleteProductConfiguration : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.ProductConfiguration.CompleteProductConfiguration) */ {
+ public:
+  CompleteProductConfiguration();
+  virtual ~CompleteProductConfiguration();
+
+  CompleteProductConfiguration(const CompleteProductConfiguration& from);
+
+  inline CompleteProductConfiguration& operator=(const CompleteProductConfiguration& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  CompleteProductConfiguration(CompleteProductConfiguration&& from) noexcept
+    : CompleteProductConfiguration() {
+    *this = ::std::move(from);
+  }
+
+  inline CompleteProductConfiguration& operator=(CompleteProductConfiguration&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const CompleteProductConfiguration& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const CompleteProductConfiguration* internal_default_instance() {
+    return reinterpret_cast<const CompleteProductConfiguration*>(
+               &_CompleteProductConfiguration_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    0;
+
+  void Swap(CompleteProductConfiguration* other);
+  friend void swap(CompleteProductConfiguration& a, CompleteProductConfiguration& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline CompleteProductConfiguration* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  CompleteProductConfiguration* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const CompleteProductConfiguration& from);
+  void MergeFrom(const CompleteProductConfiguration& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(CompleteProductConfiguration* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // string kin = 1;
+  void clear_kin();
+  static const int kKinFieldNumber = 1;
+  const ::std::string& kin() const;
+  void set_kin(const ::std::string& value);
+  #if LANG_CXX11
+  void set_kin(::std::string&& value);
+  #endif
+  void set_kin(const char* value);
+  void set_kin(const char* value, size_t size);
+  ::std::string* mutable_kin();
+  ::std::string* release_kin();
+  void set_allocated_kin(::std::string* kin);
+
+  // string assembly_plant = 4;
+  void clear_assembly_plant();
+  static const int kAssemblyPlantFieldNumber = 4;
+  const ::std::string& assembly_plant() const;
+  void set_assembly_plant(const ::std::string& value);
+  #if LANG_CXX11
+  void set_assembly_plant(::std::string&& value);
+  #endif
+  void set_assembly_plant(const char* value);
+  void set_assembly_plant(const char* value, size_t size);
+  ::std::string* mutable_assembly_plant();
+  ::std::string* release_assembly_plant();
+  void set_allocated_assembly_plant(::std::string* assembly_plant);
+
+  // string model_year = 5;
+  void clear_model_year();
+  static const int kModelYearFieldNumber = 5;
+  const ::std::string& model_year() const;
+  void set_model_year(const ::std::string& value);
+  #if LANG_CXX11
+  void set_model_year(::std::string&& value);
+  #endif
+  void set_model_year(const char* value);
+  void set_model_year(const char* value, size_t size);
+  ::std::string* mutable_model_year();
+  ::std::string* release_model_year();
+  void set_allocated_model_year(::std::string* model_year);
+
+  // .Kinova.Api.Common.CountryCode country_code = 3;
+  bool has_country_code() const;
+  void clear_country_code();
+  static const int kCountryCodeFieldNumber = 3;
+  const ::Kinova::Api::Common::CountryCode& country_code() const;
+  ::Kinova::Api::Common::CountryCode* release_country_code();
+  ::Kinova::Api::Common::CountryCode* mutable_country_code();
+  void set_allocated_country_code(::Kinova::Api::Common::CountryCode* country_code);
+
+  // .Kinova.Api.ProductConfiguration.ModelId model = 2;
+  void clear_model();
+  static const int kModelFieldNumber = 2;
+  ::Kinova::Api::ProductConfiguration::ModelId model() const;
+  void set_model(::Kinova::Api::ProductConfiguration::ModelId value);
+
+  // uint32 degree_of_freedom = 6;
+  void clear_degree_of_freedom();
+  static const int kDegreeOfFreedomFieldNumber = 6;
+  ::google::protobuf::uint32 degree_of_freedom() const;
+  void set_degree_of_freedom(::google::protobuf::uint32 value);
+
+  // .Kinova.Api.ProductConfiguration.BaseType base_type = 7;
+  void clear_base_type();
+  static const int kBaseTypeFieldNumber = 7;
+  ::Kinova::Api::ProductConfiguration::BaseType base_type() const;
+  void set_base_type(::Kinova::Api::ProductConfiguration::BaseType value);
+
+  // .Kinova.Api.ProductConfiguration.EndEffectorType end_effector_type = 8;
+  void clear_end_effector_type();
+  static const int kEndEffectorTypeFieldNumber = 8;
+  ::Kinova::Api::ProductConfiguration::EndEffectorType end_effector_type() const;
+  void set_end_effector_type(::Kinova::Api::ProductConfiguration::EndEffectorType value);
+
+  // .Kinova.Api.ProductConfiguration.VisionModuleType vision_module_type = 9;
+  void clear_vision_module_type();
+  static const int kVisionModuleTypeFieldNumber = 9;
+  ::Kinova::Api::ProductConfiguration::VisionModuleType vision_module_type() const;
+  void set_vision_module_type(::Kinova::Api::ProductConfiguration::VisionModuleType value);
+
+  // .Kinova.Api.ProductConfiguration.InterfaceModuleType interface_module_type = 10;
+  void clear_interface_module_type();
+  static const int kInterfaceModuleTypeFieldNumber = 10;
+  ::Kinova::Api::ProductConfiguration::InterfaceModuleType interface_module_type() const;
+  void set_interface_module_type(::Kinova::Api::ProductConfiguration::InterfaceModuleType value);
+
+  // .Kinova.Api.ProductConfiguration.ArmLaterality arm_laterality = 11;
+  void clear_arm_laterality();
+  static const int kArmLateralityFieldNumber = 11;
+  ::Kinova::Api::ProductConfiguration::ArmLaterality arm_laterality() const;
+  void set_arm_laterality(::Kinova::Api::ProductConfiguration::ArmLaterality value);
+
+  // .Kinova.Api.ProductConfiguration.WristType wrist_type = 12;
+  void clear_wrist_type();
+  static const int kWristTypeFieldNumber = 12;
+  ::Kinova::Api::ProductConfiguration::WristType wrist_type() const;
+  void set_wrist_type(::Kinova::Api::ProductConfiguration::WristType value);
+
+  // .Kinova.Api.ProductConfiguration.BrakeType brake_type = 13;
+  void clear_brake_type();
+  static const int kBrakeTypeFieldNumber = 13;
+  ::Kinova::Api::ProductConfiguration::BrakeType brake_type() const;
+  void set_brake_type(::Kinova::Api::ProductConfiguration::BrakeType value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.ProductConfiguration.CompleteProductConfiguration)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::internal::ArenaStringPtr kin_;
+  ::google::protobuf::internal::ArenaStringPtr assembly_plant_;
+  ::google::protobuf::internal::ArenaStringPtr model_year_;
+  ::Kinova::Api::Common::CountryCode* country_code_;
+  int model_;
+  ::google::protobuf::uint32 degree_of_freedom_;
+  int base_type_;
+  int end_effector_type_;
+  int vision_module_type_;
+  int interface_module_type_;
+  int arm_laterality_;
+  int wrist_type_;
+  int brake_type_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_ProductConfiguration_2eproto::TableStruct;
+  friend void ::protobuf_ProductConfiguration_2eproto::InitDefaultsCompleteProductConfigurationImpl();
+};
+// -------------------------------------------------------------------
+
+class ProductConfigurationEndEffectorType : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.ProductConfiguration.ProductConfigurationEndEffectorType) */ {
+ public:
+  ProductConfigurationEndEffectorType();
+  virtual ~ProductConfigurationEndEffectorType();
+
+  ProductConfigurationEndEffectorType(const ProductConfigurationEndEffectorType& from);
+
+  inline ProductConfigurationEndEffectorType& operator=(const ProductConfigurationEndEffectorType& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ProductConfigurationEndEffectorType(ProductConfigurationEndEffectorType&& from) noexcept
+    : ProductConfigurationEndEffectorType() {
+    *this = ::std::move(from);
+  }
+
+  inline ProductConfigurationEndEffectorType& operator=(ProductConfigurationEndEffectorType&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ProductConfigurationEndEffectorType& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ProductConfigurationEndEffectorType* internal_default_instance() {
+    return reinterpret_cast<const ProductConfigurationEndEffectorType*>(
+               &_ProductConfigurationEndEffectorType_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    1;
+
+  void Swap(ProductConfigurationEndEffectorType* other);
+  friend void swap(ProductConfigurationEndEffectorType& a, ProductConfigurationEndEffectorType& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ProductConfigurationEndEffectorType* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ProductConfigurationEndEffectorType* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ProductConfigurationEndEffectorType& from);
+  void MergeFrom(const ProductConfigurationEndEffectorType& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ProductConfigurationEndEffectorType* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.ProductConfiguration.EndEffectorType end_effector_type = 1;
+  void clear_end_effector_type();
+  static const int kEndEffectorTypeFieldNumber = 1;
+  ::Kinova::Api::ProductConfiguration::EndEffectorType end_effector_type() const;
+  void set_end_effector_type(::Kinova::Api::ProductConfiguration::EndEffectorType value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.ProductConfiguration.ProductConfigurationEndEffectorType)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  int end_effector_type_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_ProductConfiguration_2eproto::TableStruct;
+  friend void ::protobuf_ProductConfiguration_2eproto::InitDefaultsProductConfigurationEndEffectorTypeImpl();
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// CompleteProductConfiguration
+
+// string kin = 1;
+inline void CompleteProductConfiguration::clear_kin() {
+  kin_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& CompleteProductConfiguration::kin() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ProductConfiguration.CompleteProductConfiguration.kin)
+  return kin_.GetNoArena();
+}
+inline void CompleteProductConfiguration::set_kin(const ::std::string& value) {
+  
+  kin_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.ProductConfiguration.CompleteProductConfiguration.kin)
+}
+#if LANG_CXX11
+inline void CompleteProductConfiguration::set_kin(::std::string&& value) {
+  
+  kin_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:Kinova.Api.ProductConfiguration.CompleteProductConfiguration.kin)
+}
+#endif
+inline void CompleteProductConfiguration::set_kin(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  kin_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:Kinova.Api.ProductConfiguration.CompleteProductConfiguration.kin)
+}
+inline void CompleteProductConfiguration::set_kin(const char* value, size_t size) {
+  
+  kin_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:Kinova.Api.ProductConfiguration.CompleteProductConfiguration.kin)
+}
+inline ::std::string* CompleteProductConfiguration::mutable_kin() {
+  
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.ProductConfiguration.CompleteProductConfiguration.kin)
+  return kin_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* CompleteProductConfiguration::release_kin() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.ProductConfiguration.CompleteProductConfiguration.kin)
+  
+  return kin_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void CompleteProductConfiguration::set_allocated_kin(::std::string* kin) {
+  if (kin != NULL) {
+    
+  } else {
+    
+  }
+  kin_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), kin);
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.ProductConfiguration.CompleteProductConfiguration.kin)
+}
+
+// .Kinova.Api.ProductConfiguration.ModelId model = 2;
+inline void CompleteProductConfiguration::clear_model() {
+  model_ = 0;
+}
+inline ::Kinova::Api::ProductConfiguration::ModelId CompleteProductConfiguration::model() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ProductConfiguration.CompleteProductConfiguration.model)
+  return static_cast< ::Kinova::Api::ProductConfiguration::ModelId >(model_);
+}
+inline void CompleteProductConfiguration::set_model(::Kinova::Api::ProductConfiguration::ModelId value) {
+  
+  model_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ProductConfiguration.CompleteProductConfiguration.model)
+}
+
+// .Kinova.Api.Common.CountryCode country_code = 3;
+inline bool CompleteProductConfiguration::has_country_code() const {
+  return this != internal_default_instance() && country_code_ != NULL;
+}
+inline const ::Kinova::Api::Common::CountryCode& CompleteProductConfiguration::country_code() const {
+  const ::Kinova::Api::Common::CountryCode* p = country_code_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.ProductConfiguration.CompleteProductConfiguration.country_code)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::CountryCode*>(
+      &::Kinova::Api::Common::_CountryCode_default_instance_);
+}
+inline ::Kinova::Api::Common::CountryCode* CompleteProductConfiguration::release_country_code() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.ProductConfiguration.CompleteProductConfiguration.country_code)
+  
+  ::Kinova::Api::Common::CountryCode* temp = country_code_;
+  country_code_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::CountryCode* CompleteProductConfiguration::mutable_country_code() {
+  
+  if (country_code_ == NULL) {
+    country_code_ = new ::Kinova::Api::Common::CountryCode;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.ProductConfiguration.CompleteProductConfiguration.country_code)
+  return country_code_;
+}
+inline void CompleteProductConfiguration::set_allocated_country_code(::Kinova::Api::Common::CountryCode* country_code) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(country_code_);
+  }
+  if (country_code) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      country_code = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, country_code, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  country_code_ = country_code;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.ProductConfiguration.CompleteProductConfiguration.country_code)
+}
+
+// string assembly_plant = 4;
+inline void CompleteProductConfiguration::clear_assembly_plant() {
+  assembly_plant_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& CompleteProductConfiguration::assembly_plant() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ProductConfiguration.CompleteProductConfiguration.assembly_plant)
+  return assembly_plant_.GetNoArena();
+}
+inline void CompleteProductConfiguration::set_assembly_plant(const ::std::string& value) {
+  
+  assembly_plant_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.ProductConfiguration.CompleteProductConfiguration.assembly_plant)
+}
+#if LANG_CXX11
+inline void CompleteProductConfiguration::set_assembly_plant(::std::string&& value) {
+  
+  assembly_plant_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:Kinova.Api.ProductConfiguration.CompleteProductConfiguration.assembly_plant)
+}
+#endif
+inline void CompleteProductConfiguration::set_assembly_plant(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  assembly_plant_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:Kinova.Api.ProductConfiguration.CompleteProductConfiguration.assembly_plant)
+}
+inline void CompleteProductConfiguration::set_assembly_plant(const char* value, size_t size) {
+  
+  assembly_plant_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:Kinova.Api.ProductConfiguration.CompleteProductConfiguration.assembly_plant)
+}
+inline ::std::string* CompleteProductConfiguration::mutable_assembly_plant() {
+  
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.ProductConfiguration.CompleteProductConfiguration.assembly_plant)
+  return assembly_plant_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* CompleteProductConfiguration::release_assembly_plant() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.ProductConfiguration.CompleteProductConfiguration.assembly_plant)
+  
+  return assembly_plant_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void CompleteProductConfiguration::set_allocated_assembly_plant(::std::string* assembly_plant) {
+  if (assembly_plant != NULL) {
+    
+  } else {
+    
+  }
+  assembly_plant_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), assembly_plant);
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.ProductConfiguration.CompleteProductConfiguration.assembly_plant)
+}
+
+// string model_year = 5;
+inline void CompleteProductConfiguration::clear_model_year() {
+  model_year_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& CompleteProductConfiguration::model_year() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ProductConfiguration.CompleteProductConfiguration.model_year)
+  return model_year_.GetNoArena();
+}
+inline void CompleteProductConfiguration::set_model_year(const ::std::string& value) {
+  
+  model_year_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.ProductConfiguration.CompleteProductConfiguration.model_year)
+}
+#if LANG_CXX11
+inline void CompleteProductConfiguration::set_model_year(::std::string&& value) {
+  
+  model_year_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:Kinova.Api.ProductConfiguration.CompleteProductConfiguration.model_year)
+}
+#endif
+inline void CompleteProductConfiguration::set_model_year(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  model_year_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:Kinova.Api.ProductConfiguration.CompleteProductConfiguration.model_year)
+}
+inline void CompleteProductConfiguration::set_model_year(const char* value, size_t size) {
+  
+  model_year_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:Kinova.Api.ProductConfiguration.CompleteProductConfiguration.model_year)
+}
+inline ::std::string* CompleteProductConfiguration::mutable_model_year() {
+  
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.ProductConfiguration.CompleteProductConfiguration.model_year)
+  return model_year_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* CompleteProductConfiguration::release_model_year() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.ProductConfiguration.CompleteProductConfiguration.model_year)
+  
+  return model_year_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void CompleteProductConfiguration::set_allocated_model_year(::std::string* model_year) {
+  if (model_year != NULL) {
+    
+  } else {
+    
+  }
+  model_year_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), model_year);
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.ProductConfiguration.CompleteProductConfiguration.model_year)
+}
+
+// uint32 degree_of_freedom = 6;
+inline void CompleteProductConfiguration::clear_degree_of_freedom() {
+  degree_of_freedom_ = 0u;
+}
+inline ::google::protobuf::uint32 CompleteProductConfiguration::degree_of_freedom() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ProductConfiguration.CompleteProductConfiguration.degree_of_freedom)
+  return degree_of_freedom_;
+}
+inline void CompleteProductConfiguration::set_degree_of_freedom(::google::protobuf::uint32 value) {
+  
+  degree_of_freedom_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ProductConfiguration.CompleteProductConfiguration.degree_of_freedom)
+}
+
+// .Kinova.Api.ProductConfiguration.BaseType base_type = 7;
+inline void CompleteProductConfiguration::clear_base_type() {
+  base_type_ = 0;
+}
+inline ::Kinova::Api::ProductConfiguration::BaseType CompleteProductConfiguration::base_type() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ProductConfiguration.CompleteProductConfiguration.base_type)
+  return static_cast< ::Kinova::Api::ProductConfiguration::BaseType >(base_type_);
+}
+inline void CompleteProductConfiguration::set_base_type(::Kinova::Api::ProductConfiguration::BaseType value) {
+  
+  base_type_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ProductConfiguration.CompleteProductConfiguration.base_type)
+}
+
+// .Kinova.Api.ProductConfiguration.EndEffectorType end_effector_type = 8;
+inline void CompleteProductConfiguration::clear_end_effector_type() {
+  end_effector_type_ = 0;
+}
+inline ::Kinova::Api::ProductConfiguration::EndEffectorType CompleteProductConfiguration::end_effector_type() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ProductConfiguration.CompleteProductConfiguration.end_effector_type)
+  return static_cast< ::Kinova::Api::ProductConfiguration::EndEffectorType >(end_effector_type_);
+}
+inline void CompleteProductConfiguration::set_end_effector_type(::Kinova::Api::ProductConfiguration::EndEffectorType value) {
+  
+  end_effector_type_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ProductConfiguration.CompleteProductConfiguration.end_effector_type)
+}
+
+// .Kinova.Api.ProductConfiguration.VisionModuleType vision_module_type = 9;
+inline void CompleteProductConfiguration::clear_vision_module_type() {
+  vision_module_type_ = 0;
+}
+inline ::Kinova::Api::ProductConfiguration::VisionModuleType CompleteProductConfiguration::vision_module_type() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ProductConfiguration.CompleteProductConfiguration.vision_module_type)
+  return static_cast< ::Kinova::Api::ProductConfiguration::VisionModuleType >(vision_module_type_);
+}
+inline void CompleteProductConfiguration::set_vision_module_type(::Kinova::Api::ProductConfiguration::VisionModuleType value) {
+  
+  vision_module_type_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ProductConfiguration.CompleteProductConfiguration.vision_module_type)
+}
+
+// .Kinova.Api.ProductConfiguration.InterfaceModuleType interface_module_type = 10;
+inline void CompleteProductConfiguration::clear_interface_module_type() {
+  interface_module_type_ = 0;
+}
+inline ::Kinova::Api::ProductConfiguration::InterfaceModuleType CompleteProductConfiguration::interface_module_type() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ProductConfiguration.CompleteProductConfiguration.interface_module_type)
+  return static_cast< ::Kinova::Api::ProductConfiguration::InterfaceModuleType >(interface_module_type_);
+}
+inline void CompleteProductConfiguration::set_interface_module_type(::Kinova::Api::ProductConfiguration::InterfaceModuleType value) {
+  
+  interface_module_type_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ProductConfiguration.CompleteProductConfiguration.interface_module_type)
+}
+
+// .Kinova.Api.ProductConfiguration.ArmLaterality arm_laterality = 11;
+inline void CompleteProductConfiguration::clear_arm_laterality() {
+  arm_laterality_ = 0;
+}
+inline ::Kinova::Api::ProductConfiguration::ArmLaterality CompleteProductConfiguration::arm_laterality() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ProductConfiguration.CompleteProductConfiguration.arm_laterality)
+  return static_cast< ::Kinova::Api::ProductConfiguration::ArmLaterality >(arm_laterality_);
+}
+inline void CompleteProductConfiguration::set_arm_laterality(::Kinova::Api::ProductConfiguration::ArmLaterality value) {
+  
+  arm_laterality_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ProductConfiguration.CompleteProductConfiguration.arm_laterality)
+}
+
+// .Kinova.Api.ProductConfiguration.WristType wrist_type = 12;
+inline void CompleteProductConfiguration::clear_wrist_type() {
+  wrist_type_ = 0;
+}
+inline ::Kinova::Api::ProductConfiguration::WristType CompleteProductConfiguration::wrist_type() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ProductConfiguration.CompleteProductConfiguration.wrist_type)
+  return static_cast< ::Kinova::Api::ProductConfiguration::WristType >(wrist_type_);
+}
+inline void CompleteProductConfiguration::set_wrist_type(::Kinova::Api::ProductConfiguration::WristType value) {
+  
+  wrist_type_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ProductConfiguration.CompleteProductConfiguration.wrist_type)
+}
+
+// .Kinova.Api.ProductConfiguration.BrakeType brake_type = 13;
+inline void CompleteProductConfiguration::clear_brake_type() {
+  brake_type_ = 0;
+}
+inline ::Kinova::Api::ProductConfiguration::BrakeType CompleteProductConfiguration::brake_type() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ProductConfiguration.CompleteProductConfiguration.brake_type)
+  return static_cast< ::Kinova::Api::ProductConfiguration::BrakeType >(brake_type_);
+}
+inline void CompleteProductConfiguration::set_brake_type(::Kinova::Api::ProductConfiguration::BrakeType value) {
+  
+  brake_type_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ProductConfiguration.CompleteProductConfiguration.brake_type)
+}
+
+// -------------------------------------------------------------------
+
+// ProductConfigurationEndEffectorType
+
+// .Kinova.Api.ProductConfiguration.EndEffectorType end_effector_type = 1;
+inline void ProductConfigurationEndEffectorType::clear_end_effector_type() {
+  end_effector_type_ = 0;
+}
+inline ::Kinova::Api::ProductConfiguration::EndEffectorType ProductConfigurationEndEffectorType::end_effector_type() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.ProductConfiguration.ProductConfigurationEndEffectorType.end_effector_type)
+  return static_cast< ::Kinova::Api::ProductConfiguration::EndEffectorType >(end_effector_type_);
+}
+inline void ProductConfigurationEndEffectorType::set_end_effector_type(::Kinova::Api::ProductConfiguration::EndEffectorType value) {
+  
+  end_effector_type_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.ProductConfiguration.ProductConfigurationEndEffectorType.end_effector_type)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace ProductConfiguration
+}  // namespace Api
+}  // namespace Kinova
+
+namespace google {
+namespace protobuf {
+
+template <> struct is_proto_enum< ::Kinova::Api::ProductConfiguration::ModelId> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::ProductConfiguration::ModelId>() {
+  return ::Kinova::Api::ProductConfiguration::ModelId_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::ProductConfiguration::BaseType> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::ProductConfiguration::BaseType>() {
+  return ::Kinova::Api::ProductConfiguration::BaseType_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::ProductConfiguration::EndEffectorType> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::ProductConfiguration::EndEffectorType>() {
+  return ::Kinova::Api::ProductConfiguration::EndEffectorType_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::ProductConfiguration::VisionModuleType> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::ProductConfiguration::VisionModuleType>() {
+  return ::Kinova::Api::ProductConfiguration::VisionModuleType_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::ProductConfiguration::InterfaceModuleType> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::ProductConfiguration::InterfaceModuleType>() {
+  return ::Kinova::Api::ProductConfiguration::InterfaceModuleType_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::ProductConfiguration::ArmLaterality> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::ProductConfiguration::ArmLaterality>() {
+  return ::Kinova::Api::ProductConfiguration::ArmLaterality_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::ProductConfiguration::WristType> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::ProductConfiguration::WristType>() {
+  return ::Kinova::Api::ProductConfiguration::WristType_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::ProductConfiguration::BrakeType> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::ProductConfiguration::BrakeType>() {
+  return ::Kinova::Api::ProductConfiguration::BrakeType_descriptor();
+}
+
+}  // namespace protobuf
+}  // namespace google
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_ProductConfiguration_2eproto__INCLUDED
diff --git a/kortex_api/include/messages/Session.pb.h b/kortex_api/include/messages/Session.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..0436a654acc4deb597d07513e7f756e2ee3f2128
--- /dev/null
+++ b/kortex_api/include/messages/Session.pb.h
@@ -0,0 +1,536 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: Session.proto
+
+#ifndef PROTOBUF_Session_2eproto__INCLUDED
+#define PROTOBUF_Session_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 3005000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 3005001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "Common.pb.h"  // IWYU pragma: export
+// @@protoc_insertion_point(includes)
+
+namespace protobuf_Session_2eproto {
+// Internal implementation detail -- do not use these members.
+struct TableStruct {
+  static const ::google::protobuf::internal::ParseTableField entries[];
+  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
+  static const ::google::protobuf::internal::ParseTable schema[2];
+  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
+  static const ::google::protobuf::internal::SerializationTable serialization_table[];
+  static const ::google::protobuf::uint32 offsets[];
+};
+void AddDescriptors();
+void InitDefaultsCreateSessionInfoImpl();
+void InitDefaultsCreateSessionInfo();
+void InitDefaultsConnectionListImpl();
+void InitDefaultsConnectionList();
+inline void InitDefaults() {
+  InitDefaultsCreateSessionInfo();
+  InitDefaultsConnectionList();
+}
+}  // namespace protobuf_Session_2eproto
+namespace Kinova {
+namespace Api {
+namespace Session {
+class ConnectionList;
+class ConnectionListDefaultTypeInternal;
+extern ConnectionListDefaultTypeInternal _ConnectionList_default_instance_;
+class CreateSessionInfo;
+class CreateSessionInfoDefaultTypeInternal;
+extern CreateSessionInfoDefaultTypeInternal _CreateSessionInfo_default_instance_;
+}  // namespace Session
+}  // namespace Api
+}  // namespace Kinova
+namespace Kinova {
+namespace Api {
+namespace Session {
+
+enum ServiceVersion {
+  RESERVED_0 = 0,
+  CURRENT_VERSION = 1,
+  ServiceVersion_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  ServiceVersion_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool ServiceVersion_IsValid(int value);
+const ServiceVersion ServiceVersion_MIN = RESERVED_0;
+const ServiceVersion ServiceVersion_MAX = CURRENT_VERSION;
+const int ServiceVersion_ARRAYSIZE = ServiceVersion_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* ServiceVersion_descriptor();
+inline const ::std::string& ServiceVersion_Name(ServiceVersion value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    ServiceVersion_descriptor(), value);
+}
+inline bool ServiceVersion_Parse(
+    const ::std::string& name, ServiceVersion* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<ServiceVersion>(
+    ServiceVersion_descriptor(), name, value);
+}
+// ===================================================================
+
+class CreateSessionInfo : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Session.CreateSessionInfo) */ {
+ public:
+  CreateSessionInfo();
+  virtual ~CreateSessionInfo();
+
+  CreateSessionInfo(const CreateSessionInfo& from);
+
+  inline CreateSessionInfo& operator=(const CreateSessionInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  CreateSessionInfo(CreateSessionInfo&& from) noexcept
+    : CreateSessionInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline CreateSessionInfo& operator=(CreateSessionInfo&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const CreateSessionInfo& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const CreateSessionInfo* internal_default_instance() {
+    return reinterpret_cast<const CreateSessionInfo*>(
+               &_CreateSessionInfo_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    0;
+
+  void Swap(CreateSessionInfo* other);
+  friend void swap(CreateSessionInfo& a, CreateSessionInfo& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline CreateSessionInfo* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  CreateSessionInfo* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const CreateSessionInfo& from);
+  void MergeFrom(const CreateSessionInfo& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(CreateSessionInfo* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // string username = 1;
+  void clear_username();
+  static const int kUsernameFieldNumber = 1;
+  const ::std::string& username() const;
+  void set_username(const ::std::string& value);
+  #if LANG_CXX11
+  void set_username(::std::string&& value);
+  #endif
+  void set_username(const char* value);
+  void set_username(const char* value, size_t size);
+  ::std::string* mutable_username();
+  ::std::string* release_username();
+  void set_allocated_username(::std::string* username);
+
+  // string password = 3;
+  void clear_password();
+  static const int kPasswordFieldNumber = 3;
+  const ::std::string& password() const;
+  void set_password(const ::std::string& value);
+  #if LANG_CXX11
+  void set_password(::std::string&& value);
+  #endif
+  void set_password(const char* value);
+  void set_password(const char* value, size_t size);
+  ::std::string* mutable_password();
+  ::std::string* release_password();
+  void set_allocated_password(::std::string* password);
+
+  // uint32 session_inactivity_timeout = 2;
+  void clear_session_inactivity_timeout();
+  static const int kSessionInactivityTimeoutFieldNumber = 2;
+  ::google::protobuf::uint32 session_inactivity_timeout() const;
+  void set_session_inactivity_timeout(::google::protobuf::uint32 value);
+
+  // uint32 connection_inactivity_timeout = 4;
+  void clear_connection_inactivity_timeout();
+  static const int kConnectionInactivityTimeoutFieldNumber = 4;
+  ::google::protobuf::uint32 connection_inactivity_timeout() const;
+  void set_connection_inactivity_timeout(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Session.CreateSessionInfo)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::internal::ArenaStringPtr username_;
+  ::google::protobuf::internal::ArenaStringPtr password_;
+  ::google::protobuf::uint32 session_inactivity_timeout_;
+  ::google::protobuf::uint32 connection_inactivity_timeout_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Session_2eproto::TableStruct;
+  friend void ::protobuf_Session_2eproto::InitDefaultsCreateSessionInfoImpl();
+};
+// -------------------------------------------------------------------
+
+class ConnectionList : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Session.ConnectionList) */ {
+ public:
+  ConnectionList();
+  virtual ~ConnectionList();
+
+  ConnectionList(const ConnectionList& from);
+
+  inline ConnectionList& operator=(const ConnectionList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ConnectionList(ConnectionList&& from) noexcept
+    : ConnectionList() {
+    *this = ::std::move(from);
+  }
+
+  inline ConnectionList& operator=(ConnectionList&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ConnectionList& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ConnectionList* internal_default_instance() {
+    return reinterpret_cast<const ConnectionList*>(
+               &_ConnectionList_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    1;
+
+  void Swap(ConnectionList* other);
+  friend void swap(ConnectionList& a, ConnectionList& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ConnectionList* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ConnectionList* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ConnectionList& from);
+  void MergeFrom(const ConnectionList& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ConnectionList* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated .Kinova.Api.Common.Connection connection = 1;
+  int connection_size() const;
+  void clear_connection();
+  static const int kConnectionFieldNumber = 1;
+  const ::Kinova::Api::Common::Connection& connection(int index) const;
+  ::Kinova::Api::Common::Connection* mutable_connection(int index);
+  ::Kinova::Api::Common::Connection* add_connection();
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Common::Connection >*
+      mutable_connection();
+  const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Common::Connection >&
+      connection() const;
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Session.ConnectionList)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Common::Connection > connection_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Session_2eproto::TableStruct;
+  friend void ::protobuf_Session_2eproto::InitDefaultsConnectionListImpl();
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// CreateSessionInfo
+
+// string username = 1;
+inline void CreateSessionInfo::clear_username() {
+  username_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& CreateSessionInfo::username() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Session.CreateSessionInfo.username)
+  return username_.GetNoArena();
+}
+inline void CreateSessionInfo::set_username(const ::std::string& value) {
+  
+  username_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.Session.CreateSessionInfo.username)
+}
+#if LANG_CXX11
+inline void CreateSessionInfo::set_username(::std::string&& value) {
+  
+  username_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:Kinova.Api.Session.CreateSessionInfo.username)
+}
+#endif
+inline void CreateSessionInfo::set_username(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  username_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:Kinova.Api.Session.CreateSessionInfo.username)
+}
+inline void CreateSessionInfo::set_username(const char* value, size_t size) {
+  
+  username_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:Kinova.Api.Session.CreateSessionInfo.username)
+}
+inline ::std::string* CreateSessionInfo::mutable_username() {
+  
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Session.CreateSessionInfo.username)
+  return username_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* CreateSessionInfo::release_username() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Session.CreateSessionInfo.username)
+  
+  return username_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void CreateSessionInfo::set_allocated_username(::std::string* username) {
+  if (username != NULL) {
+    
+  } else {
+    
+  }
+  username_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), username);
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Session.CreateSessionInfo.username)
+}
+
+// uint32 session_inactivity_timeout = 2;
+inline void CreateSessionInfo::clear_session_inactivity_timeout() {
+  session_inactivity_timeout_ = 0u;
+}
+inline ::google::protobuf::uint32 CreateSessionInfo::session_inactivity_timeout() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Session.CreateSessionInfo.session_inactivity_timeout)
+  return session_inactivity_timeout_;
+}
+inline void CreateSessionInfo::set_session_inactivity_timeout(::google::protobuf::uint32 value) {
+  
+  session_inactivity_timeout_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Session.CreateSessionInfo.session_inactivity_timeout)
+}
+
+// string password = 3;
+inline void CreateSessionInfo::clear_password() {
+  password_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& CreateSessionInfo::password() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Session.CreateSessionInfo.password)
+  return password_.GetNoArena();
+}
+inline void CreateSessionInfo::set_password(const ::std::string& value) {
+  
+  password_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.Session.CreateSessionInfo.password)
+}
+#if LANG_CXX11
+inline void CreateSessionInfo::set_password(::std::string&& value) {
+  
+  password_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:Kinova.Api.Session.CreateSessionInfo.password)
+}
+#endif
+inline void CreateSessionInfo::set_password(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  password_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:Kinova.Api.Session.CreateSessionInfo.password)
+}
+inline void CreateSessionInfo::set_password(const char* value, size_t size) {
+  
+  password_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:Kinova.Api.Session.CreateSessionInfo.password)
+}
+inline ::std::string* CreateSessionInfo::mutable_password() {
+  
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Session.CreateSessionInfo.password)
+  return password_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* CreateSessionInfo::release_password() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Session.CreateSessionInfo.password)
+  
+  return password_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void CreateSessionInfo::set_allocated_password(::std::string* password) {
+  if (password != NULL) {
+    
+  } else {
+    
+  }
+  password_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), password);
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Session.CreateSessionInfo.password)
+}
+
+// uint32 connection_inactivity_timeout = 4;
+inline void CreateSessionInfo::clear_connection_inactivity_timeout() {
+  connection_inactivity_timeout_ = 0u;
+}
+inline ::google::protobuf::uint32 CreateSessionInfo::connection_inactivity_timeout() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Session.CreateSessionInfo.connection_inactivity_timeout)
+  return connection_inactivity_timeout_;
+}
+inline void CreateSessionInfo::set_connection_inactivity_timeout(::google::protobuf::uint32 value) {
+  
+  connection_inactivity_timeout_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Session.CreateSessionInfo.connection_inactivity_timeout)
+}
+
+// -------------------------------------------------------------------
+
+// ConnectionList
+
+// repeated .Kinova.Api.Common.Connection connection = 1;
+inline int ConnectionList::connection_size() const {
+  return connection_.size();
+}
+inline const ::Kinova::Api::Common::Connection& ConnectionList::connection(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Session.ConnectionList.connection)
+  return connection_.Get(index);
+}
+inline ::Kinova::Api::Common::Connection* ConnectionList::mutable_connection(int index) {
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Session.ConnectionList.connection)
+  return connection_.Mutable(index);
+}
+inline ::Kinova::Api::Common::Connection* ConnectionList::add_connection() {
+  // @@protoc_insertion_point(field_add:Kinova.Api.Session.ConnectionList.connection)
+  return connection_.Add();
+}
+inline ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Common::Connection >*
+ConnectionList::mutable_connection() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.Session.ConnectionList.connection)
+  return &connection_;
+}
+inline const ::google::protobuf::RepeatedPtrField< ::Kinova::Api::Common::Connection >&
+ConnectionList::connection() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.Session.ConnectionList.connection)
+  return connection_;
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace Session
+}  // namespace Api
+}  // namespace Kinova
+
+namespace google {
+namespace protobuf {
+
+template <> struct is_proto_enum< ::Kinova::Api::Session::ServiceVersion> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Session::ServiceVersion>() {
+  return ::Kinova::Api::Session::ServiceVersion_descriptor();
+}
+
+}  // namespace protobuf
+}  // namespace google
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_Session_2eproto__INCLUDED
diff --git a/kortex_api/include/messages/Test.pb.h b/kortex_api/include/messages/Test.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..beca21c21c8b533510db997fe86b6bfe1e8f21c4
--- /dev/null
+++ b/kortex_api/include/messages/Test.pb.h
@@ -0,0 +1,2667 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: Test.proto
+
+#ifndef PROTOBUF_Test_2eproto__INCLUDED
+#define PROTOBUF_Test_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 3005000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 3005001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "Common.pb.h"  // IWYU pragma: export
+#include "Frame.pb.h"  // IWYU pragma: export
+// @@protoc_insertion_point(includes)
+
+namespace protobuf_Test_2eproto {
+// Internal implementation detail -- do not use these members.
+struct TableStruct {
+  static const ::google::protobuf::internal::ParseTableField entries[];
+  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
+  static const ::google::protobuf::internal::ParseTable schema[13];
+  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
+  static const ::google::protobuf::internal::SerializationTable serialization_table[];
+  static const ::google::protobuf::uint32 offsets[];
+};
+void AddDescriptors();
+void InitDefaultsvalidateStructImpl();
+void InitDefaultsvalidateStruct();
+void InitDefaultsSendStructImpl();
+void InitDefaultsSendStruct();
+void InitDefaultsEmbeddedStructImpl();
+void InitDefaultsEmbeddedStruct();
+void InitDefaultsRcvStructImpl();
+void InitDefaultsRcvStruct();
+void InitDefaultsNotifOptionImpl();
+void InitDefaultsNotifOption();
+void InitDefaultsNotifDataImpl();
+void InitDefaultsNotifData();
+void InitDefaultstimeToResponseImpl();
+void InitDefaultstimeToResponse();
+void InitDefaultsTestNotificationImpl();
+void InitDefaultsTestNotification();
+void InitDefaultsTestErrorImpl();
+void InitDefaultsTestError();
+void InitDefaultsSomethingChangedImpl();
+void InitDefaultsSomethingChanged();
+void InitDefaultsDelayImpl();
+void InitDefaultsDelay();
+void InitDefaultsRequestFromServerMessageImpl();
+void InitDefaultsRequestFromServerMessage();
+void InitDefaultsResponseFromClientMessageImpl();
+void InitDefaultsResponseFromClientMessage();
+inline void InitDefaults() {
+  InitDefaultsvalidateStruct();
+  InitDefaultsSendStruct();
+  InitDefaultsEmbeddedStruct();
+  InitDefaultsRcvStruct();
+  InitDefaultsNotifOption();
+  InitDefaultsNotifData();
+  InitDefaultstimeToResponse();
+  InitDefaultsTestNotification();
+  InitDefaultsTestError();
+  InitDefaultsSomethingChanged();
+  InitDefaultsDelay();
+  InitDefaultsRequestFromServerMessage();
+  InitDefaultsResponseFromClientMessage();
+}
+}  // namespace protobuf_Test_2eproto
+namespace Kinova {
+namespace Api {
+namespace Test {
+class Delay;
+class DelayDefaultTypeInternal;
+extern DelayDefaultTypeInternal _Delay_default_instance_;
+class EmbeddedStruct;
+class EmbeddedStructDefaultTypeInternal;
+extern EmbeddedStructDefaultTypeInternal _EmbeddedStruct_default_instance_;
+class NotifData;
+class NotifDataDefaultTypeInternal;
+extern NotifDataDefaultTypeInternal _NotifData_default_instance_;
+class NotifOption;
+class NotifOptionDefaultTypeInternal;
+extern NotifOptionDefaultTypeInternal _NotifOption_default_instance_;
+class RcvStruct;
+class RcvStructDefaultTypeInternal;
+extern RcvStructDefaultTypeInternal _RcvStruct_default_instance_;
+class RequestFromServerMessage;
+class RequestFromServerMessageDefaultTypeInternal;
+extern RequestFromServerMessageDefaultTypeInternal _RequestFromServerMessage_default_instance_;
+class ResponseFromClientMessage;
+class ResponseFromClientMessageDefaultTypeInternal;
+extern ResponseFromClientMessageDefaultTypeInternal _ResponseFromClientMessage_default_instance_;
+class SendStruct;
+class SendStructDefaultTypeInternal;
+extern SendStructDefaultTypeInternal _SendStruct_default_instance_;
+class SomethingChanged;
+class SomethingChangedDefaultTypeInternal;
+extern SomethingChangedDefaultTypeInternal _SomethingChanged_default_instance_;
+class TestError;
+class TestErrorDefaultTypeInternal;
+extern TestErrorDefaultTypeInternal _TestError_default_instance_;
+class TestNotification;
+class TestNotificationDefaultTypeInternal;
+extern TestNotificationDefaultTypeInternal _TestNotification_default_instance_;
+class timeToResponse;
+class timeToResponseDefaultTypeInternal;
+extern timeToResponseDefaultTypeInternal _timeToResponse_default_instance_;
+class validateStruct;
+class validateStructDefaultTypeInternal;
+extern validateStructDefaultTypeInternal _validateStruct_default_instance_;
+}  // namespace Test
+}  // namespace Api
+}  // namespace Kinova
+namespace Kinova {
+namespace Api {
+namespace Test {
+
+enum ServiceVersion {
+  RESERVED_0 = 0,
+  CURRENT_VERSION = 1,
+  ServiceVersion_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  ServiceVersion_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool ServiceVersion_IsValid(int value);
+const ServiceVersion ServiceVersion_MIN = RESERVED_0;
+const ServiceVersion ServiceVersion_MAX = CURRENT_VERSION;
+const int ServiceVersion_ARRAYSIZE = ServiceVersion_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* ServiceVersion_descriptor();
+inline const ::std::string& ServiceVersion_Name(ServiceVersion value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    ServiceVersion_descriptor(), value);
+}
+inline bool ServiceVersion_Parse(
+    const ::std::string& name, ServiceVersion* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<ServiceVersion>(
+    ServiceVersion_descriptor(), name, value);
+}
+enum Enum {
+  ENUM_0 = 0,
+  ENUM_1 = 1,
+  ENUM_2 = 2,
+  Enum_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  Enum_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool Enum_IsValid(int value);
+const Enum Enum_MIN = ENUM_0;
+const Enum Enum_MAX = ENUM_2;
+const int Enum_ARRAYSIZE = Enum_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* Enum_descriptor();
+inline const ::std::string& Enum_Name(Enum value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    Enum_descriptor(), value);
+}
+inline bool Enum_Parse(
+    const ::std::string& name, Enum* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<Enum>(
+    Enum_descriptor(), name, value);
+}
+// ===================================================================
+
+class validateStruct : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Test.validateStruct) */ {
+ public:
+  validateStruct();
+  virtual ~validateStruct();
+
+  validateStruct(const validateStruct& from);
+
+  inline validateStruct& operator=(const validateStruct& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  validateStruct(validateStruct&& from) noexcept
+    : validateStruct() {
+    *this = ::std::move(from);
+  }
+
+  inline validateStruct& operator=(validateStruct&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const validateStruct& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const validateStruct* internal_default_instance() {
+    return reinterpret_cast<const validateStruct*>(
+               &_validateStruct_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    0;
+
+  void Swap(validateStruct* other);
+  friend void swap(validateStruct& a, validateStruct& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline validateStruct* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  validateStruct* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const validateStruct& from);
+  void MergeFrom(const validateStruct& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(validateStruct* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Test.SendStruct client_struct = 1;
+  bool has_client_struct() const;
+  void clear_client_struct();
+  static const int kClientStructFieldNumber = 1;
+  const ::Kinova::Api::Test::SendStruct& client_struct() const;
+  ::Kinova::Api::Test::SendStruct* release_client_struct();
+  ::Kinova::Api::Test::SendStruct* mutable_client_struct();
+  void set_allocated_client_struct(::Kinova::Api::Test::SendStruct* client_struct);
+
+  // .Kinova.Api.Test.RcvStruct server_struct = 2;
+  bool has_server_struct() const;
+  void clear_server_struct();
+  static const int kServerStructFieldNumber = 2;
+  const ::Kinova::Api::Test::RcvStruct& server_struct() const;
+  ::Kinova::Api::Test::RcvStruct* release_server_struct();
+  ::Kinova::Api::Test::RcvStruct* mutable_server_struct();
+  void set_allocated_server_struct(::Kinova::Api::Test::RcvStruct* server_struct);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Test.validateStruct)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::Test::SendStruct* client_struct_;
+  ::Kinova::Api::Test::RcvStruct* server_struct_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Test_2eproto::TableStruct;
+  friend void ::protobuf_Test_2eproto::InitDefaultsvalidateStructImpl();
+};
+// -------------------------------------------------------------------
+
+class SendStruct : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Test.SendStruct) */ {
+ public:
+  SendStruct();
+  virtual ~SendStruct();
+
+  SendStruct(const SendStruct& from);
+
+  inline SendStruct& operator=(const SendStruct& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  SendStruct(SendStruct&& from) noexcept
+    : SendStruct() {
+    *this = ::std::move(from);
+  }
+
+  inline SendStruct& operator=(SendStruct&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SendStruct& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const SendStruct* internal_default_instance() {
+    return reinterpret_cast<const SendStruct*>(
+               &_SendStruct_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    1;
+
+  void Swap(SendStruct* other);
+  friend void swap(SendStruct& a, SendStruct& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SendStruct* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  SendStruct* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const SendStruct& from);
+  void MergeFrom(const SendStruct& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(SendStruct* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated uint32 repeated_uint32_value = 7;
+  int repeated_uint32_value_size() const;
+  void clear_repeated_uint32_value();
+  static const int kRepeatedUint32ValueFieldNumber = 7;
+  ::google::protobuf::uint32 repeated_uint32_value(int index) const;
+  void set_repeated_uint32_value(int index, ::google::protobuf::uint32 value);
+  void add_repeated_uint32_value(::google::protobuf::uint32 value);
+  const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+      repeated_uint32_value() const;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+      mutable_repeated_uint32_value();
+
+  // bytes bytes_value = 1;
+  void clear_bytes_value();
+  static const int kBytesValueFieldNumber = 1;
+  const ::std::string& bytes_value() const;
+  void set_bytes_value(const ::std::string& value);
+  #if LANG_CXX11
+  void set_bytes_value(::std::string&& value);
+  #endif
+  void set_bytes_value(const char* value);
+  void set_bytes_value(const void* value, size_t size);
+  ::std::string* mutable_bytes_value();
+  ::std::string* release_bytes_value();
+  void set_allocated_bytes_value(::std::string* bytes_value);
+
+  // string string_value = 4;
+  void clear_string_value();
+  static const int kStringValueFieldNumber = 4;
+  const ::std::string& string_value() const;
+  void set_string_value(const ::std::string& value);
+  #if LANG_CXX11
+  void set_string_value(::std::string&& value);
+  #endif
+  void set_string_value(const char* value);
+  void set_string_value(const char* value, size_t size);
+  ::std::string* mutable_string_value();
+  ::std::string* release_string_value();
+  void set_allocated_string_value(::std::string* string_value);
+
+  // .Kinova.Api.Test.EmbeddedStruct embedded_struct_value = 6;
+  bool has_embedded_struct_value() const;
+  void clear_embedded_struct_value();
+  static const int kEmbeddedStructValueFieldNumber = 6;
+  const ::Kinova::Api::Test::EmbeddedStruct& embedded_struct_value() const;
+  ::Kinova::Api::Test::EmbeddedStruct* release_embedded_struct_value();
+  ::Kinova::Api::Test::EmbeddedStruct* mutable_embedded_struct_value();
+  void set_allocated_embedded_struct_value(::Kinova::Api::Test::EmbeddedStruct* embedded_struct_value);
+
+  // uint32 uint32_value = 2;
+  void clear_uint32_value();
+  static const int kUint32ValueFieldNumber = 2;
+  ::google::protobuf::uint32 uint32_value() const;
+  void set_uint32_value(::google::protobuf::uint32 value);
+
+  // fixed32 fixed32_value = 3;
+  void clear_fixed32_value();
+  static const int kFixed32ValueFieldNumber = 3;
+  ::google::protobuf::uint32 fixed32_value() const;
+  void set_fixed32_value(::google::protobuf::uint32 value);
+
+  // .Kinova.Api.Test.Enum enum_value = 5;
+  void clear_enum_value();
+  static const int kEnumValueFieldNumber = 5;
+  ::Kinova::Api::Test::Enum enum_value() const;
+  void set_enum_value(::Kinova::Api::Test::Enum value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Test.SendStruct)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > repeated_uint32_value_;
+  mutable int _repeated_uint32_value_cached_byte_size_;
+  ::google::protobuf::internal::ArenaStringPtr bytes_value_;
+  ::google::protobuf::internal::ArenaStringPtr string_value_;
+  ::Kinova::Api::Test::EmbeddedStruct* embedded_struct_value_;
+  ::google::protobuf::uint32 uint32_value_;
+  ::google::protobuf::uint32 fixed32_value_;
+  int enum_value_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Test_2eproto::TableStruct;
+  friend void ::protobuf_Test_2eproto::InitDefaultsSendStructImpl();
+};
+// -------------------------------------------------------------------
+
+class EmbeddedStruct : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Test.EmbeddedStruct) */ {
+ public:
+  EmbeddedStruct();
+  virtual ~EmbeddedStruct();
+
+  EmbeddedStruct(const EmbeddedStruct& from);
+
+  inline EmbeddedStruct& operator=(const EmbeddedStruct& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  EmbeddedStruct(EmbeddedStruct&& from) noexcept
+    : EmbeddedStruct() {
+    *this = ::std::move(from);
+  }
+
+  inline EmbeddedStruct& operator=(EmbeddedStruct&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const EmbeddedStruct& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const EmbeddedStruct* internal_default_instance() {
+    return reinterpret_cast<const EmbeddedStruct*>(
+               &_EmbeddedStruct_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    2;
+
+  void Swap(EmbeddedStruct* other);
+  friend void swap(EmbeddedStruct& a, EmbeddedStruct& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline EmbeddedStruct* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  EmbeddedStruct* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const EmbeddedStruct& from);
+  void MergeFrom(const EmbeddedStruct& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(EmbeddedStruct* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // uint32 embedded_uint = 1;
+  void clear_embedded_uint();
+  static const int kEmbeddedUintFieldNumber = 1;
+  ::google::protobuf::uint32 embedded_uint() const;
+  void set_embedded_uint(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Test.EmbeddedStruct)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 embedded_uint_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Test_2eproto::TableStruct;
+  friend void ::protobuf_Test_2eproto::InitDefaultsEmbeddedStructImpl();
+};
+// -------------------------------------------------------------------
+
+class RcvStruct : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Test.RcvStruct) */ {
+ public:
+  RcvStruct();
+  virtual ~RcvStruct();
+
+  RcvStruct(const RcvStruct& from);
+
+  inline RcvStruct& operator=(const RcvStruct& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  RcvStruct(RcvStruct&& from) noexcept
+    : RcvStruct() {
+    *this = ::std::move(from);
+  }
+
+  inline RcvStruct& operator=(RcvStruct&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const RcvStruct& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const RcvStruct* internal_default_instance() {
+    return reinterpret_cast<const RcvStruct*>(
+               &_RcvStruct_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    3;
+
+  void Swap(RcvStruct* other);
+  friend void swap(RcvStruct& a, RcvStruct& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline RcvStruct* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  RcvStruct* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const RcvStruct& from);
+  void MergeFrom(const RcvStruct& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(RcvStruct* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // repeated uint32 repeated_uint32_value = 7;
+  int repeated_uint32_value_size() const;
+  void clear_repeated_uint32_value();
+  static const int kRepeatedUint32ValueFieldNumber = 7;
+  ::google::protobuf::uint32 repeated_uint32_value(int index) const;
+  void set_repeated_uint32_value(int index, ::google::protobuf::uint32 value);
+  void add_repeated_uint32_value(::google::protobuf::uint32 value);
+  const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+      repeated_uint32_value() const;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+      mutable_repeated_uint32_value();
+
+  // bytes bytes_value = 1;
+  void clear_bytes_value();
+  static const int kBytesValueFieldNumber = 1;
+  const ::std::string& bytes_value() const;
+  void set_bytes_value(const ::std::string& value);
+  #if LANG_CXX11
+  void set_bytes_value(::std::string&& value);
+  #endif
+  void set_bytes_value(const char* value);
+  void set_bytes_value(const void* value, size_t size);
+  ::std::string* mutable_bytes_value();
+  ::std::string* release_bytes_value();
+  void set_allocated_bytes_value(::std::string* bytes_value);
+
+  // string string_value = 4;
+  void clear_string_value();
+  static const int kStringValueFieldNumber = 4;
+  const ::std::string& string_value() const;
+  void set_string_value(const ::std::string& value);
+  #if LANG_CXX11
+  void set_string_value(::std::string&& value);
+  #endif
+  void set_string_value(const char* value);
+  void set_string_value(const char* value, size_t size);
+  ::std::string* mutable_string_value();
+  ::std::string* release_string_value();
+  void set_allocated_string_value(::std::string* string_value);
+
+  // .Kinova.Api.Test.EmbeddedStruct embedded_struct_value = 6;
+  bool has_embedded_struct_value() const;
+  void clear_embedded_struct_value();
+  static const int kEmbeddedStructValueFieldNumber = 6;
+  const ::Kinova::Api::Test::EmbeddedStruct& embedded_struct_value() const;
+  ::Kinova::Api::Test::EmbeddedStruct* release_embedded_struct_value();
+  ::Kinova::Api::Test::EmbeddedStruct* mutable_embedded_struct_value();
+  void set_allocated_embedded_struct_value(::Kinova::Api::Test::EmbeddedStruct* embedded_struct_value);
+
+  // uint32 uint32_value = 2;
+  void clear_uint32_value();
+  static const int kUint32ValueFieldNumber = 2;
+  ::google::protobuf::uint32 uint32_value() const;
+  void set_uint32_value(::google::protobuf::uint32 value);
+
+  // fixed32 fixed32_value = 3;
+  void clear_fixed32_value();
+  static const int kFixed32ValueFieldNumber = 3;
+  ::google::protobuf::uint32 fixed32_value() const;
+  void set_fixed32_value(::google::protobuf::uint32 value);
+
+  // .Kinova.Api.Test.Enum enum_value = 5;
+  void clear_enum_value();
+  static const int kEnumValueFieldNumber = 5;
+  ::Kinova::Api::Test::Enum enum_value() const;
+  void set_enum_value(::Kinova::Api::Test::Enum value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Test.RcvStruct)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::RepeatedField< ::google::protobuf::uint32 > repeated_uint32_value_;
+  mutable int _repeated_uint32_value_cached_byte_size_;
+  ::google::protobuf::internal::ArenaStringPtr bytes_value_;
+  ::google::protobuf::internal::ArenaStringPtr string_value_;
+  ::Kinova::Api::Test::EmbeddedStruct* embedded_struct_value_;
+  ::google::protobuf::uint32 uint32_value_;
+  ::google::protobuf::uint32 fixed32_value_;
+  int enum_value_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Test_2eproto::TableStruct;
+  friend void ::protobuf_Test_2eproto::InitDefaultsRcvStructImpl();
+};
+// -------------------------------------------------------------------
+
+class NotifOption : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Test.NotifOption) */ {
+ public:
+  NotifOption();
+  virtual ~NotifOption();
+
+  NotifOption(const NotifOption& from);
+
+  inline NotifOption& operator=(const NotifOption& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  NotifOption(NotifOption&& from) noexcept
+    : NotifOption() {
+    *this = ::std::move(from);
+  }
+
+  inline NotifOption& operator=(NotifOption&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const NotifOption& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const NotifOption* internal_default_instance() {
+    return reinterpret_cast<const NotifOption*>(
+               &_NotifOption_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    4;
+
+  void Swap(NotifOption* other);
+  friend void swap(NotifOption& a, NotifOption& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline NotifOption* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  NotifOption* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const NotifOption& from);
+  void MergeFrom(const NotifOption& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(NotifOption* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // uint32 dummy_option = 1;
+  void clear_dummy_option();
+  static const int kDummyOptionFieldNumber = 1;
+  ::google::protobuf::uint32 dummy_option() const;
+  void set_dummy_option(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Test.NotifOption)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 dummy_option_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Test_2eproto::TableStruct;
+  friend void ::protobuf_Test_2eproto::InitDefaultsNotifOptionImpl();
+};
+// -------------------------------------------------------------------
+
+class NotifData : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Test.NotifData) */ {
+ public:
+  NotifData();
+  virtual ~NotifData();
+
+  NotifData(const NotifData& from);
+
+  inline NotifData& operator=(const NotifData& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  NotifData(NotifData&& from) noexcept
+    : NotifData() {
+    *this = ::std::move(from);
+  }
+
+  inline NotifData& operator=(NotifData&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const NotifData& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const NotifData* internal_default_instance() {
+    return reinterpret_cast<const NotifData*>(
+               &_NotifData_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    5;
+
+  void Swap(NotifData* other);
+  friend void swap(NotifData& a, NotifData& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline NotifData* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  NotifData* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const NotifData& from);
+  void MergeFrom(const NotifData& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(NotifData* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // uint32 data = 1;
+  void clear_data();
+  static const int kDataFieldNumber = 1;
+  ::google::protobuf::uint32 data() const;
+  void set_data(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Test.NotifData)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 data_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Test_2eproto::TableStruct;
+  friend void ::protobuf_Test_2eproto::InitDefaultsNotifDataImpl();
+};
+// -------------------------------------------------------------------
+
+class timeToResponse : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Test.timeToResponse) */ {
+ public:
+  timeToResponse();
+  virtual ~timeToResponse();
+
+  timeToResponse(const timeToResponse& from);
+
+  inline timeToResponse& operator=(const timeToResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  timeToResponse(timeToResponse&& from) noexcept
+    : timeToResponse() {
+    *this = ::std::move(from);
+  }
+
+  inline timeToResponse& operator=(timeToResponse&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const timeToResponse& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const timeToResponse* internal_default_instance() {
+    return reinterpret_cast<const timeToResponse*>(
+               &_timeToResponse_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    6;
+
+  void Swap(timeToResponse* other);
+  friend void swap(timeToResponse& a, timeToResponse& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline timeToResponse* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  timeToResponse* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const timeToResponse& from);
+  void MergeFrom(const timeToResponse& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(timeToResponse* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // uint32 time_ms = 1;
+  void clear_time_ms();
+  static const int kTimeMsFieldNumber = 1;
+  ::google::protobuf::uint32 time_ms() const;
+  void set_time_ms(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Test.timeToResponse)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 time_ms_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Test_2eproto::TableStruct;
+  friend void ::protobuf_Test_2eproto::InitDefaultstimeToResponseImpl();
+};
+// -------------------------------------------------------------------
+
+class TestNotification : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Test.TestNotification) */ {
+ public:
+  TestNotification();
+  virtual ~TestNotification();
+
+  TestNotification(const TestNotification& from);
+
+  inline TestNotification& operator=(const TestNotification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  TestNotification(TestNotification&& from) noexcept
+    : TestNotification() {
+    *this = ::std::move(from);
+  }
+
+  inline TestNotification& operator=(TestNotification&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const TestNotification& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const TestNotification* internal_default_instance() {
+    return reinterpret_cast<const TestNotification*>(
+               &_TestNotification_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    7;
+
+  void Swap(TestNotification* other);
+  friend void swap(TestNotification& a, TestNotification& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline TestNotification* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  TestNotification* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const TestNotification& from);
+  void MergeFrom(const TestNotification& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(TestNotification* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // uint32 dummy_property = 1;
+  void clear_dummy_property();
+  static const int kDummyPropertyFieldNumber = 1;
+  ::google::protobuf::uint32 dummy_property() const;
+  void set_dummy_property(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Test.TestNotification)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 dummy_property_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Test_2eproto::TableStruct;
+  friend void ::protobuf_Test_2eproto::InitDefaultsTestNotificationImpl();
+};
+// -------------------------------------------------------------------
+
+class TestError : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Test.TestError) */ {
+ public:
+  TestError();
+  virtual ~TestError();
+
+  TestError(const TestError& from);
+
+  inline TestError& operator=(const TestError& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  TestError(TestError&& from) noexcept
+    : TestError() {
+    *this = ::std::move(from);
+  }
+
+  inline TestError& operator=(TestError&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const TestError& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const TestError* internal_default_instance() {
+    return reinterpret_cast<const TestError*>(
+               &_TestError_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    8;
+
+  void Swap(TestError* other);
+  friend void swap(TestError& a, TestError& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline TestError* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  TestError* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const TestError& from);
+  void MergeFrom(const TestError& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(TestError* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // uint32 errorCode = 1;
+  void clear_errorcode();
+  static const int kErrorCodeFieldNumber = 1;
+  ::google::protobuf::uint32 errorcode() const;
+  void set_errorcode(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Test.TestError)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 errorcode_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Test_2eproto::TableStruct;
+  friend void ::protobuf_Test_2eproto::InitDefaultsTestErrorImpl();
+};
+// -------------------------------------------------------------------
+
+class SomethingChanged : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Test.SomethingChanged) */ {
+ public:
+  SomethingChanged();
+  virtual ~SomethingChanged();
+
+  SomethingChanged(const SomethingChanged& from);
+
+  inline SomethingChanged& operator=(const SomethingChanged& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  SomethingChanged(SomethingChanged&& from) noexcept
+    : SomethingChanged() {
+    *this = ::std::move(from);
+  }
+
+  inline SomethingChanged& operator=(SomethingChanged&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SomethingChanged& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const SomethingChanged* internal_default_instance() {
+    return reinterpret_cast<const SomethingChanged*>(
+               &_SomethingChanged_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    9;
+
+  void Swap(SomethingChanged* other);
+  friend void swap(SomethingChanged& a, SomethingChanged& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SomethingChanged* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  SomethingChanged* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const SomethingChanged& from);
+  void MergeFrom(const SomethingChanged& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(SomethingChanged* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.Common.Timestamp timestamp = 1;
+  bool has_timestamp() const;
+  void clear_timestamp();
+  static const int kTimestampFieldNumber = 1;
+  const ::Kinova::Api::Common::Timestamp& timestamp() const;
+  ::Kinova::Api::Common::Timestamp* release_timestamp();
+  ::Kinova::Api::Common::Timestamp* mutable_timestamp();
+  void set_allocated_timestamp(::Kinova::Api::Common::Timestamp* timestamp);
+
+  // .Kinova.Api.Common.UserProfileHandle user_handle = 2;
+  bool has_user_handle() const;
+  void clear_user_handle();
+  static const int kUserHandleFieldNumber = 2;
+  const ::Kinova::Api::Common::UserProfileHandle& user_handle() const;
+  ::Kinova::Api::Common::UserProfileHandle* release_user_handle();
+  ::Kinova::Api::Common::UserProfileHandle* mutable_user_handle();
+  void set_allocated_user_handle(::Kinova::Api::Common::UserProfileHandle* user_handle);
+
+  // .Kinova.Api.Test.NotifData data = 3;
+  bool has_data() const;
+  void clear_data();
+  static const int kDataFieldNumber = 3;
+  const ::Kinova::Api::Test::NotifData& data() const;
+  ::Kinova::Api::Test::NotifData* release_data();
+  ::Kinova::Api::Test::NotifData* mutable_data();
+  void set_allocated_data(::Kinova::Api::Test::NotifData* data);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Test.SomethingChanged)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::Common::Timestamp* timestamp_;
+  ::Kinova::Api::Common::UserProfileHandle* user_handle_;
+  ::Kinova::Api::Test::NotifData* data_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Test_2eproto::TableStruct;
+  friend void ::protobuf_Test_2eproto::InitDefaultsSomethingChangedImpl();
+};
+// -------------------------------------------------------------------
+
+class Delay : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Test.Delay) */ {
+ public:
+  Delay();
+  virtual ~Delay();
+
+  Delay(const Delay& from);
+
+  inline Delay& operator=(const Delay& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  Delay(Delay&& from) noexcept
+    : Delay() {
+    *this = ::std::move(from);
+  }
+
+  inline Delay& operator=(Delay&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const Delay& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const Delay* internal_default_instance() {
+    return reinterpret_cast<const Delay*>(
+               &_Delay_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    10;
+
+  void Swap(Delay* other);
+  friend void swap(Delay& a, Delay& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline Delay* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  Delay* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const Delay& from);
+  void MergeFrom(const Delay& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(Delay* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // uint32 ms = 1;
+  void clear_ms();
+  static const int kMsFieldNumber = 1;
+  ::google::protobuf::uint32 ms() const;
+  void set_ms(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Test.Delay)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 ms_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Test_2eproto::TableStruct;
+  friend void ::protobuf_Test_2eproto::InitDefaultsDelayImpl();
+};
+// -------------------------------------------------------------------
+
+class RequestFromServerMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Test.RequestFromServerMessage) */ {
+ public:
+  RequestFromServerMessage();
+  virtual ~RequestFromServerMessage();
+
+  RequestFromServerMessage(const RequestFromServerMessage& from);
+
+  inline RequestFromServerMessage& operator=(const RequestFromServerMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  RequestFromServerMessage(RequestFromServerMessage&& from) noexcept
+    : RequestFromServerMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline RequestFromServerMessage& operator=(RequestFromServerMessage&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const RequestFromServerMessage& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const RequestFromServerMessage* internal_default_instance() {
+    return reinterpret_cast<const RequestFromServerMessage*>(
+               &_RequestFromServerMessage_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    11;
+
+  void Swap(RequestFromServerMessage* other);
+  friend void swap(RequestFromServerMessage& a, RequestFromServerMessage& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline RequestFromServerMessage* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  RequestFromServerMessage* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const RequestFromServerMessage& from);
+  void MergeFrom(const RequestFromServerMessage& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(RequestFromServerMessage* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // string req = 1;
+  void clear_req();
+  static const int kReqFieldNumber = 1;
+  const ::std::string& req() const;
+  void set_req(const ::std::string& value);
+  #if LANG_CXX11
+  void set_req(::std::string&& value);
+  #endif
+  void set_req(const char* value);
+  void set_req(const char* value, size_t size);
+  ::std::string* mutable_req();
+  ::std::string* release_req();
+  void set_allocated_req(::std::string* req);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Test.RequestFromServerMessage)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::internal::ArenaStringPtr req_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Test_2eproto::TableStruct;
+  friend void ::protobuf_Test_2eproto::InitDefaultsRequestFromServerMessageImpl();
+};
+// -------------------------------------------------------------------
+
+class ResponseFromClientMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.Test.ResponseFromClientMessage) */ {
+ public:
+  ResponseFromClientMessage();
+  virtual ~ResponseFromClientMessage();
+
+  ResponseFromClientMessage(const ResponseFromClientMessage& from);
+
+  inline ResponseFromClientMessage& operator=(const ResponseFromClientMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ResponseFromClientMessage(ResponseFromClientMessage&& from) noexcept
+    : ResponseFromClientMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline ResponseFromClientMessage& operator=(ResponseFromClientMessage&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ResponseFromClientMessage& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ResponseFromClientMessage* internal_default_instance() {
+    return reinterpret_cast<const ResponseFromClientMessage*>(
+               &_ResponseFromClientMessage_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    12;
+
+  void Swap(ResponseFromClientMessage* other);
+  friend void swap(ResponseFromClientMessage& a, ResponseFromClientMessage& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ResponseFromClientMessage* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ResponseFromClientMessage* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ResponseFromClientMessage& from);
+  void MergeFrom(const ResponseFromClientMessage& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ResponseFromClientMessage* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // string res = 1;
+  void clear_res();
+  static const int kResFieldNumber = 1;
+  const ::std::string& res() const;
+  void set_res(const ::std::string& value);
+  #if LANG_CXX11
+  void set_res(::std::string&& value);
+  #endif
+  void set_res(const char* value);
+  void set_res(const char* value, size_t size);
+  ::std::string* mutable_res();
+  ::std::string* release_res();
+  void set_allocated_res(::std::string* res);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.Test.ResponseFromClientMessage)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::internal::ArenaStringPtr res_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_Test_2eproto::TableStruct;
+  friend void ::protobuf_Test_2eproto::InitDefaultsResponseFromClientMessageImpl();
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// validateStruct
+
+// .Kinova.Api.Test.SendStruct client_struct = 1;
+inline bool validateStruct::has_client_struct() const {
+  return this != internal_default_instance() && client_struct_ != NULL;
+}
+inline void validateStruct::clear_client_struct() {
+  if (GetArenaNoVirtual() == NULL && client_struct_ != NULL) {
+    delete client_struct_;
+  }
+  client_struct_ = NULL;
+}
+inline const ::Kinova::Api::Test::SendStruct& validateStruct::client_struct() const {
+  const ::Kinova::Api::Test::SendStruct* p = client_struct_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Test.validateStruct.client_struct)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Test::SendStruct*>(
+      &::Kinova::Api::Test::_SendStruct_default_instance_);
+}
+inline ::Kinova::Api::Test::SendStruct* validateStruct::release_client_struct() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Test.validateStruct.client_struct)
+  
+  ::Kinova::Api::Test::SendStruct* temp = client_struct_;
+  client_struct_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Test::SendStruct* validateStruct::mutable_client_struct() {
+  
+  if (client_struct_ == NULL) {
+    client_struct_ = new ::Kinova::Api::Test::SendStruct;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Test.validateStruct.client_struct)
+  return client_struct_;
+}
+inline void validateStruct::set_allocated_client_struct(::Kinova::Api::Test::SendStruct* client_struct) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete client_struct_;
+  }
+  if (client_struct) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      client_struct = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, client_struct, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  client_struct_ = client_struct;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Test.validateStruct.client_struct)
+}
+
+// .Kinova.Api.Test.RcvStruct server_struct = 2;
+inline bool validateStruct::has_server_struct() const {
+  return this != internal_default_instance() && server_struct_ != NULL;
+}
+inline void validateStruct::clear_server_struct() {
+  if (GetArenaNoVirtual() == NULL && server_struct_ != NULL) {
+    delete server_struct_;
+  }
+  server_struct_ = NULL;
+}
+inline const ::Kinova::Api::Test::RcvStruct& validateStruct::server_struct() const {
+  const ::Kinova::Api::Test::RcvStruct* p = server_struct_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Test.validateStruct.server_struct)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Test::RcvStruct*>(
+      &::Kinova::Api::Test::_RcvStruct_default_instance_);
+}
+inline ::Kinova::Api::Test::RcvStruct* validateStruct::release_server_struct() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Test.validateStruct.server_struct)
+  
+  ::Kinova::Api::Test::RcvStruct* temp = server_struct_;
+  server_struct_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Test::RcvStruct* validateStruct::mutable_server_struct() {
+  
+  if (server_struct_ == NULL) {
+    server_struct_ = new ::Kinova::Api::Test::RcvStruct;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Test.validateStruct.server_struct)
+  return server_struct_;
+}
+inline void validateStruct::set_allocated_server_struct(::Kinova::Api::Test::RcvStruct* server_struct) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete server_struct_;
+  }
+  if (server_struct) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      server_struct = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, server_struct, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  server_struct_ = server_struct;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Test.validateStruct.server_struct)
+}
+
+// -------------------------------------------------------------------
+
+// SendStruct
+
+// bytes bytes_value = 1;
+inline void SendStruct::clear_bytes_value() {
+  bytes_value_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& SendStruct::bytes_value() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Test.SendStruct.bytes_value)
+  return bytes_value_.GetNoArena();
+}
+inline void SendStruct::set_bytes_value(const ::std::string& value) {
+  
+  bytes_value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.Test.SendStruct.bytes_value)
+}
+#if LANG_CXX11
+inline void SendStruct::set_bytes_value(::std::string&& value) {
+  
+  bytes_value_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:Kinova.Api.Test.SendStruct.bytes_value)
+}
+#endif
+inline void SendStruct::set_bytes_value(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  bytes_value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:Kinova.Api.Test.SendStruct.bytes_value)
+}
+inline void SendStruct::set_bytes_value(const void* value, size_t size) {
+  
+  bytes_value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:Kinova.Api.Test.SendStruct.bytes_value)
+}
+inline ::std::string* SendStruct::mutable_bytes_value() {
+  
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Test.SendStruct.bytes_value)
+  return bytes_value_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* SendStruct::release_bytes_value() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Test.SendStruct.bytes_value)
+  
+  return bytes_value_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void SendStruct::set_allocated_bytes_value(::std::string* bytes_value) {
+  if (bytes_value != NULL) {
+    
+  } else {
+    
+  }
+  bytes_value_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), bytes_value);
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Test.SendStruct.bytes_value)
+}
+
+// uint32 uint32_value = 2;
+inline void SendStruct::clear_uint32_value() {
+  uint32_value_ = 0u;
+}
+inline ::google::protobuf::uint32 SendStruct::uint32_value() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Test.SendStruct.uint32_value)
+  return uint32_value_;
+}
+inline void SendStruct::set_uint32_value(::google::protobuf::uint32 value) {
+  
+  uint32_value_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Test.SendStruct.uint32_value)
+}
+
+// fixed32 fixed32_value = 3;
+inline void SendStruct::clear_fixed32_value() {
+  fixed32_value_ = 0u;
+}
+inline ::google::protobuf::uint32 SendStruct::fixed32_value() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Test.SendStruct.fixed32_value)
+  return fixed32_value_;
+}
+inline void SendStruct::set_fixed32_value(::google::protobuf::uint32 value) {
+  
+  fixed32_value_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Test.SendStruct.fixed32_value)
+}
+
+// string string_value = 4;
+inline void SendStruct::clear_string_value() {
+  string_value_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& SendStruct::string_value() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Test.SendStruct.string_value)
+  return string_value_.GetNoArena();
+}
+inline void SendStruct::set_string_value(const ::std::string& value) {
+  
+  string_value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.Test.SendStruct.string_value)
+}
+#if LANG_CXX11
+inline void SendStruct::set_string_value(::std::string&& value) {
+  
+  string_value_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:Kinova.Api.Test.SendStruct.string_value)
+}
+#endif
+inline void SendStruct::set_string_value(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  string_value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:Kinova.Api.Test.SendStruct.string_value)
+}
+inline void SendStruct::set_string_value(const char* value, size_t size) {
+  
+  string_value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:Kinova.Api.Test.SendStruct.string_value)
+}
+inline ::std::string* SendStruct::mutable_string_value() {
+  
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Test.SendStruct.string_value)
+  return string_value_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* SendStruct::release_string_value() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Test.SendStruct.string_value)
+  
+  return string_value_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void SendStruct::set_allocated_string_value(::std::string* string_value) {
+  if (string_value != NULL) {
+    
+  } else {
+    
+  }
+  string_value_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), string_value);
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Test.SendStruct.string_value)
+}
+
+// .Kinova.Api.Test.Enum enum_value = 5;
+inline void SendStruct::clear_enum_value() {
+  enum_value_ = 0;
+}
+inline ::Kinova::Api::Test::Enum SendStruct::enum_value() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Test.SendStruct.enum_value)
+  return static_cast< ::Kinova::Api::Test::Enum >(enum_value_);
+}
+inline void SendStruct::set_enum_value(::Kinova::Api::Test::Enum value) {
+  
+  enum_value_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Test.SendStruct.enum_value)
+}
+
+// .Kinova.Api.Test.EmbeddedStruct embedded_struct_value = 6;
+inline bool SendStruct::has_embedded_struct_value() const {
+  return this != internal_default_instance() && embedded_struct_value_ != NULL;
+}
+inline void SendStruct::clear_embedded_struct_value() {
+  if (GetArenaNoVirtual() == NULL && embedded_struct_value_ != NULL) {
+    delete embedded_struct_value_;
+  }
+  embedded_struct_value_ = NULL;
+}
+inline const ::Kinova::Api::Test::EmbeddedStruct& SendStruct::embedded_struct_value() const {
+  const ::Kinova::Api::Test::EmbeddedStruct* p = embedded_struct_value_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Test.SendStruct.embedded_struct_value)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Test::EmbeddedStruct*>(
+      &::Kinova::Api::Test::_EmbeddedStruct_default_instance_);
+}
+inline ::Kinova::Api::Test::EmbeddedStruct* SendStruct::release_embedded_struct_value() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Test.SendStruct.embedded_struct_value)
+  
+  ::Kinova::Api::Test::EmbeddedStruct* temp = embedded_struct_value_;
+  embedded_struct_value_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Test::EmbeddedStruct* SendStruct::mutable_embedded_struct_value() {
+  
+  if (embedded_struct_value_ == NULL) {
+    embedded_struct_value_ = new ::Kinova::Api::Test::EmbeddedStruct;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Test.SendStruct.embedded_struct_value)
+  return embedded_struct_value_;
+}
+inline void SendStruct::set_allocated_embedded_struct_value(::Kinova::Api::Test::EmbeddedStruct* embedded_struct_value) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete embedded_struct_value_;
+  }
+  if (embedded_struct_value) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      embedded_struct_value = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, embedded_struct_value, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  embedded_struct_value_ = embedded_struct_value;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Test.SendStruct.embedded_struct_value)
+}
+
+// repeated uint32 repeated_uint32_value = 7;
+inline int SendStruct::repeated_uint32_value_size() const {
+  return repeated_uint32_value_.size();
+}
+inline void SendStruct::clear_repeated_uint32_value() {
+  repeated_uint32_value_.Clear();
+}
+inline ::google::protobuf::uint32 SendStruct::repeated_uint32_value(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Test.SendStruct.repeated_uint32_value)
+  return repeated_uint32_value_.Get(index);
+}
+inline void SendStruct::set_repeated_uint32_value(int index, ::google::protobuf::uint32 value) {
+  repeated_uint32_value_.Set(index, value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.Test.SendStruct.repeated_uint32_value)
+}
+inline void SendStruct::add_repeated_uint32_value(::google::protobuf::uint32 value) {
+  repeated_uint32_value_.Add(value);
+  // @@protoc_insertion_point(field_add:Kinova.Api.Test.SendStruct.repeated_uint32_value)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+SendStruct::repeated_uint32_value() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.Test.SendStruct.repeated_uint32_value)
+  return repeated_uint32_value_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+SendStruct::mutable_repeated_uint32_value() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.Test.SendStruct.repeated_uint32_value)
+  return &repeated_uint32_value_;
+}
+
+// -------------------------------------------------------------------
+
+// EmbeddedStruct
+
+// uint32 embedded_uint = 1;
+inline void EmbeddedStruct::clear_embedded_uint() {
+  embedded_uint_ = 0u;
+}
+inline ::google::protobuf::uint32 EmbeddedStruct::embedded_uint() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Test.EmbeddedStruct.embedded_uint)
+  return embedded_uint_;
+}
+inline void EmbeddedStruct::set_embedded_uint(::google::protobuf::uint32 value) {
+  
+  embedded_uint_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Test.EmbeddedStruct.embedded_uint)
+}
+
+// -------------------------------------------------------------------
+
+// RcvStruct
+
+// bytes bytes_value = 1;
+inline void RcvStruct::clear_bytes_value() {
+  bytes_value_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& RcvStruct::bytes_value() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Test.RcvStruct.bytes_value)
+  return bytes_value_.GetNoArena();
+}
+inline void RcvStruct::set_bytes_value(const ::std::string& value) {
+  
+  bytes_value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.Test.RcvStruct.bytes_value)
+}
+#if LANG_CXX11
+inline void RcvStruct::set_bytes_value(::std::string&& value) {
+  
+  bytes_value_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:Kinova.Api.Test.RcvStruct.bytes_value)
+}
+#endif
+inline void RcvStruct::set_bytes_value(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  bytes_value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:Kinova.Api.Test.RcvStruct.bytes_value)
+}
+inline void RcvStruct::set_bytes_value(const void* value, size_t size) {
+  
+  bytes_value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:Kinova.Api.Test.RcvStruct.bytes_value)
+}
+inline ::std::string* RcvStruct::mutable_bytes_value() {
+  
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Test.RcvStruct.bytes_value)
+  return bytes_value_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* RcvStruct::release_bytes_value() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Test.RcvStruct.bytes_value)
+  
+  return bytes_value_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void RcvStruct::set_allocated_bytes_value(::std::string* bytes_value) {
+  if (bytes_value != NULL) {
+    
+  } else {
+    
+  }
+  bytes_value_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), bytes_value);
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Test.RcvStruct.bytes_value)
+}
+
+// uint32 uint32_value = 2;
+inline void RcvStruct::clear_uint32_value() {
+  uint32_value_ = 0u;
+}
+inline ::google::protobuf::uint32 RcvStruct::uint32_value() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Test.RcvStruct.uint32_value)
+  return uint32_value_;
+}
+inline void RcvStruct::set_uint32_value(::google::protobuf::uint32 value) {
+  
+  uint32_value_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Test.RcvStruct.uint32_value)
+}
+
+// fixed32 fixed32_value = 3;
+inline void RcvStruct::clear_fixed32_value() {
+  fixed32_value_ = 0u;
+}
+inline ::google::protobuf::uint32 RcvStruct::fixed32_value() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Test.RcvStruct.fixed32_value)
+  return fixed32_value_;
+}
+inline void RcvStruct::set_fixed32_value(::google::protobuf::uint32 value) {
+  
+  fixed32_value_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Test.RcvStruct.fixed32_value)
+}
+
+// string string_value = 4;
+inline void RcvStruct::clear_string_value() {
+  string_value_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& RcvStruct::string_value() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Test.RcvStruct.string_value)
+  return string_value_.GetNoArena();
+}
+inline void RcvStruct::set_string_value(const ::std::string& value) {
+  
+  string_value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.Test.RcvStruct.string_value)
+}
+#if LANG_CXX11
+inline void RcvStruct::set_string_value(::std::string&& value) {
+  
+  string_value_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:Kinova.Api.Test.RcvStruct.string_value)
+}
+#endif
+inline void RcvStruct::set_string_value(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  string_value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:Kinova.Api.Test.RcvStruct.string_value)
+}
+inline void RcvStruct::set_string_value(const char* value, size_t size) {
+  
+  string_value_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:Kinova.Api.Test.RcvStruct.string_value)
+}
+inline ::std::string* RcvStruct::mutable_string_value() {
+  
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Test.RcvStruct.string_value)
+  return string_value_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* RcvStruct::release_string_value() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Test.RcvStruct.string_value)
+  
+  return string_value_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void RcvStruct::set_allocated_string_value(::std::string* string_value) {
+  if (string_value != NULL) {
+    
+  } else {
+    
+  }
+  string_value_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), string_value);
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Test.RcvStruct.string_value)
+}
+
+// .Kinova.Api.Test.Enum enum_value = 5;
+inline void RcvStruct::clear_enum_value() {
+  enum_value_ = 0;
+}
+inline ::Kinova::Api::Test::Enum RcvStruct::enum_value() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Test.RcvStruct.enum_value)
+  return static_cast< ::Kinova::Api::Test::Enum >(enum_value_);
+}
+inline void RcvStruct::set_enum_value(::Kinova::Api::Test::Enum value) {
+  
+  enum_value_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Test.RcvStruct.enum_value)
+}
+
+// .Kinova.Api.Test.EmbeddedStruct embedded_struct_value = 6;
+inline bool RcvStruct::has_embedded_struct_value() const {
+  return this != internal_default_instance() && embedded_struct_value_ != NULL;
+}
+inline void RcvStruct::clear_embedded_struct_value() {
+  if (GetArenaNoVirtual() == NULL && embedded_struct_value_ != NULL) {
+    delete embedded_struct_value_;
+  }
+  embedded_struct_value_ = NULL;
+}
+inline const ::Kinova::Api::Test::EmbeddedStruct& RcvStruct::embedded_struct_value() const {
+  const ::Kinova::Api::Test::EmbeddedStruct* p = embedded_struct_value_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Test.RcvStruct.embedded_struct_value)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Test::EmbeddedStruct*>(
+      &::Kinova::Api::Test::_EmbeddedStruct_default_instance_);
+}
+inline ::Kinova::Api::Test::EmbeddedStruct* RcvStruct::release_embedded_struct_value() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Test.RcvStruct.embedded_struct_value)
+  
+  ::Kinova::Api::Test::EmbeddedStruct* temp = embedded_struct_value_;
+  embedded_struct_value_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Test::EmbeddedStruct* RcvStruct::mutable_embedded_struct_value() {
+  
+  if (embedded_struct_value_ == NULL) {
+    embedded_struct_value_ = new ::Kinova::Api::Test::EmbeddedStruct;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Test.RcvStruct.embedded_struct_value)
+  return embedded_struct_value_;
+}
+inline void RcvStruct::set_allocated_embedded_struct_value(::Kinova::Api::Test::EmbeddedStruct* embedded_struct_value) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete embedded_struct_value_;
+  }
+  if (embedded_struct_value) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      embedded_struct_value = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, embedded_struct_value, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  embedded_struct_value_ = embedded_struct_value;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Test.RcvStruct.embedded_struct_value)
+}
+
+// repeated uint32 repeated_uint32_value = 7;
+inline int RcvStruct::repeated_uint32_value_size() const {
+  return repeated_uint32_value_.size();
+}
+inline void RcvStruct::clear_repeated_uint32_value() {
+  repeated_uint32_value_.Clear();
+}
+inline ::google::protobuf::uint32 RcvStruct::repeated_uint32_value(int index) const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Test.RcvStruct.repeated_uint32_value)
+  return repeated_uint32_value_.Get(index);
+}
+inline void RcvStruct::set_repeated_uint32_value(int index, ::google::protobuf::uint32 value) {
+  repeated_uint32_value_.Set(index, value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.Test.RcvStruct.repeated_uint32_value)
+}
+inline void RcvStruct::add_repeated_uint32_value(::google::protobuf::uint32 value) {
+  repeated_uint32_value_.Add(value);
+  // @@protoc_insertion_point(field_add:Kinova.Api.Test.RcvStruct.repeated_uint32_value)
+}
+inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >&
+RcvStruct::repeated_uint32_value() const {
+  // @@protoc_insertion_point(field_list:Kinova.Api.Test.RcvStruct.repeated_uint32_value)
+  return repeated_uint32_value_;
+}
+inline ::google::protobuf::RepeatedField< ::google::protobuf::uint32 >*
+RcvStruct::mutable_repeated_uint32_value() {
+  // @@protoc_insertion_point(field_mutable_list:Kinova.Api.Test.RcvStruct.repeated_uint32_value)
+  return &repeated_uint32_value_;
+}
+
+// -------------------------------------------------------------------
+
+// NotifOption
+
+// uint32 dummy_option = 1;
+inline void NotifOption::clear_dummy_option() {
+  dummy_option_ = 0u;
+}
+inline ::google::protobuf::uint32 NotifOption::dummy_option() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Test.NotifOption.dummy_option)
+  return dummy_option_;
+}
+inline void NotifOption::set_dummy_option(::google::protobuf::uint32 value) {
+  
+  dummy_option_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Test.NotifOption.dummy_option)
+}
+
+// -------------------------------------------------------------------
+
+// NotifData
+
+// uint32 data = 1;
+inline void NotifData::clear_data() {
+  data_ = 0u;
+}
+inline ::google::protobuf::uint32 NotifData::data() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Test.NotifData.data)
+  return data_;
+}
+inline void NotifData::set_data(::google::protobuf::uint32 value) {
+  
+  data_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Test.NotifData.data)
+}
+
+// -------------------------------------------------------------------
+
+// timeToResponse
+
+// uint32 time_ms = 1;
+inline void timeToResponse::clear_time_ms() {
+  time_ms_ = 0u;
+}
+inline ::google::protobuf::uint32 timeToResponse::time_ms() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Test.timeToResponse.time_ms)
+  return time_ms_;
+}
+inline void timeToResponse::set_time_ms(::google::protobuf::uint32 value) {
+  
+  time_ms_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Test.timeToResponse.time_ms)
+}
+
+// -------------------------------------------------------------------
+
+// TestNotification
+
+// uint32 dummy_property = 1;
+inline void TestNotification::clear_dummy_property() {
+  dummy_property_ = 0u;
+}
+inline ::google::protobuf::uint32 TestNotification::dummy_property() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Test.TestNotification.dummy_property)
+  return dummy_property_;
+}
+inline void TestNotification::set_dummy_property(::google::protobuf::uint32 value) {
+  
+  dummy_property_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Test.TestNotification.dummy_property)
+}
+
+// -------------------------------------------------------------------
+
+// TestError
+
+// uint32 errorCode = 1;
+inline void TestError::clear_errorcode() {
+  errorcode_ = 0u;
+}
+inline ::google::protobuf::uint32 TestError::errorcode() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Test.TestError.errorCode)
+  return errorcode_;
+}
+inline void TestError::set_errorcode(::google::protobuf::uint32 value) {
+  
+  errorcode_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Test.TestError.errorCode)
+}
+
+// -------------------------------------------------------------------
+
+// SomethingChanged
+
+// .Kinova.Api.Common.Timestamp timestamp = 1;
+inline bool SomethingChanged::has_timestamp() const {
+  return this != internal_default_instance() && timestamp_ != NULL;
+}
+inline const ::Kinova::Api::Common::Timestamp& SomethingChanged::timestamp() const {
+  const ::Kinova::Api::Common::Timestamp* p = timestamp_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Test.SomethingChanged.timestamp)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::Timestamp*>(
+      &::Kinova::Api::Common::_Timestamp_default_instance_);
+}
+inline ::Kinova::Api::Common::Timestamp* SomethingChanged::release_timestamp() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Test.SomethingChanged.timestamp)
+  
+  ::Kinova::Api::Common::Timestamp* temp = timestamp_;
+  timestamp_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::Timestamp* SomethingChanged::mutable_timestamp() {
+  
+  if (timestamp_ == NULL) {
+    timestamp_ = new ::Kinova::Api::Common::Timestamp;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Test.SomethingChanged.timestamp)
+  return timestamp_;
+}
+inline void SomethingChanged::set_allocated_timestamp(::Kinova::Api::Common::Timestamp* timestamp) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(timestamp_);
+  }
+  if (timestamp) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      timestamp = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, timestamp, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  timestamp_ = timestamp;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Test.SomethingChanged.timestamp)
+}
+
+// .Kinova.Api.Common.UserProfileHandle user_handle = 2;
+inline bool SomethingChanged::has_user_handle() const {
+  return this != internal_default_instance() && user_handle_ != NULL;
+}
+inline const ::Kinova::Api::Common::UserProfileHandle& SomethingChanged::user_handle() const {
+  const ::Kinova::Api::Common::UserProfileHandle* p = user_handle_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Test.SomethingChanged.user_handle)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Common::UserProfileHandle*>(
+      &::Kinova::Api::Common::_UserProfileHandle_default_instance_);
+}
+inline ::Kinova::Api::Common::UserProfileHandle* SomethingChanged::release_user_handle() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Test.SomethingChanged.user_handle)
+  
+  ::Kinova::Api::Common::UserProfileHandle* temp = user_handle_;
+  user_handle_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Common::UserProfileHandle* SomethingChanged::mutable_user_handle() {
+  
+  if (user_handle_ == NULL) {
+    user_handle_ = new ::Kinova::Api::Common::UserProfileHandle;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Test.SomethingChanged.user_handle)
+  return user_handle_;
+}
+inline void SomethingChanged::set_allocated_user_handle(::Kinova::Api::Common::UserProfileHandle* user_handle) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete reinterpret_cast< ::google::protobuf::MessageLite*>(user_handle_);
+  }
+  if (user_handle) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      user_handle = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, user_handle, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  user_handle_ = user_handle;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Test.SomethingChanged.user_handle)
+}
+
+// .Kinova.Api.Test.NotifData data = 3;
+inline bool SomethingChanged::has_data() const {
+  return this != internal_default_instance() && data_ != NULL;
+}
+inline void SomethingChanged::clear_data() {
+  if (GetArenaNoVirtual() == NULL && data_ != NULL) {
+    delete data_;
+  }
+  data_ = NULL;
+}
+inline const ::Kinova::Api::Test::NotifData& SomethingChanged::data() const {
+  const ::Kinova::Api::Test::NotifData* p = data_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.Test.SomethingChanged.data)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::Test::NotifData*>(
+      &::Kinova::Api::Test::_NotifData_default_instance_);
+}
+inline ::Kinova::Api::Test::NotifData* SomethingChanged::release_data() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Test.SomethingChanged.data)
+  
+  ::Kinova::Api::Test::NotifData* temp = data_;
+  data_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::Test::NotifData* SomethingChanged::mutable_data() {
+  
+  if (data_ == NULL) {
+    data_ = new ::Kinova::Api::Test::NotifData;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Test.SomethingChanged.data)
+  return data_;
+}
+inline void SomethingChanged::set_allocated_data(::Kinova::Api::Test::NotifData* data) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete data_;
+  }
+  if (data) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      data = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, data, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  data_ = data;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Test.SomethingChanged.data)
+}
+
+// -------------------------------------------------------------------
+
+// Delay
+
+// uint32 ms = 1;
+inline void Delay::clear_ms() {
+  ms_ = 0u;
+}
+inline ::google::protobuf::uint32 Delay::ms() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Test.Delay.ms)
+  return ms_;
+}
+inline void Delay::set_ms(::google::protobuf::uint32 value) {
+  
+  ms_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.Test.Delay.ms)
+}
+
+// -------------------------------------------------------------------
+
+// RequestFromServerMessage
+
+// string req = 1;
+inline void RequestFromServerMessage::clear_req() {
+  req_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& RequestFromServerMessage::req() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Test.RequestFromServerMessage.req)
+  return req_.GetNoArena();
+}
+inline void RequestFromServerMessage::set_req(const ::std::string& value) {
+  
+  req_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.Test.RequestFromServerMessage.req)
+}
+#if LANG_CXX11
+inline void RequestFromServerMessage::set_req(::std::string&& value) {
+  
+  req_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:Kinova.Api.Test.RequestFromServerMessage.req)
+}
+#endif
+inline void RequestFromServerMessage::set_req(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  req_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:Kinova.Api.Test.RequestFromServerMessage.req)
+}
+inline void RequestFromServerMessage::set_req(const char* value, size_t size) {
+  
+  req_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:Kinova.Api.Test.RequestFromServerMessage.req)
+}
+inline ::std::string* RequestFromServerMessage::mutable_req() {
+  
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Test.RequestFromServerMessage.req)
+  return req_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* RequestFromServerMessage::release_req() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Test.RequestFromServerMessage.req)
+  
+  return req_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void RequestFromServerMessage::set_allocated_req(::std::string* req) {
+  if (req != NULL) {
+    
+  } else {
+    
+  }
+  req_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), req);
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Test.RequestFromServerMessage.req)
+}
+
+// -------------------------------------------------------------------
+
+// ResponseFromClientMessage
+
+// string res = 1;
+inline void ResponseFromClientMessage::clear_res() {
+  res_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline const ::std::string& ResponseFromClientMessage::res() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.Test.ResponseFromClientMessage.res)
+  return res_.GetNoArena();
+}
+inline void ResponseFromClientMessage::set_res(const ::std::string& value) {
+  
+  res_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value);
+  // @@protoc_insertion_point(field_set:Kinova.Api.Test.ResponseFromClientMessage.res)
+}
+#if LANG_CXX11
+inline void ResponseFromClientMessage::set_res(::std::string&& value) {
+  
+  res_.SetNoArena(
+    &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
+  // @@protoc_insertion_point(field_set_rvalue:Kinova.Api.Test.ResponseFromClientMessage.res)
+}
+#endif
+inline void ResponseFromClientMessage::set_res(const char* value) {
+  GOOGLE_DCHECK(value != NULL);
+  
+  res_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
+  // @@protoc_insertion_point(field_set_char:Kinova.Api.Test.ResponseFromClientMessage.res)
+}
+inline void ResponseFromClientMessage::set_res(const char* value, size_t size) {
+  
+  res_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(),
+      ::std::string(reinterpret_cast<const char*>(value), size));
+  // @@protoc_insertion_point(field_set_pointer:Kinova.Api.Test.ResponseFromClientMessage.res)
+}
+inline ::std::string* ResponseFromClientMessage::mutable_res() {
+  
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.Test.ResponseFromClientMessage.res)
+  return res_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline ::std::string* ResponseFromClientMessage::release_res() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.Test.ResponseFromClientMessage.res)
+  
+  return res_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
+}
+inline void ResponseFromClientMessage::set_allocated_res(::std::string* res) {
+  if (res != NULL) {
+    
+  } else {
+    
+  }
+  res_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), res);
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.Test.ResponseFromClientMessage.res)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace Test
+}  // namespace Api
+}  // namespace Kinova
+
+namespace google {
+namespace protobuf {
+
+template <> struct is_proto_enum< ::Kinova::Api::Test::ServiceVersion> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Test::ServiceVersion>() {
+  return ::Kinova::Api::Test::ServiceVersion_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::Test::Enum> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::Test::Enum>() {
+  return ::Kinova::Api::Test::Enum_descriptor();
+}
+
+}  // namespace protobuf
+}  // namespace google
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_Test_2eproto__INCLUDED
diff --git a/kortex_api/include/messages/VisionConfig.pb.h b/kortex_api/include/messages/VisionConfig.pb.h
new file mode 100644
index 0000000000000000000000000000000000000000..031fd42777185544c84d9a3c005c8350f9785b37
--- /dev/null
+++ b/kortex_api/include/messages/VisionConfig.pb.h
@@ -0,0 +1,3446 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: VisionConfig.proto
+
+#ifndef PROTOBUF_VisionConfig_2eproto__INCLUDED
+#define PROTOBUF_VisionConfig_2eproto__INCLUDED
+
+#include <string>
+
+#include <google/protobuf/stubs/common.h>
+
+#if GOOGLE_PROTOBUF_VERSION < 3005000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please update
+#error your headers.
+#endif
+#if 3005001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers.  Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "Common.pb.h"  // IWYU pragma: export
+// @@protoc_insertion_point(includes)
+
+namespace protobuf_VisionConfig_2eproto {
+// Internal implementation detail -- do not use these members.
+struct TableStruct {
+  static const ::google::protobuf::internal::ParseTableField entries[];
+  static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
+  static const ::google::protobuf::internal::ParseTable schema[16];
+  static const ::google::protobuf::internal::FieldMetadata field_metadata[];
+  static const ::google::protobuf::internal::SerializationTable serialization_table[];
+  static const ::google::protobuf::uint32 offsets[];
+};
+void AddDescriptors();
+void InitDefaultsSensorSettingsImpl();
+void InitDefaultsSensorSettings();
+void InitDefaultsSensorIdentifierImpl();
+void InitDefaultsSensorIdentifier();
+void InitDefaultsIntrinsicProfileIdentifierImpl();
+void InitDefaultsIntrinsicProfileIdentifier();
+void InitDefaultsOptionIdentifierImpl();
+void InitDefaultsOptionIdentifier();
+void InitDefaultsOptionValueImpl();
+void InitDefaultsOptionValue();
+void InitDefaultsOptionInformationImpl();
+void InitDefaultsOptionInformation();
+void InitDefaultsSensorFocusActionImpl();
+void InitDefaultsSensorFocusAction();
+void InitDefaultsFocusPointImpl();
+void InitDefaultsFocusPoint();
+void InitDefaultsManualFocusImpl();
+void InitDefaultsManualFocus();
+void InitDefaultsVisionNotificationImpl();
+void InitDefaultsVisionNotification();
+void InitDefaultsIntrinsicParametersImpl();
+void InitDefaultsIntrinsicParameters();
+void InitDefaultsDistortionCoefficientsImpl();
+void InitDefaultsDistortionCoefficients();
+void InitDefaultsExtrinsicParametersImpl();
+void InitDefaultsExtrinsicParameters();
+void InitDefaultsRotationMatrixImpl();
+void InitDefaultsRotationMatrix();
+void InitDefaultsRotationMatrixRowImpl();
+void InitDefaultsRotationMatrixRow();
+void InitDefaultsTranslationVectorImpl();
+void InitDefaultsTranslationVector();
+inline void InitDefaults() {
+  InitDefaultsSensorSettings();
+  InitDefaultsSensorIdentifier();
+  InitDefaultsIntrinsicProfileIdentifier();
+  InitDefaultsOptionIdentifier();
+  InitDefaultsOptionValue();
+  InitDefaultsOptionInformation();
+  InitDefaultsSensorFocusAction();
+  InitDefaultsFocusPoint();
+  InitDefaultsManualFocus();
+  InitDefaultsVisionNotification();
+  InitDefaultsIntrinsicParameters();
+  InitDefaultsDistortionCoefficients();
+  InitDefaultsExtrinsicParameters();
+  InitDefaultsRotationMatrix();
+  InitDefaultsRotationMatrixRow();
+  InitDefaultsTranslationVector();
+}
+}  // namespace protobuf_VisionConfig_2eproto
+namespace Kinova {
+namespace Api {
+namespace VisionConfig {
+class DistortionCoefficients;
+class DistortionCoefficientsDefaultTypeInternal;
+extern DistortionCoefficientsDefaultTypeInternal _DistortionCoefficients_default_instance_;
+class ExtrinsicParameters;
+class ExtrinsicParametersDefaultTypeInternal;
+extern ExtrinsicParametersDefaultTypeInternal _ExtrinsicParameters_default_instance_;
+class FocusPoint;
+class FocusPointDefaultTypeInternal;
+extern FocusPointDefaultTypeInternal _FocusPoint_default_instance_;
+class IntrinsicParameters;
+class IntrinsicParametersDefaultTypeInternal;
+extern IntrinsicParametersDefaultTypeInternal _IntrinsicParameters_default_instance_;
+class IntrinsicProfileIdentifier;
+class IntrinsicProfileIdentifierDefaultTypeInternal;
+extern IntrinsicProfileIdentifierDefaultTypeInternal _IntrinsicProfileIdentifier_default_instance_;
+class ManualFocus;
+class ManualFocusDefaultTypeInternal;
+extern ManualFocusDefaultTypeInternal _ManualFocus_default_instance_;
+class OptionIdentifier;
+class OptionIdentifierDefaultTypeInternal;
+extern OptionIdentifierDefaultTypeInternal _OptionIdentifier_default_instance_;
+class OptionInformation;
+class OptionInformationDefaultTypeInternal;
+extern OptionInformationDefaultTypeInternal _OptionInformation_default_instance_;
+class OptionValue;
+class OptionValueDefaultTypeInternal;
+extern OptionValueDefaultTypeInternal _OptionValue_default_instance_;
+class RotationMatrix;
+class RotationMatrixDefaultTypeInternal;
+extern RotationMatrixDefaultTypeInternal _RotationMatrix_default_instance_;
+class RotationMatrixRow;
+class RotationMatrixRowDefaultTypeInternal;
+extern RotationMatrixRowDefaultTypeInternal _RotationMatrixRow_default_instance_;
+class SensorFocusAction;
+class SensorFocusActionDefaultTypeInternal;
+extern SensorFocusActionDefaultTypeInternal _SensorFocusAction_default_instance_;
+class SensorIdentifier;
+class SensorIdentifierDefaultTypeInternal;
+extern SensorIdentifierDefaultTypeInternal _SensorIdentifier_default_instance_;
+class SensorSettings;
+class SensorSettingsDefaultTypeInternal;
+extern SensorSettingsDefaultTypeInternal _SensorSettings_default_instance_;
+class TranslationVector;
+class TranslationVectorDefaultTypeInternal;
+extern TranslationVectorDefaultTypeInternal _TranslationVector_default_instance_;
+class VisionNotification;
+class VisionNotificationDefaultTypeInternal;
+extern VisionNotificationDefaultTypeInternal _VisionNotification_default_instance_;
+}  // namespace VisionConfig
+}  // namespace Api
+}  // namespace Kinova
+namespace Kinova {
+namespace Api {
+namespace VisionConfig {
+
+enum ServiceVersion {
+  RESERVED_0 = 0,
+  CURRENT_VERSION = 1,
+  ServiceVersion_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  ServiceVersion_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool ServiceVersion_IsValid(int value);
+const ServiceVersion ServiceVersion_MIN = RESERVED_0;
+const ServiceVersion ServiceVersion_MAX = CURRENT_VERSION;
+const int ServiceVersion_ARRAYSIZE = ServiceVersion_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* ServiceVersion_descriptor();
+inline const ::std::string& ServiceVersion_Name(ServiceVersion value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    ServiceVersion_descriptor(), value);
+}
+inline bool ServiceVersion_Parse(
+    const ::std::string& name, ServiceVersion* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<ServiceVersion>(
+    ServiceVersion_descriptor(), name, value);
+}
+enum Sensor {
+  SENSOR_UNSPECIFIED = 0,
+  SENSOR_COLOR = 1,
+  SENSOR_DEPTH = 2,
+  Sensor_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  Sensor_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool Sensor_IsValid(int value);
+const Sensor Sensor_MIN = SENSOR_UNSPECIFIED;
+const Sensor Sensor_MAX = SENSOR_DEPTH;
+const int Sensor_ARRAYSIZE = Sensor_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* Sensor_descriptor();
+inline const ::std::string& Sensor_Name(Sensor value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    Sensor_descriptor(), value);
+}
+inline bool Sensor_Parse(
+    const ::std::string& name, Sensor* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<Sensor>(
+    Sensor_descriptor(), name, value);
+}
+enum Resolution {
+  RESOLUTION_UNSPECIFIED = 0,
+  RESOLUTION_320x240 = 1,
+  RESOLUTION_424x240 = 2,
+  RESOLUTION_480x270 = 3,
+  RESOLUTION_640x480 = 4,
+  RESOLUTION_1280x720 = 5,
+  RESOLUTION_1920x1080 = 6,
+  Resolution_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  Resolution_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool Resolution_IsValid(int value);
+const Resolution Resolution_MIN = RESOLUTION_UNSPECIFIED;
+const Resolution Resolution_MAX = RESOLUTION_1920x1080;
+const int Resolution_ARRAYSIZE = Resolution_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* Resolution_descriptor();
+inline const ::std::string& Resolution_Name(Resolution value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    Resolution_descriptor(), value);
+}
+inline bool Resolution_Parse(
+    const ::std::string& name, Resolution* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<Resolution>(
+    Resolution_descriptor(), name, value);
+}
+enum FrameRate {
+  FRAMERATE_UNSPECIFIED = 0,
+  FRAMERATE_6_FPS = 1,
+  FRAMERATE_15_FPS = 2,
+  FRAMERATE_30_FPS = 3,
+  FrameRate_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  FrameRate_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool FrameRate_IsValid(int value);
+const FrameRate FrameRate_MIN = FRAMERATE_UNSPECIFIED;
+const FrameRate FrameRate_MAX = FRAMERATE_30_FPS;
+const int FrameRate_ARRAYSIZE = FrameRate_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* FrameRate_descriptor();
+inline const ::std::string& FrameRate_Name(FrameRate value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    FrameRate_descriptor(), value);
+}
+inline bool FrameRate_Parse(
+    const ::std::string& name, FrameRate* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<FrameRate>(
+    FrameRate_descriptor(), name, value);
+}
+enum BitRate {
+  BITRATE_UNSPECIFIED = 0,
+  BITRATE_10_MBPS = 1,
+  BITRATE_15_MBPS = 2,
+  BITRATE_20_MBPS = 3,
+  BITRATE_25_MBPS = 4,
+  BitRate_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  BitRate_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool BitRate_IsValid(int value);
+const BitRate BitRate_MIN = BITRATE_UNSPECIFIED;
+const BitRate BitRate_MAX = BITRATE_25_MBPS;
+const int BitRate_ARRAYSIZE = BitRate_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* BitRate_descriptor();
+inline const ::std::string& BitRate_Name(BitRate value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    BitRate_descriptor(), value);
+}
+inline bool BitRate_Parse(
+    const ::std::string& name, BitRate* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<BitRate>(
+    BitRate_descriptor(), name, value);
+}
+enum Option {
+  OPTION_UNSPECIFIED = 0,
+  OPTION_BACKLIGHT_COMPENSATION = 1,
+  OPTION_BRIGHTNESS = 2,
+  OPTION_CONTRAST = 3,
+  OPTION_EXPOSURE = 4,
+  OPTION_GAIN = 5,
+  OPTION_GAMMA = 6,
+  OPTION_HUE = 7,
+  OPTION_SATURATION = 8,
+  OPTION_SHARPNESS = 9,
+  OPTION_WHITE_BALANCE = 10,
+  OPTION_ENABLE_AUTO_EXPOSURE = 11,
+  OPTION_ENABLE_AUTO_WHITE_BALANCE = 12,
+  OPTION_VISUAL_PRESET = 13,
+  OPTION_LASER_POWER = 14,
+  OPTION_ACCURACY = 15,
+  OPTION_MOTION_RANGE = 16,
+  OPTION_FILTER_OPTION = 17,
+  OPTION_CONFIDENCE_THRESHOLD = 18,
+  OPTION_EMITTER_ENABLED = 19,
+  OPTION_FRAMES_QUEUE_SIZE = 20,
+  OPTION_TOTAL_FRAME_DROPS = 21,
+  OPTION_AUTO_EXPOSURE_MODE = 22,
+  OPTION_POWER_LINE_FREQUENCY = 23,
+  OPTION_ASIC_TEMPERATURE = 24,
+  OPTION_ERROR_POLLING_ENABLED = 25,
+  OPTION_PROJECTOR_TEMPERATURE = 26,
+  OPTION_OUTPUT_TRIGGER_ENABLED = 27,
+  OPTION_MOTION_MODULE_TEMPERATURE = 28,
+  OPTION_DEPTH_UNITS = 29,
+  OPTION_ENABLE_MOTION_CORRECTION = 30,
+  OPTION_AUTO_EXPOSURE_PRIORITY = 31,
+  OPTION_COLOR_SCHEME = 32,
+  OPTION_HISTOGRAM_EQUALIZATION_ENABLED = 33,
+  OPTION_MIN_DISTANCE = 34,
+  OPTION_MAX_DISTANCE = 35,
+  OPTION_TEXTURE_SOURCE = 36,
+  OPTION_FILTER_MAGNITUDE = 37,
+  OPTION_FILTER_SMOOTH_ALPHA = 38,
+  OPTION_FILTER_SMOOTH_DELTA = 39,
+  OPTION_HOLES_FILL = 40,
+  OPTION_STEREO_BASELINE = 41,
+  OPTION_AUTO_EXPOSURE_CONVERGE_STEP = 42,
+  Option_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  Option_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool Option_IsValid(int value);
+const Option Option_MIN = OPTION_UNSPECIFIED;
+const Option Option_MAX = OPTION_AUTO_EXPOSURE_CONVERGE_STEP;
+const int Option_ARRAYSIZE = Option_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* Option_descriptor();
+inline const ::std::string& Option_Name(Option value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    Option_descriptor(), value);
+}
+inline bool Option_Parse(
+    const ::std::string& name, Option* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<Option>(
+    Option_descriptor(), name, value);
+}
+enum FocusAction {
+  FOCUSACTION_UNSPECIFIED = 0,
+  FOCUSACTION_START_CONTINUOUS_FOCUS = 1,
+  FOCUSACTION_PAUSE_CONTINUOUS_FOCUS = 2,
+  FOCUSACTION_FOCUS_NOW = 3,
+  FOCUSACTION_DISABLE_FOCUS = 4,
+  FOCUSACTION_SET_FOCUS_POINT = 5,
+  FOCUSACTION_SET_MANUAL_FOCUS = 6,
+  FocusAction_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  FocusAction_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool FocusAction_IsValid(int value);
+const FocusAction FocusAction_MIN = FOCUSACTION_UNSPECIFIED;
+const FocusAction FocusAction_MAX = FOCUSACTION_SET_MANUAL_FOCUS;
+const int FocusAction_ARRAYSIZE = FocusAction_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* FocusAction_descriptor();
+inline const ::std::string& FocusAction_Name(FocusAction value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    FocusAction_descriptor(), value);
+}
+inline bool FocusAction_Parse(
+    const ::std::string& name, FocusAction* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<FocusAction>(
+    FocusAction_descriptor(), name, value);
+}
+enum VisionEvent {
+  UNSPECIFIED_VISION_EVENT = 0,
+  SENSOR_SETTINGS_CHANGED = 1,
+  OPTION_VALUE_CHANGED = 2,
+  VisionEvent_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min,
+  VisionEvent_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max
+};
+bool VisionEvent_IsValid(int value);
+const VisionEvent VisionEvent_MIN = UNSPECIFIED_VISION_EVENT;
+const VisionEvent VisionEvent_MAX = OPTION_VALUE_CHANGED;
+const int VisionEvent_ARRAYSIZE = VisionEvent_MAX + 1;
+
+const ::google::protobuf::EnumDescriptor* VisionEvent_descriptor();
+inline const ::std::string& VisionEvent_Name(VisionEvent value) {
+  return ::google::protobuf::internal::NameOfEnum(
+    VisionEvent_descriptor(), value);
+}
+inline bool VisionEvent_Parse(
+    const ::std::string& name, VisionEvent* value) {
+  return ::google::protobuf::internal::ParseNamedEnum<VisionEvent>(
+    VisionEvent_descriptor(), name, value);
+}
+// ===================================================================
+
+class SensorSettings : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.VisionConfig.SensorSettings) */ {
+ public:
+  SensorSettings();
+  virtual ~SensorSettings();
+
+  SensorSettings(const SensorSettings& from);
+
+  inline SensorSettings& operator=(const SensorSettings& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  SensorSettings(SensorSettings&& from) noexcept
+    : SensorSettings() {
+    *this = ::std::move(from);
+  }
+
+  inline SensorSettings& operator=(SensorSettings&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SensorSettings& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const SensorSettings* internal_default_instance() {
+    return reinterpret_cast<const SensorSettings*>(
+               &_SensorSettings_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    0;
+
+  void Swap(SensorSettings* other);
+  friend void swap(SensorSettings& a, SensorSettings& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SensorSettings* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  SensorSettings* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const SensorSettings& from);
+  void MergeFrom(const SensorSettings& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(SensorSettings* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.VisionConfig.Sensor sensor = 1;
+  void clear_sensor();
+  static const int kSensorFieldNumber = 1;
+  ::Kinova::Api::VisionConfig::Sensor sensor() const;
+  void set_sensor(::Kinova::Api::VisionConfig::Sensor value);
+
+  // .Kinova.Api.VisionConfig.Resolution resolution = 2;
+  void clear_resolution();
+  static const int kResolutionFieldNumber = 2;
+  ::Kinova::Api::VisionConfig::Resolution resolution() const;
+  void set_resolution(::Kinova::Api::VisionConfig::Resolution value);
+
+  // .Kinova.Api.VisionConfig.FrameRate frame_rate = 3;
+  void clear_frame_rate();
+  static const int kFrameRateFieldNumber = 3;
+  ::Kinova::Api::VisionConfig::FrameRate frame_rate() const;
+  void set_frame_rate(::Kinova::Api::VisionConfig::FrameRate value);
+
+  // .Kinova.Api.VisionConfig.BitRate bit_rate = 4;
+  void clear_bit_rate();
+  static const int kBitRateFieldNumber = 4;
+  ::Kinova::Api::VisionConfig::BitRate bit_rate() const;
+  void set_bit_rate(::Kinova::Api::VisionConfig::BitRate value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.VisionConfig.SensorSettings)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  int sensor_;
+  int resolution_;
+  int frame_rate_;
+  int bit_rate_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_VisionConfig_2eproto::TableStruct;
+  friend void ::protobuf_VisionConfig_2eproto::InitDefaultsSensorSettingsImpl();
+};
+// -------------------------------------------------------------------
+
+class SensorIdentifier : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.VisionConfig.SensorIdentifier) */ {
+ public:
+  SensorIdentifier();
+  virtual ~SensorIdentifier();
+
+  SensorIdentifier(const SensorIdentifier& from);
+
+  inline SensorIdentifier& operator=(const SensorIdentifier& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  SensorIdentifier(SensorIdentifier&& from) noexcept
+    : SensorIdentifier() {
+    *this = ::std::move(from);
+  }
+
+  inline SensorIdentifier& operator=(SensorIdentifier&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SensorIdentifier& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const SensorIdentifier* internal_default_instance() {
+    return reinterpret_cast<const SensorIdentifier*>(
+               &_SensorIdentifier_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    1;
+
+  void Swap(SensorIdentifier* other);
+  friend void swap(SensorIdentifier& a, SensorIdentifier& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SensorIdentifier* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  SensorIdentifier* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const SensorIdentifier& from);
+  void MergeFrom(const SensorIdentifier& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(SensorIdentifier* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.VisionConfig.Sensor sensor = 1;
+  void clear_sensor();
+  static const int kSensorFieldNumber = 1;
+  ::Kinova::Api::VisionConfig::Sensor sensor() const;
+  void set_sensor(::Kinova::Api::VisionConfig::Sensor value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.VisionConfig.SensorIdentifier)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  int sensor_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_VisionConfig_2eproto::TableStruct;
+  friend void ::protobuf_VisionConfig_2eproto::InitDefaultsSensorIdentifierImpl();
+};
+// -------------------------------------------------------------------
+
+class IntrinsicProfileIdentifier : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.VisionConfig.IntrinsicProfileIdentifier) */ {
+ public:
+  IntrinsicProfileIdentifier();
+  virtual ~IntrinsicProfileIdentifier();
+
+  IntrinsicProfileIdentifier(const IntrinsicProfileIdentifier& from);
+
+  inline IntrinsicProfileIdentifier& operator=(const IntrinsicProfileIdentifier& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  IntrinsicProfileIdentifier(IntrinsicProfileIdentifier&& from) noexcept
+    : IntrinsicProfileIdentifier() {
+    *this = ::std::move(from);
+  }
+
+  inline IntrinsicProfileIdentifier& operator=(IntrinsicProfileIdentifier&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const IntrinsicProfileIdentifier& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const IntrinsicProfileIdentifier* internal_default_instance() {
+    return reinterpret_cast<const IntrinsicProfileIdentifier*>(
+               &_IntrinsicProfileIdentifier_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    2;
+
+  void Swap(IntrinsicProfileIdentifier* other);
+  friend void swap(IntrinsicProfileIdentifier& a, IntrinsicProfileIdentifier& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline IntrinsicProfileIdentifier* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  IntrinsicProfileIdentifier* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const IntrinsicProfileIdentifier& from);
+  void MergeFrom(const IntrinsicProfileIdentifier& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(IntrinsicProfileIdentifier* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.VisionConfig.Sensor sensor = 1;
+  void clear_sensor();
+  static const int kSensorFieldNumber = 1;
+  ::Kinova::Api::VisionConfig::Sensor sensor() const;
+  void set_sensor(::Kinova::Api::VisionConfig::Sensor value);
+
+  // .Kinova.Api.VisionConfig.Resolution resolution = 2;
+  void clear_resolution();
+  static const int kResolutionFieldNumber = 2;
+  ::Kinova::Api::VisionConfig::Resolution resolution() const;
+  void set_resolution(::Kinova::Api::VisionConfig::Resolution value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.VisionConfig.IntrinsicProfileIdentifier)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  int sensor_;
+  int resolution_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_VisionConfig_2eproto::TableStruct;
+  friend void ::protobuf_VisionConfig_2eproto::InitDefaultsIntrinsicProfileIdentifierImpl();
+};
+// -------------------------------------------------------------------
+
+class OptionIdentifier : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.VisionConfig.OptionIdentifier) */ {
+ public:
+  OptionIdentifier();
+  virtual ~OptionIdentifier();
+
+  OptionIdentifier(const OptionIdentifier& from);
+
+  inline OptionIdentifier& operator=(const OptionIdentifier& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  OptionIdentifier(OptionIdentifier&& from) noexcept
+    : OptionIdentifier() {
+    *this = ::std::move(from);
+  }
+
+  inline OptionIdentifier& operator=(OptionIdentifier&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const OptionIdentifier& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const OptionIdentifier* internal_default_instance() {
+    return reinterpret_cast<const OptionIdentifier*>(
+               &_OptionIdentifier_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    3;
+
+  void Swap(OptionIdentifier* other);
+  friend void swap(OptionIdentifier& a, OptionIdentifier& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline OptionIdentifier* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  OptionIdentifier* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const OptionIdentifier& from);
+  void MergeFrom(const OptionIdentifier& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(OptionIdentifier* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.VisionConfig.Sensor sensor = 1;
+  void clear_sensor();
+  static const int kSensorFieldNumber = 1;
+  ::Kinova::Api::VisionConfig::Sensor sensor() const;
+  void set_sensor(::Kinova::Api::VisionConfig::Sensor value);
+
+  // .Kinova.Api.VisionConfig.Option option = 2;
+  void clear_option();
+  static const int kOptionFieldNumber = 2;
+  ::Kinova::Api::VisionConfig::Option option() const;
+  void set_option(::Kinova::Api::VisionConfig::Option value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.VisionConfig.OptionIdentifier)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  int sensor_;
+  int option_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_VisionConfig_2eproto::TableStruct;
+  friend void ::protobuf_VisionConfig_2eproto::InitDefaultsOptionIdentifierImpl();
+};
+// -------------------------------------------------------------------
+
+class OptionValue : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.VisionConfig.OptionValue) */ {
+ public:
+  OptionValue();
+  virtual ~OptionValue();
+
+  OptionValue(const OptionValue& from);
+
+  inline OptionValue& operator=(const OptionValue& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  OptionValue(OptionValue&& from) noexcept
+    : OptionValue() {
+    *this = ::std::move(from);
+  }
+
+  inline OptionValue& operator=(OptionValue&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const OptionValue& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const OptionValue* internal_default_instance() {
+    return reinterpret_cast<const OptionValue*>(
+               &_OptionValue_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    4;
+
+  void Swap(OptionValue* other);
+  friend void swap(OptionValue& a, OptionValue& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline OptionValue* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  OptionValue* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const OptionValue& from);
+  void MergeFrom(const OptionValue& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(OptionValue* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.VisionConfig.Sensor sensor = 1;
+  void clear_sensor();
+  static const int kSensorFieldNumber = 1;
+  ::Kinova::Api::VisionConfig::Sensor sensor() const;
+  void set_sensor(::Kinova::Api::VisionConfig::Sensor value);
+
+  // .Kinova.Api.VisionConfig.Option option = 2;
+  void clear_option();
+  static const int kOptionFieldNumber = 2;
+  ::Kinova::Api::VisionConfig::Option option() const;
+  void set_option(::Kinova::Api::VisionConfig::Option value);
+
+  // float value = 3;
+  void clear_value();
+  static const int kValueFieldNumber = 3;
+  float value() const;
+  void set_value(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.VisionConfig.OptionValue)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  int sensor_;
+  int option_;
+  float value_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_VisionConfig_2eproto::TableStruct;
+  friend void ::protobuf_VisionConfig_2eproto::InitDefaultsOptionValueImpl();
+};
+// -------------------------------------------------------------------
+
+class OptionInformation : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.VisionConfig.OptionInformation) */ {
+ public:
+  OptionInformation();
+  virtual ~OptionInformation();
+
+  OptionInformation(const OptionInformation& from);
+
+  inline OptionInformation& operator=(const OptionInformation& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  OptionInformation(OptionInformation&& from) noexcept
+    : OptionInformation() {
+    *this = ::std::move(from);
+  }
+
+  inline OptionInformation& operator=(OptionInformation&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const OptionInformation& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const OptionInformation* internal_default_instance() {
+    return reinterpret_cast<const OptionInformation*>(
+               &_OptionInformation_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    5;
+
+  void Swap(OptionInformation* other);
+  friend void swap(OptionInformation& a, OptionInformation& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline OptionInformation* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  OptionInformation* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const OptionInformation& from);
+  void MergeFrom(const OptionInformation& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(OptionInformation* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.VisionConfig.Sensor sensor = 1;
+  void clear_sensor();
+  static const int kSensorFieldNumber = 1;
+  ::Kinova::Api::VisionConfig::Sensor sensor() const;
+  void set_sensor(::Kinova::Api::VisionConfig::Sensor value);
+
+  // .Kinova.Api.VisionConfig.Option option = 2;
+  void clear_option();
+  static const int kOptionFieldNumber = 2;
+  ::Kinova::Api::VisionConfig::Option option() const;
+  void set_option(::Kinova::Api::VisionConfig::Option value);
+
+  // bool supported = 3;
+  void clear_supported();
+  static const int kSupportedFieldNumber = 3;
+  bool supported() const;
+  void set_supported(bool value);
+
+  // bool read_only = 4;
+  void clear_read_only();
+  static const int kReadOnlyFieldNumber = 4;
+  bool read_only() const;
+  void set_read_only(bool value);
+
+  // float minimum = 5;
+  void clear_minimum();
+  static const int kMinimumFieldNumber = 5;
+  float minimum() const;
+  void set_minimum(float value);
+
+  // float maximum = 6;
+  void clear_maximum();
+  static const int kMaximumFieldNumber = 6;
+  float maximum() const;
+  void set_maximum(float value);
+
+  // float step = 7;
+  void clear_step();
+  static const int kStepFieldNumber = 7;
+  float step() const;
+  void set_step(float value);
+
+  // float default_value = 8;
+  void clear_default_value();
+  static const int kDefaultValueFieldNumber = 8;
+  float default_value() const;
+  void set_default_value(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.VisionConfig.OptionInformation)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  int sensor_;
+  int option_;
+  bool supported_;
+  bool read_only_;
+  float minimum_;
+  float maximum_;
+  float step_;
+  float default_value_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_VisionConfig_2eproto::TableStruct;
+  friend void ::protobuf_VisionConfig_2eproto::InitDefaultsOptionInformationImpl();
+};
+// -------------------------------------------------------------------
+
+class SensorFocusAction : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.VisionConfig.SensorFocusAction) */ {
+ public:
+  SensorFocusAction();
+  virtual ~SensorFocusAction();
+
+  SensorFocusAction(const SensorFocusAction& from);
+
+  inline SensorFocusAction& operator=(const SensorFocusAction& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  SensorFocusAction(SensorFocusAction&& from) noexcept
+    : SensorFocusAction() {
+    *this = ::std::move(from);
+  }
+
+  inline SensorFocusAction& operator=(SensorFocusAction&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const SensorFocusAction& default_instance();
+
+  enum ActionParametersCase {
+    kFocusPoint = 3,
+    kManualFocus = 4,
+    ACTION_PARAMETERS_NOT_SET = 0,
+  };
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const SensorFocusAction* internal_default_instance() {
+    return reinterpret_cast<const SensorFocusAction*>(
+               &_SensorFocusAction_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    6;
+
+  void Swap(SensorFocusAction* other);
+  friend void swap(SensorFocusAction& a, SensorFocusAction& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SensorFocusAction* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  SensorFocusAction* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const SensorFocusAction& from);
+  void MergeFrom(const SensorFocusAction& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(SensorFocusAction* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.VisionConfig.Sensor sensor = 1;
+  void clear_sensor();
+  static const int kSensorFieldNumber = 1;
+  ::Kinova::Api::VisionConfig::Sensor sensor() const;
+  void set_sensor(::Kinova::Api::VisionConfig::Sensor value);
+
+  // .Kinova.Api.VisionConfig.FocusAction focus_action = 2;
+  void clear_focus_action();
+  static const int kFocusActionFieldNumber = 2;
+  ::Kinova::Api::VisionConfig::FocusAction focus_action() const;
+  void set_focus_action(::Kinova::Api::VisionConfig::FocusAction value);
+
+  // .Kinova.Api.VisionConfig.FocusPoint focus_point = 3;
+  bool has_focus_point() const;
+  void clear_focus_point();
+  static const int kFocusPointFieldNumber = 3;
+  const ::Kinova::Api::VisionConfig::FocusPoint& focus_point() const;
+  ::Kinova::Api::VisionConfig::FocusPoint* release_focus_point();
+  ::Kinova::Api::VisionConfig::FocusPoint* mutable_focus_point();
+  void set_allocated_focus_point(::Kinova::Api::VisionConfig::FocusPoint* focus_point);
+
+  // .Kinova.Api.VisionConfig.ManualFocus manual_focus = 4;
+  bool has_manual_focus() const;
+  void clear_manual_focus();
+  static const int kManualFocusFieldNumber = 4;
+  const ::Kinova::Api::VisionConfig::ManualFocus& manual_focus() const;
+  ::Kinova::Api::VisionConfig::ManualFocus* release_manual_focus();
+  ::Kinova::Api::VisionConfig::ManualFocus* mutable_manual_focus();
+  void set_allocated_manual_focus(::Kinova::Api::VisionConfig::ManualFocus* manual_focus);
+
+  ActionParametersCase action_parameters_case() const;
+  // @@protoc_insertion_point(class_scope:Kinova.Api.VisionConfig.SensorFocusAction)
+ private:
+  void set_has_focus_point();
+  void set_has_manual_focus();
+
+  inline bool has_action_parameters() const;
+  void clear_action_parameters();
+  inline void clear_has_action_parameters();
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  int sensor_;
+  int focus_action_;
+  union ActionParametersUnion {
+    ActionParametersUnion() {}
+    ::Kinova::Api::VisionConfig::FocusPoint* focus_point_;
+    ::Kinova::Api::VisionConfig::ManualFocus* manual_focus_;
+  } action_parameters_;
+  mutable int _cached_size_;
+  ::google::protobuf::uint32 _oneof_case_[1];
+
+  friend struct ::protobuf_VisionConfig_2eproto::TableStruct;
+  friend void ::protobuf_VisionConfig_2eproto::InitDefaultsSensorFocusActionImpl();
+};
+// -------------------------------------------------------------------
+
+class FocusPoint : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.VisionConfig.FocusPoint) */ {
+ public:
+  FocusPoint();
+  virtual ~FocusPoint();
+
+  FocusPoint(const FocusPoint& from);
+
+  inline FocusPoint& operator=(const FocusPoint& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  FocusPoint(FocusPoint&& from) noexcept
+    : FocusPoint() {
+    *this = ::std::move(from);
+  }
+
+  inline FocusPoint& operator=(FocusPoint&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const FocusPoint& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const FocusPoint* internal_default_instance() {
+    return reinterpret_cast<const FocusPoint*>(
+               &_FocusPoint_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    7;
+
+  void Swap(FocusPoint* other);
+  friend void swap(FocusPoint& a, FocusPoint& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline FocusPoint* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  FocusPoint* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const FocusPoint& from);
+  void MergeFrom(const FocusPoint& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(FocusPoint* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // uint32 x = 1;
+  void clear_x();
+  static const int kXFieldNumber = 1;
+  ::google::protobuf::uint32 x() const;
+  void set_x(::google::protobuf::uint32 value);
+
+  // uint32 y = 2;
+  void clear_y();
+  static const int kYFieldNumber = 2;
+  ::google::protobuf::uint32 y() const;
+  void set_y(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.VisionConfig.FocusPoint)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 x_;
+  ::google::protobuf::uint32 y_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_VisionConfig_2eproto::TableStruct;
+  friend void ::protobuf_VisionConfig_2eproto::InitDefaultsFocusPointImpl();
+};
+// -------------------------------------------------------------------
+
+class ManualFocus : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.VisionConfig.ManualFocus) */ {
+ public:
+  ManualFocus();
+  virtual ~ManualFocus();
+
+  ManualFocus(const ManualFocus& from);
+
+  inline ManualFocus& operator=(const ManualFocus& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ManualFocus(ManualFocus&& from) noexcept
+    : ManualFocus() {
+    *this = ::std::move(from);
+  }
+
+  inline ManualFocus& operator=(ManualFocus&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ManualFocus& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ManualFocus* internal_default_instance() {
+    return reinterpret_cast<const ManualFocus*>(
+               &_ManualFocus_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    8;
+
+  void Swap(ManualFocus* other);
+  friend void swap(ManualFocus& a, ManualFocus& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ManualFocus* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ManualFocus* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ManualFocus& from);
+  void MergeFrom(const ManualFocus& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ManualFocus* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // uint32 value = 1;
+  void clear_value();
+  static const int kValueFieldNumber = 1;
+  ::google::protobuf::uint32 value() const;
+  void set_value(::google::protobuf::uint32 value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.VisionConfig.ManualFocus)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::google::protobuf::uint32 value_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_VisionConfig_2eproto::TableStruct;
+  friend void ::protobuf_VisionConfig_2eproto::InitDefaultsManualFocusImpl();
+};
+// -------------------------------------------------------------------
+
+class VisionNotification : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.VisionConfig.VisionNotification) */ {
+ public:
+  VisionNotification();
+  virtual ~VisionNotification();
+
+  VisionNotification(const VisionNotification& from);
+
+  inline VisionNotification& operator=(const VisionNotification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  VisionNotification(VisionNotification&& from) noexcept
+    : VisionNotification() {
+    *this = ::std::move(from);
+  }
+
+  inline VisionNotification& operator=(VisionNotification&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const VisionNotification& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const VisionNotification* internal_default_instance() {
+    return reinterpret_cast<const VisionNotification*>(
+               &_VisionNotification_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    9;
+
+  void Swap(VisionNotification* other);
+  friend void swap(VisionNotification& a, VisionNotification& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline VisionNotification* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  VisionNotification* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const VisionNotification& from);
+  void MergeFrom(const VisionNotification& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(VisionNotification* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.VisionConfig.VisionEvent event = 1;
+  void clear_event();
+  static const int kEventFieldNumber = 1;
+  ::Kinova::Api::VisionConfig::VisionEvent event() const;
+  void set_event(::Kinova::Api::VisionConfig::VisionEvent value);
+
+  // .Kinova.Api.VisionConfig.Sensor sensor = 2;
+  void clear_sensor();
+  static const int kSensorFieldNumber = 2;
+  ::Kinova::Api::VisionConfig::Sensor sensor() const;
+  void set_sensor(::Kinova::Api::VisionConfig::Sensor value);
+
+  // .Kinova.Api.VisionConfig.Option option = 3;
+  void clear_option();
+  static const int kOptionFieldNumber = 3;
+  ::Kinova::Api::VisionConfig::Option option() const;
+  void set_option(::Kinova::Api::VisionConfig::Option value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.VisionConfig.VisionNotification)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  int event_;
+  int sensor_;
+  int option_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_VisionConfig_2eproto::TableStruct;
+  friend void ::protobuf_VisionConfig_2eproto::InitDefaultsVisionNotificationImpl();
+};
+// -------------------------------------------------------------------
+
+class IntrinsicParameters : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.VisionConfig.IntrinsicParameters) */ {
+ public:
+  IntrinsicParameters();
+  virtual ~IntrinsicParameters();
+
+  IntrinsicParameters(const IntrinsicParameters& from);
+
+  inline IntrinsicParameters& operator=(const IntrinsicParameters& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  IntrinsicParameters(IntrinsicParameters&& from) noexcept
+    : IntrinsicParameters() {
+    *this = ::std::move(from);
+  }
+
+  inline IntrinsicParameters& operator=(IntrinsicParameters&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const IntrinsicParameters& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const IntrinsicParameters* internal_default_instance() {
+    return reinterpret_cast<const IntrinsicParameters*>(
+               &_IntrinsicParameters_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    10;
+
+  void Swap(IntrinsicParameters* other);
+  friend void swap(IntrinsicParameters& a, IntrinsicParameters& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline IntrinsicParameters* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  IntrinsicParameters* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const IntrinsicParameters& from);
+  void MergeFrom(const IntrinsicParameters& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(IntrinsicParameters* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.VisionConfig.DistortionCoefficients distortion_coeffs = 7;
+  bool has_distortion_coeffs() const;
+  void clear_distortion_coeffs();
+  static const int kDistortionCoeffsFieldNumber = 7;
+  const ::Kinova::Api::VisionConfig::DistortionCoefficients& distortion_coeffs() const;
+  ::Kinova::Api::VisionConfig::DistortionCoefficients* release_distortion_coeffs();
+  ::Kinova::Api::VisionConfig::DistortionCoefficients* mutable_distortion_coeffs();
+  void set_allocated_distortion_coeffs(::Kinova::Api::VisionConfig::DistortionCoefficients* distortion_coeffs);
+
+  // .Kinova.Api.VisionConfig.Sensor sensor = 1;
+  void clear_sensor();
+  static const int kSensorFieldNumber = 1;
+  ::Kinova::Api::VisionConfig::Sensor sensor() const;
+  void set_sensor(::Kinova::Api::VisionConfig::Sensor value);
+
+  // .Kinova.Api.VisionConfig.Resolution resolution = 2;
+  void clear_resolution();
+  static const int kResolutionFieldNumber = 2;
+  ::Kinova::Api::VisionConfig::Resolution resolution() const;
+  void set_resolution(::Kinova::Api::VisionConfig::Resolution value);
+
+  // float principal_point_x = 3;
+  void clear_principal_point_x();
+  static const int kPrincipalPointXFieldNumber = 3;
+  float principal_point_x() const;
+  void set_principal_point_x(float value);
+
+  // float principal_point_y = 4;
+  void clear_principal_point_y();
+  static const int kPrincipalPointYFieldNumber = 4;
+  float principal_point_y() const;
+  void set_principal_point_y(float value);
+
+  // float focal_length_x = 5;
+  void clear_focal_length_x();
+  static const int kFocalLengthXFieldNumber = 5;
+  float focal_length_x() const;
+  void set_focal_length_x(float value);
+
+  // float focal_length_y = 6;
+  void clear_focal_length_y();
+  static const int kFocalLengthYFieldNumber = 6;
+  float focal_length_y() const;
+  void set_focal_length_y(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.VisionConfig.IntrinsicParameters)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::VisionConfig::DistortionCoefficients* distortion_coeffs_;
+  int sensor_;
+  int resolution_;
+  float principal_point_x_;
+  float principal_point_y_;
+  float focal_length_x_;
+  float focal_length_y_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_VisionConfig_2eproto::TableStruct;
+  friend void ::protobuf_VisionConfig_2eproto::InitDefaultsIntrinsicParametersImpl();
+};
+// -------------------------------------------------------------------
+
+class DistortionCoefficients : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.VisionConfig.DistortionCoefficients) */ {
+ public:
+  DistortionCoefficients();
+  virtual ~DistortionCoefficients();
+
+  DistortionCoefficients(const DistortionCoefficients& from);
+
+  inline DistortionCoefficients& operator=(const DistortionCoefficients& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  DistortionCoefficients(DistortionCoefficients&& from) noexcept
+    : DistortionCoefficients() {
+    *this = ::std::move(from);
+  }
+
+  inline DistortionCoefficients& operator=(DistortionCoefficients&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const DistortionCoefficients& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const DistortionCoefficients* internal_default_instance() {
+    return reinterpret_cast<const DistortionCoefficients*>(
+               &_DistortionCoefficients_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    11;
+
+  void Swap(DistortionCoefficients* other);
+  friend void swap(DistortionCoefficients& a, DistortionCoefficients& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline DistortionCoefficients* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  DistortionCoefficients* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const DistortionCoefficients& from);
+  void MergeFrom(const DistortionCoefficients& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(DistortionCoefficients* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // float k1 = 1;
+  void clear_k1();
+  static const int kK1FieldNumber = 1;
+  float k1() const;
+  void set_k1(float value);
+
+  // float k2 = 2;
+  void clear_k2();
+  static const int kK2FieldNumber = 2;
+  float k2() const;
+  void set_k2(float value);
+
+  // float k3 = 3;
+  void clear_k3();
+  static const int kK3FieldNumber = 3;
+  float k3() const;
+  void set_k3(float value);
+
+  // float p1 = 4;
+  void clear_p1();
+  static const int kP1FieldNumber = 4;
+  float p1() const;
+  void set_p1(float value);
+
+  // float p2 = 5;
+  void clear_p2();
+  static const int kP2FieldNumber = 5;
+  float p2() const;
+  void set_p2(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.VisionConfig.DistortionCoefficients)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  float k1_;
+  float k2_;
+  float k3_;
+  float p1_;
+  float p2_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_VisionConfig_2eproto::TableStruct;
+  friend void ::protobuf_VisionConfig_2eproto::InitDefaultsDistortionCoefficientsImpl();
+};
+// -------------------------------------------------------------------
+
+class ExtrinsicParameters : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.VisionConfig.ExtrinsicParameters) */ {
+ public:
+  ExtrinsicParameters();
+  virtual ~ExtrinsicParameters();
+
+  ExtrinsicParameters(const ExtrinsicParameters& from);
+
+  inline ExtrinsicParameters& operator=(const ExtrinsicParameters& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  ExtrinsicParameters(ExtrinsicParameters&& from) noexcept
+    : ExtrinsicParameters() {
+    *this = ::std::move(from);
+  }
+
+  inline ExtrinsicParameters& operator=(ExtrinsicParameters&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const ExtrinsicParameters& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const ExtrinsicParameters* internal_default_instance() {
+    return reinterpret_cast<const ExtrinsicParameters*>(
+               &_ExtrinsicParameters_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    12;
+
+  void Swap(ExtrinsicParameters* other);
+  friend void swap(ExtrinsicParameters& a, ExtrinsicParameters& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ExtrinsicParameters* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  ExtrinsicParameters* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const ExtrinsicParameters& from);
+  void MergeFrom(const ExtrinsicParameters& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(ExtrinsicParameters* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.VisionConfig.RotationMatrix rotation = 1;
+  bool has_rotation() const;
+  void clear_rotation();
+  static const int kRotationFieldNumber = 1;
+  const ::Kinova::Api::VisionConfig::RotationMatrix& rotation() const;
+  ::Kinova::Api::VisionConfig::RotationMatrix* release_rotation();
+  ::Kinova::Api::VisionConfig::RotationMatrix* mutable_rotation();
+  void set_allocated_rotation(::Kinova::Api::VisionConfig::RotationMatrix* rotation);
+
+  // .Kinova.Api.VisionConfig.TranslationVector translation = 2;
+  bool has_translation() const;
+  void clear_translation();
+  static const int kTranslationFieldNumber = 2;
+  const ::Kinova::Api::VisionConfig::TranslationVector& translation() const;
+  ::Kinova::Api::VisionConfig::TranslationVector* release_translation();
+  ::Kinova::Api::VisionConfig::TranslationVector* mutable_translation();
+  void set_allocated_translation(::Kinova::Api::VisionConfig::TranslationVector* translation);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.VisionConfig.ExtrinsicParameters)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::VisionConfig::RotationMatrix* rotation_;
+  ::Kinova::Api::VisionConfig::TranslationVector* translation_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_VisionConfig_2eproto::TableStruct;
+  friend void ::protobuf_VisionConfig_2eproto::InitDefaultsExtrinsicParametersImpl();
+};
+// -------------------------------------------------------------------
+
+class RotationMatrix : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.VisionConfig.RotationMatrix) */ {
+ public:
+  RotationMatrix();
+  virtual ~RotationMatrix();
+
+  RotationMatrix(const RotationMatrix& from);
+
+  inline RotationMatrix& operator=(const RotationMatrix& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  RotationMatrix(RotationMatrix&& from) noexcept
+    : RotationMatrix() {
+    *this = ::std::move(from);
+  }
+
+  inline RotationMatrix& operator=(RotationMatrix&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const RotationMatrix& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const RotationMatrix* internal_default_instance() {
+    return reinterpret_cast<const RotationMatrix*>(
+               &_RotationMatrix_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    13;
+
+  void Swap(RotationMatrix* other);
+  friend void swap(RotationMatrix& a, RotationMatrix& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline RotationMatrix* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  RotationMatrix* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const RotationMatrix& from);
+  void MergeFrom(const RotationMatrix& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(RotationMatrix* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // .Kinova.Api.VisionConfig.RotationMatrixRow row1 = 1;
+  bool has_row1() const;
+  void clear_row1();
+  static const int kRow1FieldNumber = 1;
+  const ::Kinova::Api::VisionConfig::RotationMatrixRow& row1() const;
+  ::Kinova::Api::VisionConfig::RotationMatrixRow* release_row1();
+  ::Kinova::Api::VisionConfig::RotationMatrixRow* mutable_row1();
+  void set_allocated_row1(::Kinova::Api::VisionConfig::RotationMatrixRow* row1);
+
+  // .Kinova.Api.VisionConfig.RotationMatrixRow row2 = 2;
+  bool has_row2() const;
+  void clear_row2();
+  static const int kRow2FieldNumber = 2;
+  const ::Kinova::Api::VisionConfig::RotationMatrixRow& row2() const;
+  ::Kinova::Api::VisionConfig::RotationMatrixRow* release_row2();
+  ::Kinova::Api::VisionConfig::RotationMatrixRow* mutable_row2();
+  void set_allocated_row2(::Kinova::Api::VisionConfig::RotationMatrixRow* row2);
+
+  // .Kinova.Api.VisionConfig.RotationMatrixRow row3 = 3;
+  bool has_row3() const;
+  void clear_row3();
+  static const int kRow3FieldNumber = 3;
+  const ::Kinova::Api::VisionConfig::RotationMatrixRow& row3() const;
+  ::Kinova::Api::VisionConfig::RotationMatrixRow* release_row3();
+  ::Kinova::Api::VisionConfig::RotationMatrixRow* mutable_row3();
+  void set_allocated_row3(::Kinova::Api::VisionConfig::RotationMatrixRow* row3);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.VisionConfig.RotationMatrix)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  ::Kinova::Api::VisionConfig::RotationMatrixRow* row1_;
+  ::Kinova::Api::VisionConfig::RotationMatrixRow* row2_;
+  ::Kinova::Api::VisionConfig::RotationMatrixRow* row3_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_VisionConfig_2eproto::TableStruct;
+  friend void ::protobuf_VisionConfig_2eproto::InitDefaultsRotationMatrixImpl();
+};
+// -------------------------------------------------------------------
+
+class RotationMatrixRow : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.VisionConfig.RotationMatrixRow) */ {
+ public:
+  RotationMatrixRow();
+  virtual ~RotationMatrixRow();
+
+  RotationMatrixRow(const RotationMatrixRow& from);
+
+  inline RotationMatrixRow& operator=(const RotationMatrixRow& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  RotationMatrixRow(RotationMatrixRow&& from) noexcept
+    : RotationMatrixRow() {
+    *this = ::std::move(from);
+  }
+
+  inline RotationMatrixRow& operator=(RotationMatrixRow&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const RotationMatrixRow& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const RotationMatrixRow* internal_default_instance() {
+    return reinterpret_cast<const RotationMatrixRow*>(
+               &_RotationMatrixRow_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    14;
+
+  void Swap(RotationMatrixRow* other);
+  friend void swap(RotationMatrixRow& a, RotationMatrixRow& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline RotationMatrixRow* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  RotationMatrixRow* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const RotationMatrixRow& from);
+  void MergeFrom(const RotationMatrixRow& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(RotationMatrixRow* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // float column1 = 1;
+  void clear_column1();
+  static const int kColumn1FieldNumber = 1;
+  float column1() const;
+  void set_column1(float value);
+
+  // float column2 = 2;
+  void clear_column2();
+  static const int kColumn2FieldNumber = 2;
+  float column2() const;
+  void set_column2(float value);
+
+  // float column3 = 3;
+  void clear_column3();
+  static const int kColumn3FieldNumber = 3;
+  float column3() const;
+  void set_column3(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.VisionConfig.RotationMatrixRow)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  float column1_;
+  float column2_;
+  float column3_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_VisionConfig_2eproto::TableStruct;
+  friend void ::protobuf_VisionConfig_2eproto::InitDefaultsRotationMatrixRowImpl();
+};
+// -------------------------------------------------------------------
+
+class TranslationVector : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:Kinova.Api.VisionConfig.TranslationVector) */ {
+ public:
+  TranslationVector();
+  virtual ~TranslationVector();
+
+  TranslationVector(const TranslationVector& from);
+
+  inline TranslationVector& operator=(const TranslationVector& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  #if LANG_CXX11
+  TranslationVector(TranslationVector&& from) noexcept
+    : TranslationVector() {
+    *this = ::std::move(from);
+  }
+
+  inline TranslationVector& operator=(TranslationVector&& from) noexcept {
+    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
+      if (this != &from) InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+  #endif
+  static const ::google::protobuf::Descriptor* descriptor();
+  static const TranslationVector& default_instance();
+
+  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
+  static inline const TranslationVector* internal_default_instance() {
+    return reinterpret_cast<const TranslationVector*>(
+               &_TranslationVector_default_instance_);
+  }
+  static PROTOBUF_CONSTEXPR int const kIndexInFileMessages =
+    15;
+
+  void Swap(TranslationVector* other);
+  friend void swap(TranslationVector& a, TranslationVector& b) {
+    a.Swap(&b);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline TranslationVector* New() const PROTOBUF_FINAL { return New(NULL); }
+
+  TranslationVector* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL;
+  void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL;
+  void CopyFrom(const TranslationVector& from);
+  void MergeFrom(const TranslationVector& from);
+  void Clear() PROTOBUF_FINAL;
+  bool IsInitialized() const PROTOBUF_FINAL;
+
+  size_t ByteSizeLong() const PROTOBUF_FINAL;
+  bool MergePartialFromCodedStream(
+      ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL;
+  void SerializeWithCachedSizes(
+      ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL;
+  ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray(
+      bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL;
+  int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; }
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const PROTOBUF_FINAL;
+  void InternalSwap(TranslationVector* other);
+  private:
+  inline ::google::protobuf::Arena* GetArenaNoVirtual() const {
+    return NULL;
+  }
+  inline void* MaybeArenaPtr() const {
+    return NULL;
+  }
+  public:
+
+  ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  // float t_x = 1;
+  void clear_t_x();
+  static const int kTXFieldNumber = 1;
+  float t_x() const;
+  void set_t_x(float value);
+
+  // float t_y = 2;
+  void clear_t_y();
+  static const int kTYFieldNumber = 2;
+  float t_y() const;
+  void set_t_y(float value);
+
+  // float t_z = 3;
+  void clear_t_z();
+  static const int kTZFieldNumber = 3;
+  float t_z() const;
+  void set_t_z(float value);
+
+  // @@protoc_insertion_point(class_scope:Kinova.Api.VisionConfig.TranslationVector)
+ private:
+
+  ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_;
+  float t_x_;
+  float t_y_;
+  float t_z_;
+  mutable int _cached_size_;
+  friend struct ::protobuf_VisionConfig_2eproto::TableStruct;
+  friend void ::protobuf_VisionConfig_2eproto::InitDefaultsTranslationVectorImpl();
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// SensorSettings
+
+// .Kinova.Api.VisionConfig.Sensor sensor = 1;
+inline void SensorSettings::clear_sensor() {
+  sensor_ = 0;
+}
+inline ::Kinova::Api::VisionConfig::Sensor SensorSettings::sensor() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.VisionConfig.SensorSettings.sensor)
+  return static_cast< ::Kinova::Api::VisionConfig::Sensor >(sensor_);
+}
+inline void SensorSettings::set_sensor(::Kinova::Api::VisionConfig::Sensor value) {
+  
+  sensor_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.VisionConfig.SensorSettings.sensor)
+}
+
+// .Kinova.Api.VisionConfig.Resolution resolution = 2;
+inline void SensorSettings::clear_resolution() {
+  resolution_ = 0;
+}
+inline ::Kinova::Api::VisionConfig::Resolution SensorSettings::resolution() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.VisionConfig.SensorSettings.resolution)
+  return static_cast< ::Kinova::Api::VisionConfig::Resolution >(resolution_);
+}
+inline void SensorSettings::set_resolution(::Kinova::Api::VisionConfig::Resolution value) {
+  
+  resolution_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.VisionConfig.SensorSettings.resolution)
+}
+
+// .Kinova.Api.VisionConfig.FrameRate frame_rate = 3;
+inline void SensorSettings::clear_frame_rate() {
+  frame_rate_ = 0;
+}
+inline ::Kinova::Api::VisionConfig::FrameRate SensorSettings::frame_rate() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.VisionConfig.SensorSettings.frame_rate)
+  return static_cast< ::Kinova::Api::VisionConfig::FrameRate >(frame_rate_);
+}
+inline void SensorSettings::set_frame_rate(::Kinova::Api::VisionConfig::FrameRate value) {
+  
+  frame_rate_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.VisionConfig.SensorSettings.frame_rate)
+}
+
+// .Kinova.Api.VisionConfig.BitRate bit_rate = 4;
+inline void SensorSettings::clear_bit_rate() {
+  bit_rate_ = 0;
+}
+inline ::Kinova::Api::VisionConfig::BitRate SensorSettings::bit_rate() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.VisionConfig.SensorSettings.bit_rate)
+  return static_cast< ::Kinova::Api::VisionConfig::BitRate >(bit_rate_);
+}
+inline void SensorSettings::set_bit_rate(::Kinova::Api::VisionConfig::BitRate value) {
+  
+  bit_rate_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.VisionConfig.SensorSettings.bit_rate)
+}
+
+// -------------------------------------------------------------------
+
+// SensorIdentifier
+
+// .Kinova.Api.VisionConfig.Sensor sensor = 1;
+inline void SensorIdentifier::clear_sensor() {
+  sensor_ = 0;
+}
+inline ::Kinova::Api::VisionConfig::Sensor SensorIdentifier::sensor() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.VisionConfig.SensorIdentifier.sensor)
+  return static_cast< ::Kinova::Api::VisionConfig::Sensor >(sensor_);
+}
+inline void SensorIdentifier::set_sensor(::Kinova::Api::VisionConfig::Sensor value) {
+  
+  sensor_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.VisionConfig.SensorIdentifier.sensor)
+}
+
+// -------------------------------------------------------------------
+
+// IntrinsicProfileIdentifier
+
+// .Kinova.Api.VisionConfig.Sensor sensor = 1;
+inline void IntrinsicProfileIdentifier::clear_sensor() {
+  sensor_ = 0;
+}
+inline ::Kinova::Api::VisionConfig::Sensor IntrinsicProfileIdentifier::sensor() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.VisionConfig.IntrinsicProfileIdentifier.sensor)
+  return static_cast< ::Kinova::Api::VisionConfig::Sensor >(sensor_);
+}
+inline void IntrinsicProfileIdentifier::set_sensor(::Kinova::Api::VisionConfig::Sensor value) {
+  
+  sensor_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.VisionConfig.IntrinsicProfileIdentifier.sensor)
+}
+
+// .Kinova.Api.VisionConfig.Resolution resolution = 2;
+inline void IntrinsicProfileIdentifier::clear_resolution() {
+  resolution_ = 0;
+}
+inline ::Kinova::Api::VisionConfig::Resolution IntrinsicProfileIdentifier::resolution() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.VisionConfig.IntrinsicProfileIdentifier.resolution)
+  return static_cast< ::Kinova::Api::VisionConfig::Resolution >(resolution_);
+}
+inline void IntrinsicProfileIdentifier::set_resolution(::Kinova::Api::VisionConfig::Resolution value) {
+  
+  resolution_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.VisionConfig.IntrinsicProfileIdentifier.resolution)
+}
+
+// -------------------------------------------------------------------
+
+// OptionIdentifier
+
+// .Kinova.Api.VisionConfig.Sensor sensor = 1;
+inline void OptionIdentifier::clear_sensor() {
+  sensor_ = 0;
+}
+inline ::Kinova::Api::VisionConfig::Sensor OptionIdentifier::sensor() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.VisionConfig.OptionIdentifier.sensor)
+  return static_cast< ::Kinova::Api::VisionConfig::Sensor >(sensor_);
+}
+inline void OptionIdentifier::set_sensor(::Kinova::Api::VisionConfig::Sensor value) {
+  
+  sensor_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.VisionConfig.OptionIdentifier.sensor)
+}
+
+// .Kinova.Api.VisionConfig.Option option = 2;
+inline void OptionIdentifier::clear_option() {
+  option_ = 0;
+}
+inline ::Kinova::Api::VisionConfig::Option OptionIdentifier::option() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.VisionConfig.OptionIdentifier.option)
+  return static_cast< ::Kinova::Api::VisionConfig::Option >(option_);
+}
+inline void OptionIdentifier::set_option(::Kinova::Api::VisionConfig::Option value) {
+  
+  option_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.VisionConfig.OptionIdentifier.option)
+}
+
+// -------------------------------------------------------------------
+
+// OptionValue
+
+// .Kinova.Api.VisionConfig.Sensor sensor = 1;
+inline void OptionValue::clear_sensor() {
+  sensor_ = 0;
+}
+inline ::Kinova::Api::VisionConfig::Sensor OptionValue::sensor() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.VisionConfig.OptionValue.sensor)
+  return static_cast< ::Kinova::Api::VisionConfig::Sensor >(sensor_);
+}
+inline void OptionValue::set_sensor(::Kinova::Api::VisionConfig::Sensor value) {
+  
+  sensor_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.VisionConfig.OptionValue.sensor)
+}
+
+// .Kinova.Api.VisionConfig.Option option = 2;
+inline void OptionValue::clear_option() {
+  option_ = 0;
+}
+inline ::Kinova::Api::VisionConfig::Option OptionValue::option() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.VisionConfig.OptionValue.option)
+  return static_cast< ::Kinova::Api::VisionConfig::Option >(option_);
+}
+inline void OptionValue::set_option(::Kinova::Api::VisionConfig::Option value) {
+  
+  option_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.VisionConfig.OptionValue.option)
+}
+
+// float value = 3;
+inline void OptionValue::clear_value() {
+  value_ = 0;
+}
+inline float OptionValue::value() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.VisionConfig.OptionValue.value)
+  return value_;
+}
+inline void OptionValue::set_value(float value) {
+  
+  value_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.VisionConfig.OptionValue.value)
+}
+
+// -------------------------------------------------------------------
+
+// OptionInformation
+
+// .Kinova.Api.VisionConfig.Sensor sensor = 1;
+inline void OptionInformation::clear_sensor() {
+  sensor_ = 0;
+}
+inline ::Kinova::Api::VisionConfig::Sensor OptionInformation::sensor() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.VisionConfig.OptionInformation.sensor)
+  return static_cast< ::Kinova::Api::VisionConfig::Sensor >(sensor_);
+}
+inline void OptionInformation::set_sensor(::Kinova::Api::VisionConfig::Sensor value) {
+  
+  sensor_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.VisionConfig.OptionInformation.sensor)
+}
+
+// .Kinova.Api.VisionConfig.Option option = 2;
+inline void OptionInformation::clear_option() {
+  option_ = 0;
+}
+inline ::Kinova::Api::VisionConfig::Option OptionInformation::option() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.VisionConfig.OptionInformation.option)
+  return static_cast< ::Kinova::Api::VisionConfig::Option >(option_);
+}
+inline void OptionInformation::set_option(::Kinova::Api::VisionConfig::Option value) {
+  
+  option_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.VisionConfig.OptionInformation.option)
+}
+
+// bool supported = 3;
+inline void OptionInformation::clear_supported() {
+  supported_ = false;
+}
+inline bool OptionInformation::supported() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.VisionConfig.OptionInformation.supported)
+  return supported_;
+}
+inline void OptionInformation::set_supported(bool value) {
+  
+  supported_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.VisionConfig.OptionInformation.supported)
+}
+
+// bool read_only = 4;
+inline void OptionInformation::clear_read_only() {
+  read_only_ = false;
+}
+inline bool OptionInformation::read_only() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.VisionConfig.OptionInformation.read_only)
+  return read_only_;
+}
+inline void OptionInformation::set_read_only(bool value) {
+  
+  read_only_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.VisionConfig.OptionInformation.read_only)
+}
+
+// float minimum = 5;
+inline void OptionInformation::clear_minimum() {
+  minimum_ = 0;
+}
+inline float OptionInformation::minimum() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.VisionConfig.OptionInformation.minimum)
+  return minimum_;
+}
+inline void OptionInformation::set_minimum(float value) {
+  
+  minimum_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.VisionConfig.OptionInformation.minimum)
+}
+
+// float maximum = 6;
+inline void OptionInformation::clear_maximum() {
+  maximum_ = 0;
+}
+inline float OptionInformation::maximum() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.VisionConfig.OptionInformation.maximum)
+  return maximum_;
+}
+inline void OptionInformation::set_maximum(float value) {
+  
+  maximum_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.VisionConfig.OptionInformation.maximum)
+}
+
+// float step = 7;
+inline void OptionInformation::clear_step() {
+  step_ = 0;
+}
+inline float OptionInformation::step() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.VisionConfig.OptionInformation.step)
+  return step_;
+}
+inline void OptionInformation::set_step(float value) {
+  
+  step_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.VisionConfig.OptionInformation.step)
+}
+
+// float default_value = 8;
+inline void OptionInformation::clear_default_value() {
+  default_value_ = 0;
+}
+inline float OptionInformation::default_value() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.VisionConfig.OptionInformation.default_value)
+  return default_value_;
+}
+inline void OptionInformation::set_default_value(float value) {
+  
+  default_value_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.VisionConfig.OptionInformation.default_value)
+}
+
+// -------------------------------------------------------------------
+
+// SensorFocusAction
+
+// .Kinova.Api.VisionConfig.Sensor sensor = 1;
+inline void SensorFocusAction::clear_sensor() {
+  sensor_ = 0;
+}
+inline ::Kinova::Api::VisionConfig::Sensor SensorFocusAction::sensor() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.VisionConfig.SensorFocusAction.sensor)
+  return static_cast< ::Kinova::Api::VisionConfig::Sensor >(sensor_);
+}
+inline void SensorFocusAction::set_sensor(::Kinova::Api::VisionConfig::Sensor value) {
+  
+  sensor_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.VisionConfig.SensorFocusAction.sensor)
+}
+
+// .Kinova.Api.VisionConfig.FocusAction focus_action = 2;
+inline void SensorFocusAction::clear_focus_action() {
+  focus_action_ = 0;
+}
+inline ::Kinova::Api::VisionConfig::FocusAction SensorFocusAction::focus_action() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.VisionConfig.SensorFocusAction.focus_action)
+  return static_cast< ::Kinova::Api::VisionConfig::FocusAction >(focus_action_);
+}
+inline void SensorFocusAction::set_focus_action(::Kinova::Api::VisionConfig::FocusAction value) {
+  
+  focus_action_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.VisionConfig.SensorFocusAction.focus_action)
+}
+
+// .Kinova.Api.VisionConfig.FocusPoint focus_point = 3;
+inline bool SensorFocusAction::has_focus_point() const {
+  return action_parameters_case() == kFocusPoint;
+}
+inline void SensorFocusAction::set_has_focus_point() {
+  _oneof_case_[0] = kFocusPoint;
+}
+inline void SensorFocusAction::clear_focus_point() {
+  if (has_focus_point()) {
+    delete action_parameters_.focus_point_;
+    clear_has_action_parameters();
+  }
+}
+inline ::Kinova::Api::VisionConfig::FocusPoint* SensorFocusAction::release_focus_point() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.VisionConfig.SensorFocusAction.focus_point)
+  if (has_focus_point()) {
+    clear_has_action_parameters();
+      ::Kinova::Api::VisionConfig::FocusPoint* temp = action_parameters_.focus_point_;
+    action_parameters_.focus_point_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline const ::Kinova::Api::VisionConfig::FocusPoint& SensorFocusAction::focus_point() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.VisionConfig.SensorFocusAction.focus_point)
+  return has_focus_point()
+      ? *action_parameters_.focus_point_
+      : *reinterpret_cast< ::Kinova::Api::VisionConfig::FocusPoint*>(&::Kinova::Api::VisionConfig::_FocusPoint_default_instance_);
+}
+inline ::Kinova::Api::VisionConfig::FocusPoint* SensorFocusAction::mutable_focus_point() {
+  if (!has_focus_point()) {
+    clear_action_parameters();
+    set_has_focus_point();
+    action_parameters_.focus_point_ = new ::Kinova::Api::VisionConfig::FocusPoint;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.VisionConfig.SensorFocusAction.focus_point)
+  return action_parameters_.focus_point_;
+}
+
+// .Kinova.Api.VisionConfig.ManualFocus manual_focus = 4;
+inline bool SensorFocusAction::has_manual_focus() const {
+  return action_parameters_case() == kManualFocus;
+}
+inline void SensorFocusAction::set_has_manual_focus() {
+  _oneof_case_[0] = kManualFocus;
+}
+inline void SensorFocusAction::clear_manual_focus() {
+  if (has_manual_focus()) {
+    delete action_parameters_.manual_focus_;
+    clear_has_action_parameters();
+  }
+}
+inline ::Kinova::Api::VisionConfig::ManualFocus* SensorFocusAction::release_manual_focus() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.VisionConfig.SensorFocusAction.manual_focus)
+  if (has_manual_focus()) {
+    clear_has_action_parameters();
+      ::Kinova::Api::VisionConfig::ManualFocus* temp = action_parameters_.manual_focus_;
+    action_parameters_.manual_focus_ = NULL;
+    return temp;
+  } else {
+    return NULL;
+  }
+}
+inline const ::Kinova::Api::VisionConfig::ManualFocus& SensorFocusAction::manual_focus() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.VisionConfig.SensorFocusAction.manual_focus)
+  return has_manual_focus()
+      ? *action_parameters_.manual_focus_
+      : *reinterpret_cast< ::Kinova::Api::VisionConfig::ManualFocus*>(&::Kinova::Api::VisionConfig::_ManualFocus_default_instance_);
+}
+inline ::Kinova::Api::VisionConfig::ManualFocus* SensorFocusAction::mutable_manual_focus() {
+  if (!has_manual_focus()) {
+    clear_action_parameters();
+    set_has_manual_focus();
+    action_parameters_.manual_focus_ = new ::Kinova::Api::VisionConfig::ManualFocus;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.VisionConfig.SensorFocusAction.manual_focus)
+  return action_parameters_.manual_focus_;
+}
+
+inline bool SensorFocusAction::has_action_parameters() const {
+  return action_parameters_case() != ACTION_PARAMETERS_NOT_SET;
+}
+inline void SensorFocusAction::clear_has_action_parameters() {
+  _oneof_case_[0] = ACTION_PARAMETERS_NOT_SET;
+}
+inline SensorFocusAction::ActionParametersCase SensorFocusAction::action_parameters_case() const {
+  return SensorFocusAction::ActionParametersCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// FocusPoint
+
+// uint32 x = 1;
+inline void FocusPoint::clear_x() {
+  x_ = 0u;
+}
+inline ::google::protobuf::uint32 FocusPoint::x() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.VisionConfig.FocusPoint.x)
+  return x_;
+}
+inline void FocusPoint::set_x(::google::protobuf::uint32 value) {
+  
+  x_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.VisionConfig.FocusPoint.x)
+}
+
+// uint32 y = 2;
+inline void FocusPoint::clear_y() {
+  y_ = 0u;
+}
+inline ::google::protobuf::uint32 FocusPoint::y() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.VisionConfig.FocusPoint.y)
+  return y_;
+}
+inline void FocusPoint::set_y(::google::protobuf::uint32 value) {
+  
+  y_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.VisionConfig.FocusPoint.y)
+}
+
+// -------------------------------------------------------------------
+
+// ManualFocus
+
+// uint32 value = 1;
+inline void ManualFocus::clear_value() {
+  value_ = 0u;
+}
+inline ::google::protobuf::uint32 ManualFocus::value() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.VisionConfig.ManualFocus.value)
+  return value_;
+}
+inline void ManualFocus::set_value(::google::protobuf::uint32 value) {
+  
+  value_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.VisionConfig.ManualFocus.value)
+}
+
+// -------------------------------------------------------------------
+
+// VisionNotification
+
+// .Kinova.Api.VisionConfig.VisionEvent event = 1;
+inline void VisionNotification::clear_event() {
+  event_ = 0;
+}
+inline ::Kinova::Api::VisionConfig::VisionEvent VisionNotification::event() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.VisionConfig.VisionNotification.event)
+  return static_cast< ::Kinova::Api::VisionConfig::VisionEvent >(event_);
+}
+inline void VisionNotification::set_event(::Kinova::Api::VisionConfig::VisionEvent value) {
+  
+  event_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.VisionConfig.VisionNotification.event)
+}
+
+// .Kinova.Api.VisionConfig.Sensor sensor = 2;
+inline void VisionNotification::clear_sensor() {
+  sensor_ = 0;
+}
+inline ::Kinova::Api::VisionConfig::Sensor VisionNotification::sensor() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.VisionConfig.VisionNotification.sensor)
+  return static_cast< ::Kinova::Api::VisionConfig::Sensor >(sensor_);
+}
+inline void VisionNotification::set_sensor(::Kinova::Api::VisionConfig::Sensor value) {
+  
+  sensor_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.VisionConfig.VisionNotification.sensor)
+}
+
+// .Kinova.Api.VisionConfig.Option option = 3;
+inline void VisionNotification::clear_option() {
+  option_ = 0;
+}
+inline ::Kinova::Api::VisionConfig::Option VisionNotification::option() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.VisionConfig.VisionNotification.option)
+  return static_cast< ::Kinova::Api::VisionConfig::Option >(option_);
+}
+inline void VisionNotification::set_option(::Kinova::Api::VisionConfig::Option value) {
+  
+  option_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.VisionConfig.VisionNotification.option)
+}
+
+// -------------------------------------------------------------------
+
+// IntrinsicParameters
+
+// .Kinova.Api.VisionConfig.Sensor sensor = 1;
+inline void IntrinsicParameters::clear_sensor() {
+  sensor_ = 0;
+}
+inline ::Kinova::Api::VisionConfig::Sensor IntrinsicParameters::sensor() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.VisionConfig.IntrinsicParameters.sensor)
+  return static_cast< ::Kinova::Api::VisionConfig::Sensor >(sensor_);
+}
+inline void IntrinsicParameters::set_sensor(::Kinova::Api::VisionConfig::Sensor value) {
+  
+  sensor_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.VisionConfig.IntrinsicParameters.sensor)
+}
+
+// .Kinova.Api.VisionConfig.Resolution resolution = 2;
+inline void IntrinsicParameters::clear_resolution() {
+  resolution_ = 0;
+}
+inline ::Kinova::Api::VisionConfig::Resolution IntrinsicParameters::resolution() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.VisionConfig.IntrinsicParameters.resolution)
+  return static_cast< ::Kinova::Api::VisionConfig::Resolution >(resolution_);
+}
+inline void IntrinsicParameters::set_resolution(::Kinova::Api::VisionConfig::Resolution value) {
+  
+  resolution_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.VisionConfig.IntrinsicParameters.resolution)
+}
+
+// float principal_point_x = 3;
+inline void IntrinsicParameters::clear_principal_point_x() {
+  principal_point_x_ = 0;
+}
+inline float IntrinsicParameters::principal_point_x() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.VisionConfig.IntrinsicParameters.principal_point_x)
+  return principal_point_x_;
+}
+inline void IntrinsicParameters::set_principal_point_x(float value) {
+  
+  principal_point_x_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.VisionConfig.IntrinsicParameters.principal_point_x)
+}
+
+// float principal_point_y = 4;
+inline void IntrinsicParameters::clear_principal_point_y() {
+  principal_point_y_ = 0;
+}
+inline float IntrinsicParameters::principal_point_y() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.VisionConfig.IntrinsicParameters.principal_point_y)
+  return principal_point_y_;
+}
+inline void IntrinsicParameters::set_principal_point_y(float value) {
+  
+  principal_point_y_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.VisionConfig.IntrinsicParameters.principal_point_y)
+}
+
+// float focal_length_x = 5;
+inline void IntrinsicParameters::clear_focal_length_x() {
+  focal_length_x_ = 0;
+}
+inline float IntrinsicParameters::focal_length_x() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.VisionConfig.IntrinsicParameters.focal_length_x)
+  return focal_length_x_;
+}
+inline void IntrinsicParameters::set_focal_length_x(float value) {
+  
+  focal_length_x_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.VisionConfig.IntrinsicParameters.focal_length_x)
+}
+
+// float focal_length_y = 6;
+inline void IntrinsicParameters::clear_focal_length_y() {
+  focal_length_y_ = 0;
+}
+inline float IntrinsicParameters::focal_length_y() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.VisionConfig.IntrinsicParameters.focal_length_y)
+  return focal_length_y_;
+}
+inline void IntrinsicParameters::set_focal_length_y(float value) {
+  
+  focal_length_y_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.VisionConfig.IntrinsicParameters.focal_length_y)
+}
+
+// .Kinova.Api.VisionConfig.DistortionCoefficients distortion_coeffs = 7;
+inline bool IntrinsicParameters::has_distortion_coeffs() const {
+  return this != internal_default_instance() && distortion_coeffs_ != NULL;
+}
+inline void IntrinsicParameters::clear_distortion_coeffs() {
+  if (GetArenaNoVirtual() == NULL && distortion_coeffs_ != NULL) {
+    delete distortion_coeffs_;
+  }
+  distortion_coeffs_ = NULL;
+}
+inline const ::Kinova::Api::VisionConfig::DistortionCoefficients& IntrinsicParameters::distortion_coeffs() const {
+  const ::Kinova::Api::VisionConfig::DistortionCoefficients* p = distortion_coeffs_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.VisionConfig.IntrinsicParameters.distortion_coeffs)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::VisionConfig::DistortionCoefficients*>(
+      &::Kinova::Api::VisionConfig::_DistortionCoefficients_default_instance_);
+}
+inline ::Kinova::Api::VisionConfig::DistortionCoefficients* IntrinsicParameters::release_distortion_coeffs() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.VisionConfig.IntrinsicParameters.distortion_coeffs)
+  
+  ::Kinova::Api::VisionConfig::DistortionCoefficients* temp = distortion_coeffs_;
+  distortion_coeffs_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::VisionConfig::DistortionCoefficients* IntrinsicParameters::mutable_distortion_coeffs() {
+  
+  if (distortion_coeffs_ == NULL) {
+    distortion_coeffs_ = new ::Kinova::Api::VisionConfig::DistortionCoefficients;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.VisionConfig.IntrinsicParameters.distortion_coeffs)
+  return distortion_coeffs_;
+}
+inline void IntrinsicParameters::set_allocated_distortion_coeffs(::Kinova::Api::VisionConfig::DistortionCoefficients* distortion_coeffs) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete distortion_coeffs_;
+  }
+  if (distortion_coeffs) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      distortion_coeffs = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, distortion_coeffs, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  distortion_coeffs_ = distortion_coeffs;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.VisionConfig.IntrinsicParameters.distortion_coeffs)
+}
+
+// -------------------------------------------------------------------
+
+// DistortionCoefficients
+
+// float k1 = 1;
+inline void DistortionCoefficients::clear_k1() {
+  k1_ = 0;
+}
+inline float DistortionCoefficients::k1() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.VisionConfig.DistortionCoefficients.k1)
+  return k1_;
+}
+inline void DistortionCoefficients::set_k1(float value) {
+  
+  k1_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.VisionConfig.DistortionCoefficients.k1)
+}
+
+// float k2 = 2;
+inline void DistortionCoefficients::clear_k2() {
+  k2_ = 0;
+}
+inline float DistortionCoefficients::k2() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.VisionConfig.DistortionCoefficients.k2)
+  return k2_;
+}
+inline void DistortionCoefficients::set_k2(float value) {
+  
+  k2_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.VisionConfig.DistortionCoefficients.k2)
+}
+
+// float k3 = 3;
+inline void DistortionCoefficients::clear_k3() {
+  k3_ = 0;
+}
+inline float DistortionCoefficients::k3() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.VisionConfig.DistortionCoefficients.k3)
+  return k3_;
+}
+inline void DistortionCoefficients::set_k3(float value) {
+  
+  k3_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.VisionConfig.DistortionCoefficients.k3)
+}
+
+// float p1 = 4;
+inline void DistortionCoefficients::clear_p1() {
+  p1_ = 0;
+}
+inline float DistortionCoefficients::p1() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.VisionConfig.DistortionCoefficients.p1)
+  return p1_;
+}
+inline void DistortionCoefficients::set_p1(float value) {
+  
+  p1_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.VisionConfig.DistortionCoefficients.p1)
+}
+
+// float p2 = 5;
+inline void DistortionCoefficients::clear_p2() {
+  p2_ = 0;
+}
+inline float DistortionCoefficients::p2() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.VisionConfig.DistortionCoefficients.p2)
+  return p2_;
+}
+inline void DistortionCoefficients::set_p2(float value) {
+  
+  p2_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.VisionConfig.DistortionCoefficients.p2)
+}
+
+// -------------------------------------------------------------------
+
+// ExtrinsicParameters
+
+// .Kinova.Api.VisionConfig.RotationMatrix rotation = 1;
+inline bool ExtrinsicParameters::has_rotation() const {
+  return this != internal_default_instance() && rotation_ != NULL;
+}
+inline void ExtrinsicParameters::clear_rotation() {
+  if (GetArenaNoVirtual() == NULL && rotation_ != NULL) {
+    delete rotation_;
+  }
+  rotation_ = NULL;
+}
+inline const ::Kinova::Api::VisionConfig::RotationMatrix& ExtrinsicParameters::rotation() const {
+  const ::Kinova::Api::VisionConfig::RotationMatrix* p = rotation_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.VisionConfig.ExtrinsicParameters.rotation)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::VisionConfig::RotationMatrix*>(
+      &::Kinova::Api::VisionConfig::_RotationMatrix_default_instance_);
+}
+inline ::Kinova::Api::VisionConfig::RotationMatrix* ExtrinsicParameters::release_rotation() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.VisionConfig.ExtrinsicParameters.rotation)
+  
+  ::Kinova::Api::VisionConfig::RotationMatrix* temp = rotation_;
+  rotation_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::VisionConfig::RotationMatrix* ExtrinsicParameters::mutable_rotation() {
+  
+  if (rotation_ == NULL) {
+    rotation_ = new ::Kinova::Api::VisionConfig::RotationMatrix;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.VisionConfig.ExtrinsicParameters.rotation)
+  return rotation_;
+}
+inline void ExtrinsicParameters::set_allocated_rotation(::Kinova::Api::VisionConfig::RotationMatrix* rotation) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete rotation_;
+  }
+  if (rotation) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      rotation = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, rotation, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  rotation_ = rotation;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.VisionConfig.ExtrinsicParameters.rotation)
+}
+
+// .Kinova.Api.VisionConfig.TranslationVector translation = 2;
+inline bool ExtrinsicParameters::has_translation() const {
+  return this != internal_default_instance() && translation_ != NULL;
+}
+inline void ExtrinsicParameters::clear_translation() {
+  if (GetArenaNoVirtual() == NULL && translation_ != NULL) {
+    delete translation_;
+  }
+  translation_ = NULL;
+}
+inline const ::Kinova::Api::VisionConfig::TranslationVector& ExtrinsicParameters::translation() const {
+  const ::Kinova::Api::VisionConfig::TranslationVector* p = translation_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.VisionConfig.ExtrinsicParameters.translation)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::VisionConfig::TranslationVector*>(
+      &::Kinova::Api::VisionConfig::_TranslationVector_default_instance_);
+}
+inline ::Kinova::Api::VisionConfig::TranslationVector* ExtrinsicParameters::release_translation() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.VisionConfig.ExtrinsicParameters.translation)
+  
+  ::Kinova::Api::VisionConfig::TranslationVector* temp = translation_;
+  translation_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::VisionConfig::TranslationVector* ExtrinsicParameters::mutable_translation() {
+  
+  if (translation_ == NULL) {
+    translation_ = new ::Kinova::Api::VisionConfig::TranslationVector;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.VisionConfig.ExtrinsicParameters.translation)
+  return translation_;
+}
+inline void ExtrinsicParameters::set_allocated_translation(::Kinova::Api::VisionConfig::TranslationVector* translation) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete translation_;
+  }
+  if (translation) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      translation = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, translation, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  translation_ = translation;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.VisionConfig.ExtrinsicParameters.translation)
+}
+
+// -------------------------------------------------------------------
+
+// RotationMatrix
+
+// .Kinova.Api.VisionConfig.RotationMatrixRow row1 = 1;
+inline bool RotationMatrix::has_row1() const {
+  return this != internal_default_instance() && row1_ != NULL;
+}
+inline void RotationMatrix::clear_row1() {
+  if (GetArenaNoVirtual() == NULL && row1_ != NULL) {
+    delete row1_;
+  }
+  row1_ = NULL;
+}
+inline const ::Kinova::Api::VisionConfig::RotationMatrixRow& RotationMatrix::row1() const {
+  const ::Kinova::Api::VisionConfig::RotationMatrixRow* p = row1_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.VisionConfig.RotationMatrix.row1)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::VisionConfig::RotationMatrixRow*>(
+      &::Kinova::Api::VisionConfig::_RotationMatrixRow_default_instance_);
+}
+inline ::Kinova::Api::VisionConfig::RotationMatrixRow* RotationMatrix::release_row1() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.VisionConfig.RotationMatrix.row1)
+  
+  ::Kinova::Api::VisionConfig::RotationMatrixRow* temp = row1_;
+  row1_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::VisionConfig::RotationMatrixRow* RotationMatrix::mutable_row1() {
+  
+  if (row1_ == NULL) {
+    row1_ = new ::Kinova::Api::VisionConfig::RotationMatrixRow;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.VisionConfig.RotationMatrix.row1)
+  return row1_;
+}
+inline void RotationMatrix::set_allocated_row1(::Kinova::Api::VisionConfig::RotationMatrixRow* row1) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete row1_;
+  }
+  if (row1) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      row1 = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, row1, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  row1_ = row1;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.VisionConfig.RotationMatrix.row1)
+}
+
+// .Kinova.Api.VisionConfig.RotationMatrixRow row2 = 2;
+inline bool RotationMatrix::has_row2() const {
+  return this != internal_default_instance() && row2_ != NULL;
+}
+inline void RotationMatrix::clear_row2() {
+  if (GetArenaNoVirtual() == NULL && row2_ != NULL) {
+    delete row2_;
+  }
+  row2_ = NULL;
+}
+inline const ::Kinova::Api::VisionConfig::RotationMatrixRow& RotationMatrix::row2() const {
+  const ::Kinova::Api::VisionConfig::RotationMatrixRow* p = row2_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.VisionConfig.RotationMatrix.row2)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::VisionConfig::RotationMatrixRow*>(
+      &::Kinova::Api::VisionConfig::_RotationMatrixRow_default_instance_);
+}
+inline ::Kinova::Api::VisionConfig::RotationMatrixRow* RotationMatrix::release_row2() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.VisionConfig.RotationMatrix.row2)
+  
+  ::Kinova::Api::VisionConfig::RotationMatrixRow* temp = row2_;
+  row2_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::VisionConfig::RotationMatrixRow* RotationMatrix::mutable_row2() {
+  
+  if (row2_ == NULL) {
+    row2_ = new ::Kinova::Api::VisionConfig::RotationMatrixRow;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.VisionConfig.RotationMatrix.row2)
+  return row2_;
+}
+inline void RotationMatrix::set_allocated_row2(::Kinova::Api::VisionConfig::RotationMatrixRow* row2) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete row2_;
+  }
+  if (row2) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      row2 = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, row2, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  row2_ = row2;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.VisionConfig.RotationMatrix.row2)
+}
+
+// .Kinova.Api.VisionConfig.RotationMatrixRow row3 = 3;
+inline bool RotationMatrix::has_row3() const {
+  return this != internal_default_instance() && row3_ != NULL;
+}
+inline void RotationMatrix::clear_row3() {
+  if (GetArenaNoVirtual() == NULL && row3_ != NULL) {
+    delete row3_;
+  }
+  row3_ = NULL;
+}
+inline const ::Kinova::Api::VisionConfig::RotationMatrixRow& RotationMatrix::row3() const {
+  const ::Kinova::Api::VisionConfig::RotationMatrixRow* p = row3_;
+  // @@protoc_insertion_point(field_get:Kinova.Api.VisionConfig.RotationMatrix.row3)
+  return p != NULL ? *p : *reinterpret_cast<const ::Kinova::Api::VisionConfig::RotationMatrixRow*>(
+      &::Kinova::Api::VisionConfig::_RotationMatrixRow_default_instance_);
+}
+inline ::Kinova::Api::VisionConfig::RotationMatrixRow* RotationMatrix::release_row3() {
+  // @@protoc_insertion_point(field_release:Kinova.Api.VisionConfig.RotationMatrix.row3)
+  
+  ::Kinova::Api::VisionConfig::RotationMatrixRow* temp = row3_;
+  row3_ = NULL;
+  return temp;
+}
+inline ::Kinova::Api::VisionConfig::RotationMatrixRow* RotationMatrix::mutable_row3() {
+  
+  if (row3_ == NULL) {
+    row3_ = new ::Kinova::Api::VisionConfig::RotationMatrixRow;
+  }
+  // @@protoc_insertion_point(field_mutable:Kinova.Api.VisionConfig.RotationMatrix.row3)
+  return row3_;
+}
+inline void RotationMatrix::set_allocated_row3(::Kinova::Api::VisionConfig::RotationMatrixRow* row3) {
+  ::google::protobuf::Arena* message_arena = GetArenaNoVirtual();
+  if (message_arena == NULL) {
+    delete row3_;
+  }
+  if (row3) {
+    ::google::protobuf::Arena* submessage_arena = NULL;
+    if (message_arena != submessage_arena) {
+      row3 = ::google::protobuf::internal::GetOwnedMessage(
+          message_arena, row3, submessage_arena);
+    }
+    
+  } else {
+    
+  }
+  row3_ = row3;
+  // @@protoc_insertion_point(field_set_allocated:Kinova.Api.VisionConfig.RotationMatrix.row3)
+}
+
+// -------------------------------------------------------------------
+
+// RotationMatrixRow
+
+// float column1 = 1;
+inline void RotationMatrixRow::clear_column1() {
+  column1_ = 0;
+}
+inline float RotationMatrixRow::column1() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.VisionConfig.RotationMatrixRow.column1)
+  return column1_;
+}
+inline void RotationMatrixRow::set_column1(float value) {
+  
+  column1_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.VisionConfig.RotationMatrixRow.column1)
+}
+
+// float column2 = 2;
+inline void RotationMatrixRow::clear_column2() {
+  column2_ = 0;
+}
+inline float RotationMatrixRow::column2() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.VisionConfig.RotationMatrixRow.column2)
+  return column2_;
+}
+inline void RotationMatrixRow::set_column2(float value) {
+  
+  column2_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.VisionConfig.RotationMatrixRow.column2)
+}
+
+// float column3 = 3;
+inline void RotationMatrixRow::clear_column3() {
+  column3_ = 0;
+}
+inline float RotationMatrixRow::column3() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.VisionConfig.RotationMatrixRow.column3)
+  return column3_;
+}
+inline void RotationMatrixRow::set_column3(float value) {
+  
+  column3_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.VisionConfig.RotationMatrixRow.column3)
+}
+
+// -------------------------------------------------------------------
+
+// TranslationVector
+
+// float t_x = 1;
+inline void TranslationVector::clear_t_x() {
+  t_x_ = 0;
+}
+inline float TranslationVector::t_x() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.VisionConfig.TranslationVector.t_x)
+  return t_x_;
+}
+inline void TranslationVector::set_t_x(float value) {
+  
+  t_x_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.VisionConfig.TranslationVector.t_x)
+}
+
+// float t_y = 2;
+inline void TranslationVector::clear_t_y() {
+  t_y_ = 0;
+}
+inline float TranslationVector::t_y() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.VisionConfig.TranslationVector.t_y)
+  return t_y_;
+}
+inline void TranslationVector::set_t_y(float value) {
+  
+  t_y_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.VisionConfig.TranslationVector.t_y)
+}
+
+// float t_z = 3;
+inline void TranslationVector::clear_t_z() {
+  t_z_ = 0;
+}
+inline float TranslationVector::t_z() const {
+  // @@protoc_insertion_point(field_get:Kinova.Api.VisionConfig.TranslationVector.t_z)
+  return t_z_;
+}
+inline void TranslationVector::set_t_z(float value) {
+  
+  t_z_ = value;
+  // @@protoc_insertion_point(field_set:Kinova.Api.VisionConfig.TranslationVector.t_z)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace VisionConfig
+}  // namespace Api
+}  // namespace Kinova
+
+namespace google {
+namespace protobuf {
+
+template <> struct is_proto_enum< ::Kinova::Api::VisionConfig::ServiceVersion> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::VisionConfig::ServiceVersion>() {
+  return ::Kinova::Api::VisionConfig::ServiceVersion_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::VisionConfig::Sensor> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::VisionConfig::Sensor>() {
+  return ::Kinova::Api::VisionConfig::Sensor_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::VisionConfig::Resolution> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::VisionConfig::Resolution>() {
+  return ::Kinova::Api::VisionConfig::Resolution_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::VisionConfig::FrameRate> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::VisionConfig::FrameRate>() {
+  return ::Kinova::Api::VisionConfig::FrameRate_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::VisionConfig::BitRate> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::VisionConfig::BitRate>() {
+  return ::Kinova::Api::VisionConfig::BitRate_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::VisionConfig::Option> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::VisionConfig::Option>() {
+  return ::Kinova::Api::VisionConfig::Option_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::VisionConfig::FocusAction> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::VisionConfig::FocusAction>() {
+  return ::Kinova::Api::VisionConfig::FocusAction_descriptor();
+}
+template <> struct is_proto_enum< ::Kinova::Api::VisionConfig::VisionEvent> : ::google::protobuf::internal::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::Kinova::Api::VisionConfig::VisionEvent>() {
+  return ::Kinova::Api::VisionConfig::VisionEvent_descriptor();
+}
+
+}  // namespace protobuf
+}  // namespace google
+
+// @@protoc_insertion_point(global_scope)
+
+#endif  // PROTOBUF_VisionConfig_2eproto__INCLUDED
diff --git a/kortex_api/lib/release/KortexApiCpp.lib b/kortex_api/lib/release/KortexApiCpp.lib
new file mode 100644
index 0000000000000000000000000000000000000000..7e9fb79b2ebd10ac08e521583d847e4fa6ea6d52
--- /dev/null
+++ b/kortex_api/lib/release/KortexApiCpp.lib
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b79a5fa15a1adb2ca45002bb46946f9612c2e8416d4cbdf4b17b31ab2768aa1e
+size 126670868
diff --git a/kortex_api/lib/release/KortexApiCpp_without_protobuf.lib b/kortex_api/lib/release/KortexApiCpp_without_protobuf.lib
new file mode 100644
index 0000000000000000000000000000000000000000..dd87601d3b69194c0c969530226c160420b7a822
--- /dev/null
+++ b/kortex_api/lib/release/KortexApiCpp_without_protobuf.lib
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7f689852c74fe893b56983119be59a48c8a1c70e126844dbf8fd9f452823109f
+size 93083234