From 7720c87e0c8c129698070bbf46706f7295a73012 Mon Sep 17 00:00:00 2001 From: Mislav Novakovic Date: Wed, 10 May 2017 15:34:53 +0200 Subject: [PATCH] add sysrepo Signed-off-by: Mislav Novakovic --- net/sysrepo/Makefile | 139 + net/sysrepo/files/libsysrepo.default | 13 + net/sysrepo/files/sysrepo-plugind.init | 19 + net/sysrepo/files/sysrepod.init | 19 + ...obuf-remove-protoc-command-from-cmake-file | 14782 ++++++++++++++++ .../002-remove-buildtime-module-install | 26 + net/sysrepo/patches/003-missing-time-header | 12 + 7 files changed, 15010 insertions(+) create mode 100644 net/sysrepo/Makefile create mode 100644 net/sysrepo/files/libsysrepo.default create mode 100644 net/sysrepo/files/sysrepo-plugind.init create mode 100644 net/sysrepo/files/sysrepod.init create mode 100644 net/sysrepo/patches/001-protobuf-remove-protoc-command-from-cmake-file create mode 100644 net/sysrepo/patches/002-remove-buildtime-module-install create mode 100644 net/sysrepo/patches/003-missing-time-header diff --git a/net/sysrepo/Makefile b/net/sysrepo/Makefile new file mode 100644 index 000000000..eecf8286d --- /dev/null +++ b/net/sysrepo/Makefile @@ -0,0 +1,139 @@ +# +# Copyright (C) 2017 OpenWrt.org +# +# This is free software, licensed under the GNU General Public License v2. +# See /LICENSE for more information. +# + +include $(TOPDIR)/rules.mk + +PKG_LICENSE:=ASL-2.0 +PKG_MAINTAINER:=Mislav Novakovic + +PKG_NAME:=sysrepo +PKG_VERSION:=0.6.0 + +PKG_SOURCE_PROTO:=git +PKG_SOURCE_VERSION:=e4a5705a4c5293ba121048c71899b98243d99edf +PKG_SOURCE:=$(PKG_NAME)-$(PKG_SOURCE_VERSION).tar.bz2 +PKG_SOURCE_URL:=https://github.com/sysrepo/sysrepo.git +PKG_SOURCE_SUBDIR:=$(PKG_NAME)-$(PKG_SOURCE_VERSION) + +PKG_BUILD_DIR:=$(BUILD_DIR)/$(PKG_SOURCE_SUBDIR) + +CMAKE_INSTALL:=1 + +PKG_BUILD_PARALLEL:=1 +PKG_INSTALL:=1 + +include $(INCLUDE_DIR)/package.mk +include $(INCLUDE_DIR)/cmake.mk + +define Package/libsysrepo + SECTION:=util + CATEGORY:=Utilities + URL:=$(PKG_SOURCE_URL) + TITLE:=YANG-based data store library + DEPENDS:=+libyang +libprotobuf-c +libev +libavl +endef + +define Package/sysrepod + SECTION:=util + CATEGORY:=Utilities + URL:=$(PKG_SOURCE_URL) + TITLE:=YANG-based data store daemon + DEPENDS:=+libsysrepo +endef + +define Package/sysrepoctl + SECTION:=util + CATEGORY:=Utilities + URL:=$(PKG_SOURCE_URL) + TITLE:=sysrepo cli tool + DEPENDS:=+libsysrepo +endef + +define Package/sysrepocfg + SECTION:=util + CATEGORY:=Utilities + URL:=$(PKG_SOURCE_URL) + TITLE:=sysrepo configuration tool + DEPENDS:=+libsysrepo +endef + +define Package/sysrepo-plugind + SECTION:=util + CATEGORY:=Utilities + URL:=$(PKG_SOURCE_URL) + TITLE:=sysrepo plugin daemon + DEPENDS:=+libsysrepo +endef + +define Package/sysrepo/description +Sysrepo is an YANG-based configuration and operational state data store for Unix/Linux applications. +endef + +CMAKE_OPTIONS += \ + -DCMAKE_BUILD_TYPE:STRING=Release \ + -DENABLE_TESTS:BOOL=FALSE \ + -DBUILD_EXAMPLES:BOOL=FALSE \ + -DCMAKE_DISABLE_FIND_PACKAGE_SWIG=TRUE \ + -DGEN_LANGUAGE_BINDINGS:BOOL=FALSE \ + -DREPOSITORY_LOC:PATH=/etc/sysrepo \ + -DCMAKE_INSTALL_PREFIX:PATH=/usr \ + -DENABLE_NACM:BOOL=FALSE + +define Package/libsysrepo/install + $(INSTALL_DIR) $(1)/usr/lib + $(INSTALL_BIN) $(PKG_BUILD_DIR)/src/libsysrepo.so* $(1)/usr/lib/ + + $(INSTALL_DIR) $(1)/etc/sysrepo/yang/internal + $(INSTALL_CONF) $(PKG_BUILD_DIR)/yang/sysrepo-module-dependencies.yang $(1)/etc/sysrepo/yang/internal + $(INSTALL_CONF) $(PKG_BUILD_DIR)/yang/sysrepo-notification-store.yang $(1)/etc/sysrepo/yang/internal + $(INSTALL_CONF) $(PKG_BUILD_DIR)/yang/sysrepo-persistent-data.yang $(1)/etc/sysrepo/yang/internal + + $(INSTALL_DIR) $(1)/etc/sysrepo/yang + $(INSTALL_DATA) $(PKG_BUILD_DIR)/yang/ietf-netconf-acm@2012-02-22.yang $(1)/etc/sysrepo/yang/ + $(INSTALL_DATA) $(PKG_BUILD_DIR)/yang/ietf-netconf-notifications.yang $(1)/etc/sysrepo/yang/ + $(INSTALL_DATA) $(PKG_BUILD_DIR)/yang/nc-notifications.yang $(1)/etc/sysrepo/yang/ + $(INSTALL_DATA) $(PKG_BUILD_DIR)/yang/notifications.yang $(1)/etc/sysrepo/yang/ + $(INSTALL_DATA) $(PKG_BUILD_DIR)/yang/ietf-netconf@2011-06-01.yang $(1)/etc/sysrepo/yang/ + + $(INSTALL_DIR) $(1)/etc/sysrepo/data/internal + $(INSTALL_DIR) $(1)/etc/sysrepo/data/notifications + + $(INSTALL_DIR) $(1)/etc/uci-defaults + $(INSTALL_BIN) ./files/libsysrepo.default $(1)/etc/uci-defaults/95_libsysrepo +endef + +define Package/sysrepod/install + $(INSTALL_DIR) $(1)/bin + $(INSTALL_BIN) $(PKG_BUILD_DIR)/src/sysrepod $(1)/bin/ + + $(INSTALL_DIR) $(1)/etc/init.d/ + $(INSTALL_BIN) ./files/sysrepod.init $(1)/etc/init.d/sysrepod +endef + +define Package/sysrepoctl/install + $(INSTALL_DIR) $(1)/bin + $(INSTALL_BIN) $(PKG_BUILD_DIR)/src/sysrepoctl $(1)/bin/ +endef + +define Package/sysrepocfg/install + $(INSTALL_DIR) $(1)/bin + $(INSTALL_BIN) $(PKG_BUILD_DIR)/src/sysrepocfg $(1)/bin/ +endef + +define Package/sysrepo-plugind/install + $(INSTALL_DIR) $(1)/bin + $(INSTALL_BIN) $(PKG_BUILD_DIR)/src/sysrepo-plugind $(1)/bin/ + + $(INSTALL_DIR) $(1)/etc/init.d/ + $(INSTALL_BIN) ./files/sysrepo-plugind.init $(1)/etc/init.d/sysrepo-plugind +endef + +$(eval $(call BuildPackage,libsysrepo)) +$(eval $(call BuildPackage,sysrepod)) +$(eval $(call BuildPackage,sysrepoctl)) +$(eval $(call BuildPackage,sysrepocfg)) +$(eval $(call BuildPackage,sysrepo-plugind)) diff --git a/net/sysrepo/files/libsysrepo.default b/net/sysrepo/files/libsysrepo.default new file mode 100644 index 000000000..4e00cc79f --- /dev/null +++ b/net/sysrepo/files/libsysrepo.default @@ -0,0 +1,13 @@ +#!/bin/sh + +# Warning, problems can occur if the device restarts in the middle of this uci-default script + +if [ -x /bin/sysrepoctl ]; then + sysrepoctl --install --yang=/etc/sysrepo/yang/ietf-netconf-acm@2012-02-22.yang -p 644 + sysrepoctl --install --yang=/etc/sysrepo/yang/ietf-netconf-notifications.yang -p 600 + sysrepoctl --install --yang=/etc/sysrepo/yang/nc-notifications.yang -p 666 + sysrepoctl --install --yang=/etc/sysrepo/yang/notifications.yang -p 666 + sysrepoctl --install --yang=/etc/sysrepo/yang/ietf-netconf@2011-06-01.yang -p 600 +fi + +exit 0 diff --git a/net/sysrepo/files/sysrepo-plugind.init b/net/sysrepo/files/sysrepo-plugind.init new file mode 100644 index 000000000..d394256ae --- /dev/null +++ b/net/sysrepo/files/sysrepo-plugind.init @@ -0,0 +1,19 @@ +#!/bin/sh /etc/rc.common + +START=90 +STOP=10 + +USE_PROCD=1 +PROG=/bin/sysrepo-plugind + +start_service() { + procd_open_instance + procd_set_param command $PROG + procd_set_param respawn + procd_close_instance +} + +stop_service() +{ + service_stop ${PROG} +} diff --git a/net/sysrepo/files/sysrepod.init b/net/sysrepo/files/sysrepod.init new file mode 100644 index 000000000..843e3b56c --- /dev/null +++ b/net/sysrepo/files/sysrepod.init @@ -0,0 +1,19 @@ +#!/bin/sh /etc/rc.common + +START=70 +STOP=10 + +USE_PROCD=1 +PROG=/bin/sysrepod + +start_service() { + procd_open_instance + procd_set_param command $PROG + procd_set_param respawn + procd_close_instance +} + +stop_service() +{ + service_stop ${PROG} +} diff --git a/net/sysrepo/patches/001-protobuf-remove-protoc-command-from-cmake-file b/net/sysrepo/patches/001-protobuf-remove-protoc-command-from-cmake-file new file mode 100644 index 000000000..50c4bceb7 --- /dev/null +++ b/net/sysrepo/patches/001-protobuf-remove-protoc-command-from-cmake-file @@ -0,0 +1,14782 @@ +Index: sysrepo-e4a5705a4c5293ba121048c71899b98243d99edf/src/CMakeLists.txt +=================================================================== +--- sysrepo-e4a5705a4c5293ba121048c71899b98243d99edf.orig/src/CMakeLists.txt ++++ sysrepo-e4a5705a4c5293ba121048c71899b98243d99edf/src/CMakeLists.txt +@@ -21,14 +21,6 @@ set(GENERATED_PROTO_H "${COMMON_BIN_DIR} + set(GENERATED_PROTO_C "${COMMON_BIN_DIR}/${PROTO_NAME}.pb-c.c") + + get_filename_component(ABS_PATH ${PROTO_FILE} PATH) +-add_custom_command( +- OUTPUT "${GENERATED_PROTO_C}" +- "${GENERATED_PROTO_H}" +- COMMAND ${PROTOBUFC_PROTOC_EXECUTABLE} +- ARGS --c_out ${COMMON_BIN_DIR} -I ${ABS_PATH} ${PROTO_FILE} +- DEPENDS ${PROTO_FILE} +- COMMENT "Running C protocol buffer compiler on ${PROTO_FILE}" +- VERBATIM ) + + configure_file("${COMMON_DIR}/sr_constants.h.in" "${COMMON_BIN_DIR}/sr_constants.h" ESCAPE_QUOTES @ONLY) + +Index: sysrepo-e4a5705a4c5293ba121048c71899b98243d99edf/src/common/sysrepo.pb-c.c +=================================================================== +--- /dev/null ++++ sysrepo-e4a5705a4c5293ba121048c71899b98243d99edf/src/common/sysrepo.pb-c.c +@@ -0,0 +1,10517 @@ ++/* Generated by the protocol buffer compiler. DO NOT EDIT! */ ++/* Generated from: sysrepo.proto */ ++ ++/* Do not generate deprecated warnings for self */ ++#ifndef PROTOBUF_C__NO_DEPRECATED ++#define PROTOBUF_C__NO_DEPRECATED ++#endif ++ ++#include "sysrepo.pb-c.h" ++void sr__value__init ++ (Sr__Value *message) ++{ ++ static Sr__Value init_value = SR__VALUE__INIT; ++ *message = init_value; ++} ++size_t sr__value__get_packed_size ++ (const Sr__Value *message) ++{ ++ assert(message->base.descriptor == &sr__value__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__value__pack ++ (const Sr__Value *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__value__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__value__pack_to_buffer ++ (const Sr__Value *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__value__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__Value * ++ sr__value__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__Value *) ++ protobuf_c_message_unpack (&sr__value__descriptor, ++ allocator, len, data); ++} ++void sr__value__free_unpacked ++ (Sr__Value *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__value__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__node__init ++ (Sr__Node *message) ++{ ++ static Sr__Node init_value = SR__NODE__INIT; ++ *message = init_value; ++} ++size_t sr__node__get_packed_size ++ (const Sr__Node *message) ++{ ++ assert(message->base.descriptor == &sr__node__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__node__pack ++ (const Sr__Node *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__node__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__node__pack_to_buffer ++ (const Sr__Node *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__node__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__Node * ++ sr__node__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__Node *) ++ protobuf_c_message_unpack (&sr__node__descriptor, ++ allocator, len, data); ++} ++void sr__node__free_unpacked ++ (Sr__Node *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__node__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__error__init ++ (Sr__Error *message) ++{ ++ static Sr__Error init_value = SR__ERROR__INIT; ++ *message = init_value; ++} ++size_t sr__error__get_packed_size ++ (const Sr__Error *message) ++{ ++ assert(message->base.descriptor == &sr__error__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__error__pack ++ (const Sr__Error *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__error__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__error__pack_to_buffer ++ (const Sr__Error *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__error__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__Error * ++ sr__error__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__Error *) ++ protobuf_c_message_unpack (&sr__error__descriptor, ++ allocator, len, data); ++} ++void sr__error__free_unpacked ++ (Sr__Error *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__error__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__session_start_req__init ++ (Sr__SessionStartReq *message) ++{ ++ static Sr__SessionStartReq init_value = SR__SESSION_START_REQ__INIT; ++ *message = init_value; ++} ++size_t sr__session_start_req__get_packed_size ++ (const Sr__SessionStartReq *message) ++{ ++ assert(message->base.descriptor == &sr__session_start_req__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__session_start_req__pack ++ (const Sr__SessionStartReq *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__session_start_req__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__session_start_req__pack_to_buffer ++ (const Sr__SessionStartReq *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__session_start_req__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__SessionStartReq * ++ sr__session_start_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__SessionStartReq *) ++ protobuf_c_message_unpack (&sr__session_start_req__descriptor, ++ allocator, len, data); ++} ++void sr__session_start_req__free_unpacked ++ (Sr__SessionStartReq *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__session_start_req__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__session_start_resp__init ++ (Sr__SessionStartResp *message) ++{ ++ static Sr__SessionStartResp init_value = SR__SESSION_START_RESP__INIT; ++ *message = init_value; ++} ++size_t sr__session_start_resp__get_packed_size ++ (const Sr__SessionStartResp *message) ++{ ++ assert(message->base.descriptor == &sr__session_start_resp__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__session_start_resp__pack ++ (const Sr__SessionStartResp *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__session_start_resp__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__session_start_resp__pack_to_buffer ++ (const Sr__SessionStartResp *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__session_start_resp__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__SessionStartResp * ++ sr__session_start_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__SessionStartResp *) ++ protobuf_c_message_unpack (&sr__session_start_resp__descriptor, ++ allocator, len, data); ++} ++void sr__session_start_resp__free_unpacked ++ (Sr__SessionStartResp *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__session_start_resp__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__session_stop_req__init ++ (Sr__SessionStopReq *message) ++{ ++ static Sr__SessionStopReq init_value = SR__SESSION_STOP_REQ__INIT; ++ *message = init_value; ++} ++size_t sr__session_stop_req__get_packed_size ++ (const Sr__SessionStopReq *message) ++{ ++ assert(message->base.descriptor == &sr__session_stop_req__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__session_stop_req__pack ++ (const Sr__SessionStopReq *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__session_stop_req__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__session_stop_req__pack_to_buffer ++ (const Sr__SessionStopReq *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__session_stop_req__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__SessionStopReq * ++ sr__session_stop_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__SessionStopReq *) ++ protobuf_c_message_unpack (&sr__session_stop_req__descriptor, ++ allocator, len, data); ++} ++void sr__session_stop_req__free_unpacked ++ (Sr__SessionStopReq *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__session_stop_req__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__session_stop_resp__init ++ (Sr__SessionStopResp *message) ++{ ++ static Sr__SessionStopResp init_value = SR__SESSION_STOP_RESP__INIT; ++ *message = init_value; ++} ++size_t sr__session_stop_resp__get_packed_size ++ (const Sr__SessionStopResp *message) ++{ ++ assert(message->base.descriptor == &sr__session_stop_resp__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__session_stop_resp__pack ++ (const Sr__SessionStopResp *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__session_stop_resp__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__session_stop_resp__pack_to_buffer ++ (const Sr__SessionStopResp *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__session_stop_resp__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__SessionStopResp * ++ sr__session_stop_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__SessionStopResp *) ++ protobuf_c_message_unpack (&sr__session_stop_resp__descriptor, ++ allocator, len, data); ++} ++void sr__session_stop_resp__free_unpacked ++ (Sr__SessionStopResp *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__session_stop_resp__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__session_refresh_req__init ++ (Sr__SessionRefreshReq *message) ++{ ++ static Sr__SessionRefreshReq init_value = SR__SESSION_REFRESH_REQ__INIT; ++ *message = init_value; ++} ++size_t sr__session_refresh_req__get_packed_size ++ (const Sr__SessionRefreshReq *message) ++{ ++ assert(message->base.descriptor == &sr__session_refresh_req__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__session_refresh_req__pack ++ (const Sr__SessionRefreshReq *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__session_refresh_req__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__session_refresh_req__pack_to_buffer ++ (const Sr__SessionRefreshReq *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__session_refresh_req__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__SessionRefreshReq * ++ sr__session_refresh_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__SessionRefreshReq *) ++ protobuf_c_message_unpack (&sr__session_refresh_req__descriptor, ++ allocator, len, data); ++} ++void sr__session_refresh_req__free_unpacked ++ (Sr__SessionRefreshReq *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__session_refresh_req__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__session_refresh_resp__init ++ (Sr__SessionRefreshResp *message) ++{ ++ static Sr__SessionRefreshResp init_value = SR__SESSION_REFRESH_RESP__INIT; ++ *message = init_value; ++} ++size_t sr__session_refresh_resp__get_packed_size ++ (const Sr__SessionRefreshResp *message) ++{ ++ assert(message->base.descriptor == &sr__session_refresh_resp__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__session_refresh_resp__pack ++ (const Sr__SessionRefreshResp *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__session_refresh_resp__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__session_refresh_resp__pack_to_buffer ++ (const Sr__SessionRefreshResp *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__session_refresh_resp__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__SessionRefreshResp * ++ sr__session_refresh_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__SessionRefreshResp *) ++ protobuf_c_message_unpack (&sr__session_refresh_resp__descriptor, ++ allocator, len, data); ++} ++void sr__session_refresh_resp__free_unpacked ++ (Sr__SessionRefreshResp *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__session_refresh_resp__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__session_check_req__init ++ (Sr__SessionCheckReq *message) ++{ ++ static Sr__SessionCheckReq init_value = SR__SESSION_CHECK_REQ__INIT; ++ *message = init_value; ++} ++size_t sr__session_check_req__get_packed_size ++ (const Sr__SessionCheckReq *message) ++{ ++ assert(message->base.descriptor == &sr__session_check_req__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__session_check_req__pack ++ (const Sr__SessionCheckReq *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__session_check_req__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__session_check_req__pack_to_buffer ++ (const Sr__SessionCheckReq *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__session_check_req__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__SessionCheckReq * ++ sr__session_check_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__SessionCheckReq *) ++ protobuf_c_message_unpack (&sr__session_check_req__descriptor, ++ allocator, len, data); ++} ++void sr__session_check_req__free_unpacked ++ (Sr__SessionCheckReq *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__session_check_req__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__session_check_resp__init ++ (Sr__SessionCheckResp *message) ++{ ++ static Sr__SessionCheckResp init_value = SR__SESSION_CHECK_RESP__INIT; ++ *message = init_value; ++} ++size_t sr__session_check_resp__get_packed_size ++ (const Sr__SessionCheckResp *message) ++{ ++ assert(message->base.descriptor == &sr__session_check_resp__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__session_check_resp__pack ++ (const Sr__SessionCheckResp *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__session_check_resp__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__session_check_resp__pack_to_buffer ++ (const Sr__SessionCheckResp *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__session_check_resp__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__SessionCheckResp * ++ sr__session_check_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__SessionCheckResp *) ++ protobuf_c_message_unpack (&sr__session_check_resp__descriptor, ++ allocator, len, data); ++} ++void sr__session_check_resp__free_unpacked ++ (Sr__SessionCheckResp *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__session_check_resp__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__session_switch_ds_req__init ++ (Sr__SessionSwitchDsReq *message) ++{ ++ static Sr__SessionSwitchDsReq init_value = SR__SESSION_SWITCH_DS_REQ__INIT; ++ *message = init_value; ++} ++size_t sr__session_switch_ds_req__get_packed_size ++ (const Sr__SessionSwitchDsReq *message) ++{ ++ assert(message->base.descriptor == &sr__session_switch_ds_req__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__session_switch_ds_req__pack ++ (const Sr__SessionSwitchDsReq *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__session_switch_ds_req__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__session_switch_ds_req__pack_to_buffer ++ (const Sr__SessionSwitchDsReq *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__session_switch_ds_req__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__SessionSwitchDsReq * ++ sr__session_switch_ds_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__SessionSwitchDsReq *) ++ protobuf_c_message_unpack (&sr__session_switch_ds_req__descriptor, ++ allocator, len, data); ++} ++void sr__session_switch_ds_req__free_unpacked ++ (Sr__SessionSwitchDsReq *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__session_switch_ds_req__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__session_switch_ds_resp__init ++ (Sr__SessionSwitchDsResp *message) ++{ ++ static Sr__SessionSwitchDsResp init_value = SR__SESSION_SWITCH_DS_RESP__INIT; ++ *message = init_value; ++} ++size_t sr__session_switch_ds_resp__get_packed_size ++ (const Sr__SessionSwitchDsResp *message) ++{ ++ assert(message->base.descriptor == &sr__session_switch_ds_resp__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__session_switch_ds_resp__pack ++ (const Sr__SessionSwitchDsResp *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__session_switch_ds_resp__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__session_switch_ds_resp__pack_to_buffer ++ (const Sr__SessionSwitchDsResp *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__session_switch_ds_resp__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__SessionSwitchDsResp * ++ sr__session_switch_ds_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__SessionSwitchDsResp *) ++ protobuf_c_message_unpack (&sr__session_switch_ds_resp__descriptor, ++ allocator, len, data); ++} ++void sr__session_switch_ds_resp__free_unpacked ++ (Sr__SessionSwitchDsResp *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__session_switch_ds_resp__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__session_set_opts_req__init ++ (Sr__SessionSetOptsReq *message) ++{ ++ static Sr__SessionSetOptsReq init_value = SR__SESSION_SET_OPTS_REQ__INIT; ++ *message = init_value; ++} ++size_t sr__session_set_opts_req__get_packed_size ++ (const Sr__SessionSetOptsReq *message) ++{ ++ assert(message->base.descriptor == &sr__session_set_opts_req__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__session_set_opts_req__pack ++ (const Sr__SessionSetOptsReq *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__session_set_opts_req__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__session_set_opts_req__pack_to_buffer ++ (const Sr__SessionSetOptsReq *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__session_set_opts_req__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__SessionSetOptsReq * ++ sr__session_set_opts_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__SessionSetOptsReq *) ++ protobuf_c_message_unpack (&sr__session_set_opts_req__descriptor, ++ allocator, len, data); ++} ++void sr__session_set_opts_req__free_unpacked ++ (Sr__SessionSetOptsReq *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__session_set_opts_req__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__session_set_opts_resp__init ++ (Sr__SessionSetOptsResp *message) ++{ ++ static Sr__SessionSetOptsResp init_value = SR__SESSION_SET_OPTS_RESP__INIT; ++ *message = init_value; ++} ++size_t sr__session_set_opts_resp__get_packed_size ++ (const Sr__SessionSetOptsResp *message) ++{ ++ assert(message->base.descriptor == &sr__session_set_opts_resp__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__session_set_opts_resp__pack ++ (const Sr__SessionSetOptsResp *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__session_set_opts_resp__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__session_set_opts_resp__pack_to_buffer ++ (const Sr__SessionSetOptsResp *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__session_set_opts_resp__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__SessionSetOptsResp * ++ sr__session_set_opts_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__SessionSetOptsResp *) ++ protobuf_c_message_unpack (&sr__session_set_opts_resp__descriptor, ++ allocator, len, data); ++} ++void sr__session_set_opts_resp__free_unpacked ++ (Sr__SessionSetOptsResp *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__session_set_opts_resp__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__version_verify_req__init ++ (Sr__VersionVerifyReq *message) ++{ ++ static Sr__VersionVerifyReq init_value = SR__VERSION_VERIFY_REQ__INIT; ++ *message = init_value; ++} ++size_t sr__version_verify_req__get_packed_size ++ (const Sr__VersionVerifyReq *message) ++{ ++ assert(message->base.descriptor == &sr__version_verify_req__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__version_verify_req__pack ++ (const Sr__VersionVerifyReq *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__version_verify_req__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__version_verify_req__pack_to_buffer ++ (const Sr__VersionVerifyReq *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__version_verify_req__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__VersionVerifyReq * ++ sr__version_verify_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__VersionVerifyReq *) ++ protobuf_c_message_unpack (&sr__version_verify_req__descriptor, ++ allocator, len, data); ++} ++void sr__version_verify_req__free_unpacked ++ (Sr__VersionVerifyReq *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__version_verify_req__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__version_verify_resp__init ++ (Sr__VersionVerifyResp *message) ++{ ++ static Sr__VersionVerifyResp init_value = SR__VERSION_VERIFY_RESP__INIT; ++ *message = init_value; ++} ++size_t sr__version_verify_resp__get_packed_size ++ (const Sr__VersionVerifyResp *message) ++{ ++ assert(message->base.descriptor == &sr__version_verify_resp__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__version_verify_resp__pack ++ (const Sr__VersionVerifyResp *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__version_verify_resp__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__version_verify_resp__pack_to_buffer ++ (const Sr__VersionVerifyResp *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__version_verify_resp__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__VersionVerifyResp * ++ sr__version_verify_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__VersionVerifyResp *) ++ protobuf_c_message_unpack (&sr__version_verify_resp__descriptor, ++ allocator, len, data); ++} ++void sr__version_verify_resp__free_unpacked ++ (Sr__VersionVerifyResp *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__version_verify_resp__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__schema_revision__init ++ (Sr__SchemaRevision *message) ++{ ++ static Sr__SchemaRevision init_value = SR__SCHEMA_REVISION__INIT; ++ *message = init_value; ++} ++size_t sr__schema_revision__get_packed_size ++ (const Sr__SchemaRevision *message) ++{ ++ assert(message->base.descriptor == &sr__schema_revision__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__schema_revision__pack ++ (const Sr__SchemaRevision *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__schema_revision__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__schema_revision__pack_to_buffer ++ (const Sr__SchemaRevision *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__schema_revision__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__SchemaRevision * ++ sr__schema_revision__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__SchemaRevision *) ++ protobuf_c_message_unpack (&sr__schema_revision__descriptor, ++ allocator, len, data); ++} ++void sr__schema_revision__free_unpacked ++ (Sr__SchemaRevision *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__schema_revision__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__schema_submodule__init ++ (Sr__SchemaSubmodule *message) ++{ ++ static Sr__SchemaSubmodule init_value = SR__SCHEMA_SUBMODULE__INIT; ++ *message = init_value; ++} ++size_t sr__schema_submodule__get_packed_size ++ (const Sr__SchemaSubmodule *message) ++{ ++ assert(message->base.descriptor == &sr__schema_submodule__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__schema_submodule__pack ++ (const Sr__SchemaSubmodule *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__schema_submodule__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__schema_submodule__pack_to_buffer ++ (const Sr__SchemaSubmodule *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__schema_submodule__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__SchemaSubmodule * ++ sr__schema_submodule__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__SchemaSubmodule *) ++ protobuf_c_message_unpack (&sr__schema_submodule__descriptor, ++ allocator, len, data); ++} ++void sr__schema_submodule__free_unpacked ++ (Sr__SchemaSubmodule *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__schema_submodule__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__schema__init ++ (Sr__Schema *message) ++{ ++ static Sr__Schema init_value = SR__SCHEMA__INIT; ++ *message = init_value; ++} ++size_t sr__schema__get_packed_size ++ (const Sr__Schema *message) ++{ ++ assert(message->base.descriptor == &sr__schema__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__schema__pack ++ (const Sr__Schema *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__schema__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__schema__pack_to_buffer ++ (const Sr__Schema *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__schema__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__Schema * ++ sr__schema__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__Schema *) ++ protobuf_c_message_unpack (&sr__schema__descriptor, ++ allocator, len, data); ++} ++void sr__schema__free_unpacked ++ (Sr__Schema *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__schema__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__list_schemas_req__init ++ (Sr__ListSchemasReq *message) ++{ ++ static Sr__ListSchemasReq init_value = SR__LIST_SCHEMAS_REQ__INIT; ++ *message = init_value; ++} ++size_t sr__list_schemas_req__get_packed_size ++ (const Sr__ListSchemasReq *message) ++{ ++ assert(message->base.descriptor == &sr__list_schemas_req__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__list_schemas_req__pack ++ (const Sr__ListSchemasReq *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__list_schemas_req__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__list_schemas_req__pack_to_buffer ++ (const Sr__ListSchemasReq *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__list_schemas_req__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__ListSchemasReq * ++ sr__list_schemas_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__ListSchemasReq *) ++ protobuf_c_message_unpack (&sr__list_schemas_req__descriptor, ++ allocator, len, data); ++} ++void sr__list_schemas_req__free_unpacked ++ (Sr__ListSchemasReq *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__list_schemas_req__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__list_schemas_resp__init ++ (Sr__ListSchemasResp *message) ++{ ++ static Sr__ListSchemasResp init_value = SR__LIST_SCHEMAS_RESP__INIT; ++ *message = init_value; ++} ++size_t sr__list_schemas_resp__get_packed_size ++ (const Sr__ListSchemasResp *message) ++{ ++ assert(message->base.descriptor == &sr__list_schemas_resp__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__list_schemas_resp__pack ++ (const Sr__ListSchemasResp *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__list_schemas_resp__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__list_schemas_resp__pack_to_buffer ++ (const Sr__ListSchemasResp *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__list_schemas_resp__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__ListSchemasResp * ++ sr__list_schemas_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__ListSchemasResp *) ++ protobuf_c_message_unpack (&sr__list_schemas_resp__descriptor, ++ allocator, len, data); ++} ++void sr__list_schemas_resp__free_unpacked ++ (Sr__ListSchemasResp *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__list_schemas_resp__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__get_schema_req__init ++ (Sr__GetSchemaReq *message) ++{ ++ static Sr__GetSchemaReq init_value = SR__GET_SCHEMA_REQ__INIT; ++ *message = init_value; ++} ++size_t sr__get_schema_req__get_packed_size ++ (const Sr__GetSchemaReq *message) ++{ ++ assert(message->base.descriptor == &sr__get_schema_req__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__get_schema_req__pack ++ (const Sr__GetSchemaReq *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__get_schema_req__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__get_schema_req__pack_to_buffer ++ (const Sr__GetSchemaReq *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__get_schema_req__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__GetSchemaReq * ++ sr__get_schema_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__GetSchemaReq *) ++ protobuf_c_message_unpack (&sr__get_schema_req__descriptor, ++ allocator, len, data); ++} ++void sr__get_schema_req__free_unpacked ++ (Sr__GetSchemaReq *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__get_schema_req__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__get_schema_resp__init ++ (Sr__GetSchemaResp *message) ++{ ++ static Sr__GetSchemaResp init_value = SR__GET_SCHEMA_RESP__INIT; ++ *message = init_value; ++} ++size_t sr__get_schema_resp__get_packed_size ++ (const Sr__GetSchemaResp *message) ++{ ++ assert(message->base.descriptor == &sr__get_schema_resp__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__get_schema_resp__pack ++ (const Sr__GetSchemaResp *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__get_schema_resp__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__get_schema_resp__pack_to_buffer ++ (const Sr__GetSchemaResp *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__get_schema_resp__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__GetSchemaResp * ++ sr__get_schema_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__GetSchemaResp *) ++ protobuf_c_message_unpack (&sr__get_schema_resp__descriptor, ++ allocator, len, data); ++} ++void sr__get_schema_resp__free_unpacked ++ (Sr__GetSchemaResp *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__get_schema_resp__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__get_item_req__init ++ (Sr__GetItemReq *message) ++{ ++ static Sr__GetItemReq init_value = SR__GET_ITEM_REQ__INIT; ++ *message = init_value; ++} ++size_t sr__get_item_req__get_packed_size ++ (const Sr__GetItemReq *message) ++{ ++ assert(message->base.descriptor == &sr__get_item_req__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__get_item_req__pack ++ (const Sr__GetItemReq *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__get_item_req__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__get_item_req__pack_to_buffer ++ (const Sr__GetItemReq *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__get_item_req__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__GetItemReq * ++ sr__get_item_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__GetItemReq *) ++ protobuf_c_message_unpack (&sr__get_item_req__descriptor, ++ allocator, len, data); ++} ++void sr__get_item_req__free_unpacked ++ (Sr__GetItemReq *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__get_item_req__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__get_item_resp__init ++ (Sr__GetItemResp *message) ++{ ++ static Sr__GetItemResp init_value = SR__GET_ITEM_RESP__INIT; ++ *message = init_value; ++} ++size_t sr__get_item_resp__get_packed_size ++ (const Sr__GetItemResp *message) ++{ ++ assert(message->base.descriptor == &sr__get_item_resp__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__get_item_resp__pack ++ (const Sr__GetItemResp *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__get_item_resp__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__get_item_resp__pack_to_buffer ++ (const Sr__GetItemResp *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__get_item_resp__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__GetItemResp * ++ sr__get_item_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__GetItemResp *) ++ protobuf_c_message_unpack (&sr__get_item_resp__descriptor, ++ allocator, len, data); ++} ++void sr__get_item_resp__free_unpacked ++ (Sr__GetItemResp *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__get_item_resp__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__get_items_req__init ++ (Sr__GetItemsReq *message) ++{ ++ static Sr__GetItemsReq init_value = SR__GET_ITEMS_REQ__INIT; ++ *message = init_value; ++} ++size_t sr__get_items_req__get_packed_size ++ (const Sr__GetItemsReq *message) ++{ ++ assert(message->base.descriptor == &sr__get_items_req__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__get_items_req__pack ++ (const Sr__GetItemsReq *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__get_items_req__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__get_items_req__pack_to_buffer ++ (const Sr__GetItemsReq *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__get_items_req__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__GetItemsReq * ++ sr__get_items_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__GetItemsReq *) ++ protobuf_c_message_unpack (&sr__get_items_req__descriptor, ++ allocator, len, data); ++} ++void sr__get_items_req__free_unpacked ++ (Sr__GetItemsReq *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__get_items_req__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__get_items_resp__init ++ (Sr__GetItemsResp *message) ++{ ++ static Sr__GetItemsResp init_value = SR__GET_ITEMS_RESP__INIT; ++ *message = init_value; ++} ++size_t sr__get_items_resp__get_packed_size ++ (const Sr__GetItemsResp *message) ++{ ++ assert(message->base.descriptor == &sr__get_items_resp__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__get_items_resp__pack ++ (const Sr__GetItemsResp *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__get_items_resp__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__get_items_resp__pack_to_buffer ++ (const Sr__GetItemsResp *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__get_items_resp__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__GetItemsResp * ++ sr__get_items_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__GetItemsResp *) ++ protobuf_c_message_unpack (&sr__get_items_resp__descriptor, ++ allocator, len, data); ++} ++void sr__get_items_resp__free_unpacked ++ (Sr__GetItemsResp *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__get_items_resp__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__get_subtree_req__init ++ (Sr__GetSubtreeReq *message) ++{ ++ static Sr__GetSubtreeReq init_value = SR__GET_SUBTREE_REQ__INIT; ++ *message = init_value; ++} ++size_t sr__get_subtree_req__get_packed_size ++ (const Sr__GetSubtreeReq *message) ++{ ++ assert(message->base.descriptor == &sr__get_subtree_req__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__get_subtree_req__pack ++ (const Sr__GetSubtreeReq *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__get_subtree_req__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__get_subtree_req__pack_to_buffer ++ (const Sr__GetSubtreeReq *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__get_subtree_req__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__GetSubtreeReq * ++ sr__get_subtree_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__GetSubtreeReq *) ++ protobuf_c_message_unpack (&sr__get_subtree_req__descriptor, ++ allocator, len, data); ++} ++void sr__get_subtree_req__free_unpacked ++ (Sr__GetSubtreeReq *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__get_subtree_req__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__get_subtree_resp__init ++ (Sr__GetSubtreeResp *message) ++{ ++ static Sr__GetSubtreeResp init_value = SR__GET_SUBTREE_RESP__INIT; ++ *message = init_value; ++} ++size_t sr__get_subtree_resp__get_packed_size ++ (const Sr__GetSubtreeResp *message) ++{ ++ assert(message->base.descriptor == &sr__get_subtree_resp__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__get_subtree_resp__pack ++ (const Sr__GetSubtreeResp *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__get_subtree_resp__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__get_subtree_resp__pack_to_buffer ++ (const Sr__GetSubtreeResp *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__get_subtree_resp__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__GetSubtreeResp * ++ sr__get_subtree_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__GetSubtreeResp *) ++ protobuf_c_message_unpack (&sr__get_subtree_resp__descriptor, ++ allocator, len, data); ++} ++void sr__get_subtree_resp__free_unpacked ++ (Sr__GetSubtreeResp *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__get_subtree_resp__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__get_subtrees_req__init ++ (Sr__GetSubtreesReq *message) ++{ ++ static Sr__GetSubtreesReq init_value = SR__GET_SUBTREES_REQ__INIT; ++ *message = init_value; ++} ++size_t sr__get_subtrees_req__get_packed_size ++ (const Sr__GetSubtreesReq *message) ++{ ++ assert(message->base.descriptor == &sr__get_subtrees_req__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__get_subtrees_req__pack ++ (const Sr__GetSubtreesReq *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__get_subtrees_req__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__get_subtrees_req__pack_to_buffer ++ (const Sr__GetSubtreesReq *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__get_subtrees_req__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__GetSubtreesReq * ++ sr__get_subtrees_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__GetSubtreesReq *) ++ protobuf_c_message_unpack (&sr__get_subtrees_req__descriptor, ++ allocator, len, data); ++} ++void sr__get_subtrees_req__free_unpacked ++ (Sr__GetSubtreesReq *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__get_subtrees_req__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__get_subtrees_resp__init ++ (Sr__GetSubtreesResp *message) ++{ ++ static Sr__GetSubtreesResp init_value = SR__GET_SUBTREES_RESP__INIT; ++ *message = init_value; ++} ++size_t sr__get_subtrees_resp__get_packed_size ++ (const Sr__GetSubtreesResp *message) ++{ ++ assert(message->base.descriptor == &sr__get_subtrees_resp__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__get_subtrees_resp__pack ++ (const Sr__GetSubtreesResp *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__get_subtrees_resp__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__get_subtrees_resp__pack_to_buffer ++ (const Sr__GetSubtreesResp *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__get_subtrees_resp__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__GetSubtreesResp * ++ sr__get_subtrees_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__GetSubtreesResp *) ++ protobuf_c_message_unpack (&sr__get_subtrees_resp__descriptor, ++ allocator, len, data); ++} ++void sr__get_subtrees_resp__free_unpacked ++ (Sr__GetSubtreesResp *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__get_subtrees_resp__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__get_subtree_chunk_req__init ++ (Sr__GetSubtreeChunkReq *message) ++{ ++ static Sr__GetSubtreeChunkReq init_value = SR__GET_SUBTREE_CHUNK_REQ__INIT; ++ *message = init_value; ++} ++size_t sr__get_subtree_chunk_req__get_packed_size ++ (const Sr__GetSubtreeChunkReq *message) ++{ ++ assert(message->base.descriptor == &sr__get_subtree_chunk_req__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__get_subtree_chunk_req__pack ++ (const Sr__GetSubtreeChunkReq *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__get_subtree_chunk_req__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__get_subtree_chunk_req__pack_to_buffer ++ (const Sr__GetSubtreeChunkReq *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__get_subtree_chunk_req__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__GetSubtreeChunkReq * ++ sr__get_subtree_chunk_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__GetSubtreeChunkReq *) ++ protobuf_c_message_unpack (&sr__get_subtree_chunk_req__descriptor, ++ allocator, len, data); ++} ++void sr__get_subtree_chunk_req__free_unpacked ++ (Sr__GetSubtreeChunkReq *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__get_subtree_chunk_req__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__get_subtree_chunk_resp__init ++ (Sr__GetSubtreeChunkResp *message) ++{ ++ static Sr__GetSubtreeChunkResp init_value = SR__GET_SUBTREE_CHUNK_RESP__INIT; ++ *message = init_value; ++} ++size_t sr__get_subtree_chunk_resp__get_packed_size ++ (const Sr__GetSubtreeChunkResp *message) ++{ ++ assert(message->base.descriptor == &sr__get_subtree_chunk_resp__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__get_subtree_chunk_resp__pack ++ (const Sr__GetSubtreeChunkResp *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__get_subtree_chunk_resp__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__get_subtree_chunk_resp__pack_to_buffer ++ (const Sr__GetSubtreeChunkResp *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__get_subtree_chunk_resp__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__GetSubtreeChunkResp * ++ sr__get_subtree_chunk_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__GetSubtreeChunkResp *) ++ protobuf_c_message_unpack (&sr__get_subtree_chunk_resp__descriptor, ++ allocator, len, data); ++} ++void sr__get_subtree_chunk_resp__free_unpacked ++ (Sr__GetSubtreeChunkResp *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__get_subtree_chunk_resp__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__set_item_req__init ++ (Sr__SetItemReq *message) ++{ ++ static Sr__SetItemReq init_value = SR__SET_ITEM_REQ__INIT; ++ *message = init_value; ++} ++size_t sr__set_item_req__get_packed_size ++ (const Sr__SetItemReq *message) ++{ ++ assert(message->base.descriptor == &sr__set_item_req__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__set_item_req__pack ++ (const Sr__SetItemReq *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__set_item_req__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__set_item_req__pack_to_buffer ++ (const Sr__SetItemReq *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__set_item_req__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__SetItemReq * ++ sr__set_item_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__SetItemReq *) ++ protobuf_c_message_unpack (&sr__set_item_req__descriptor, ++ allocator, len, data); ++} ++void sr__set_item_req__free_unpacked ++ (Sr__SetItemReq *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__set_item_req__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__set_item_resp__init ++ (Sr__SetItemResp *message) ++{ ++ static Sr__SetItemResp init_value = SR__SET_ITEM_RESP__INIT; ++ *message = init_value; ++} ++size_t sr__set_item_resp__get_packed_size ++ (const Sr__SetItemResp *message) ++{ ++ assert(message->base.descriptor == &sr__set_item_resp__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__set_item_resp__pack ++ (const Sr__SetItemResp *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__set_item_resp__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__set_item_resp__pack_to_buffer ++ (const Sr__SetItemResp *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__set_item_resp__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__SetItemResp * ++ sr__set_item_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__SetItemResp *) ++ protobuf_c_message_unpack (&sr__set_item_resp__descriptor, ++ allocator, len, data); ++} ++void sr__set_item_resp__free_unpacked ++ (Sr__SetItemResp *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__set_item_resp__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__set_item_str_req__init ++ (Sr__SetItemStrReq *message) ++{ ++ static Sr__SetItemStrReq init_value = SR__SET_ITEM_STR_REQ__INIT; ++ *message = init_value; ++} ++size_t sr__set_item_str_req__get_packed_size ++ (const Sr__SetItemStrReq *message) ++{ ++ assert(message->base.descriptor == &sr__set_item_str_req__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__set_item_str_req__pack ++ (const Sr__SetItemStrReq *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__set_item_str_req__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__set_item_str_req__pack_to_buffer ++ (const Sr__SetItemStrReq *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__set_item_str_req__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__SetItemStrReq * ++ sr__set_item_str_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__SetItemStrReq *) ++ protobuf_c_message_unpack (&sr__set_item_str_req__descriptor, ++ allocator, len, data); ++} ++void sr__set_item_str_req__free_unpacked ++ (Sr__SetItemStrReq *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__set_item_str_req__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__set_item_str_resp__init ++ (Sr__SetItemStrResp *message) ++{ ++ static Sr__SetItemStrResp init_value = SR__SET_ITEM_STR_RESP__INIT; ++ *message = init_value; ++} ++size_t sr__set_item_str_resp__get_packed_size ++ (const Sr__SetItemStrResp *message) ++{ ++ assert(message->base.descriptor == &sr__set_item_str_resp__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__set_item_str_resp__pack ++ (const Sr__SetItemStrResp *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__set_item_str_resp__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__set_item_str_resp__pack_to_buffer ++ (const Sr__SetItemStrResp *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__set_item_str_resp__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__SetItemStrResp * ++ sr__set_item_str_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__SetItemStrResp *) ++ protobuf_c_message_unpack (&sr__set_item_str_resp__descriptor, ++ allocator, len, data); ++} ++void sr__set_item_str_resp__free_unpacked ++ (Sr__SetItemStrResp *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__set_item_str_resp__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__delete_item_req__init ++ (Sr__DeleteItemReq *message) ++{ ++ static Sr__DeleteItemReq init_value = SR__DELETE_ITEM_REQ__INIT; ++ *message = init_value; ++} ++size_t sr__delete_item_req__get_packed_size ++ (const Sr__DeleteItemReq *message) ++{ ++ assert(message->base.descriptor == &sr__delete_item_req__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__delete_item_req__pack ++ (const Sr__DeleteItemReq *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__delete_item_req__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__delete_item_req__pack_to_buffer ++ (const Sr__DeleteItemReq *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__delete_item_req__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__DeleteItemReq * ++ sr__delete_item_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__DeleteItemReq *) ++ protobuf_c_message_unpack (&sr__delete_item_req__descriptor, ++ allocator, len, data); ++} ++void sr__delete_item_req__free_unpacked ++ (Sr__DeleteItemReq *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__delete_item_req__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__delete_item_resp__init ++ (Sr__DeleteItemResp *message) ++{ ++ static Sr__DeleteItemResp init_value = SR__DELETE_ITEM_RESP__INIT; ++ *message = init_value; ++} ++size_t sr__delete_item_resp__get_packed_size ++ (const Sr__DeleteItemResp *message) ++{ ++ assert(message->base.descriptor == &sr__delete_item_resp__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__delete_item_resp__pack ++ (const Sr__DeleteItemResp *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__delete_item_resp__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__delete_item_resp__pack_to_buffer ++ (const Sr__DeleteItemResp *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__delete_item_resp__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__DeleteItemResp * ++ sr__delete_item_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__DeleteItemResp *) ++ protobuf_c_message_unpack (&sr__delete_item_resp__descriptor, ++ allocator, len, data); ++} ++void sr__delete_item_resp__free_unpacked ++ (Sr__DeleteItemResp *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__delete_item_resp__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__move_item_req__init ++ (Sr__MoveItemReq *message) ++{ ++ static Sr__MoveItemReq init_value = SR__MOVE_ITEM_REQ__INIT; ++ *message = init_value; ++} ++size_t sr__move_item_req__get_packed_size ++ (const Sr__MoveItemReq *message) ++{ ++ assert(message->base.descriptor == &sr__move_item_req__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__move_item_req__pack ++ (const Sr__MoveItemReq *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__move_item_req__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__move_item_req__pack_to_buffer ++ (const Sr__MoveItemReq *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__move_item_req__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__MoveItemReq * ++ sr__move_item_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__MoveItemReq *) ++ protobuf_c_message_unpack (&sr__move_item_req__descriptor, ++ allocator, len, data); ++} ++void sr__move_item_req__free_unpacked ++ (Sr__MoveItemReq *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__move_item_req__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__move_item_resp__init ++ (Sr__MoveItemResp *message) ++{ ++ static Sr__MoveItemResp init_value = SR__MOVE_ITEM_RESP__INIT; ++ *message = init_value; ++} ++size_t sr__move_item_resp__get_packed_size ++ (const Sr__MoveItemResp *message) ++{ ++ assert(message->base.descriptor == &sr__move_item_resp__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__move_item_resp__pack ++ (const Sr__MoveItemResp *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__move_item_resp__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__move_item_resp__pack_to_buffer ++ (const Sr__MoveItemResp *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__move_item_resp__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__MoveItemResp * ++ sr__move_item_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__MoveItemResp *) ++ protobuf_c_message_unpack (&sr__move_item_resp__descriptor, ++ allocator, len, data); ++} ++void sr__move_item_resp__free_unpacked ++ (Sr__MoveItemResp *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__move_item_resp__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__validate_req__init ++ (Sr__ValidateReq *message) ++{ ++ static Sr__ValidateReq init_value = SR__VALIDATE_REQ__INIT; ++ *message = init_value; ++} ++size_t sr__validate_req__get_packed_size ++ (const Sr__ValidateReq *message) ++{ ++ assert(message->base.descriptor == &sr__validate_req__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__validate_req__pack ++ (const Sr__ValidateReq *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__validate_req__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__validate_req__pack_to_buffer ++ (const Sr__ValidateReq *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__validate_req__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__ValidateReq * ++ sr__validate_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__ValidateReq *) ++ protobuf_c_message_unpack (&sr__validate_req__descriptor, ++ allocator, len, data); ++} ++void sr__validate_req__free_unpacked ++ (Sr__ValidateReq *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__validate_req__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__validate_resp__init ++ (Sr__ValidateResp *message) ++{ ++ static Sr__ValidateResp init_value = SR__VALIDATE_RESP__INIT; ++ *message = init_value; ++} ++size_t sr__validate_resp__get_packed_size ++ (const Sr__ValidateResp *message) ++{ ++ assert(message->base.descriptor == &sr__validate_resp__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__validate_resp__pack ++ (const Sr__ValidateResp *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__validate_resp__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__validate_resp__pack_to_buffer ++ (const Sr__ValidateResp *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__validate_resp__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__ValidateResp * ++ sr__validate_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__ValidateResp *) ++ protobuf_c_message_unpack (&sr__validate_resp__descriptor, ++ allocator, len, data); ++} ++void sr__validate_resp__free_unpacked ++ (Sr__ValidateResp *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__validate_resp__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__commit_req__init ++ (Sr__CommitReq *message) ++{ ++ static Sr__CommitReq init_value = SR__COMMIT_REQ__INIT; ++ *message = init_value; ++} ++size_t sr__commit_req__get_packed_size ++ (const Sr__CommitReq *message) ++{ ++ assert(message->base.descriptor == &sr__commit_req__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__commit_req__pack ++ (const Sr__CommitReq *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__commit_req__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__commit_req__pack_to_buffer ++ (const Sr__CommitReq *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__commit_req__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__CommitReq * ++ sr__commit_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__CommitReq *) ++ protobuf_c_message_unpack (&sr__commit_req__descriptor, ++ allocator, len, data); ++} ++void sr__commit_req__free_unpacked ++ (Sr__CommitReq *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__commit_req__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__commit_resp__init ++ (Sr__CommitResp *message) ++{ ++ static Sr__CommitResp init_value = SR__COMMIT_RESP__INIT; ++ *message = init_value; ++} ++size_t sr__commit_resp__get_packed_size ++ (const Sr__CommitResp *message) ++{ ++ assert(message->base.descriptor == &sr__commit_resp__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__commit_resp__pack ++ (const Sr__CommitResp *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__commit_resp__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__commit_resp__pack_to_buffer ++ (const Sr__CommitResp *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__commit_resp__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__CommitResp * ++ sr__commit_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__CommitResp *) ++ protobuf_c_message_unpack (&sr__commit_resp__descriptor, ++ allocator, len, data); ++} ++void sr__commit_resp__free_unpacked ++ (Sr__CommitResp *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__commit_resp__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__discard_changes_req__init ++ (Sr__DiscardChangesReq *message) ++{ ++ static Sr__DiscardChangesReq init_value = SR__DISCARD_CHANGES_REQ__INIT; ++ *message = init_value; ++} ++size_t sr__discard_changes_req__get_packed_size ++ (const Sr__DiscardChangesReq *message) ++{ ++ assert(message->base.descriptor == &sr__discard_changes_req__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__discard_changes_req__pack ++ (const Sr__DiscardChangesReq *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__discard_changes_req__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__discard_changes_req__pack_to_buffer ++ (const Sr__DiscardChangesReq *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__discard_changes_req__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__DiscardChangesReq * ++ sr__discard_changes_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__DiscardChangesReq *) ++ protobuf_c_message_unpack (&sr__discard_changes_req__descriptor, ++ allocator, len, data); ++} ++void sr__discard_changes_req__free_unpacked ++ (Sr__DiscardChangesReq *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__discard_changes_req__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__discard_changes_resp__init ++ (Sr__DiscardChangesResp *message) ++{ ++ static Sr__DiscardChangesResp init_value = SR__DISCARD_CHANGES_RESP__INIT; ++ *message = init_value; ++} ++size_t sr__discard_changes_resp__get_packed_size ++ (const Sr__DiscardChangesResp *message) ++{ ++ assert(message->base.descriptor == &sr__discard_changes_resp__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__discard_changes_resp__pack ++ (const Sr__DiscardChangesResp *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__discard_changes_resp__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__discard_changes_resp__pack_to_buffer ++ (const Sr__DiscardChangesResp *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__discard_changes_resp__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__DiscardChangesResp * ++ sr__discard_changes_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__DiscardChangesResp *) ++ protobuf_c_message_unpack (&sr__discard_changes_resp__descriptor, ++ allocator, len, data); ++} ++void sr__discard_changes_resp__free_unpacked ++ (Sr__DiscardChangesResp *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__discard_changes_resp__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__copy_config_req__init ++ (Sr__CopyConfigReq *message) ++{ ++ static Sr__CopyConfigReq init_value = SR__COPY_CONFIG_REQ__INIT; ++ *message = init_value; ++} ++size_t sr__copy_config_req__get_packed_size ++ (const Sr__CopyConfigReq *message) ++{ ++ assert(message->base.descriptor == &sr__copy_config_req__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__copy_config_req__pack ++ (const Sr__CopyConfigReq *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__copy_config_req__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__copy_config_req__pack_to_buffer ++ (const Sr__CopyConfigReq *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__copy_config_req__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__CopyConfigReq * ++ sr__copy_config_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__CopyConfigReq *) ++ protobuf_c_message_unpack (&sr__copy_config_req__descriptor, ++ allocator, len, data); ++} ++void sr__copy_config_req__free_unpacked ++ (Sr__CopyConfigReq *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__copy_config_req__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__copy_config_resp__init ++ (Sr__CopyConfigResp *message) ++{ ++ static Sr__CopyConfigResp init_value = SR__COPY_CONFIG_RESP__INIT; ++ *message = init_value; ++} ++size_t sr__copy_config_resp__get_packed_size ++ (const Sr__CopyConfigResp *message) ++{ ++ assert(message->base.descriptor == &sr__copy_config_resp__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__copy_config_resp__pack ++ (const Sr__CopyConfigResp *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__copy_config_resp__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__copy_config_resp__pack_to_buffer ++ (const Sr__CopyConfigResp *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__copy_config_resp__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__CopyConfigResp * ++ sr__copy_config_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__CopyConfigResp *) ++ protobuf_c_message_unpack (&sr__copy_config_resp__descriptor, ++ allocator, len, data); ++} ++void sr__copy_config_resp__free_unpacked ++ (Sr__CopyConfigResp *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__copy_config_resp__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__lock_req__init ++ (Sr__LockReq *message) ++{ ++ static Sr__LockReq init_value = SR__LOCK_REQ__INIT; ++ *message = init_value; ++} ++size_t sr__lock_req__get_packed_size ++ (const Sr__LockReq *message) ++{ ++ assert(message->base.descriptor == &sr__lock_req__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__lock_req__pack ++ (const Sr__LockReq *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__lock_req__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__lock_req__pack_to_buffer ++ (const Sr__LockReq *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__lock_req__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__LockReq * ++ sr__lock_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__LockReq *) ++ protobuf_c_message_unpack (&sr__lock_req__descriptor, ++ allocator, len, data); ++} ++void sr__lock_req__free_unpacked ++ (Sr__LockReq *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__lock_req__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__lock_resp__init ++ (Sr__LockResp *message) ++{ ++ static Sr__LockResp init_value = SR__LOCK_RESP__INIT; ++ *message = init_value; ++} ++size_t sr__lock_resp__get_packed_size ++ (const Sr__LockResp *message) ++{ ++ assert(message->base.descriptor == &sr__lock_resp__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__lock_resp__pack ++ (const Sr__LockResp *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__lock_resp__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__lock_resp__pack_to_buffer ++ (const Sr__LockResp *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__lock_resp__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__LockResp * ++ sr__lock_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__LockResp *) ++ protobuf_c_message_unpack (&sr__lock_resp__descriptor, ++ allocator, len, data); ++} ++void sr__lock_resp__free_unpacked ++ (Sr__LockResp *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__lock_resp__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__unlock_req__init ++ (Sr__UnlockReq *message) ++{ ++ static Sr__UnlockReq init_value = SR__UNLOCK_REQ__INIT; ++ *message = init_value; ++} ++size_t sr__unlock_req__get_packed_size ++ (const Sr__UnlockReq *message) ++{ ++ assert(message->base.descriptor == &sr__unlock_req__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__unlock_req__pack ++ (const Sr__UnlockReq *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__unlock_req__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__unlock_req__pack_to_buffer ++ (const Sr__UnlockReq *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__unlock_req__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__UnlockReq * ++ sr__unlock_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__UnlockReq *) ++ protobuf_c_message_unpack (&sr__unlock_req__descriptor, ++ allocator, len, data); ++} ++void sr__unlock_req__free_unpacked ++ (Sr__UnlockReq *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__unlock_req__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__unlock_resp__init ++ (Sr__UnlockResp *message) ++{ ++ static Sr__UnlockResp init_value = SR__UNLOCK_RESP__INIT; ++ *message = init_value; ++} ++size_t sr__unlock_resp__get_packed_size ++ (const Sr__UnlockResp *message) ++{ ++ assert(message->base.descriptor == &sr__unlock_resp__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__unlock_resp__pack ++ (const Sr__UnlockResp *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__unlock_resp__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__unlock_resp__pack_to_buffer ++ (const Sr__UnlockResp *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__unlock_resp__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__UnlockResp * ++ sr__unlock_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__UnlockResp *) ++ protobuf_c_message_unpack (&sr__unlock_resp__descriptor, ++ allocator, len, data); ++} ++void sr__unlock_resp__free_unpacked ++ (Sr__UnlockResp *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__unlock_resp__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__subscribe_req__init ++ (Sr__SubscribeReq *message) ++{ ++ static Sr__SubscribeReq init_value = SR__SUBSCRIBE_REQ__INIT; ++ *message = init_value; ++} ++size_t sr__subscribe_req__get_packed_size ++ (const Sr__SubscribeReq *message) ++{ ++ assert(message->base.descriptor == &sr__subscribe_req__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__subscribe_req__pack ++ (const Sr__SubscribeReq *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__subscribe_req__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__subscribe_req__pack_to_buffer ++ (const Sr__SubscribeReq *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__subscribe_req__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__SubscribeReq * ++ sr__subscribe_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__SubscribeReq *) ++ protobuf_c_message_unpack (&sr__subscribe_req__descriptor, ++ allocator, len, data); ++} ++void sr__subscribe_req__free_unpacked ++ (Sr__SubscribeReq *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__subscribe_req__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__subscribe_resp__init ++ (Sr__SubscribeResp *message) ++{ ++ static Sr__SubscribeResp init_value = SR__SUBSCRIBE_RESP__INIT; ++ *message = init_value; ++} ++size_t sr__subscribe_resp__get_packed_size ++ (const Sr__SubscribeResp *message) ++{ ++ assert(message->base.descriptor == &sr__subscribe_resp__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__subscribe_resp__pack ++ (const Sr__SubscribeResp *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__subscribe_resp__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__subscribe_resp__pack_to_buffer ++ (const Sr__SubscribeResp *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__subscribe_resp__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__SubscribeResp * ++ sr__subscribe_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__SubscribeResp *) ++ protobuf_c_message_unpack (&sr__subscribe_resp__descriptor, ++ allocator, len, data); ++} ++void sr__subscribe_resp__free_unpacked ++ (Sr__SubscribeResp *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__subscribe_resp__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__unsubscribe_req__init ++ (Sr__UnsubscribeReq *message) ++{ ++ static Sr__UnsubscribeReq init_value = SR__UNSUBSCRIBE_REQ__INIT; ++ *message = init_value; ++} ++size_t sr__unsubscribe_req__get_packed_size ++ (const Sr__UnsubscribeReq *message) ++{ ++ assert(message->base.descriptor == &sr__unsubscribe_req__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__unsubscribe_req__pack ++ (const Sr__UnsubscribeReq *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__unsubscribe_req__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__unsubscribe_req__pack_to_buffer ++ (const Sr__UnsubscribeReq *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__unsubscribe_req__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__UnsubscribeReq * ++ sr__unsubscribe_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__UnsubscribeReq *) ++ protobuf_c_message_unpack (&sr__unsubscribe_req__descriptor, ++ allocator, len, data); ++} ++void sr__unsubscribe_req__free_unpacked ++ (Sr__UnsubscribeReq *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__unsubscribe_req__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__unsubscribe_resp__init ++ (Sr__UnsubscribeResp *message) ++{ ++ static Sr__UnsubscribeResp init_value = SR__UNSUBSCRIBE_RESP__INIT; ++ *message = init_value; ++} ++size_t sr__unsubscribe_resp__get_packed_size ++ (const Sr__UnsubscribeResp *message) ++{ ++ assert(message->base.descriptor == &sr__unsubscribe_resp__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__unsubscribe_resp__pack ++ (const Sr__UnsubscribeResp *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__unsubscribe_resp__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__unsubscribe_resp__pack_to_buffer ++ (const Sr__UnsubscribeResp *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__unsubscribe_resp__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__UnsubscribeResp * ++ sr__unsubscribe_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__UnsubscribeResp *) ++ protobuf_c_message_unpack (&sr__unsubscribe_resp__descriptor, ++ allocator, len, data); ++} ++void sr__unsubscribe_resp__free_unpacked ++ (Sr__UnsubscribeResp *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__unsubscribe_resp__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__check_enabled_running_req__init ++ (Sr__CheckEnabledRunningReq *message) ++{ ++ static Sr__CheckEnabledRunningReq init_value = SR__CHECK_ENABLED_RUNNING_REQ__INIT; ++ *message = init_value; ++} ++size_t sr__check_enabled_running_req__get_packed_size ++ (const Sr__CheckEnabledRunningReq *message) ++{ ++ assert(message->base.descriptor == &sr__check_enabled_running_req__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__check_enabled_running_req__pack ++ (const Sr__CheckEnabledRunningReq *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__check_enabled_running_req__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__check_enabled_running_req__pack_to_buffer ++ (const Sr__CheckEnabledRunningReq *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__check_enabled_running_req__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__CheckEnabledRunningReq * ++ sr__check_enabled_running_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__CheckEnabledRunningReq *) ++ protobuf_c_message_unpack (&sr__check_enabled_running_req__descriptor, ++ allocator, len, data); ++} ++void sr__check_enabled_running_req__free_unpacked ++ (Sr__CheckEnabledRunningReq *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__check_enabled_running_req__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__check_enabled_running_resp__init ++ (Sr__CheckEnabledRunningResp *message) ++{ ++ static Sr__CheckEnabledRunningResp init_value = SR__CHECK_ENABLED_RUNNING_RESP__INIT; ++ *message = init_value; ++} ++size_t sr__check_enabled_running_resp__get_packed_size ++ (const Sr__CheckEnabledRunningResp *message) ++{ ++ assert(message->base.descriptor == &sr__check_enabled_running_resp__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__check_enabled_running_resp__pack ++ (const Sr__CheckEnabledRunningResp *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__check_enabled_running_resp__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__check_enabled_running_resp__pack_to_buffer ++ (const Sr__CheckEnabledRunningResp *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__check_enabled_running_resp__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__CheckEnabledRunningResp * ++ sr__check_enabled_running_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__CheckEnabledRunningResp *) ++ protobuf_c_message_unpack (&sr__check_enabled_running_resp__descriptor, ++ allocator, len, data); ++} ++void sr__check_enabled_running_resp__free_unpacked ++ (Sr__CheckEnabledRunningResp *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__check_enabled_running_resp__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__module_install_notification__init ++ (Sr__ModuleInstallNotification *message) ++{ ++ static Sr__ModuleInstallNotification init_value = SR__MODULE_INSTALL_NOTIFICATION__INIT; ++ *message = init_value; ++} ++size_t sr__module_install_notification__get_packed_size ++ (const Sr__ModuleInstallNotification *message) ++{ ++ assert(message->base.descriptor == &sr__module_install_notification__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__module_install_notification__pack ++ (const Sr__ModuleInstallNotification *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__module_install_notification__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__module_install_notification__pack_to_buffer ++ (const Sr__ModuleInstallNotification *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__module_install_notification__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__ModuleInstallNotification * ++ sr__module_install_notification__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__ModuleInstallNotification *) ++ protobuf_c_message_unpack (&sr__module_install_notification__descriptor, ++ allocator, len, data); ++} ++void sr__module_install_notification__free_unpacked ++ (Sr__ModuleInstallNotification *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__module_install_notification__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__feature_enable_notification__init ++ (Sr__FeatureEnableNotification *message) ++{ ++ static Sr__FeatureEnableNotification init_value = SR__FEATURE_ENABLE_NOTIFICATION__INIT; ++ *message = init_value; ++} ++size_t sr__feature_enable_notification__get_packed_size ++ (const Sr__FeatureEnableNotification *message) ++{ ++ assert(message->base.descriptor == &sr__feature_enable_notification__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__feature_enable_notification__pack ++ (const Sr__FeatureEnableNotification *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__feature_enable_notification__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__feature_enable_notification__pack_to_buffer ++ (const Sr__FeatureEnableNotification *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__feature_enable_notification__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__FeatureEnableNotification * ++ sr__feature_enable_notification__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__FeatureEnableNotification *) ++ protobuf_c_message_unpack (&sr__feature_enable_notification__descriptor, ++ allocator, len, data); ++} ++void sr__feature_enable_notification__free_unpacked ++ (Sr__FeatureEnableNotification *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__feature_enable_notification__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__module_change_notification__init ++ (Sr__ModuleChangeNotification *message) ++{ ++ static Sr__ModuleChangeNotification init_value = SR__MODULE_CHANGE_NOTIFICATION__INIT; ++ *message = init_value; ++} ++size_t sr__module_change_notification__get_packed_size ++ (const Sr__ModuleChangeNotification *message) ++{ ++ assert(message->base.descriptor == &sr__module_change_notification__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__module_change_notification__pack ++ (const Sr__ModuleChangeNotification *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__module_change_notification__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__module_change_notification__pack_to_buffer ++ (const Sr__ModuleChangeNotification *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__module_change_notification__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__ModuleChangeNotification * ++ sr__module_change_notification__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__ModuleChangeNotification *) ++ protobuf_c_message_unpack (&sr__module_change_notification__descriptor, ++ allocator, len, data); ++} ++void sr__module_change_notification__free_unpacked ++ (Sr__ModuleChangeNotification *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__module_change_notification__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__subtree_change_notification__init ++ (Sr__SubtreeChangeNotification *message) ++{ ++ static Sr__SubtreeChangeNotification init_value = SR__SUBTREE_CHANGE_NOTIFICATION__INIT; ++ *message = init_value; ++} ++size_t sr__subtree_change_notification__get_packed_size ++ (const Sr__SubtreeChangeNotification *message) ++{ ++ assert(message->base.descriptor == &sr__subtree_change_notification__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__subtree_change_notification__pack ++ (const Sr__SubtreeChangeNotification *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__subtree_change_notification__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__subtree_change_notification__pack_to_buffer ++ (const Sr__SubtreeChangeNotification *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__subtree_change_notification__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__SubtreeChangeNotification * ++ sr__subtree_change_notification__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__SubtreeChangeNotification *) ++ protobuf_c_message_unpack (&sr__subtree_change_notification__descriptor, ++ allocator, len, data); ++} ++void sr__subtree_change_notification__free_unpacked ++ (Sr__SubtreeChangeNotification *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__subtree_change_notification__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__change__init ++ (Sr__Change *message) ++{ ++ static Sr__Change init_value = SR__CHANGE__INIT; ++ *message = init_value; ++} ++size_t sr__change__get_packed_size ++ (const Sr__Change *message) ++{ ++ assert(message->base.descriptor == &sr__change__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__change__pack ++ (const Sr__Change *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__change__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__change__pack_to_buffer ++ (const Sr__Change *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__change__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__Change * ++ sr__change__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__Change *) ++ protobuf_c_message_unpack (&sr__change__descriptor, ++ allocator, len, data); ++} ++void sr__change__free_unpacked ++ (Sr__Change *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__change__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__get_changes_req__init ++ (Sr__GetChangesReq *message) ++{ ++ static Sr__GetChangesReq init_value = SR__GET_CHANGES_REQ__INIT; ++ *message = init_value; ++} ++size_t sr__get_changes_req__get_packed_size ++ (const Sr__GetChangesReq *message) ++{ ++ assert(message->base.descriptor == &sr__get_changes_req__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__get_changes_req__pack ++ (const Sr__GetChangesReq *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__get_changes_req__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__get_changes_req__pack_to_buffer ++ (const Sr__GetChangesReq *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__get_changes_req__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__GetChangesReq * ++ sr__get_changes_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__GetChangesReq *) ++ protobuf_c_message_unpack (&sr__get_changes_req__descriptor, ++ allocator, len, data); ++} ++void sr__get_changes_req__free_unpacked ++ (Sr__GetChangesReq *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__get_changes_req__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__get_changes_resp__init ++ (Sr__GetChangesResp *message) ++{ ++ static Sr__GetChangesResp init_value = SR__GET_CHANGES_RESP__INIT; ++ *message = init_value; ++} ++size_t sr__get_changes_resp__get_packed_size ++ (const Sr__GetChangesResp *message) ++{ ++ assert(message->base.descriptor == &sr__get_changes_resp__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__get_changes_resp__pack ++ (const Sr__GetChangesResp *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__get_changes_resp__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__get_changes_resp__pack_to_buffer ++ (const Sr__GetChangesResp *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__get_changes_resp__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__GetChangesResp * ++ sr__get_changes_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__GetChangesResp *) ++ protobuf_c_message_unpack (&sr__get_changes_resp__descriptor, ++ allocator, len, data); ++} ++void sr__get_changes_resp__free_unpacked ++ (Sr__GetChangesResp *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__get_changes_resp__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__check_exec_perm_req__init ++ (Sr__CheckExecPermReq *message) ++{ ++ static Sr__CheckExecPermReq init_value = SR__CHECK_EXEC_PERM_REQ__INIT; ++ *message = init_value; ++} ++size_t sr__check_exec_perm_req__get_packed_size ++ (const Sr__CheckExecPermReq *message) ++{ ++ assert(message->base.descriptor == &sr__check_exec_perm_req__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__check_exec_perm_req__pack ++ (const Sr__CheckExecPermReq *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__check_exec_perm_req__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__check_exec_perm_req__pack_to_buffer ++ (const Sr__CheckExecPermReq *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__check_exec_perm_req__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__CheckExecPermReq * ++ sr__check_exec_perm_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__CheckExecPermReq *) ++ protobuf_c_message_unpack (&sr__check_exec_perm_req__descriptor, ++ allocator, len, data); ++} ++void sr__check_exec_perm_req__free_unpacked ++ (Sr__CheckExecPermReq *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__check_exec_perm_req__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__check_exec_perm_resp__init ++ (Sr__CheckExecPermResp *message) ++{ ++ static Sr__CheckExecPermResp init_value = SR__CHECK_EXEC_PERM_RESP__INIT; ++ *message = init_value; ++} ++size_t sr__check_exec_perm_resp__get_packed_size ++ (const Sr__CheckExecPermResp *message) ++{ ++ assert(message->base.descriptor == &sr__check_exec_perm_resp__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__check_exec_perm_resp__pack ++ (const Sr__CheckExecPermResp *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__check_exec_perm_resp__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__check_exec_perm_resp__pack_to_buffer ++ (const Sr__CheckExecPermResp *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__check_exec_perm_resp__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__CheckExecPermResp * ++ sr__check_exec_perm_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__CheckExecPermResp *) ++ protobuf_c_message_unpack (&sr__check_exec_perm_resp__descriptor, ++ allocator, len, data); ++} ++void sr__check_exec_perm_resp__free_unpacked ++ (Sr__CheckExecPermResp *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__check_exec_perm_resp__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__rpcreq__init ++ (Sr__RPCReq *message) ++{ ++ static Sr__RPCReq init_value = SR__RPCREQ__INIT; ++ *message = init_value; ++} ++size_t sr__rpcreq__get_packed_size ++ (const Sr__RPCReq *message) ++{ ++ assert(message->base.descriptor == &sr__rpcreq__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__rpcreq__pack ++ (const Sr__RPCReq *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__rpcreq__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__rpcreq__pack_to_buffer ++ (const Sr__RPCReq *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__rpcreq__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__RPCReq * ++ sr__rpcreq__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__RPCReq *) ++ protobuf_c_message_unpack (&sr__rpcreq__descriptor, ++ allocator, len, data); ++} ++void sr__rpcreq__free_unpacked ++ (Sr__RPCReq *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__rpcreq__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__rpcresp__init ++ (Sr__RPCResp *message) ++{ ++ static Sr__RPCResp init_value = SR__RPCRESP__INIT; ++ *message = init_value; ++} ++size_t sr__rpcresp__get_packed_size ++ (const Sr__RPCResp *message) ++{ ++ assert(message->base.descriptor == &sr__rpcresp__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__rpcresp__pack ++ (const Sr__RPCResp *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__rpcresp__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__rpcresp__pack_to_buffer ++ (const Sr__RPCResp *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__rpcresp__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__RPCResp * ++ sr__rpcresp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__RPCResp *) ++ protobuf_c_message_unpack (&sr__rpcresp__descriptor, ++ allocator, len, data); ++} ++void sr__rpcresp__free_unpacked ++ (Sr__RPCResp *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__rpcresp__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__event_notif_req__init ++ (Sr__EventNotifReq *message) ++{ ++ static Sr__EventNotifReq init_value = SR__EVENT_NOTIF_REQ__INIT; ++ *message = init_value; ++} ++size_t sr__event_notif_req__get_packed_size ++ (const Sr__EventNotifReq *message) ++{ ++ assert(message->base.descriptor == &sr__event_notif_req__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__event_notif_req__pack ++ (const Sr__EventNotifReq *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__event_notif_req__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__event_notif_req__pack_to_buffer ++ (const Sr__EventNotifReq *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__event_notif_req__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__EventNotifReq * ++ sr__event_notif_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__EventNotifReq *) ++ protobuf_c_message_unpack (&sr__event_notif_req__descriptor, ++ allocator, len, data); ++} ++void sr__event_notif_req__free_unpacked ++ (Sr__EventNotifReq *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__event_notif_req__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__event_notif_resp__init ++ (Sr__EventNotifResp *message) ++{ ++ static Sr__EventNotifResp init_value = SR__EVENT_NOTIF_RESP__INIT; ++ *message = init_value; ++} ++size_t sr__event_notif_resp__get_packed_size ++ (const Sr__EventNotifResp *message) ++{ ++ assert(message->base.descriptor == &sr__event_notif_resp__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__event_notif_resp__pack ++ (const Sr__EventNotifResp *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__event_notif_resp__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__event_notif_resp__pack_to_buffer ++ (const Sr__EventNotifResp *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__event_notif_resp__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__EventNotifResp * ++ sr__event_notif_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__EventNotifResp *) ++ protobuf_c_message_unpack (&sr__event_notif_resp__descriptor, ++ allocator, len, data); ++} ++void sr__event_notif_resp__free_unpacked ++ (Sr__EventNotifResp *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__event_notif_resp__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__event_notif_replay_req__init ++ (Sr__EventNotifReplayReq *message) ++{ ++ static Sr__EventNotifReplayReq init_value = SR__EVENT_NOTIF_REPLAY_REQ__INIT; ++ *message = init_value; ++} ++size_t sr__event_notif_replay_req__get_packed_size ++ (const Sr__EventNotifReplayReq *message) ++{ ++ assert(message->base.descriptor == &sr__event_notif_replay_req__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__event_notif_replay_req__pack ++ (const Sr__EventNotifReplayReq *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__event_notif_replay_req__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__event_notif_replay_req__pack_to_buffer ++ (const Sr__EventNotifReplayReq *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__event_notif_replay_req__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__EventNotifReplayReq * ++ sr__event_notif_replay_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__EventNotifReplayReq *) ++ protobuf_c_message_unpack (&sr__event_notif_replay_req__descriptor, ++ allocator, len, data); ++} ++void sr__event_notif_replay_req__free_unpacked ++ (Sr__EventNotifReplayReq *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__event_notif_replay_req__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__event_notif_replay_resp__init ++ (Sr__EventNotifReplayResp *message) ++{ ++ static Sr__EventNotifReplayResp init_value = SR__EVENT_NOTIF_REPLAY_RESP__INIT; ++ *message = init_value; ++} ++size_t sr__event_notif_replay_resp__get_packed_size ++ (const Sr__EventNotifReplayResp *message) ++{ ++ assert(message->base.descriptor == &sr__event_notif_replay_resp__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__event_notif_replay_resp__pack ++ (const Sr__EventNotifReplayResp *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__event_notif_replay_resp__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__event_notif_replay_resp__pack_to_buffer ++ (const Sr__EventNotifReplayResp *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__event_notif_replay_resp__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__EventNotifReplayResp * ++ sr__event_notif_replay_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__EventNotifReplayResp *) ++ protobuf_c_message_unpack (&sr__event_notif_replay_resp__descriptor, ++ allocator, len, data); ++} ++void sr__event_notif_replay_resp__free_unpacked ++ (Sr__EventNotifReplayResp *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__event_notif_replay_resp__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__data_provide_req__init ++ (Sr__DataProvideReq *message) ++{ ++ static Sr__DataProvideReq init_value = SR__DATA_PROVIDE_REQ__INIT; ++ *message = init_value; ++} ++size_t sr__data_provide_req__get_packed_size ++ (const Sr__DataProvideReq *message) ++{ ++ assert(message->base.descriptor == &sr__data_provide_req__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__data_provide_req__pack ++ (const Sr__DataProvideReq *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__data_provide_req__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__data_provide_req__pack_to_buffer ++ (const Sr__DataProvideReq *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__data_provide_req__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__DataProvideReq * ++ sr__data_provide_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__DataProvideReq *) ++ protobuf_c_message_unpack (&sr__data_provide_req__descriptor, ++ allocator, len, data); ++} ++void sr__data_provide_req__free_unpacked ++ (Sr__DataProvideReq *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__data_provide_req__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__data_provide_resp__init ++ (Sr__DataProvideResp *message) ++{ ++ static Sr__DataProvideResp init_value = SR__DATA_PROVIDE_RESP__INIT; ++ *message = init_value; ++} ++size_t sr__data_provide_resp__get_packed_size ++ (const Sr__DataProvideResp *message) ++{ ++ assert(message->base.descriptor == &sr__data_provide_resp__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__data_provide_resp__pack ++ (const Sr__DataProvideResp *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__data_provide_resp__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__data_provide_resp__pack_to_buffer ++ (const Sr__DataProvideResp *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__data_provide_resp__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__DataProvideResp * ++ sr__data_provide_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__DataProvideResp *) ++ protobuf_c_message_unpack (&sr__data_provide_resp__descriptor, ++ allocator, len, data); ++} ++void sr__data_provide_resp__free_unpacked ++ (Sr__DataProvideResp *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__data_provide_resp__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__module_install_req__init ++ (Sr__ModuleInstallReq *message) ++{ ++ static Sr__ModuleInstallReq init_value = SR__MODULE_INSTALL_REQ__INIT; ++ *message = init_value; ++} ++size_t sr__module_install_req__get_packed_size ++ (const Sr__ModuleInstallReq *message) ++{ ++ assert(message->base.descriptor == &sr__module_install_req__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__module_install_req__pack ++ (const Sr__ModuleInstallReq *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__module_install_req__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__module_install_req__pack_to_buffer ++ (const Sr__ModuleInstallReq *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__module_install_req__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__ModuleInstallReq * ++ sr__module_install_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__ModuleInstallReq *) ++ protobuf_c_message_unpack (&sr__module_install_req__descriptor, ++ allocator, len, data); ++} ++void sr__module_install_req__free_unpacked ++ (Sr__ModuleInstallReq *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__module_install_req__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__module_install_resp__init ++ (Sr__ModuleInstallResp *message) ++{ ++ static Sr__ModuleInstallResp init_value = SR__MODULE_INSTALL_RESP__INIT; ++ *message = init_value; ++} ++size_t sr__module_install_resp__get_packed_size ++ (const Sr__ModuleInstallResp *message) ++{ ++ assert(message->base.descriptor == &sr__module_install_resp__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__module_install_resp__pack ++ (const Sr__ModuleInstallResp *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__module_install_resp__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__module_install_resp__pack_to_buffer ++ (const Sr__ModuleInstallResp *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__module_install_resp__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__ModuleInstallResp * ++ sr__module_install_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__ModuleInstallResp *) ++ protobuf_c_message_unpack (&sr__module_install_resp__descriptor, ++ allocator, len, data); ++} ++void sr__module_install_resp__free_unpacked ++ (Sr__ModuleInstallResp *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__module_install_resp__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__feature_enable_req__init ++ (Sr__FeatureEnableReq *message) ++{ ++ static Sr__FeatureEnableReq init_value = SR__FEATURE_ENABLE_REQ__INIT; ++ *message = init_value; ++} ++size_t sr__feature_enable_req__get_packed_size ++ (const Sr__FeatureEnableReq *message) ++{ ++ assert(message->base.descriptor == &sr__feature_enable_req__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__feature_enable_req__pack ++ (const Sr__FeatureEnableReq *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__feature_enable_req__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__feature_enable_req__pack_to_buffer ++ (const Sr__FeatureEnableReq *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__feature_enable_req__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__FeatureEnableReq * ++ sr__feature_enable_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__FeatureEnableReq *) ++ protobuf_c_message_unpack (&sr__feature_enable_req__descriptor, ++ allocator, len, data); ++} ++void sr__feature_enable_req__free_unpacked ++ (Sr__FeatureEnableReq *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__feature_enable_req__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__feature_enable_resp__init ++ (Sr__FeatureEnableResp *message) ++{ ++ static Sr__FeatureEnableResp init_value = SR__FEATURE_ENABLE_RESP__INIT; ++ *message = init_value; ++} ++size_t sr__feature_enable_resp__get_packed_size ++ (const Sr__FeatureEnableResp *message) ++{ ++ assert(message->base.descriptor == &sr__feature_enable_resp__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__feature_enable_resp__pack ++ (const Sr__FeatureEnableResp *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__feature_enable_resp__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__feature_enable_resp__pack_to_buffer ++ (const Sr__FeatureEnableResp *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__feature_enable_resp__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__FeatureEnableResp * ++ sr__feature_enable_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__FeatureEnableResp *) ++ protobuf_c_message_unpack (&sr__feature_enable_resp__descriptor, ++ allocator, len, data); ++} ++void sr__feature_enable_resp__free_unpacked ++ (Sr__FeatureEnableResp *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__feature_enable_resp__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__unsubscribe_destination_req__init ++ (Sr__UnsubscribeDestinationReq *message) ++{ ++ static Sr__UnsubscribeDestinationReq init_value = SR__UNSUBSCRIBE_DESTINATION_REQ__INIT; ++ *message = init_value; ++} ++size_t sr__unsubscribe_destination_req__get_packed_size ++ (const Sr__UnsubscribeDestinationReq *message) ++{ ++ assert(message->base.descriptor == &sr__unsubscribe_destination_req__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__unsubscribe_destination_req__pack ++ (const Sr__UnsubscribeDestinationReq *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__unsubscribe_destination_req__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__unsubscribe_destination_req__pack_to_buffer ++ (const Sr__UnsubscribeDestinationReq *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__unsubscribe_destination_req__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__UnsubscribeDestinationReq * ++ sr__unsubscribe_destination_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__UnsubscribeDestinationReq *) ++ protobuf_c_message_unpack (&sr__unsubscribe_destination_req__descriptor, ++ allocator, len, data); ++} ++void sr__unsubscribe_destination_req__free_unpacked ++ (Sr__UnsubscribeDestinationReq *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__unsubscribe_destination_req__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__commit_timeout_req__init ++ (Sr__CommitTimeoutReq *message) ++{ ++ static Sr__CommitTimeoutReq init_value = SR__COMMIT_TIMEOUT_REQ__INIT; ++ *message = init_value; ++} ++size_t sr__commit_timeout_req__get_packed_size ++ (const Sr__CommitTimeoutReq *message) ++{ ++ assert(message->base.descriptor == &sr__commit_timeout_req__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__commit_timeout_req__pack ++ (const Sr__CommitTimeoutReq *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__commit_timeout_req__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__commit_timeout_req__pack_to_buffer ++ (const Sr__CommitTimeoutReq *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__commit_timeout_req__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__CommitTimeoutReq * ++ sr__commit_timeout_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__CommitTimeoutReq *) ++ protobuf_c_message_unpack (&sr__commit_timeout_req__descriptor, ++ allocator, len, data); ++} ++void sr__commit_timeout_req__free_unpacked ++ (Sr__CommitTimeoutReq *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__commit_timeout_req__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__oper_data_timeout_req__init ++ (Sr__OperDataTimeoutReq *message) ++{ ++ static Sr__OperDataTimeoutReq init_value = SR__OPER_DATA_TIMEOUT_REQ__INIT; ++ *message = init_value; ++} ++size_t sr__oper_data_timeout_req__get_packed_size ++ (const Sr__OperDataTimeoutReq *message) ++{ ++ assert(message->base.descriptor == &sr__oper_data_timeout_req__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__oper_data_timeout_req__pack ++ (const Sr__OperDataTimeoutReq *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__oper_data_timeout_req__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__oper_data_timeout_req__pack_to_buffer ++ (const Sr__OperDataTimeoutReq *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__oper_data_timeout_req__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__OperDataTimeoutReq * ++ sr__oper_data_timeout_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__OperDataTimeoutReq *) ++ protobuf_c_message_unpack (&sr__oper_data_timeout_req__descriptor, ++ allocator, len, data); ++} ++void sr__oper_data_timeout_req__free_unpacked ++ (Sr__OperDataTimeoutReq *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__oper_data_timeout_req__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__internal_state_data_req__init ++ (Sr__InternalStateDataReq *message) ++{ ++ static Sr__InternalStateDataReq init_value = SR__INTERNAL_STATE_DATA_REQ__INIT; ++ *message = init_value; ++} ++size_t sr__internal_state_data_req__get_packed_size ++ (const Sr__InternalStateDataReq *message) ++{ ++ assert(message->base.descriptor == &sr__internal_state_data_req__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__internal_state_data_req__pack ++ (const Sr__InternalStateDataReq *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__internal_state_data_req__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__internal_state_data_req__pack_to_buffer ++ (const Sr__InternalStateDataReq *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__internal_state_data_req__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__InternalStateDataReq * ++ sr__internal_state_data_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__InternalStateDataReq *) ++ protobuf_c_message_unpack (&sr__internal_state_data_req__descriptor, ++ allocator, len, data); ++} ++void sr__internal_state_data_req__free_unpacked ++ (Sr__InternalStateDataReq *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__internal_state_data_req__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__notif_store_cleanup_req__init ++ (Sr__NotifStoreCleanupReq *message) ++{ ++ static Sr__NotifStoreCleanupReq init_value = SR__NOTIF_STORE_CLEANUP_REQ__INIT; ++ *message = init_value; ++} ++size_t sr__notif_store_cleanup_req__get_packed_size ++ (const Sr__NotifStoreCleanupReq *message) ++{ ++ assert(message->base.descriptor == &sr__notif_store_cleanup_req__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__notif_store_cleanup_req__pack ++ (const Sr__NotifStoreCleanupReq *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__notif_store_cleanup_req__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__notif_store_cleanup_req__pack_to_buffer ++ (const Sr__NotifStoreCleanupReq *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__notif_store_cleanup_req__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__NotifStoreCleanupReq * ++ sr__notif_store_cleanup_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__NotifStoreCleanupReq *) ++ protobuf_c_message_unpack (&sr__notif_store_cleanup_req__descriptor, ++ allocator, len, data); ++} ++void sr__notif_store_cleanup_req__free_unpacked ++ (Sr__NotifStoreCleanupReq *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__notif_store_cleanup_req__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__delayed_msg_req__init ++ (Sr__DelayedMsgReq *message) ++{ ++ static Sr__DelayedMsgReq init_value = SR__DELAYED_MSG_REQ__INIT; ++ *message = init_value; ++} ++size_t sr__delayed_msg_req__get_packed_size ++ (const Sr__DelayedMsgReq *message) ++{ ++ assert(message->base.descriptor == &sr__delayed_msg_req__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__delayed_msg_req__pack ++ (const Sr__DelayedMsgReq *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__delayed_msg_req__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__delayed_msg_req__pack_to_buffer ++ (const Sr__DelayedMsgReq *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__delayed_msg_req__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__DelayedMsgReq * ++ sr__delayed_msg_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__DelayedMsgReq *) ++ protobuf_c_message_unpack (&sr__delayed_msg_req__descriptor, ++ allocator, len, data); ++} ++void sr__delayed_msg_req__free_unpacked ++ (Sr__DelayedMsgReq *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__delayed_msg_req__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__nacm_reload_req__init ++ (Sr__NacmReloadReq *message) ++{ ++ static Sr__NacmReloadReq init_value = SR__NACM_RELOAD_REQ__INIT; ++ *message = init_value; ++} ++size_t sr__nacm_reload_req__get_packed_size ++ (const Sr__NacmReloadReq *message) ++{ ++ assert(message->base.descriptor == &sr__nacm_reload_req__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__nacm_reload_req__pack ++ (const Sr__NacmReloadReq *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__nacm_reload_req__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__nacm_reload_req__pack_to_buffer ++ (const Sr__NacmReloadReq *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__nacm_reload_req__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__NacmReloadReq * ++ sr__nacm_reload_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__NacmReloadReq *) ++ protobuf_c_message_unpack (&sr__nacm_reload_req__descriptor, ++ allocator, len, data); ++} ++void sr__nacm_reload_req__free_unpacked ++ (Sr__NacmReloadReq *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__nacm_reload_req__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__request__init ++ (Sr__Request *message) ++{ ++ static Sr__Request init_value = SR__REQUEST__INIT; ++ *message = init_value; ++} ++size_t sr__request__get_packed_size ++ (const Sr__Request *message) ++{ ++ assert(message->base.descriptor == &sr__request__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__request__pack ++ (const Sr__Request *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__request__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__request__pack_to_buffer ++ (const Sr__Request *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__request__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__Request * ++ sr__request__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__Request *) ++ protobuf_c_message_unpack (&sr__request__descriptor, ++ allocator, len, data); ++} ++void sr__request__free_unpacked ++ (Sr__Request *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__request__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__response__init ++ (Sr__Response *message) ++{ ++ static Sr__Response init_value = SR__RESPONSE__INIT; ++ *message = init_value; ++} ++size_t sr__response__get_packed_size ++ (const Sr__Response *message) ++{ ++ assert(message->base.descriptor == &sr__response__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__response__pack ++ (const Sr__Response *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__response__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__response__pack_to_buffer ++ (const Sr__Response *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__response__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__Response * ++ sr__response__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__Response *) ++ protobuf_c_message_unpack (&sr__response__descriptor, ++ allocator, len, data); ++} ++void sr__response__free_unpacked ++ (Sr__Response *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__response__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__notification__init ++ (Sr__Notification *message) ++{ ++ static Sr__Notification init_value = SR__NOTIFICATION__INIT; ++ *message = init_value; ++} ++size_t sr__notification__get_packed_size ++ (const Sr__Notification *message) ++{ ++ assert(message->base.descriptor == &sr__notification__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__notification__pack ++ (const Sr__Notification *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__notification__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__notification__pack_to_buffer ++ (const Sr__Notification *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__notification__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__Notification * ++ sr__notification__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__Notification *) ++ protobuf_c_message_unpack (&sr__notification__descriptor, ++ allocator, len, data); ++} ++void sr__notification__free_unpacked ++ (Sr__Notification *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__notification__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__notification_ack__init ++ (Sr__NotificationAck *message) ++{ ++ static Sr__NotificationAck init_value = SR__NOTIFICATION_ACK__INIT; ++ *message = init_value; ++} ++size_t sr__notification_ack__get_packed_size ++ (const Sr__NotificationAck *message) ++{ ++ assert(message->base.descriptor == &sr__notification_ack__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__notification_ack__pack ++ (const Sr__NotificationAck *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__notification_ack__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__notification_ack__pack_to_buffer ++ (const Sr__NotificationAck *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__notification_ack__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__NotificationAck * ++ sr__notification_ack__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__NotificationAck *) ++ protobuf_c_message_unpack (&sr__notification_ack__descriptor, ++ allocator, len, data); ++} ++void sr__notification_ack__free_unpacked ++ (Sr__NotificationAck *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__notification_ack__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__internal_request__init ++ (Sr__InternalRequest *message) ++{ ++ static Sr__InternalRequest init_value = SR__INTERNAL_REQUEST__INIT; ++ *message = init_value; ++} ++size_t sr__internal_request__get_packed_size ++ (const Sr__InternalRequest *message) ++{ ++ assert(message->base.descriptor == &sr__internal_request__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__internal_request__pack ++ (const Sr__InternalRequest *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__internal_request__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__internal_request__pack_to_buffer ++ (const Sr__InternalRequest *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__internal_request__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__InternalRequest * ++ sr__internal_request__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__InternalRequest *) ++ protobuf_c_message_unpack (&sr__internal_request__descriptor, ++ allocator, len, data); ++} ++void sr__internal_request__free_unpacked ++ (Sr__InternalRequest *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__internal_request__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++void sr__msg__init ++ (Sr__Msg *message) ++{ ++ static Sr__Msg init_value = SR__MSG__INIT; ++ *message = init_value; ++} ++size_t sr__msg__get_packed_size ++ (const Sr__Msg *message) ++{ ++ assert(message->base.descriptor == &sr__msg__descriptor); ++ return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message)); ++} ++size_t sr__msg__pack ++ (const Sr__Msg *message, ++ uint8_t *out) ++{ ++ assert(message->base.descriptor == &sr__msg__descriptor); ++ return protobuf_c_message_pack ((const ProtobufCMessage*)message, out); ++} ++size_t sr__msg__pack_to_buffer ++ (const Sr__Msg *message, ++ ProtobufCBuffer *buffer) ++{ ++ assert(message->base.descriptor == &sr__msg__descriptor); ++ return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer); ++} ++Sr__Msg * ++ sr__msg__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data) ++{ ++ return (Sr__Msg *) ++ protobuf_c_message_unpack (&sr__msg__descriptor, ++ allocator, len, data); ++} ++void sr__msg__free_unpacked ++ (Sr__Msg *message, ++ ProtobufCAllocator *allocator) ++{ ++ assert(message->base.descriptor == &sr__msg__descriptor); ++ protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator); ++} ++static const ProtobufCEnumValue sr__value__types__enum_values_by_number[22] = ++{ ++ { "LIST", "SR__VALUE__TYPES__LIST", 1 }, ++ { "CONTAINER", "SR__VALUE__TYPES__CONTAINER", 2 }, ++ { "CONTAINER_PRESENCE", "SR__VALUE__TYPES__CONTAINER_PRESENCE", 3 }, ++ { "LEAF_EMPTY", "SR__VALUE__TYPES__LEAF_EMPTY", 4 }, ++ { "BINARY", "SR__VALUE__TYPES__BINARY", 10 }, ++ { "BITS", "SR__VALUE__TYPES__BITS", 11 }, ++ { "BOOL", "SR__VALUE__TYPES__BOOL", 12 }, ++ { "DECIMAL64", "SR__VALUE__TYPES__DECIMAL64", 13 }, ++ { "ENUM", "SR__VALUE__TYPES__ENUM", 14 }, ++ { "IDENTITYREF", "SR__VALUE__TYPES__IDENTITYREF", 15 }, ++ { "INSTANCEID", "SR__VALUE__TYPES__INSTANCEID", 16 }, ++ { "INT8", "SR__VALUE__TYPES__INT8", 17 }, ++ { "INT16", "SR__VALUE__TYPES__INT16", 18 }, ++ { "INT32", "SR__VALUE__TYPES__INT32", 19 }, ++ { "INT64", "SR__VALUE__TYPES__INT64", 20 }, ++ { "STRING", "SR__VALUE__TYPES__STRING", 21 }, ++ { "UINT8", "SR__VALUE__TYPES__UINT8", 22 }, ++ { "UINT16", "SR__VALUE__TYPES__UINT16", 23 }, ++ { "UINT32", "SR__VALUE__TYPES__UINT32", 24 }, ++ { "UINT64", "SR__VALUE__TYPES__UINT64", 25 }, ++ { "ANYXML", "SR__VALUE__TYPES__ANYXML", 26 }, ++ { "ANYDATA", "SR__VALUE__TYPES__ANYDATA", 27 }, ++}; ++static const ProtobufCIntRange sr__value__types__value_ranges[] = { ++{1, 0},{10, 4},{0, 22} ++}; ++static const ProtobufCEnumValueIndex sr__value__types__enum_values_by_name[22] = ++{ ++ { "ANYDATA", 21 }, ++ { "ANYXML", 20 }, ++ { "BINARY", 4 }, ++ { "BITS", 5 }, ++ { "BOOL", 6 }, ++ { "CONTAINER", 1 }, ++ { "CONTAINER_PRESENCE", 2 }, ++ { "DECIMAL64", 7 }, ++ { "ENUM", 8 }, ++ { "IDENTITYREF", 9 }, ++ { "INSTANCEID", 10 }, ++ { "INT16", 12 }, ++ { "INT32", 13 }, ++ { "INT64", 14 }, ++ { "INT8", 11 }, ++ { "LEAF_EMPTY", 3 }, ++ { "LIST", 0 }, ++ { "STRING", 15 }, ++ { "UINT16", 17 }, ++ { "UINT32", 18 }, ++ { "UINT64", 19 }, ++ { "UINT8", 16 }, ++}; ++const ProtobufCEnumDescriptor sr__value__types__descriptor = ++{ ++ PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC, ++ "sr.Value.Types", ++ "Types", ++ "Sr__Value__Types", ++ "sr", ++ 22, ++ sr__value__types__enum_values_by_number, ++ 22, ++ sr__value__types__enum_values_by_name, ++ 2, ++ sr__value__types__value_ranges, ++ NULL,NULL,NULL,NULL /* reserved[1234] */ ++}; ++static const ProtobufCFieldDescriptor sr__value__field_descriptors[21] = ++{ ++ { ++ "xpath", ++ 1, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Value, xpath), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "type", ++ 2, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_ENUM, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Value, type), ++ &sr__value__types__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "dflt", ++ 3, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_BOOL, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Value, dflt), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "binary_val", ++ 10, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Value, binary_val), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "bits_val", ++ 11, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Value, bits_val), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "bool_val", ++ 12, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_BOOL, ++ offsetof(Sr__Value, has_bool_val), ++ offsetof(Sr__Value, bool_val), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "decimal64_val", ++ 13, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_DOUBLE, ++ offsetof(Sr__Value, has_decimal64_val), ++ offsetof(Sr__Value, decimal64_val), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "enum_val", ++ 14, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Value, enum_val), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "identityref_val", ++ 15, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Value, identityref_val), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "instanceid_val", ++ 16, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Value, instanceid_val), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "int8_val", ++ 17, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_INT32, ++ offsetof(Sr__Value, has_int8_val), ++ offsetof(Sr__Value, int8_val), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "int16_val", ++ 18, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_INT32, ++ offsetof(Sr__Value, has_int16_val), ++ offsetof(Sr__Value, int16_val), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "int32_val", ++ 19, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_INT32, ++ offsetof(Sr__Value, has_int32_val), ++ offsetof(Sr__Value, int32_val), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "int64_val", ++ 20, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_INT64, ++ offsetof(Sr__Value, has_int64_val), ++ offsetof(Sr__Value, int64_val), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "string_val", ++ 21, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Value, string_val), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "uint8_val", ++ 22, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_UINT32, ++ offsetof(Sr__Value, has_uint8_val), ++ offsetof(Sr__Value, uint8_val), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "uint16_val", ++ 23, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_UINT32, ++ offsetof(Sr__Value, has_uint16_val), ++ offsetof(Sr__Value, uint16_val), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "uint32_val", ++ 24, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_UINT32, ++ offsetof(Sr__Value, has_uint32_val), ++ offsetof(Sr__Value, uint32_val), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "uint64_val", ++ 25, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_UINT64, ++ offsetof(Sr__Value, has_uint64_val), ++ offsetof(Sr__Value, uint64_val), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "anyxml_val", ++ 26, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Value, anyxml_val), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "anydata_val", ++ 27, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Value, anydata_val), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__value__field_indices_by_name[] = { ++ 20, /* field[20] = anydata_val */ ++ 19, /* field[19] = anyxml_val */ ++ 3, /* field[3] = binary_val */ ++ 4, /* field[4] = bits_val */ ++ 5, /* field[5] = bool_val */ ++ 6, /* field[6] = decimal64_val */ ++ 2, /* field[2] = dflt */ ++ 7, /* field[7] = enum_val */ ++ 8, /* field[8] = identityref_val */ ++ 9, /* field[9] = instanceid_val */ ++ 11, /* field[11] = int16_val */ ++ 12, /* field[12] = int32_val */ ++ 13, /* field[13] = int64_val */ ++ 10, /* field[10] = int8_val */ ++ 14, /* field[14] = string_val */ ++ 1, /* field[1] = type */ ++ 16, /* field[16] = uint16_val */ ++ 17, /* field[17] = uint32_val */ ++ 18, /* field[18] = uint64_val */ ++ 15, /* field[15] = uint8_val */ ++ 0, /* field[0] = xpath */ ++}; ++static const ProtobufCIntRange sr__value__number_ranges[2 + 1] = ++{ ++ { 1, 0 }, ++ { 10, 3 }, ++ { 0, 21 } ++}; ++const ProtobufCMessageDescriptor sr__value__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.Value", ++ "Value", ++ "Sr__Value", ++ "sr", ++ sizeof(Sr__Value), ++ 21, ++ sr__value__field_descriptors, ++ sr__value__field_indices_by_name, ++ 2, sr__value__number_ranges, ++ (ProtobufCMessageInit) sr__value__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__node__field_descriptors[3] = ++{ ++ { ++ "value", ++ 1, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Node, value), ++ &sr__value__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "module_name", ++ 2, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Node, module_name), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "children", ++ 3, ++ PROTOBUF_C_LABEL_REPEATED, ++ PROTOBUF_C_TYPE_MESSAGE, ++ offsetof(Sr__Node, n_children), ++ offsetof(Sr__Node, children), ++ &sr__node__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__node__field_indices_by_name[] = { ++ 2, /* field[2] = children */ ++ 1, /* field[1] = module_name */ ++ 0, /* field[0] = value */ ++}; ++static const ProtobufCIntRange sr__node__number_ranges[1 + 1] = ++{ ++ { 1, 0 }, ++ { 0, 3 } ++}; ++const ProtobufCMessageDescriptor sr__node__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.Node", ++ "Node", ++ "Sr__Node", ++ "sr", ++ sizeof(Sr__Node), ++ 3, ++ sr__node__field_descriptors, ++ sr__node__field_indices_by_name, ++ 1, sr__node__number_ranges, ++ (ProtobufCMessageInit) sr__node__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__error__field_descriptors[2] = ++{ ++ { ++ "message", ++ 1, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Error, message), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "xpath", ++ 2, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Error, xpath), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__error__field_indices_by_name[] = { ++ 0, /* field[0] = message */ ++ 1, /* field[1] = xpath */ ++}; ++static const ProtobufCIntRange sr__error__number_ranges[1 + 1] = ++{ ++ { 1, 0 }, ++ { 0, 2 } ++}; ++const ProtobufCMessageDescriptor sr__error__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.Error", ++ "Error", ++ "Sr__Error", ++ "sr", ++ sizeof(Sr__Error), ++ 2, ++ sr__error__field_descriptors, ++ sr__error__field_indices_by_name, ++ 1, sr__error__number_ranges, ++ (ProtobufCMessageInit) sr__error__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__session_start_req__field_descriptors[4] = ++{ ++ { ++ "datastore", ++ 1, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_ENUM, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__SessionStartReq, datastore), ++ &sr__data_store__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "user_name", ++ 2, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__SessionStartReq, user_name), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "options", ++ 3, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_UINT32, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__SessionStartReq, options), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "commit_id", ++ 4, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_UINT32, ++ offsetof(Sr__SessionStartReq, has_commit_id), ++ offsetof(Sr__SessionStartReq, commit_id), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__session_start_req__field_indices_by_name[] = { ++ 3, /* field[3] = commit_id */ ++ 0, /* field[0] = datastore */ ++ 2, /* field[2] = options */ ++ 1, /* field[1] = user_name */ ++}; ++static const ProtobufCIntRange sr__session_start_req__number_ranges[1 + 1] = ++{ ++ { 1, 0 }, ++ { 0, 4 } ++}; ++const ProtobufCMessageDescriptor sr__session_start_req__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.SessionStartReq", ++ "SessionStartReq", ++ "Sr__SessionStartReq", ++ "sr", ++ sizeof(Sr__SessionStartReq), ++ 4, ++ sr__session_start_req__field_descriptors, ++ sr__session_start_req__field_indices_by_name, ++ 1, sr__session_start_req__number_ranges, ++ (ProtobufCMessageInit) sr__session_start_req__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__session_start_resp__field_descriptors[1] = ++{ ++ { ++ "session_id", ++ 1, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_UINT32, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__SessionStartResp, session_id), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__session_start_resp__field_indices_by_name[] = { ++ 0, /* field[0] = session_id */ ++}; ++static const ProtobufCIntRange sr__session_start_resp__number_ranges[1 + 1] = ++{ ++ { 1, 0 }, ++ { 0, 1 } ++}; ++const ProtobufCMessageDescriptor sr__session_start_resp__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.SessionStartResp", ++ "SessionStartResp", ++ "Sr__SessionStartResp", ++ "sr", ++ sizeof(Sr__SessionStartResp), ++ 1, ++ sr__session_start_resp__field_descriptors, ++ sr__session_start_resp__field_indices_by_name, ++ 1, sr__session_start_resp__number_ranges, ++ (ProtobufCMessageInit) sr__session_start_resp__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__session_stop_req__field_descriptors[1] = ++{ ++ { ++ "session_id", ++ 1, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_UINT32, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__SessionStopReq, session_id), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__session_stop_req__field_indices_by_name[] = { ++ 0, /* field[0] = session_id */ ++}; ++static const ProtobufCIntRange sr__session_stop_req__number_ranges[1 + 1] = ++{ ++ { 1, 0 }, ++ { 0, 1 } ++}; ++const ProtobufCMessageDescriptor sr__session_stop_req__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.SessionStopReq", ++ "SessionStopReq", ++ "Sr__SessionStopReq", ++ "sr", ++ sizeof(Sr__SessionStopReq), ++ 1, ++ sr__session_stop_req__field_descriptors, ++ sr__session_stop_req__field_indices_by_name, ++ 1, sr__session_stop_req__number_ranges, ++ (ProtobufCMessageInit) sr__session_stop_req__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__session_stop_resp__field_descriptors[1] = ++{ ++ { ++ "session_id", ++ 1, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_UINT32, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__SessionStopResp, session_id), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__session_stop_resp__field_indices_by_name[] = { ++ 0, /* field[0] = session_id */ ++}; ++static const ProtobufCIntRange sr__session_stop_resp__number_ranges[1 + 1] = ++{ ++ { 1, 0 }, ++ { 0, 1 } ++}; ++const ProtobufCMessageDescriptor sr__session_stop_resp__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.SessionStopResp", ++ "SessionStopResp", ++ "Sr__SessionStopResp", ++ "sr", ++ sizeof(Sr__SessionStopResp), ++ 1, ++ sr__session_stop_resp__field_descriptors, ++ sr__session_stop_resp__field_indices_by_name, ++ 1, sr__session_stop_resp__number_ranges, ++ (ProtobufCMessageInit) sr__session_stop_resp__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++#define sr__session_refresh_req__field_descriptors NULL ++#define sr__session_refresh_req__field_indices_by_name NULL ++#define sr__session_refresh_req__number_ranges NULL ++const ProtobufCMessageDescriptor sr__session_refresh_req__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.SessionRefreshReq", ++ "SessionRefreshReq", ++ "Sr__SessionRefreshReq", ++ "sr", ++ sizeof(Sr__SessionRefreshReq), ++ 0, ++ sr__session_refresh_req__field_descriptors, ++ sr__session_refresh_req__field_indices_by_name, ++ 0, sr__session_refresh_req__number_ranges, ++ (ProtobufCMessageInit) sr__session_refresh_req__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__session_refresh_resp__field_descriptors[1] = ++{ ++ { ++ "errors", ++ 1, ++ PROTOBUF_C_LABEL_REPEATED, ++ PROTOBUF_C_TYPE_MESSAGE, ++ offsetof(Sr__SessionRefreshResp, n_errors), ++ offsetof(Sr__SessionRefreshResp, errors), ++ &sr__error__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__session_refresh_resp__field_indices_by_name[] = { ++ 0, /* field[0] = errors */ ++}; ++static const ProtobufCIntRange sr__session_refresh_resp__number_ranges[1 + 1] = ++{ ++ { 1, 0 }, ++ { 0, 1 } ++}; ++const ProtobufCMessageDescriptor sr__session_refresh_resp__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.SessionRefreshResp", ++ "SessionRefreshResp", ++ "Sr__SessionRefreshResp", ++ "sr", ++ sizeof(Sr__SessionRefreshResp), ++ 1, ++ sr__session_refresh_resp__field_descriptors, ++ sr__session_refresh_resp__field_indices_by_name, ++ 1, sr__session_refresh_resp__number_ranges, ++ (ProtobufCMessageInit) sr__session_refresh_resp__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++#define sr__session_check_req__field_descriptors NULL ++#define sr__session_check_req__field_indices_by_name NULL ++#define sr__session_check_req__number_ranges NULL ++const ProtobufCMessageDescriptor sr__session_check_req__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.SessionCheckReq", ++ "SessionCheckReq", ++ "Sr__SessionCheckReq", ++ "sr", ++ sizeof(Sr__SessionCheckReq), ++ 0, ++ sr__session_check_req__field_descriptors, ++ sr__session_check_req__field_indices_by_name, ++ 0, sr__session_check_req__number_ranges, ++ (ProtobufCMessageInit) sr__session_check_req__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__session_check_resp__field_descriptors[1] = ++{ ++ { ++ "errors", ++ 1, ++ PROTOBUF_C_LABEL_REPEATED, ++ PROTOBUF_C_TYPE_MESSAGE, ++ offsetof(Sr__SessionCheckResp, n_errors), ++ offsetof(Sr__SessionCheckResp, errors), ++ &sr__error__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__session_check_resp__field_indices_by_name[] = { ++ 0, /* field[0] = errors */ ++}; ++static const ProtobufCIntRange sr__session_check_resp__number_ranges[1 + 1] = ++{ ++ { 1, 0 }, ++ { 0, 1 } ++}; ++const ProtobufCMessageDescriptor sr__session_check_resp__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.SessionCheckResp", ++ "SessionCheckResp", ++ "Sr__SessionCheckResp", ++ "sr", ++ sizeof(Sr__SessionCheckResp), ++ 1, ++ sr__session_check_resp__field_descriptors, ++ sr__session_check_resp__field_indices_by_name, ++ 1, sr__session_check_resp__number_ranges, ++ (ProtobufCMessageInit) sr__session_check_resp__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__session_switch_ds_req__field_descriptors[1] = ++{ ++ { ++ "datastore", ++ 1, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_ENUM, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__SessionSwitchDsReq, datastore), ++ &sr__data_store__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__session_switch_ds_req__field_indices_by_name[] = { ++ 0, /* field[0] = datastore */ ++}; ++static const ProtobufCIntRange sr__session_switch_ds_req__number_ranges[1 + 1] = ++{ ++ { 1, 0 }, ++ { 0, 1 } ++}; ++const ProtobufCMessageDescriptor sr__session_switch_ds_req__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.SessionSwitchDsReq", ++ "SessionSwitchDsReq", ++ "Sr__SessionSwitchDsReq", ++ "sr", ++ sizeof(Sr__SessionSwitchDsReq), ++ 1, ++ sr__session_switch_ds_req__field_descriptors, ++ sr__session_switch_ds_req__field_indices_by_name, ++ 1, sr__session_switch_ds_req__number_ranges, ++ (ProtobufCMessageInit) sr__session_switch_ds_req__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++#define sr__session_switch_ds_resp__field_descriptors NULL ++#define sr__session_switch_ds_resp__field_indices_by_name NULL ++#define sr__session_switch_ds_resp__number_ranges NULL ++const ProtobufCMessageDescriptor sr__session_switch_ds_resp__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.SessionSwitchDsResp", ++ "SessionSwitchDsResp", ++ "Sr__SessionSwitchDsResp", ++ "sr", ++ sizeof(Sr__SessionSwitchDsResp), ++ 0, ++ sr__session_switch_ds_resp__field_descriptors, ++ sr__session_switch_ds_resp__field_indices_by_name, ++ 0, sr__session_switch_ds_resp__number_ranges, ++ (ProtobufCMessageInit) sr__session_switch_ds_resp__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__session_set_opts_req__field_descriptors[1] = ++{ ++ { ++ "options", ++ 1, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_UINT32, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__SessionSetOptsReq, options), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__session_set_opts_req__field_indices_by_name[] = { ++ 0, /* field[0] = options */ ++}; ++static const ProtobufCIntRange sr__session_set_opts_req__number_ranges[1 + 1] = ++{ ++ { 1, 0 }, ++ { 0, 1 } ++}; ++const ProtobufCMessageDescriptor sr__session_set_opts_req__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.SessionSetOptsReq", ++ "SessionSetOptsReq", ++ "Sr__SessionSetOptsReq", ++ "sr", ++ sizeof(Sr__SessionSetOptsReq), ++ 1, ++ sr__session_set_opts_req__field_descriptors, ++ sr__session_set_opts_req__field_indices_by_name, ++ 1, sr__session_set_opts_req__number_ranges, ++ (ProtobufCMessageInit) sr__session_set_opts_req__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++#define sr__session_set_opts_resp__field_descriptors NULL ++#define sr__session_set_opts_resp__field_indices_by_name NULL ++#define sr__session_set_opts_resp__number_ranges NULL ++const ProtobufCMessageDescriptor sr__session_set_opts_resp__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.SessionSetOptsResp", ++ "SessionSetOptsResp", ++ "Sr__SessionSetOptsResp", ++ "sr", ++ sizeof(Sr__SessionSetOptsResp), ++ 0, ++ sr__session_set_opts_resp__field_descriptors, ++ sr__session_set_opts_resp__field_indices_by_name, ++ 0, sr__session_set_opts_resp__number_ranges, ++ (ProtobufCMessageInit) sr__session_set_opts_resp__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__version_verify_req__field_descriptors[1] = ++{ ++ { ++ "soname", ++ 1, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__VersionVerifyReq, soname), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__version_verify_req__field_indices_by_name[] = { ++ 0, /* field[0] = soname */ ++}; ++static const ProtobufCIntRange sr__version_verify_req__number_ranges[1 + 1] = ++{ ++ { 1, 0 }, ++ { 0, 1 } ++}; ++const ProtobufCMessageDescriptor sr__version_verify_req__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.VersionVerifyReq", ++ "VersionVerifyReq", ++ "Sr__VersionVerifyReq", ++ "sr", ++ sizeof(Sr__VersionVerifyReq), ++ 1, ++ sr__version_verify_req__field_descriptors, ++ sr__version_verify_req__field_indices_by_name, ++ 1, sr__version_verify_req__number_ranges, ++ (ProtobufCMessageInit) sr__version_verify_req__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__version_verify_resp__field_descriptors[1] = ++{ ++ { ++ "soname", ++ 1, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__VersionVerifyResp, soname), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__version_verify_resp__field_indices_by_name[] = { ++ 0, /* field[0] = soname */ ++}; ++static const ProtobufCIntRange sr__version_verify_resp__number_ranges[1 + 1] = ++{ ++ { 1, 0 }, ++ { 0, 1 } ++}; ++const ProtobufCMessageDescriptor sr__version_verify_resp__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.VersionVerifyResp", ++ "VersionVerifyResp", ++ "Sr__VersionVerifyResp", ++ "sr", ++ sizeof(Sr__VersionVerifyResp), ++ 1, ++ sr__version_verify_resp__field_descriptors, ++ sr__version_verify_resp__field_indices_by_name, ++ 1, sr__version_verify_resp__number_ranges, ++ (ProtobufCMessageInit) sr__version_verify_resp__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__schema_revision__field_descriptors[3] = ++{ ++ { ++ "revision", ++ 1, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__SchemaRevision, revision), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "file_path_yang", ++ 2, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__SchemaRevision, file_path_yang), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "file_path_yin", ++ 3, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__SchemaRevision, file_path_yin), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__schema_revision__field_indices_by_name[] = { ++ 1, /* field[1] = file_path_yang */ ++ 2, /* field[2] = file_path_yin */ ++ 0, /* field[0] = revision */ ++}; ++static const ProtobufCIntRange sr__schema_revision__number_ranges[1 + 1] = ++{ ++ { 1, 0 }, ++ { 0, 3 } ++}; ++const ProtobufCMessageDescriptor sr__schema_revision__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.SchemaRevision", ++ "SchemaRevision", ++ "Sr__SchemaRevision", ++ "sr", ++ sizeof(Sr__SchemaRevision), ++ 3, ++ sr__schema_revision__field_descriptors, ++ sr__schema_revision__field_indices_by_name, ++ 1, sr__schema_revision__number_ranges, ++ (ProtobufCMessageInit) sr__schema_revision__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__schema_submodule__field_descriptors[2] = ++{ ++ { ++ "submodule_name", ++ 1, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__SchemaSubmodule, submodule_name), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "revision", ++ 2, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__SchemaSubmodule, revision), ++ &sr__schema_revision__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__schema_submodule__field_indices_by_name[] = { ++ 1, /* field[1] = revision */ ++ 0, /* field[0] = submodule_name */ ++}; ++static const ProtobufCIntRange sr__schema_submodule__number_ranges[1 + 1] = ++{ ++ { 1, 0 }, ++ { 0, 2 } ++}; ++const ProtobufCMessageDescriptor sr__schema_submodule__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.SchemaSubmodule", ++ "SchemaSubmodule", ++ "Sr__SchemaSubmodule", ++ "sr", ++ sizeof(Sr__SchemaSubmodule), ++ 2, ++ sr__schema_submodule__field_descriptors, ++ sr__schema_submodule__field_indices_by_name, ++ 1, sr__schema_submodule__number_ranges, ++ (ProtobufCMessageInit) sr__schema_submodule__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__schema__field_descriptors[8] = ++{ ++ { ++ "module_name", ++ 1, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Schema, module_name), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "ns", ++ 2, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Schema, ns), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "prefix", ++ 3, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Schema, prefix), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "installed", ++ 4, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_BOOL, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Schema, installed), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "implemented", ++ 5, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_BOOL, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Schema, implemented), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "revision", ++ 6, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Schema, revision), ++ &sr__schema_revision__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "submodules", ++ 7, ++ PROTOBUF_C_LABEL_REPEATED, ++ PROTOBUF_C_TYPE_MESSAGE, ++ offsetof(Sr__Schema, n_submodules), ++ offsetof(Sr__Schema, submodules), ++ &sr__schema_submodule__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "enabled_features", ++ 8, ++ PROTOBUF_C_LABEL_REPEATED, ++ PROTOBUF_C_TYPE_STRING, ++ offsetof(Sr__Schema, n_enabled_features), ++ offsetof(Sr__Schema, enabled_features), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__schema__field_indices_by_name[] = { ++ 7, /* field[7] = enabled_features */ ++ 4, /* field[4] = implemented */ ++ 3, /* field[3] = installed */ ++ 0, /* field[0] = module_name */ ++ 1, /* field[1] = ns */ ++ 2, /* field[2] = prefix */ ++ 5, /* field[5] = revision */ ++ 6, /* field[6] = submodules */ ++}; ++static const ProtobufCIntRange sr__schema__number_ranges[1 + 1] = ++{ ++ { 1, 0 }, ++ { 0, 8 } ++}; ++const ProtobufCMessageDescriptor sr__schema__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.Schema", ++ "Schema", ++ "Sr__Schema", ++ "sr", ++ sizeof(Sr__Schema), ++ 8, ++ sr__schema__field_descriptors, ++ sr__schema__field_indices_by_name, ++ 1, sr__schema__number_ranges, ++ (ProtobufCMessageInit) sr__schema__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++#define sr__list_schemas_req__field_descriptors NULL ++#define sr__list_schemas_req__field_indices_by_name NULL ++#define sr__list_schemas_req__number_ranges NULL ++const ProtobufCMessageDescriptor sr__list_schemas_req__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.ListSchemasReq", ++ "ListSchemasReq", ++ "Sr__ListSchemasReq", ++ "sr", ++ sizeof(Sr__ListSchemasReq), ++ 0, ++ sr__list_schemas_req__field_descriptors, ++ sr__list_schemas_req__field_indices_by_name, ++ 0, sr__list_schemas_req__number_ranges, ++ (ProtobufCMessageInit) sr__list_schemas_req__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__list_schemas_resp__field_descriptors[1] = ++{ ++ { ++ "schemas", ++ 1, ++ PROTOBUF_C_LABEL_REPEATED, ++ PROTOBUF_C_TYPE_MESSAGE, ++ offsetof(Sr__ListSchemasResp, n_schemas), ++ offsetof(Sr__ListSchemasResp, schemas), ++ &sr__schema__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__list_schemas_resp__field_indices_by_name[] = { ++ 0, /* field[0] = schemas */ ++}; ++static const ProtobufCIntRange sr__list_schemas_resp__number_ranges[1 + 1] = ++{ ++ { 1, 0 }, ++ { 0, 1 } ++}; ++const ProtobufCMessageDescriptor sr__list_schemas_resp__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.ListSchemasResp", ++ "ListSchemasResp", ++ "Sr__ListSchemasResp", ++ "sr", ++ sizeof(Sr__ListSchemasResp), ++ 1, ++ sr__list_schemas_resp__field_descriptors, ++ sr__list_schemas_resp__field_indices_by_name, ++ 1, sr__list_schemas_resp__number_ranges, ++ (ProtobufCMessageInit) sr__list_schemas_resp__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__get_schema_req__field_descriptors[5] = ++{ ++ { ++ "module_name", ++ 1, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__GetSchemaReq, module_name), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "revision", ++ 2, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__GetSchemaReq, revision), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "submodule_name", ++ 3, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__GetSchemaReq, submodule_name), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "submodule_revision", ++ 4, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__GetSchemaReq, submodule_revision), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "yang_format", ++ 5, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_BOOL, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__GetSchemaReq, yang_format), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__get_schema_req__field_indices_by_name[] = { ++ 0, /* field[0] = module_name */ ++ 1, /* field[1] = revision */ ++ 2, /* field[2] = submodule_name */ ++ 3, /* field[3] = submodule_revision */ ++ 4, /* field[4] = yang_format */ ++}; ++static const ProtobufCIntRange sr__get_schema_req__number_ranges[1 + 1] = ++{ ++ { 1, 0 }, ++ { 0, 5 } ++}; ++const ProtobufCMessageDescriptor sr__get_schema_req__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.GetSchemaReq", ++ "GetSchemaReq", ++ "Sr__GetSchemaReq", ++ "sr", ++ sizeof(Sr__GetSchemaReq), ++ 5, ++ sr__get_schema_req__field_descriptors, ++ sr__get_schema_req__field_indices_by_name, ++ 1, sr__get_schema_req__number_ranges, ++ (ProtobufCMessageInit) sr__get_schema_req__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__get_schema_resp__field_descriptors[1] = ++{ ++ { ++ "schema_content", ++ 1, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__GetSchemaResp, schema_content), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__get_schema_resp__field_indices_by_name[] = { ++ 0, /* field[0] = schema_content */ ++}; ++static const ProtobufCIntRange sr__get_schema_resp__number_ranges[1 + 1] = ++{ ++ { 1, 0 }, ++ { 0, 1 } ++}; ++const ProtobufCMessageDescriptor sr__get_schema_resp__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.GetSchemaResp", ++ "GetSchemaResp", ++ "Sr__GetSchemaResp", ++ "sr", ++ sizeof(Sr__GetSchemaResp), ++ 1, ++ sr__get_schema_resp__field_descriptors, ++ sr__get_schema_resp__field_indices_by_name, ++ 1, sr__get_schema_resp__number_ranges, ++ (ProtobufCMessageInit) sr__get_schema_resp__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__get_item_req__field_descriptors[1] = ++{ ++ { ++ "xpath", ++ 1, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__GetItemReq, xpath), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__get_item_req__field_indices_by_name[] = { ++ 0, /* field[0] = xpath */ ++}; ++static const ProtobufCIntRange sr__get_item_req__number_ranges[1 + 1] = ++{ ++ { 1, 0 }, ++ { 0, 1 } ++}; ++const ProtobufCMessageDescriptor sr__get_item_req__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.GetItemReq", ++ "GetItemReq", ++ "Sr__GetItemReq", ++ "sr", ++ sizeof(Sr__GetItemReq), ++ 1, ++ sr__get_item_req__field_descriptors, ++ sr__get_item_req__field_indices_by_name, ++ 1, sr__get_item_req__number_ranges, ++ (ProtobufCMessageInit) sr__get_item_req__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__get_item_resp__field_descriptors[1] = ++{ ++ { ++ "value", ++ 1, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__GetItemResp, value), ++ &sr__value__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__get_item_resp__field_indices_by_name[] = { ++ 0, /* field[0] = value */ ++}; ++static const ProtobufCIntRange sr__get_item_resp__number_ranges[1 + 1] = ++{ ++ { 1, 0 }, ++ { 0, 1 } ++}; ++const ProtobufCMessageDescriptor sr__get_item_resp__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.GetItemResp", ++ "GetItemResp", ++ "Sr__GetItemResp", ++ "sr", ++ sizeof(Sr__GetItemResp), ++ 1, ++ sr__get_item_resp__field_descriptors, ++ sr__get_item_resp__field_indices_by_name, ++ 1, sr__get_item_resp__number_ranges, ++ (ProtobufCMessageInit) sr__get_item_resp__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__get_items_req__field_descriptors[3] = ++{ ++ { ++ "xpath", ++ 1, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__GetItemsReq, xpath), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "limit", ++ 2, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_UINT32, ++ offsetof(Sr__GetItemsReq, has_limit), ++ offsetof(Sr__GetItemsReq, limit), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "offset", ++ 3, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_UINT32, ++ offsetof(Sr__GetItemsReq, has_offset), ++ offsetof(Sr__GetItemsReq, offset), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__get_items_req__field_indices_by_name[] = { ++ 1, /* field[1] = limit */ ++ 2, /* field[2] = offset */ ++ 0, /* field[0] = xpath */ ++}; ++static const ProtobufCIntRange sr__get_items_req__number_ranges[1 + 1] = ++{ ++ { 1, 0 }, ++ { 0, 3 } ++}; ++const ProtobufCMessageDescriptor sr__get_items_req__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.GetItemsReq", ++ "GetItemsReq", ++ "Sr__GetItemsReq", ++ "sr", ++ sizeof(Sr__GetItemsReq), ++ 3, ++ sr__get_items_req__field_descriptors, ++ sr__get_items_req__field_indices_by_name, ++ 1, sr__get_items_req__number_ranges, ++ (ProtobufCMessageInit) sr__get_items_req__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__get_items_resp__field_descriptors[1] = ++{ ++ { ++ "values", ++ 1, ++ PROTOBUF_C_LABEL_REPEATED, ++ PROTOBUF_C_TYPE_MESSAGE, ++ offsetof(Sr__GetItemsResp, n_values), ++ offsetof(Sr__GetItemsResp, values), ++ &sr__value__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__get_items_resp__field_indices_by_name[] = { ++ 0, /* field[0] = values */ ++}; ++static const ProtobufCIntRange sr__get_items_resp__number_ranges[1 + 1] = ++{ ++ { 1, 0 }, ++ { 0, 1 } ++}; ++const ProtobufCMessageDescriptor sr__get_items_resp__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.GetItemsResp", ++ "GetItemsResp", ++ "Sr__GetItemsResp", ++ "sr", ++ sizeof(Sr__GetItemsResp), ++ 1, ++ sr__get_items_resp__field_descriptors, ++ sr__get_items_resp__field_indices_by_name, ++ 1, sr__get_items_resp__number_ranges, ++ (ProtobufCMessageInit) sr__get_items_resp__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__get_subtree_req__field_descriptors[1] = ++{ ++ { ++ "xpath", ++ 1, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__GetSubtreeReq, xpath), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__get_subtree_req__field_indices_by_name[] = { ++ 0, /* field[0] = xpath */ ++}; ++static const ProtobufCIntRange sr__get_subtree_req__number_ranges[1 + 1] = ++{ ++ { 1, 0 }, ++ { 0, 1 } ++}; ++const ProtobufCMessageDescriptor sr__get_subtree_req__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.GetSubtreeReq", ++ "GetSubtreeReq", ++ "Sr__GetSubtreeReq", ++ "sr", ++ sizeof(Sr__GetSubtreeReq), ++ 1, ++ sr__get_subtree_req__field_descriptors, ++ sr__get_subtree_req__field_indices_by_name, ++ 1, sr__get_subtree_req__number_ranges, ++ (ProtobufCMessageInit) sr__get_subtree_req__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__get_subtree_resp__field_descriptors[1] = ++{ ++ { ++ "tree", ++ 1, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__GetSubtreeResp, tree), ++ &sr__node__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__get_subtree_resp__field_indices_by_name[] = { ++ 0, /* field[0] = tree */ ++}; ++static const ProtobufCIntRange sr__get_subtree_resp__number_ranges[1 + 1] = ++{ ++ { 1, 0 }, ++ { 0, 1 } ++}; ++const ProtobufCMessageDescriptor sr__get_subtree_resp__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.GetSubtreeResp", ++ "GetSubtreeResp", ++ "Sr__GetSubtreeResp", ++ "sr", ++ sizeof(Sr__GetSubtreeResp), ++ 1, ++ sr__get_subtree_resp__field_descriptors, ++ sr__get_subtree_resp__field_indices_by_name, ++ 1, sr__get_subtree_resp__number_ranges, ++ (ProtobufCMessageInit) sr__get_subtree_resp__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__get_subtrees_req__field_descriptors[1] = ++{ ++ { ++ "xpath", ++ 1, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__GetSubtreesReq, xpath), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__get_subtrees_req__field_indices_by_name[] = { ++ 0, /* field[0] = xpath */ ++}; ++static const ProtobufCIntRange sr__get_subtrees_req__number_ranges[1 + 1] = ++{ ++ { 1, 0 }, ++ { 0, 1 } ++}; ++const ProtobufCMessageDescriptor sr__get_subtrees_req__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.GetSubtreesReq", ++ "GetSubtreesReq", ++ "Sr__GetSubtreesReq", ++ "sr", ++ sizeof(Sr__GetSubtreesReq), ++ 1, ++ sr__get_subtrees_req__field_descriptors, ++ sr__get_subtrees_req__field_indices_by_name, ++ 1, sr__get_subtrees_req__number_ranges, ++ (ProtobufCMessageInit) sr__get_subtrees_req__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__get_subtrees_resp__field_descriptors[1] = ++{ ++ { ++ "trees", ++ 1, ++ PROTOBUF_C_LABEL_REPEATED, ++ PROTOBUF_C_TYPE_MESSAGE, ++ offsetof(Sr__GetSubtreesResp, n_trees), ++ offsetof(Sr__GetSubtreesResp, trees), ++ &sr__node__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__get_subtrees_resp__field_indices_by_name[] = { ++ 0, /* field[0] = trees */ ++}; ++static const ProtobufCIntRange sr__get_subtrees_resp__number_ranges[1 + 1] = ++{ ++ { 1, 0 }, ++ { 0, 1 } ++}; ++const ProtobufCMessageDescriptor sr__get_subtrees_resp__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.GetSubtreesResp", ++ "GetSubtreesResp", ++ "Sr__GetSubtreesResp", ++ "sr", ++ sizeof(Sr__GetSubtreesResp), ++ 1, ++ sr__get_subtrees_resp__field_descriptors, ++ sr__get_subtrees_resp__field_indices_by_name, ++ 1, sr__get_subtrees_resp__number_ranges, ++ (ProtobufCMessageInit) sr__get_subtrees_resp__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__get_subtree_chunk_req__field_descriptors[6] = ++{ ++ { ++ "xpath", ++ 1, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__GetSubtreeChunkReq, xpath), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "single", ++ 2, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_BOOL, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__GetSubtreeChunkReq, single), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "slice_offset", ++ 3, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_UINT32, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__GetSubtreeChunkReq, slice_offset), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "slice_width", ++ 4, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_UINT32, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__GetSubtreeChunkReq, slice_width), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "child_limit", ++ 5, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_UINT32, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__GetSubtreeChunkReq, child_limit), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "depth_limit", ++ 6, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_UINT32, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__GetSubtreeChunkReq, depth_limit), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__get_subtree_chunk_req__field_indices_by_name[] = { ++ 4, /* field[4] = child_limit */ ++ 5, /* field[5] = depth_limit */ ++ 1, /* field[1] = single */ ++ 2, /* field[2] = slice_offset */ ++ 3, /* field[3] = slice_width */ ++ 0, /* field[0] = xpath */ ++}; ++static const ProtobufCIntRange sr__get_subtree_chunk_req__number_ranges[1 + 1] = ++{ ++ { 1, 0 }, ++ { 0, 6 } ++}; ++const ProtobufCMessageDescriptor sr__get_subtree_chunk_req__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.GetSubtreeChunkReq", ++ "GetSubtreeChunkReq", ++ "Sr__GetSubtreeChunkReq", ++ "sr", ++ sizeof(Sr__GetSubtreeChunkReq), ++ 6, ++ sr__get_subtree_chunk_req__field_descriptors, ++ sr__get_subtree_chunk_req__field_indices_by_name, ++ 1, sr__get_subtree_chunk_req__number_ranges, ++ (ProtobufCMessageInit) sr__get_subtree_chunk_req__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__get_subtree_chunk_resp__field_descriptors[2] = ++{ ++ { ++ "xpath", ++ 1, ++ PROTOBUF_C_LABEL_REPEATED, ++ PROTOBUF_C_TYPE_STRING, ++ offsetof(Sr__GetSubtreeChunkResp, n_xpath), ++ offsetof(Sr__GetSubtreeChunkResp, xpath), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "chunk", ++ 2, ++ PROTOBUF_C_LABEL_REPEATED, ++ PROTOBUF_C_TYPE_MESSAGE, ++ offsetof(Sr__GetSubtreeChunkResp, n_chunk), ++ offsetof(Sr__GetSubtreeChunkResp, chunk), ++ &sr__node__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__get_subtree_chunk_resp__field_indices_by_name[] = { ++ 1, /* field[1] = chunk */ ++ 0, /* field[0] = xpath */ ++}; ++static const ProtobufCIntRange sr__get_subtree_chunk_resp__number_ranges[1 + 1] = ++{ ++ { 1, 0 }, ++ { 0, 2 } ++}; ++const ProtobufCMessageDescriptor sr__get_subtree_chunk_resp__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.GetSubtreeChunkResp", ++ "GetSubtreeChunkResp", ++ "Sr__GetSubtreeChunkResp", ++ "sr", ++ sizeof(Sr__GetSubtreeChunkResp), ++ 2, ++ sr__get_subtree_chunk_resp__field_descriptors, ++ sr__get_subtree_chunk_resp__field_indices_by_name, ++ 1, sr__get_subtree_chunk_resp__number_ranges, ++ (ProtobufCMessageInit) sr__get_subtree_chunk_resp__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__set_item_req__field_descriptors[3] = ++{ ++ { ++ "xpath", ++ 1, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__SetItemReq, xpath), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "value", ++ 2, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__SetItemReq, value), ++ &sr__value__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "options", ++ 3, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_UINT32, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__SetItemReq, options), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__set_item_req__field_indices_by_name[] = { ++ 2, /* field[2] = options */ ++ 1, /* field[1] = value */ ++ 0, /* field[0] = xpath */ ++}; ++static const ProtobufCIntRange sr__set_item_req__number_ranges[1 + 1] = ++{ ++ { 1, 0 }, ++ { 0, 3 } ++}; ++const ProtobufCMessageDescriptor sr__set_item_req__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.SetItemReq", ++ "SetItemReq", ++ "Sr__SetItemReq", ++ "sr", ++ sizeof(Sr__SetItemReq), ++ 3, ++ sr__set_item_req__field_descriptors, ++ sr__set_item_req__field_indices_by_name, ++ 1, sr__set_item_req__number_ranges, ++ (ProtobufCMessageInit) sr__set_item_req__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++#define sr__set_item_resp__field_descriptors NULL ++#define sr__set_item_resp__field_indices_by_name NULL ++#define sr__set_item_resp__number_ranges NULL ++const ProtobufCMessageDescriptor sr__set_item_resp__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.SetItemResp", ++ "SetItemResp", ++ "Sr__SetItemResp", ++ "sr", ++ sizeof(Sr__SetItemResp), ++ 0, ++ sr__set_item_resp__field_descriptors, ++ sr__set_item_resp__field_indices_by_name, ++ 0, sr__set_item_resp__number_ranges, ++ (ProtobufCMessageInit) sr__set_item_resp__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__set_item_str_req__field_descriptors[3] = ++{ ++ { ++ "xpath", ++ 1, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__SetItemStrReq, xpath), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "value", ++ 2, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__SetItemStrReq, value), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "options", ++ 3, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_UINT32, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__SetItemStrReq, options), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__set_item_str_req__field_indices_by_name[] = { ++ 2, /* field[2] = options */ ++ 1, /* field[1] = value */ ++ 0, /* field[0] = xpath */ ++}; ++static const ProtobufCIntRange sr__set_item_str_req__number_ranges[1 + 1] = ++{ ++ { 1, 0 }, ++ { 0, 3 } ++}; ++const ProtobufCMessageDescriptor sr__set_item_str_req__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.SetItemStrReq", ++ "SetItemStrReq", ++ "Sr__SetItemStrReq", ++ "sr", ++ sizeof(Sr__SetItemStrReq), ++ 3, ++ sr__set_item_str_req__field_descriptors, ++ sr__set_item_str_req__field_indices_by_name, ++ 1, sr__set_item_str_req__number_ranges, ++ (ProtobufCMessageInit) sr__set_item_str_req__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++#define sr__set_item_str_resp__field_descriptors NULL ++#define sr__set_item_str_resp__field_indices_by_name NULL ++#define sr__set_item_str_resp__number_ranges NULL ++const ProtobufCMessageDescriptor sr__set_item_str_resp__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.SetItemStrResp", ++ "SetItemStrResp", ++ "Sr__SetItemStrResp", ++ "sr", ++ sizeof(Sr__SetItemStrResp), ++ 0, ++ sr__set_item_str_resp__field_descriptors, ++ sr__set_item_str_resp__field_indices_by_name, ++ 0, sr__set_item_str_resp__number_ranges, ++ (ProtobufCMessageInit) sr__set_item_str_resp__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__delete_item_req__field_descriptors[2] = ++{ ++ { ++ "xpath", ++ 1, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__DeleteItemReq, xpath), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "options", ++ 3, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_UINT32, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__DeleteItemReq, options), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__delete_item_req__field_indices_by_name[] = { ++ 1, /* field[1] = options */ ++ 0, /* field[0] = xpath */ ++}; ++static const ProtobufCIntRange sr__delete_item_req__number_ranges[2 + 1] = ++{ ++ { 1, 0 }, ++ { 3, 1 }, ++ { 0, 2 } ++}; ++const ProtobufCMessageDescriptor sr__delete_item_req__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.DeleteItemReq", ++ "DeleteItemReq", ++ "Sr__DeleteItemReq", ++ "sr", ++ sizeof(Sr__DeleteItemReq), ++ 2, ++ sr__delete_item_req__field_descriptors, ++ sr__delete_item_req__field_indices_by_name, ++ 2, sr__delete_item_req__number_ranges, ++ (ProtobufCMessageInit) sr__delete_item_req__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++#define sr__delete_item_resp__field_descriptors NULL ++#define sr__delete_item_resp__field_indices_by_name NULL ++#define sr__delete_item_resp__number_ranges NULL ++const ProtobufCMessageDescriptor sr__delete_item_resp__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.DeleteItemResp", ++ "DeleteItemResp", ++ "Sr__DeleteItemResp", ++ "sr", ++ sizeof(Sr__DeleteItemResp), ++ 0, ++ sr__delete_item_resp__field_descriptors, ++ sr__delete_item_resp__field_indices_by_name, ++ 0, sr__delete_item_resp__number_ranges, ++ (ProtobufCMessageInit) sr__delete_item_resp__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCEnumValue sr__move_item_req__move_position__enum_values_by_number[4] = ++{ ++ { "BEFORE", "SR__MOVE_ITEM_REQ__MOVE_POSITION__BEFORE", 1 }, ++ { "AFTER", "SR__MOVE_ITEM_REQ__MOVE_POSITION__AFTER", 2 }, ++ { "FIRST", "SR__MOVE_ITEM_REQ__MOVE_POSITION__FIRST", 3 }, ++ { "LAST", "SR__MOVE_ITEM_REQ__MOVE_POSITION__LAST", 4 }, ++}; ++static const ProtobufCIntRange sr__move_item_req__move_position__value_ranges[] = { ++{1, 0},{0, 4} ++}; ++static const ProtobufCEnumValueIndex sr__move_item_req__move_position__enum_values_by_name[4] = ++{ ++ { "AFTER", 1 }, ++ { "BEFORE", 0 }, ++ { "FIRST", 2 }, ++ { "LAST", 3 }, ++}; ++const ProtobufCEnumDescriptor sr__move_item_req__move_position__descriptor = ++{ ++ PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC, ++ "sr.MoveItemReq.MovePosition", ++ "MovePosition", ++ "Sr__MoveItemReq__MovePosition", ++ "sr", ++ 4, ++ sr__move_item_req__move_position__enum_values_by_number, ++ 4, ++ sr__move_item_req__move_position__enum_values_by_name, ++ 1, ++ sr__move_item_req__move_position__value_ranges, ++ NULL,NULL,NULL,NULL /* reserved[1234] */ ++}; ++static const ProtobufCFieldDescriptor sr__move_item_req__field_descriptors[3] = ++{ ++ { ++ "xpath", ++ 1, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__MoveItemReq, xpath), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "position", ++ 2, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_ENUM, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__MoveItemReq, position), ++ &sr__move_item_req__move_position__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "relative_item", ++ 3, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__MoveItemReq, relative_item), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__move_item_req__field_indices_by_name[] = { ++ 1, /* field[1] = position */ ++ 2, /* field[2] = relative_item */ ++ 0, /* field[0] = xpath */ ++}; ++static const ProtobufCIntRange sr__move_item_req__number_ranges[1 + 1] = ++{ ++ { 1, 0 }, ++ { 0, 3 } ++}; ++const ProtobufCMessageDescriptor sr__move_item_req__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.MoveItemReq", ++ "MoveItemReq", ++ "Sr__MoveItemReq", ++ "sr", ++ sizeof(Sr__MoveItemReq), ++ 3, ++ sr__move_item_req__field_descriptors, ++ sr__move_item_req__field_indices_by_name, ++ 1, sr__move_item_req__number_ranges, ++ (ProtobufCMessageInit) sr__move_item_req__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++#define sr__move_item_resp__field_descriptors NULL ++#define sr__move_item_resp__field_indices_by_name NULL ++#define sr__move_item_resp__number_ranges NULL ++const ProtobufCMessageDescriptor sr__move_item_resp__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.MoveItemResp", ++ "MoveItemResp", ++ "Sr__MoveItemResp", ++ "sr", ++ sizeof(Sr__MoveItemResp), ++ 0, ++ sr__move_item_resp__field_descriptors, ++ sr__move_item_resp__field_indices_by_name, ++ 0, sr__move_item_resp__number_ranges, ++ (ProtobufCMessageInit) sr__move_item_resp__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++#define sr__validate_req__field_descriptors NULL ++#define sr__validate_req__field_indices_by_name NULL ++#define sr__validate_req__number_ranges NULL ++const ProtobufCMessageDescriptor sr__validate_req__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.ValidateReq", ++ "ValidateReq", ++ "Sr__ValidateReq", ++ "sr", ++ sizeof(Sr__ValidateReq), ++ 0, ++ sr__validate_req__field_descriptors, ++ sr__validate_req__field_indices_by_name, ++ 0, sr__validate_req__number_ranges, ++ (ProtobufCMessageInit) sr__validate_req__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__validate_resp__field_descriptors[1] = ++{ ++ { ++ "errors", ++ 1, ++ PROTOBUF_C_LABEL_REPEATED, ++ PROTOBUF_C_TYPE_MESSAGE, ++ offsetof(Sr__ValidateResp, n_errors), ++ offsetof(Sr__ValidateResp, errors), ++ &sr__error__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__validate_resp__field_indices_by_name[] = { ++ 0, /* field[0] = errors */ ++}; ++static const ProtobufCIntRange sr__validate_resp__number_ranges[1 + 1] = ++{ ++ { 1, 0 }, ++ { 0, 1 } ++}; ++const ProtobufCMessageDescriptor sr__validate_resp__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.ValidateResp", ++ "ValidateResp", ++ "Sr__ValidateResp", ++ "sr", ++ sizeof(Sr__ValidateResp), ++ 1, ++ sr__validate_resp__field_descriptors, ++ sr__validate_resp__field_indices_by_name, ++ 1, sr__validate_resp__number_ranges, ++ (ProtobufCMessageInit) sr__validate_resp__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++#define sr__commit_req__field_descriptors NULL ++#define sr__commit_req__field_indices_by_name NULL ++#define sr__commit_req__number_ranges NULL ++const ProtobufCMessageDescriptor sr__commit_req__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.CommitReq", ++ "CommitReq", ++ "Sr__CommitReq", ++ "sr", ++ sizeof(Sr__CommitReq), ++ 0, ++ sr__commit_req__field_descriptors, ++ sr__commit_req__field_indices_by_name, ++ 0, sr__commit_req__number_ranges, ++ (ProtobufCMessageInit) sr__commit_req__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__commit_resp__field_descriptors[1] = ++{ ++ { ++ "errors", ++ 1, ++ PROTOBUF_C_LABEL_REPEATED, ++ PROTOBUF_C_TYPE_MESSAGE, ++ offsetof(Sr__CommitResp, n_errors), ++ offsetof(Sr__CommitResp, errors), ++ &sr__error__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__commit_resp__field_indices_by_name[] = { ++ 0, /* field[0] = errors */ ++}; ++static const ProtobufCIntRange sr__commit_resp__number_ranges[1 + 1] = ++{ ++ { 1, 0 }, ++ { 0, 1 } ++}; ++const ProtobufCMessageDescriptor sr__commit_resp__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.CommitResp", ++ "CommitResp", ++ "Sr__CommitResp", ++ "sr", ++ sizeof(Sr__CommitResp), ++ 1, ++ sr__commit_resp__field_descriptors, ++ sr__commit_resp__field_indices_by_name, ++ 1, sr__commit_resp__number_ranges, ++ (ProtobufCMessageInit) sr__commit_resp__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++#define sr__discard_changes_req__field_descriptors NULL ++#define sr__discard_changes_req__field_indices_by_name NULL ++#define sr__discard_changes_req__number_ranges NULL ++const ProtobufCMessageDescriptor sr__discard_changes_req__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.DiscardChangesReq", ++ "DiscardChangesReq", ++ "Sr__DiscardChangesReq", ++ "sr", ++ sizeof(Sr__DiscardChangesReq), ++ 0, ++ sr__discard_changes_req__field_descriptors, ++ sr__discard_changes_req__field_indices_by_name, ++ 0, sr__discard_changes_req__number_ranges, ++ (ProtobufCMessageInit) sr__discard_changes_req__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++#define sr__discard_changes_resp__field_descriptors NULL ++#define sr__discard_changes_resp__field_indices_by_name NULL ++#define sr__discard_changes_resp__number_ranges NULL ++const ProtobufCMessageDescriptor sr__discard_changes_resp__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.DiscardChangesResp", ++ "DiscardChangesResp", ++ "Sr__DiscardChangesResp", ++ "sr", ++ sizeof(Sr__DiscardChangesResp), ++ 0, ++ sr__discard_changes_resp__field_descriptors, ++ sr__discard_changes_resp__field_indices_by_name, ++ 0, sr__discard_changes_resp__number_ranges, ++ (ProtobufCMessageInit) sr__discard_changes_resp__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__copy_config_req__field_descriptors[3] = ++{ ++ { ++ "src_datastore", ++ 1, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_ENUM, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__CopyConfigReq, src_datastore), ++ &sr__data_store__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "dst_datastore", ++ 2, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_ENUM, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__CopyConfigReq, dst_datastore), ++ &sr__data_store__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "module_name", ++ 3, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__CopyConfigReq, module_name), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__copy_config_req__field_indices_by_name[] = { ++ 1, /* field[1] = dst_datastore */ ++ 2, /* field[2] = module_name */ ++ 0, /* field[0] = src_datastore */ ++}; ++static const ProtobufCIntRange sr__copy_config_req__number_ranges[1 + 1] = ++{ ++ { 1, 0 }, ++ { 0, 3 } ++}; ++const ProtobufCMessageDescriptor sr__copy_config_req__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.CopyConfigReq", ++ "CopyConfigReq", ++ "Sr__CopyConfigReq", ++ "sr", ++ sizeof(Sr__CopyConfigReq), ++ 3, ++ sr__copy_config_req__field_descriptors, ++ sr__copy_config_req__field_indices_by_name, ++ 1, sr__copy_config_req__number_ranges, ++ (ProtobufCMessageInit) sr__copy_config_req__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++#define sr__copy_config_resp__field_descriptors NULL ++#define sr__copy_config_resp__field_indices_by_name NULL ++#define sr__copy_config_resp__number_ranges NULL ++const ProtobufCMessageDescriptor sr__copy_config_resp__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.CopyConfigResp", ++ "CopyConfigResp", ++ "Sr__CopyConfigResp", ++ "sr", ++ sizeof(Sr__CopyConfigResp), ++ 0, ++ sr__copy_config_resp__field_descriptors, ++ sr__copy_config_resp__field_indices_by_name, ++ 0, sr__copy_config_resp__number_ranges, ++ (ProtobufCMessageInit) sr__copy_config_resp__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__lock_req__field_descriptors[1] = ++{ ++ { ++ "module_name", ++ 1, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__LockReq, module_name), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__lock_req__field_indices_by_name[] = { ++ 0, /* field[0] = module_name */ ++}; ++static const ProtobufCIntRange sr__lock_req__number_ranges[1 + 1] = ++{ ++ { 1, 0 }, ++ { 0, 1 } ++}; ++const ProtobufCMessageDescriptor sr__lock_req__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.LockReq", ++ "LockReq", ++ "Sr__LockReq", ++ "sr", ++ sizeof(Sr__LockReq), ++ 1, ++ sr__lock_req__field_descriptors, ++ sr__lock_req__field_indices_by_name, ++ 1, sr__lock_req__number_ranges, ++ (ProtobufCMessageInit) sr__lock_req__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++#define sr__lock_resp__field_descriptors NULL ++#define sr__lock_resp__field_indices_by_name NULL ++#define sr__lock_resp__number_ranges NULL ++const ProtobufCMessageDescriptor sr__lock_resp__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.LockResp", ++ "LockResp", ++ "Sr__LockResp", ++ "sr", ++ sizeof(Sr__LockResp), ++ 0, ++ sr__lock_resp__field_descriptors, ++ sr__lock_resp__field_indices_by_name, ++ 0, sr__lock_resp__number_ranges, ++ (ProtobufCMessageInit) sr__lock_resp__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__unlock_req__field_descriptors[1] = ++{ ++ { ++ "module_name", ++ 1, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__UnlockReq, module_name), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__unlock_req__field_indices_by_name[] = { ++ 0, /* field[0] = module_name */ ++}; ++static const ProtobufCIntRange sr__unlock_req__number_ranges[1 + 1] = ++{ ++ { 1, 0 }, ++ { 0, 1 } ++}; ++const ProtobufCMessageDescriptor sr__unlock_req__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.UnlockReq", ++ "UnlockReq", ++ "Sr__UnlockReq", ++ "sr", ++ sizeof(Sr__UnlockReq), ++ 1, ++ sr__unlock_req__field_descriptors, ++ sr__unlock_req__field_indices_by_name, ++ 1, sr__unlock_req__number_ranges, ++ (ProtobufCMessageInit) sr__unlock_req__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++#define sr__unlock_resp__field_descriptors NULL ++#define sr__unlock_resp__field_indices_by_name NULL ++#define sr__unlock_resp__number_ranges NULL ++const ProtobufCMessageDescriptor sr__unlock_resp__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.UnlockResp", ++ "UnlockResp", ++ "Sr__UnlockResp", ++ "sr", ++ sizeof(Sr__UnlockResp), ++ 0, ++ sr__unlock_resp__field_descriptors, ++ sr__unlock_resp__field_indices_by_name, ++ 0, sr__unlock_resp__number_ranges, ++ (ProtobufCMessageInit) sr__unlock_resp__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__subscribe_req__field_descriptors[10] = ++{ ++ { ++ "type", ++ 1, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_ENUM, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__SubscribeReq, type), ++ &sr__subscription_type__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "destination", ++ 2, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__SubscribeReq, destination), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "subscription_id", ++ 3, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_UINT32, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__SubscribeReq, subscription_id), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "module_name", ++ 4, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__SubscribeReq, module_name), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "xpath", ++ 5, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__SubscribeReq, xpath), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "notif_event", ++ 10, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_ENUM, ++ offsetof(Sr__SubscribeReq, has_notif_event), ++ offsetof(Sr__SubscribeReq, notif_event), ++ &sr__notification_event__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "priority", ++ 11, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_UINT32, ++ offsetof(Sr__SubscribeReq, has_priority), ++ offsetof(Sr__SubscribeReq, priority), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "enable_running", ++ 12, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_BOOL, ++ offsetof(Sr__SubscribeReq, has_enable_running), ++ offsetof(Sr__SubscribeReq, enable_running), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "enable_event", ++ 13, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_BOOL, ++ offsetof(Sr__SubscribeReq, has_enable_event), ++ offsetof(Sr__SubscribeReq, enable_event), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "api_variant", ++ 20, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_ENUM, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__SubscribeReq, api_variant), ++ &sr__api_variant__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__subscribe_req__field_indices_by_name[] = { ++ 9, /* field[9] = api_variant */ ++ 1, /* field[1] = destination */ ++ 8, /* field[8] = enable_event */ ++ 7, /* field[7] = enable_running */ ++ 3, /* field[3] = module_name */ ++ 5, /* field[5] = notif_event */ ++ 6, /* field[6] = priority */ ++ 2, /* field[2] = subscription_id */ ++ 0, /* field[0] = type */ ++ 4, /* field[4] = xpath */ ++}; ++static const ProtobufCIntRange sr__subscribe_req__number_ranges[3 + 1] = ++{ ++ { 1, 0 }, ++ { 10, 5 }, ++ { 20, 9 }, ++ { 0, 10 } ++}; ++const ProtobufCMessageDescriptor sr__subscribe_req__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.SubscribeReq", ++ "SubscribeReq", ++ "Sr__SubscribeReq", ++ "sr", ++ sizeof(Sr__SubscribeReq), ++ 10, ++ sr__subscribe_req__field_descriptors, ++ sr__subscribe_req__field_indices_by_name, ++ 3, sr__subscribe_req__number_ranges, ++ (ProtobufCMessageInit) sr__subscribe_req__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++#define sr__subscribe_resp__field_descriptors NULL ++#define sr__subscribe_resp__field_indices_by_name NULL ++#define sr__subscribe_resp__number_ranges NULL ++const ProtobufCMessageDescriptor sr__subscribe_resp__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.SubscribeResp", ++ "SubscribeResp", ++ "Sr__SubscribeResp", ++ "sr", ++ sizeof(Sr__SubscribeResp), ++ 0, ++ sr__subscribe_resp__field_descriptors, ++ sr__subscribe_resp__field_indices_by_name, ++ 0, sr__subscribe_resp__number_ranges, ++ (ProtobufCMessageInit) sr__subscribe_resp__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__unsubscribe_req__field_descriptors[4] = ++{ ++ { ++ "type", ++ 1, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_ENUM, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__UnsubscribeReq, type), ++ &sr__subscription_type__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "destination", ++ 2, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__UnsubscribeReq, destination), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "subscription_id", ++ 3, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_UINT32, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__UnsubscribeReq, subscription_id), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "module_name", ++ 4, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__UnsubscribeReq, module_name), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__unsubscribe_req__field_indices_by_name[] = { ++ 1, /* field[1] = destination */ ++ 3, /* field[3] = module_name */ ++ 2, /* field[2] = subscription_id */ ++ 0, /* field[0] = type */ ++}; ++static const ProtobufCIntRange sr__unsubscribe_req__number_ranges[1 + 1] = ++{ ++ { 1, 0 }, ++ { 0, 4 } ++}; ++const ProtobufCMessageDescriptor sr__unsubscribe_req__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.UnsubscribeReq", ++ "UnsubscribeReq", ++ "Sr__UnsubscribeReq", ++ "sr", ++ sizeof(Sr__UnsubscribeReq), ++ 4, ++ sr__unsubscribe_req__field_descriptors, ++ sr__unsubscribe_req__field_indices_by_name, ++ 1, sr__unsubscribe_req__number_ranges, ++ (ProtobufCMessageInit) sr__unsubscribe_req__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++#define sr__unsubscribe_resp__field_descriptors NULL ++#define sr__unsubscribe_resp__field_indices_by_name NULL ++#define sr__unsubscribe_resp__number_ranges NULL ++const ProtobufCMessageDescriptor sr__unsubscribe_resp__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.UnsubscribeResp", ++ "UnsubscribeResp", ++ "Sr__UnsubscribeResp", ++ "sr", ++ sizeof(Sr__UnsubscribeResp), ++ 0, ++ sr__unsubscribe_resp__field_descriptors, ++ sr__unsubscribe_resp__field_indices_by_name, ++ 0, sr__unsubscribe_resp__number_ranges, ++ (ProtobufCMessageInit) sr__unsubscribe_resp__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__check_enabled_running_req__field_descriptors[1] = ++{ ++ { ++ "module_name", ++ 1, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__CheckEnabledRunningReq, module_name), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__check_enabled_running_req__field_indices_by_name[] = { ++ 0, /* field[0] = module_name */ ++}; ++static const ProtobufCIntRange sr__check_enabled_running_req__number_ranges[1 + 1] = ++{ ++ { 1, 0 }, ++ { 0, 1 } ++}; ++const ProtobufCMessageDescriptor sr__check_enabled_running_req__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.CheckEnabledRunningReq", ++ "CheckEnabledRunningReq", ++ "Sr__CheckEnabledRunningReq", ++ "sr", ++ sizeof(Sr__CheckEnabledRunningReq), ++ 1, ++ sr__check_enabled_running_req__field_descriptors, ++ sr__check_enabled_running_req__field_indices_by_name, ++ 1, sr__check_enabled_running_req__number_ranges, ++ (ProtobufCMessageInit) sr__check_enabled_running_req__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__check_enabled_running_resp__field_descriptors[1] = ++{ ++ { ++ "enabled", ++ 1, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_BOOL, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__CheckEnabledRunningResp, enabled), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__check_enabled_running_resp__field_indices_by_name[] = { ++ 0, /* field[0] = enabled */ ++}; ++static const ProtobufCIntRange sr__check_enabled_running_resp__number_ranges[1 + 1] = ++{ ++ { 1, 0 }, ++ { 0, 1 } ++}; ++const ProtobufCMessageDescriptor sr__check_enabled_running_resp__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.CheckEnabledRunningResp", ++ "CheckEnabledRunningResp", ++ "Sr__CheckEnabledRunningResp", ++ "sr", ++ sizeof(Sr__CheckEnabledRunningResp), ++ 1, ++ sr__check_enabled_running_resp__field_descriptors, ++ sr__check_enabled_running_resp__field_indices_by_name, ++ 1, sr__check_enabled_running_resp__number_ranges, ++ (ProtobufCMessageInit) sr__check_enabled_running_resp__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__module_install_notification__field_descriptors[3] = ++{ ++ { ++ "module_name", ++ 1, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__ModuleInstallNotification, module_name), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "revision", ++ 2, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__ModuleInstallNotification, revision), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "state", ++ 3, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_ENUM, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__ModuleInstallNotification, state), ++ &sr__module_state__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__module_install_notification__field_indices_by_name[] = { ++ 0, /* field[0] = module_name */ ++ 1, /* field[1] = revision */ ++ 2, /* field[2] = state */ ++}; ++static const ProtobufCIntRange sr__module_install_notification__number_ranges[1 + 1] = ++{ ++ { 1, 0 }, ++ { 0, 3 } ++}; ++const ProtobufCMessageDescriptor sr__module_install_notification__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.ModuleInstallNotification", ++ "ModuleInstallNotification", ++ "Sr__ModuleInstallNotification", ++ "sr", ++ sizeof(Sr__ModuleInstallNotification), ++ 3, ++ sr__module_install_notification__field_descriptors, ++ sr__module_install_notification__field_indices_by_name, ++ 1, sr__module_install_notification__number_ranges, ++ (ProtobufCMessageInit) sr__module_install_notification__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__feature_enable_notification__field_descriptors[3] = ++{ ++ { ++ "module_name", ++ 1, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__FeatureEnableNotification, module_name), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "feature_name", ++ 2, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__FeatureEnableNotification, feature_name), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "enabled", ++ 3, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_BOOL, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__FeatureEnableNotification, enabled), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__feature_enable_notification__field_indices_by_name[] = { ++ 2, /* field[2] = enabled */ ++ 1, /* field[1] = feature_name */ ++ 0, /* field[0] = module_name */ ++}; ++static const ProtobufCIntRange sr__feature_enable_notification__number_ranges[1 + 1] = ++{ ++ { 1, 0 }, ++ { 0, 3 } ++}; ++const ProtobufCMessageDescriptor sr__feature_enable_notification__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.FeatureEnableNotification", ++ "FeatureEnableNotification", ++ "Sr__FeatureEnableNotification", ++ "sr", ++ sizeof(Sr__FeatureEnableNotification), ++ 3, ++ sr__feature_enable_notification__field_descriptors, ++ sr__feature_enable_notification__field_indices_by_name, ++ 1, sr__feature_enable_notification__number_ranges, ++ (ProtobufCMessageInit) sr__feature_enable_notification__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__module_change_notification__field_descriptors[2] = ++{ ++ { ++ "event", ++ 1, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_ENUM, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__ModuleChangeNotification, event), ++ &sr__notification_event__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "module_name", ++ 2, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__ModuleChangeNotification, module_name), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__module_change_notification__field_indices_by_name[] = { ++ 0, /* field[0] = event */ ++ 1, /* field[1] = module_name */ ++}; ++static const ProtobufCIntRange sr__module_change_notification__number_ranges[1 + 1] = ++{ ++ { 1, 0 }, ++ { 0, 2 } ++}; ++const ProtobufCMessageDescriptor sr__module_change_notification__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.ModuleChangeNotification", ++ "ModuleChangeNotification", ++ "Sr__ModuleChangeNotification", ++ "sr", ++ sizeof(Sr__ModuleChangeNotification), ++ 2, ++ sr__module_change_notification__field_descriptors, ++ sr__module_change_notification__field_indices_by_name, ++ 1, sr__module_change_notification__number_ranges, ++ (ProtobufCMessageInit) sr__module_change_notification__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__subtree_change_notification__field_descriptors[2] = ++{ ++ { ++ "event", ++ 1, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_ENUM, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__SubtreeChangeNotification, event), ++ &sr__notification_event__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "xpath", ++ 2, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__SubtreeChangeNotification, xpath), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__subtree_change_notification__field_indices_by_name[] = { ++ 0, /* field[0] = event */ ++ 1, /* field[1] = xpath */ ++}; ++static const ProtobufCIntRange sr__subtree_change_notification__number_ranges[1 + 1] = ++{ ++ { 1, 0 }, ++ { 0, 2 } ++}; ++const ProtobufCMessageDescriptor sr__subtree_change_notification__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.SubtreeChangeNotification", ++ "SubtreeChangeNotification", ++ "Sr__SubtreeChangeNotification", ++ "sr", ++ sizeof(Sr__SubtreeChangeNotification), ++ 2, ++ sr__subtree_change_notification__field_descriptors, ++ sr__subtree_change_notification__field_indices_by_name, ++ 1, sr__subtree_change_notification__number_ranges, ++ (ProtobufCMessageInit) sr__subtree_change_notification__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__change__field_descriptors[3] = ++{ ++ { ++ "changeOperation", ++ 1, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_ENUM, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Change, changeoperation), ++ &sr__change_operation__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "new_value", ++ 2, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Change, new_value), ++ &sr__value__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "old_value", ++ 3, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Change, old_value), ++ &sr__value__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__change__field_indices_by_name[] = { ++ 0, /* field[0] = changeOperation */ ++ 1, /* field[1] = new_value */ ++ 2, /* field[2] = old_value */ ++}; ++static const ProtobufCIntRange sr__change__number_ranges[1 + 1] = ++{ ++ { 1, 0 }, ++ { 0, 3 } ++}; ++const ProtobufCMessageDescriptor sr__change__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.Change", ++ "Change", ++ "Sr__Change", ++ "sr", ++ sizeof(Sr__Change), ++ 3, ++ sr__change__field_descriptors, ++ sr__change__field_indices_by_name, ++ 1, sr__change__number_ranges, ++ (ProtobufCMessageInit) sr__change__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__get_changes_req__field_descriptors[3] = ++{ ++ { ++ "xpath", ++ 1, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__GetChangesReq, xpath), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "limit", ++ 2, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_UINT32, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__GetChangesReq, limit), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "offset", ++ 3, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_UINT32, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__GetChangesReq, offset), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__get_changes_req__field_indices_by_name[] = { ++ 1, /* field[1] = limit */ ++ 2, /* field[2] = offset */ ++ 0, /* field[0] = xpath */ ++}; ++static const ProtobufCIntRange sr__get_changes_req__number_ranges[1 + 1] = ++{ ++ { 1, 0 }, ++ { 0, 3 } ++}; ++const ProtobufCMessageDescriptor sr__get_changes_req__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.GetChangesReq", ++ "GetChangesReq", ++ "Sr__GetChangesReq", ++ "sr", ++ sizeof(Sr__GetChangesReq), ++ 3, ++ sr__get_changes_req__field_descriptors, ++ sr__get_changes_req__field_indices_by_name, ++ 1, sr__get_changes_req__number_ranges, ++ (ProtobufCMessageInit) sr__get_changes_req__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__get_changes_resp__field_descriptors[1] = ++{ ++ { ++ "changes", ++ 1, ++ PROTOBUF_C_LABEL_REPEATED, ++ PROTOBUF_C_TYPE_MESSAGE, ++ offsetof(Sr__GetChangesResp, n_changes), ++ offsetof(Sr__GetChangesResp, changes), ++ &sr__change__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__get_changes_resp__field_indices_by_name[] = { ++ 0, /* field[0] = changes */ ++}; ++static const ProtobufCIntRange sr__get_changes_resp__number_ranges[1 + 1] = ++{ ++ { 1, 0 }, ++ { 0, 1 } ++}; ++const ProtobufCMessageDescriptor sr__get_changes_resp__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.GetChangesResp", ++ "GetChangesResp", ++ "Sr__GetChangesResp", ++ "sr", ++ sizeof(Sr__GetChangesResp), ++ 1, ++ sr__get_changes_resp__field_descriptors, ++ sr__get_changes_resp__field_indices_by_name, ++ 1, sr__get_changes_resp__number_ranges, ++ (ProtobufCMessageInit) sr__get_changes_resp__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__check_exec_perm_req__field_descriptors[1] = ++{ ++ { ++ "xpath", ++ 1, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__CheckExecPermReq, xpath), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__check_exec_perm_req__field_indices_by_name[] = { ++ 0, /* field[0] = xpath */ ++}; ++static const ProtobufCIntRange sr__check_exec_perm_req__number_ranges[1 + 1] = ++{ ++ { 1, 0 }, ++ { 0, 1 } ++}; ++const ProtobufCMessageDescriptor sr__check_exec_perm_req__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.CheckExecPermReq", ++ "CheckExecPermReq", ++ "Sr__CheckExecPermReq", ++ "sr", ++ sizeof(Sr__CheckExecPermReq), ++ 1, ++ sr__check_exec_perm_req__field_descriptors, ++ sr__check_exec_perm_req__field_indices_by_name, ++ 1, sr__check_exec_perm_req__number_ranges, ++ (ProtobufCMessageInit) sr__check_exec_perm_req__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__check_exec_perm_resp__field_descriptors[1] = ++{ ++ { ++ "permitted", ++ 1, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_BOOL, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__CheckExecPermResp, permitted), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__check_exec_perm_resp__field_indices_by_name[] = { ++ 0, /* field[0] = permitted */ ++}; ++static const ProtobufCIntRange sr__check_exec_perm_resp__number_ranges[1 + 1] = ++{ ++ { 1, 0 }, ++ { 0, 1 } ++}; ++const ProtobufCMessageDescriptor sr__check_exec_perm_resp__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.CheckExecPermResp", ++ "CheckExecPermResp", ++ "Sr__CheckExecPermResp", ++ "sr", ++ sizeof(Sr__CheckExecPermResp), ++ 1, ++ sr__check_exec_perm_resp__field_descriptors, ++ sr__check_exec_perm_resp__field_indices_by_name, ++ 1, sr__check_exec_perm_resp__number_ranges, ++ (ProtobufCMessageInit) sr__check_exec_perm_resp__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__rpcreq__field_descriptors[7] = ++{ ++ { ++ "action", ++ 1, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_BOOL, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__RPCReq, action), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "xpath", ++ 2, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__RPCReq, xpath), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "orig_api_variant", ++ 3, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_ENUM, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__RPCReq, orig_api_variant), ++ &sr__api_variant__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "input", ++ 4, ++ PROTOBUF_C_LABEL_REPEATED, ++ PROTOBUF_C_TYPE_MESSAGE, ++ offsetof(Sr__RPCReq, n_input), ++ offsetof(Sr__RPCReq, input), ++ &sr__value__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "input_tree", ++ 5, ++ PROTOBUF_C_LABEL_REPEATED, ++ PROTOBUF_C_TYPE_MESSAGE, ++ offsetof(Sr__RPCReq, n_input_tree), ++ offsetof(Sr__RPCReq, input_tree), ++ &sr__node__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "subscriber_address", ++ 10, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__RPCReq, subscriber_address), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "subscription_id", ++ 11, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_UINT32, ++ offsetof(Sr__RPCReq, has_subscription_id), ++ offsetof(Sr__RPCReq, subscription_id), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__rpcreq__field_indices_by_name[] = { ++ 0, /* field[0] = action */ ++ 3, /* field[3] = input */ ++ 4, /* field[4] = input_tree */ ++ 2, /* field[2] = orig_api_variant */ ++ 5, /* field[5] = subscriber_address */ ++ 6, /* field[6] = subscription_id */ ++ 1, /* field[1] = xpath */ ++}; ++static const ProtobufCIntRange sr__rpcreq__number_ranges[2 + 1] = ++{ ++ { 1, 0 }, ++ { 10, 5 }, ++ { 0, 7 } ++}; ++const ProtobufCMessageDescriptor sr__rpcreq__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.RPCReq", ++ "RPCReq", ++ "Sr__RPCReq", ++ "sr", ++ sizeof(Sr__RPCReq), ++ 7, ++ sr__rpcreq__field_descriptors, ++ sr__rpcreq__field_indices_by_name, ++ 2, sr__rpcreq__number_ranges, ++ (ProtobufCMessageInit) sr__rpcreq__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__rpcresp__field_descriptors[5] = ++{ ++ { ++ "action", ++ 1, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_BOOL, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__RPCResp, action), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "xpath", ++ 2, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__RPCResp, xpath), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "orig_api_variant", ++ 3, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_ENUM, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__RPCResp, orig_api_variant), ++ &sr__api_variant__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "output", ++ 4, ++ PROTOBUF_C_LABEL_REPEATED, ++ PROTOBUF_C_TYPE_MESSAGE, ++ offsetof(Sr__RPCResp, n_output), ++ offsetof(Sr__RPCResp, output), ++ &sr__value__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "output_tree", ++ 5, ++ PROTOBUF_C_LABEL_REPEATED, ++ PROTOBUF_C_TYPE_MESSAGE, ++ offsetof(Sr__RPCResp, n_output_tree), ++ offsetof(Sr__RPCResp, output_tree), ++ &sr__node__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__rpcresp__field_indices_by_name[] = { ++ 0, /* field[0] = action */ ++ 2, /* field[2] = orig_api_variant */ ++ 3, /* field[3] = output */ ++ 4, /* field[4] = output_tree */ ++ 1, /* field[1] = xpath */ ++}; ++static const ProtobufCIntRange sr__rpcresp__number_ranges[1 + 1] = ++{ ++ { 1, 0 }, ++ { 0, 5 } ++}; ++const ProtobufCMessageDescriptor sr__rpcresp__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.RPCResp", ++ "RPCResp", ++ "Sr__RPCResp", ++ "sr", ++ sizeof(Sr__RPCResp), ++ 5, ++ sr__rpcresp__field_descriptors, ++ sr__rpcresp__field_indices_by_name, ++ 1, sr__rpcresp__number_ranges, ++ (ProtobufCMessageInit) sr__rpcresp__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCEnumValue sr__event_notif_req__notif_type__enum_values_by_number[4] = ++{ ++ { "REALTIME", "SR__EVENT_NOTIF_REQ__NOTIF_TYPE__REALTIME", 1 }, ++ { "REPLAY", "SR__EVENT_NOTIF_REQ__NOTIF_TYPE__REPLAY", 2 }, ++ { "REPLAY_COMPLETE", "SR__EVENT_NOTIF_REQ__NOTIF_TYPE__REPLAY_COMPLETE", 3 }, ++ { "REPLAY_STOP", "SR__EVENT_NOTIF_REQ__NOTIF_TYPE__REPLAY_STOP", 4 }, ++}; ++static const ProtobufCIntRange sr__event_notif_req__notif_type__value_ranges[] = { ++{1, 0},{0, 4} ++}; ++static const ProtobufCEnumValueIndex sr__event_notif_req__notif_type__enum_values_by_name[4] = ++{ ++ { "REALTIME", 0 }, ++ { "REPLAY", 1 }, ++ { "REPLAY_COMPLETE", 2 }, ++ { "REPLAY_STOP", 3 }, ++}; ++const ProtobufCEnumDescriptor sr__event_notif_req__notif_type__descriptor = ++{ ++ PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC, ++ "sr.EventNotifReq.NotifType", ++ "NotifType", ++ "Sr__EventNotifReq__NotifType", ++ "sr", ++ 4, ++ sr__event_notif_req__notif_type__enum_values_by_number, ++ 4, ++ sr__event_notif_req__notif_type__enum_values_by_name, ++ 1, ++ sr__event_notif_req__notif_type__value_ranges, ++ NULL,NULL,NULL,NULL /* reserved[1234] */ ++}; ++static const ProtobufCEnumValue sr__event_notif_req__notif_flags__enum_values_by_number[2] = ++{ ++ { "DEFAULT", "SR__EVENT_NOTIF_REQ__NOTIF_FLAGS__DEFAULT", 0 }, ++ { "EPHEMERAL", "SR__EVENT_NOTIF_REQ__NOTIF_FLAGS__EPHEMERAL", 1 }, ++}; ++static const ProtobufCIntRange sr__event_notif_req__notif_flags__value_ranges[] = { ++{0, 0},{0, 2} ++}; ++static const ProtobufCEnumValueIndex sr__event_notif_req__notif_flags__enum_values_by_name[2] = ++{ ++ { "DEFAULT", 0 }, ++ { "EPHEMERAL", 1 }, ++}; ++const ProtobufCEnumDescriptor sr__event_notif_req__notif_flags__descriptor = ++{ ++ PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC, ++ "sr.EventNotifReq.NotifFlags", ++ "NotifFlags", ++ "Sr__EventNotifReq__NotifFlags", ++ "sr", ++ 2, ++ sr__event_notif_req__notif_flags__enum_values_by_number, ++ 2, ++ sr__event_notif_req__notif_flags__enum_values_by_name, ++ 1, ++ sr__event_notif_req__notif_flags__value_ranges, ++ NULL,NULL,NULL,NULL /* reserved[1234] */ ++}; ++static const ProtobufCFieldDescriptor sr__event_notif_req__field_descriptors[9] = ++{ ++ { ++ "type", ++ 1, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_ENUM, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__EventNotifReq, type), ++ &sr__event_notif_req__notif_type__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "options", ++ 2, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_UINT32, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__EventNotifReq, options), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "xpath", ++ 3, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__EventNotifReq, xpath), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "values", ++ 4, ++ PROTOBUF_C_LABEL_REPEATED, ++ PROTOBUF_C_TYPE_MESSAGE, ++ offsetof(Sr__EventNotifReq, n_values), ++ offsetof(Sr__EventNotifReq, values), ++ &sr__value__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "trees", ++ 5, ++ PROTOBUF_C_LABEL_REPEATED, ++ PROTOBUF_C_TYPE_MESSAGE, ++ offsetof(Sr__EventNotifReq, n_trees), ++ offsetof(Sr__EventNotifReq, trees), ++ &sr__node__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "timestamp", ++ 6, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_UINT64, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__EventNotifReq, timestamp), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "subscriber_address", ++ 10, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__EventNotifReq, subscriber_address), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "subscription_id", ++ 11, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_UINT32, ++ offsetof(Sr__EventNotifReq, has_subscription_id), ++ offsetof(Sr__EventNotifReq, subscription_id), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "do_not_send_reply", ++ 20, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_BOOL, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__EventNotifReq, do_not_send_reply), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__event_notif_req__field_indices_by_name[] = { ++ 8, /* field[8] = do_not_send_reply */ ++ 1, /* field[1] = options */ ++ 6, /* field[6] = subscriber_address */ ++ 7, /* field[7] = subscription_id */ ++ 5, /* field[5] = timestamp */ ++ 4, /* field[4] = trees */ ++ 0, /* field[0] = type */ ++ 3, /* field[3] = values */ ++ 2, /* field[2] = xpath */ ++}; ++static const ProtobufCIntRange sr__event_notif_req__number_ranges[3 + 1] = ++{ ++ { 1, 0 }, ++ { 10, 6 }, ++ { 20, 8 }, ++ { 0, 9 } ++}; ++const ProtobufCMessageDescriptor sr__event_notif_req__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.EventNotifReq", ++ "EventNotifReq", ++ "Sr__EventNotifReq", ++ "sr", ++ sizeof(Sr__EventNotifReq), ++ 9, ++ sr__event_notif_req__field_descriptors, ++ sr__event_notif_req__field_indices_by_name, ++ 3, sr__event_notif_req__number_ranges, ++ (ProtobufCMessageInit) sr__event_notif_req__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++#define sr__event_notif_resp__field_descriptors NULL ++#define sr__event_notif_resp__field_indices_by_name NULL ++#define sr__event_notif_resp__number_ranges NULL ++const ProtobufCMessageDescriptor sr__event_notif_resp__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.EventNotifResp", ++ "EventNotifResp", ++ "Sr__EventNotifResp", ++ "sr", ++ sizeof(Sr__EventNotifResp), ++ 0, ++ sr__event_notif_resp__field_descriptors, ++ sr__event_notif_resp__field_indices_by_name, ++ 0, sr__event_notif_resp__number_ranges, ++ (ProtobufCMessageInit) sr__event_notif_resp__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__event_notif_replay_req__field_descriptors[6] = ++{ ++ { ++ "xpath", ++ 1, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__EventNotifReplayReq, xpath), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "start_time", ++ 2, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_UINT64, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__EventNotifReplayReq, start_time), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "stop_time", ++ 3, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_UINT64, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__EventNotifReplayReq, stop_time), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "subscriber_address", ++ 10, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__EventNotifReplayReq, subscriber_address), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "subscription_id", ++ 11, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_UINT32, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__EventNotifReplayReq, subscription_id), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "api_variant", ++ 12, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_ENUM, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__EventNotifReplayReq, api_variant), ++ &sr__api_variant__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__event_notif_replay_req__field_indices_by_name[] = { ++ 5, /* field[5] = api_variant */ ++ 1, /* field[1] = start_time */ ++ 2, /* field[2] = stop_time */ ++ 3, /* field[3] = subscriber_address */ ++ 4, /* field[4] = subscription_id */ ++ 0, /* field[0] = xpath */ ++}; ++static const ProtobufCIntRange sr__event_notif_replay_req__number_ranges[2 + 1] = ++{ ++ { 1, 0 }, ++ { 10, 3 }, ++ { 0, 6 } ++}; ++const ProtobufCMessageDescriptor sr__event_notif_replay_req__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.EventNotifReplayReq", ++ "EventNotifReplayReq", ++ "Sr__EventNotifReplayReq", ++ "sr", ++ sizeof(Sr__EventNotifReplayReq), ++ 6, ++ sr__event_notif_replay_req__field_descriptors, ++ sr__event_notif_replay_req__field_indices_by_name, ++ 2, sr__event_notif_replay_req__number_ranges, ++ (ProtobufCMessageInit) sr__event_notif_replay_req__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++#define sr__event_notif_replay_resp__field_descriptors NULL ++#define sr__event_notif_replay_resp__field_indices_by_name NULL ++#define sr__event_notif_replay_resp__number_ranges NULL ++const ProtobufCMessageDescriptor sr__event_notif_replay_resp__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.EventNotifReplayResp", ++ "EventNotifReplayResp", ++ "Sr__EventNotifReplayResp", ++ "sr", ++ sizeof(Sr__EventNotifReplayResp), ++ 0, ++ sr__event_notif_replay_resp__field_descriptors, ++ sr__event_notif_replay_resp__field_indices_by_name, ++ 0, sr__event_notif_replay_resp__number_ranges, ++ (ProtobufCMessageInit) sr__event_notif_replay_resp__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__data_provide_req__field_descriptors[4] = ++{ ++ { ++ "xpath", ++ 1, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__DataProvideReq, xpath), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "subscriber_address", ++ 10, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__DataProvideReq, subscriber_address), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "subscription_id", ++ 11, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_UINT32, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__DataProvideReq, subscription_id), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "request_id", ++ 20, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_UINT64, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__DataProvideReq, request_id), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__data_provide_req__field_indices_by_name[] = { ++ 3, /* field[3] = request_id */ ++ 1, /* field[1] = subscriber_address */ ++ 2, /* field[2] = subscription_id */ ++ 0, /* field[0] = xpath */ ++}; ++static const ProtobufCIntRange sr__data_provide_req__number_ranges[3 + 1] = ++{ ++ { 1, 0 }, ++ { 10, 1 }, ++ { 20, 3 }, ++ { 0, 4 } ++}; ++const ProtobufCMessageDescriptor sr__data_provide_req__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.DataProvideReq", ++ "DataProvideReq", ++ "Sr__DataProvideReq", ++ "sr", ++ sizeof(Sr__DataProvideReq), ++ 4, ++ sr__data_provide_req__field_descriptors, ++ sr__data_provide_req__field_indices_by_name, ++ 3, sr__data_provide_req__number_ranges, ++ (ProtobufCMessageInit) sr__data_provide_req__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__data_provide_resp__field_descriptors[3] = ++{ ++ { ++ "xpath", ++ 1, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__DataProvideResp, xpath), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "values", ++ 2, ++ PROTOBUF_C_LABEL_REPEATED, ++ PROTOBUF_C_TYPE_MESSAGE, ++ offsetof(Sr__DataProvideResp, n_values), ++ offsetof(Sr__DataProvideResp, values), ++ &sr__value__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "request_id", ++ 10, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_UINT64, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__DataProvideResp, request_id), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__data_provide_resp__field_indices_by_name[] = { ++ 2, /* field[2] = request_id */ ++ 1, /* field[1] = values */ ++ 0, /* field[0] = xpath */ ++}; ++static const ProtobufCIntRange sr__data_provide_resp__number_ranges[2 + 1] = ++{ ++ { 1, 0 }, ++ { 10, 2 }, ++ { 0, 3 } ++}; ++const ProtobufCMessageDescriptor sr__data_provide_resp__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.DataProvideResp", ++ "DataProvideResp", ++ "Sr__DataProvideResp", ++ "sr", ++ sizeof(Sr__DataProvideResp), ++ 3, ++ sr__data_provide_resp__field_descriptors, ++ sr__data_provide_resp__field_indices_by_name, ++ 2, sr__data_provide_resp__number_ranges, ++ (ProtobufCMessageInit) sr__data_provide_resp__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__module_install_req__field_descriptors[4] = ++{ ++ { ++ "module_name", ++ 1, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__ModuleInstallReq, module_name), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "revision", ++ 2, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__ModuleInstallReq, revision), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "file_name", ++ 3, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__ModuleInstallReq, file_name), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "installed", ++ 4, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_BOOL, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__ModuleInstallReq, installed), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__module_install_req__field_indices_by_name[] = { ++ 2, /* field[2] = file_name */ ++ 3, /* field[3] = installed */ ++ 0, /* field[0] = module_name */ ++ 1, /* field[1] = revision */ ++}; ++static const ProtobufCIntRange sr__module_install_req__number_ranges[1 + 1] = ++{ ++ { 1, 0 }, ++ { 0, 4 } ++}; ++const ProtobufCMessageDescriptor sr__module_install_req__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.ModuleInstallReq", ++ "ModuleInstallReq", ++ "Sr__ModuleInstallReq", ++ "sr", ++ sizeof(Sr__ModuleInstallReq), ++ 4, ++ sr__module_install_req__field_descriptors, ++ sr__module_install_req__field_indices_by_name, ++ 1, sr__module_install_req__number_ranges, ++ (ProtobufCMessageInit) sr__module_install_req__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++#define sr__module_install_resp__field_descriptors NULL ++#define sr__module_install_resp__field_indices_by_name NULL ++#define sr__module_install_resp__number_ranges NULL ++const ProtobufCMessageDescriptor sr__module_install_resp__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.ModuleInstallResp", ++ "ModuleInstallResp", ++ "Sr__ModuleInstallResp", ++ "sr", ++ sizeof(Sr__ModuleInstallResp), ++ 0, ++ sr__module_install_resp__field_descriptors, ++ sr__module_install_resp__field_indices_by_name, ++ 0, sr__module_install_resp__number_ranges, ++ (ProtobufCMessageInit) sr__module_install_resp__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__feature_enable_req__field_descriptors[3] = ++{ ++ { ++ "module_name", ++ 1, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__FeatureEnableReq, module_name), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "feature_name", ++ 2, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__FeatureEnableReq, feature_name), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "enabled", ++ 3, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_BOOL, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__FeatureEnableReq, enabled), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__feature_enable_req__field_indices_by_name[] = { ++ 2, /* field[2] = enabled */ ++ 1, /* field[1] = feature_name */ ++ 0, /* field[0] = module_name */ ++}; ++static const ProtobufCIntRange sr__feature_enable_req__number_ranges[1 + 1] = ++{ ++ { 1, 0 }, ++ { 0, 3 } ++}; ++const ProtobufCMessageDescriptor sr__feature_enable_req__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.FeatureEnableReq", ++ "FeatureEnableReq", ++ "Sr__FeatureEnableReq", ++ "sr", ++ sizeof(Sr__FeatureEnableReq), ++ 3, ++ sr__feature_enable_req__field_descriptors, ++ sr__feature_enable_req__field_indices_by_name, ++ 1, sr__feature_enable_req__number_ranges, ++ (ProtobufCMessageInit) sr__feature_enable_req__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++#define sr__feature_enable_resp__field_descriptors NULL ++#define sr__feature_enable_resp__field_indices_by_name NULL ++#define sr__feature_enable_resp__number_ranges NULL ++const ProtobufCMessageDescriptor sr__feature_enable_resp__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.FeatureEnableResp", ++ "FeatureEnableResp", ++ "Sr__FeatureEnableResp", ++ "sr", ++ sizeof(Sr__FeatureEnableResp), ++ 0, ++ sr__feature_enable_resp__field_descriptors, ++ sr__feature_enable_resp__field_indices_by_name, ++ 0, sr__feature_enable_resp__number_ranges, ++ (ProtobufCMessageInit) sr__feature_enable_resp__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__unsubscribe_destination_req__field_descriptors[1] = ++{ ++ { ++ "destination", ++ 1, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__UnsubscribeDestinationReq, destination), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__unsubscribe_destination_req__field_indices_by_name[] = { ++ 0, /* field[0] = destination */ ++}; ++static const ProtobufCIntRange sr__unsubscribe_destination_req__number_ranges[1 + 1] = ++{ ++ { 1, 0 }, ++ { 0, 1 } ++}; ++const ProtobufCMessageDescriptor sr__unsubscribe_destination_req__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.UnsubscribeDestinationReq", ++ "UnsubscribeDestinationReq", ++ "Sr__UnsubscribeDestinationReq", ++ "sr", ++ sizeof(Sr__UnsubscribeDestinationReq), ++ 1, ++ sr__unsubscribe_destination_req__field_descriptors, ++ sr__unsubscribe_destination_req__field_indices_by_name, ++ 1, sr__unsubscribe_destination_req__number_ranges, ++ (ProtobufCMessageInit) sr__unsubscribe_destination_req__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__commit_timeout_req__field_descriptors[2] = ++{ ++ { ++ "commit_id", ++ 1, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_UINT32, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__CommitTimeoutReq, commit_id), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "expired", ++ 2, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_BOOL, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__CommitTimeoutReq, expired), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__commit_timeout_req__field_indices_by_name[] = { ++ 0, /* field[0] = commit_id */ ++ 1, /* field[1] = expired */ ++}; ++static const ProtobufCIntRange sr__commit_timeout_req__number_ranges[1 + 1] = ++{ ++ { 1, 0 }, ++ { 0, 2 } ++}; ++const ProtobufCMessageDescriptor sr__commit_timeout_req__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.CommitTimeoutReq", ++ "CommitTimeoutReq", ++ "Sr__CommitTimeoutReq", ++ "sr", ++ sizeof(Sr__CommitTimeoutReq), ++ 2, ++ sr__commit_timeout_req__field_descriptors, ++ sr__commit_timeout_req__field_indices_by_name, ++ 1, sr__commit_timeout_req__number_ranges, ++ (ProtobufCMessageInit) sr__commit_timeout_req__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__oper_data_timeout_req__field_descriptors[1] = ++{ ++ { ++ "request_id", ++ 1, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_UINT64, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__OperDataTimeoutReq, request_id), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__oper_data_timeout_req__field_indices_by_name[] = { ++ 0, /* field[0] = request_id */ ++}; ++static const ProtobufCIntRange sr__oper_data_timeout_req__number_ranges[1 + 1] = ++{ ++ { 1, 0 }, ++ { 0, 1 } ++}; ++const ProtobufCMessageDescriptor sr__oper_data_timeout_req__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.OperDataTimeoutReq", ++ "OperDataTimeoutReq", ++ "Sr__OperDataTimeoutReq", ++ "sr", ++ sizeof(Sr__OperDataTimeoutReq), ++ 1, ++ sr__oper_data_timeout_req__field_descriptors, ++ sr__oper_data_timeout_req__field_indices_by_name, ++ 1, sr__oper_data_timeout_req__number_ranges, ++ (ProtobufCMessageInit) sr__oper_data_timeout_req__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__internal_state_data_req__field_descriptors[2] = ++{ ++ { ++ "request_id", ++ 1, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_UINT64, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__InternalStateDataReq, request_id), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "xpath", ++ 2, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__InternalStateDataReq, xpath), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__internal_state_data_req__field_indices_by_name[] = { ++ 0, /* field[0] = request_id */ ++ 1, /* field[1] = xpath */ ++}; ++static const ProtobufCIntRange sr__internal_state_data_req__number_ranges[1 + 1] = ++{ ++ { 1, 0 }, ++ { 0, 2 } ++}; ++const ProtobufCMessageDescriptor sr__internal_state_data_req__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.InternalStateDataReq", ++ "InternalStateDataReq", ++ "Sr__InternalStateDataReq", ++ "sr", ++ sizeof(Sr__InternalStateDataReq), ++ 2, ++ sr__internal_state_data_req__field_descriptors, ++ sr__internal_state_data_req__field_indices_by_name, ++ 1, sr__internal_state_data_req__number_ranges, ++ (ProtobufCMessageInit) sr__internal_state_data_req__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++#define sr__notif_store_cleanup_req__field_descriptors NULL ++#define sr__notif_store_cleanup_req__field_indices_by_name NULL ++#define sr__notif_store_cleanup_req__number_ranges NULL ++const ProtobufCMessageDescriptor sr__notif_store_cleanup_req__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.NotifStoreCleanupReq", ++ "NotifStoreCleanupReq", ++ "Sr__NotifStoreCleanupReq", ++ "sr", ++ sizeof(Sr__NotifStoreCleanupReq), ++ 0, ++ sr__notif_store_cleanup_req__field_descriptors, ++ sr__notif_store_cleanup_req__field_indices_by_name, ++ 0, sr__notif_store_cleanup_req__number_ranges, ++ (ProtobufCMessageInit) sr__notif_store_cleanup_req__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__delayed_msg_req__field_descriptors[1] = ++{ ++ { ++ "message", ++ 1, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__DelayedMsgReq, message), ++ &sr__msg__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__delayed_msg_req__field_indices_by_name[] = { ++ 0, /* field[0] = message */ ++}; ++static const ProtobufCIntRange sr__delayed_msg_req__number_ranges[1 + 1] = ++{ ++ { 1, 0 }, ++ { 0, 1 } ++}; ++const ProtobufCMessageDescriptor sr__delayed_msg_req__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.DelayedMsgReq", ++ "DelayedMsgReq", ++ "Sr__DelayedMsgReq", ++ "sr", ++ sizeof(Sr__DelayedMsgReq), ++ 1, ++ sr__delayed_msg_req__field_descriptors, ++ sr__delayed_msg_req__field_indices_by_name, ++ 1, sr__delayed_msg_req__number_ranges, ++ (ProtobufCMessageInit) sr__delayed_msg_req__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++#define sr__nacm_reload_req__field_descriptors NULL ++#define sr__nacm_reload_req__field_indices_by_name NULL ++#define sr__nacm_reload_req__number_ranges NULL ++const ProtobufCMessageDescriptor sr__nacm_reload_req__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.NacmReloadReq", ++ "NacmReloadReq", ++ "Sr__NacmReloadReq", ++ "sr", ++ sizeof(Sr__NacmReloadReq), ++ 0, ++ sr__nacm_reload_req__field_descriptors, ++ sr__nacm_reload_req__field_indices_by_name, ++ 0, sr__nacm_reload_req__number_ranges, ++ (ProtobufCMessageInit) sr__nacm_reload_req__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__request__field_descriptors[37] = ++{ ++ { ++ "_id", ++ 1, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_UINT64, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Request, _id), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "operation", ++ 2, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_ENUM, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Request, operation), ++ &sr__operation__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "session_start_req", ++ 10, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Request, session_start_req), ++ &sr__session_start_req__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "session_stop_req", ++ 11, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Request, session_stop_req), ++ &sr__session_stop_req__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "session_refresh_req", ++ 12, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Request, session_refresh_req), ++ &sr__session_refresh_req__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "session_check_req", ++ 13, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Request, session_check_req), ++ &sr__session_check_req__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "session_switch_ds_req", ++ 14, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Request, session_switch_ds_req), ++ &sr__session_switch_ds_req__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "session_set_opts_req", ++ 15, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Request, session_set_opts_req), ++ &sr__session_set_opts_req__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "version_verify_req", ++ 16, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Request, version_verify_req), ++ &sr__version_verify_req__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "list_schemas_req", ++ 20, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Request, list_schemas_req), ++ &sr__list_schemas_req__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "get_schema_req", ++ 21, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Request, get_schema_req), ++ &sr__get_schema_req__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "module_install_req", ++ 22, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Request, module_install_req), ++ &sr__module_install_req__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "feature_enable_req", ++ 23, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Request, feature_enable_req), ++ &sr__feature_enable_req__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "get_item_req", ++ 30, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Request, get_item_req), ++ &sr__get_item_req__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "get_items_req", ++ 31, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Request, get_items_req), ++ &sr__get_items_req__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "get_subtree_req", ++ 32, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Request, get_subtree_req), ++ &sr__get_subtree_req__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "get_subtrees_req", ++ 33, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Request, get_subtrees_req), ++ &sr__get_subtrees_req__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "get_subtree_chunk_req", ++ 34, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Request, get_subtree_chunk_req), ++ &sr__get_subtree_chunk_req__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "set_item_req", ++ 40, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Request, set_item_req), ++ &sr__set_item_req__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "delete_item_req", ++ 41, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Request, delete_item_req), ++ &sr__delete_item_req__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "move_item_req", ++ 42, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Request, move_item_req), ++ &sr__move_item_req__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "set_item_str_req", ++ 43, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Request, set_item_str_req), ++ &sr__set_item_str_req__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "validate_req", ++ 50, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Request, validate_req), ++ &sr__validate_req__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "commit_req", ++ 51, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Request, commit_req), ++ &sr__commit_req__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "discard_changes_req", ++ 52, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Request, discard_changes_req), ++ &sr__discard_changes_req__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "copy_config_req", ++ 53, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Request, copy_config_req), ++ &sr__copy_config_req__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "lock_req", ++ 60, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Request, lock_req), ++ &sr__lock_req__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "unlock_req", ++ 61, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Request, unlock_req), ++ &sr__unlock_req__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "subscribe_req", ++ 70, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Request, subscribe_req), ++ &sr__subscribe_req__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "unsubscribe_req", ++ 71, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Request, unsubscribe_req), ++ &sr__unsubscribe_req__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "check_enabled_running_req", ++ 72, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Request, check_enabled_running_req), ++ &sr__check_enabled_running_req__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "get_changes_req", ++ 73, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Request, get_changes_req), ++ &sr__get_changes_req__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "data_provide_req", ++ 80, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Request, data_provide_req), ++ &sr__data_provide_req__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "check_exec_perm_req", ++ 81, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Request, check_exec_perm_req), ++ &sr__check_exec_perm_req__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "rpc_req", ++ 82, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Request, rpc_req), ++ &sr__rpcreq__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "event_notif_req", ++ 83, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Request, event_notif_req), ++ &sr__event_notif_req__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "event_notif_replay_req", ++ 84, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Request, event_notif_replay_req), ++ &sr__event_notif_replay_req__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__request__field_indices_by_name[] = { ++ 0, /* field[0] = _id */ ++ 30, /* field[30] = check_enabled_running_req */ ++ 33, /* field[33] = check_exec_perm_req */ ++ 23, /* field[23] = commit_req */ ++ 25, /* field[25] = copy_config_req */ ++ 32, /* field[32] = data_provide_req */ ++ 19, /* field[19] = delete_item_req */ ++ 24, /* field[24] = discard_changes_req */ ++ 36, /* field[36] = event_notif_replay_req */ ++ 35, /* field[35] = event_notif_req */ ++ 12, /* field[12] = feature_enable_req */ ++ 31, /* field[31] = get_changes_req */ ++ 13, /* field[13] = get_item_req */ ++ 14, /* field[14] = get_items_req */ ++ 10, /* field[10] = get_schema_req */ ++ 17, /* field[17] = get_subtree_chunk_req */ ++ 15, /* field[15] = get_subtree_req */ ++ 16, /* field[16] = get_subtrees_req */ ++ 9, /* field[9] = list_schemas_req */ ++ 26, /* field[26] = lock_req */ ++ 11, /* field[11] = module_install_req */ ++ 20, /* field[20] = move_item_req */ ++ 1, /* field[1] = operation */ ++ 34, /* field[34] = rpc_req */ ++ 5, /* field[5] = session_check_req */ ++ 4, /* field[4] = session_refresh_req */ ++ 7, /* field[7] = session_set_opts_req */ ++ 2, /* field[2] = session_start_req */ ++ 3, /* field[3] = session_stop_req */ ++ 6, /* field[6] = session_switch_ds_req */ ++ 18, /* field[18] = set_item_req */ ++ 21, /* field[21] = set_item_str_req */ ++ 28, /* field[28] = subscribe_req */ ++ 27, /* field[27] = unlock_req */ ++ 29, /* field[29] = unsubscribe_req */ ++ 22, /* field[22] = validate_req */ ++ 8, /* field[8] = version_verify_req */ ++}; ++static const ProtobufCIntRange sr__request__number_ranges[9 + 1] = ++{ ++ { 1, 0 }, ++ { 10, 2 }, ++ { 20, 9 }, ++ { 30, 13 }, ++ { 40, 18 }, ++ { 50, 22 }, ++ { 60, 26 }, ++ { 70, 28 }, ++ { 80, 32 }, ++ { 0, 37 } ++}; ++const ProtobufCMessageDescriptor sr__request__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.Request", ++ "Request", ++ "Sr__Request", ++ "sr", ++ sizeof(Sr__Request), ++ 37, ++ sr__request__field_descriptors, ++ sr__request__field_indices_by_name, ++ 9, sr__request__number_ranges, ++ (ProtobufCMessageInit) sr__request__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__response__field_descriptors[38] = ++{ ++ { ++ "operation", ++ 1, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_ENUM, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Response, operation), ++ &sr__operation__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "result", ++ 2, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_UINT32, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Response, result), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "error", ++ 3, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Response, error), ++ &sr__error__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "session_start_resp", ++ 10, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Response, session_start_resp), ++ &sr__session_start_resp__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "session_stop_resp", ++ 11, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Response, session_stop_resp), ++ &sr__session_stop_resp__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "session_refresh_resp", ++ 12, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Response, session_refresh_resp), ++ &sr__session_refresh_resp__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "session_check_resp", ++ 13, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Response, session_check_resp), ++ &sr__session_check_resp__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "session_switch_ds_resp", ++ 14, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Response, session_switch_ds_resp), ++ &sr__session_switch_ds_resp__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "session_set_opts_resp", ++ 15, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Response, session_set_opts_resp), ++ &sr__session_set_opts_resp__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "version_verify_resp", ++ 16, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Response, version_verify_resp), ++ &sr__version_verify_resp__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "list_schemas_resp", ++ 20, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Response, list_schemas_resp), ++ &sr__list_schemas_resp__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "get_schema_resp", ++ 21, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Response, get_schema_resp), ++ &sr__get_schema_resp__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "module_install_resp", ++ 22, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Response, module_install_resp), ++ &sr__module_install_resp__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "feature_enable_resp", ++ 23, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Response, feature_enable_resp), ++ &sr__feature_enable_resp__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "get_item_resp", ++ 30, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Response, get_item_resp), ++ &sr__get_item_resp__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "get_items_resp", ++ 31, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Response, get_items_resp), ++ &sr__get_items_resp__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "get_subtree_resp", ++ 32, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Response, get_subtree_resp), ++ &sr__get_subtree_resp__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "get_subtrees_resp", ++ 33, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Response, get_subtrees_resp), ++ &sr__get_subtrees_resp__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "get_subtree_chunk_resp", ++ 34, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Response, get_subtree_chunk_resp), ++ &sr__get_subtree_chunk_resp__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "set_item_resp", ++ 40, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Response, set_item_resp), ++ &sr__set_item_resp__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "delete_item_resp", ++ 41, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Response, delete_item_resp), ++ &sr__delete_item_resp__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "move_item_resp", ++ 42, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Response, move_item_resp), ++ &sr__move_item_resp__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "set_item_str_resp", ++ 43, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Response, set_item_str_resp), ++ &sr__set_item_str_resp__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "validate_resp", ++ 50, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Response, validate_resp), ++ &sr__validate_resp__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "commit_resp", ++ 51, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Response, commit_resp), ++ &sr__commit_resp__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "discard_changes_resp", ++ 52, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Response, discard_changes_resp), ++ &sr__discard_changes_resp__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "copy_config_resp", ++ 53, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Response, copy_config_resp), ++ &sr__copy_config_resp__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "lock_resp", ++ 60, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Response, lock_resp), ++ &sr__lock_resp__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "unlock_resp", ++ 61, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Response, unlock_resp), ++ &sr__unlock_resp__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "subscribe_resp", ++ 70, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Response, subscribe_resp), ++ &sr__subscribe_resp__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "unsubscribe_resp", ++ 71, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Response, unsubscribe_resp), ++ &sr__unsubscribe_resp__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "check_enabled_running_resp", ++ 72, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Response, check_enabled_running_resp), ++ &sr__check_enabled_running_resp__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "get_changes_resp", ++ 73, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Response, get_changes_resp), ++ &sr__get_changes_resp__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "data_provide_resp", ++ 80, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Response, data_provide_resp), ++ &sr__data_provide_resp__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "check_exec_perm_resp", ++ 81, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Response, check_exec_perm_resp), ++ &sr__check_exec_perm_resp__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "rpc_resp", ++ 82, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Response, rpc_resp), ++ &sr__rpcresp__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "event_notif_resp", ++ 83, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Response, event_notif_resp), ++ &sr__event_notif_resp__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "event_notif_replay_resp", ++ 84, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Response, event_notif_replay_resp), ++ &sr__event_notif_replay_resp__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__response__field_indices_by_name[] = { ++ 31, /* field[31] = check_enabled_running_resp */ ++ 34, /* field[34] = check_exec_perm_resp */ ++ 24, /* field[24] = commit_resp */ ++ 26, /* field[26] = copy_config_resp */ ++ 33, /* field[33] = data_provide_resp */ ++ 20, /* field[20] = delete_item_resp */ ++ 25, /* field[25] = discard_changes_resp */ ++ 2, /* field[2] = error */ ++ 37, /* field[37] = event_notif_replay_resp */ ++ 36, /* field[36] = event_notif_resp */ ++ 13, /* field[13] = feature_enable_resp */ ++ 32, /* field[32] = get_changes_resp */ ++ 14, /* field[14] = get_item_resp */ ++ 15, /* field[15] = get_items_resp */ ++ 11, /* field[11] = get_schema_resp */ ++ 18, /* field[18] = get_subtree_chunk_resp */ ++ 16, /* field[16] = get_subtree_resp */ ++ 17, /* field[17] = get_subtrees_resp */ ++ 10, /* field[10] = list_schemas_resp */ ++ 27, /* field[27] = lock_resp */ ++ 12, /* field[12] = module_install_resp */ ++ 21, /* field[21] = move_item_resp */ ++ 0, /* field[0] = operation */ ++ 1, /* field[1] = result */ ++ 35, /* field[35] = rpc_resp */ ++ 6, /* field[6] = session_check_resp */ ++ 5, /* field[5] = session_refresh_resp */ ++ 8, /* field[8] = session_set_opts_resp */ ++ 3, /* field[3] = session_start_resp */ ++ 4, /* field[4] = session_stop_resp */ ++ 7, /* field[7] = session_switch_ds_resp */ ++ 19, /* field[19] = set_item_resp */ ++ 22, /* field[22] = set_item_str_resp */ ++ 29, /* field[29] = subscribe_resp */ ++ 28, /* field[28] = unlock_resp */ ++ 30, /* field[30] = unsubscribe_resp */ ++ 23, /* field[23] = validate_resp */ ++ 9, /* field[9] = version_verify_resp */ ++}; ++static const ProtobufCIntRange sr__response__number_ranges[9 + 1] = ++{ ++ { 1, 0 }, ++ { 10, 3 }, ++ { 20, 10 }, ++ { 30, 14 }, ++ { 40, 19 }, ++ { 50, 23 }, ++ { 60, 27 }, ++ { 70, 29 }, ++ { 80, 33 }, ++ { 0, 38 } ++}; ++const ProtobufCMessageDescriptor sr__response__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.Response", ++ "Response", ++ "Sr__Response", ++ "sr", ++ sizeof(Sr__Response), ++ 38, ++ sr__response__field_descriptors, ++ sr__response__field_indices_by_name, ++ 9, sr__response__number_ranges, ++ (ProtobufCMessageInit) sr__response__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__notification__field_descriptors[10] = ++{ ++ { ++ "type", ++ 1, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_ENUM, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Notification, type), ++ &sr__subscription_type__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "destination_address", ++ 2, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Notification, destination_address), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "source_address", ++ 3, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_STRING, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Notification, source_address), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "source_pid", ++ 4, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_UINT32, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Notification, source_pid), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "subscription_id", ++ 5, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_UINT32, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Notification, subscription_id), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "commit_id", ++ 6, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_UINT32, ++ offsetof(Sr__Notification, has_commit_id), ++ offsetof(Sr__Notification, commit_id), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "module_install_notif", ++ 10, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Notification, module_install_notif), ++ &sr__module_install_notification__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "feature_enable_notif", ++ 11, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Notification, feature_enable_notif), ++ &sr__feature_enable_notification__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "module_change_notif", ++ 12, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Notification, module_change_notif), ++ &sr__module_change_notification__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "subtree_change_notif", ++ 13, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Notification, subtree_change_notif), ++ &sr__subtree_change_notification__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__notification__field_indices_by_name[] = { ++ 5, /* field[5] = commit_id */ ++ 1, /* field[1] = destination_address */ ++ 7, /* field[7] = feature_enable_notif */ ++ 8, /* field[8] = module_change_notif */ ++ 6, /* field[6] = module_install_notif */ ++ 2, /* field[2] = source_address */ ++ 3, /* field[3] = source_pid */ ++ 4, /* field[4] = subscription_id */ ++ 9, /* field[9] = subtree_change_notif */ ++ 0, /* field[0] = type */ ++}; ++static const ProtobufCIntRange sr__notification__number_ranges[2 + 1] = ++{ ++ { 1, 0 }, ++ { 10, 6 }, ++ { 0, 10 } ++}; ++const ProtobufCMessageDescriptor sr__notification__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.Notification", ++ "Notification", ++ "Sr__Notification", ++ "sr", ++ sizeof(Sr__Notification), ++ 10, ++ sr__notification__field_descriptors, ++ sr__notification__field_indices_by_name, ++ 2, sr__notification__number_ranges, ++ (ProtobufCMessageInit) sr__notification__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__notification_ack__field_descriptors[4] = ++{ ++ { ++ "notif", ++ 1, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__NotificationAck, notif), ++ &sr__notification__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "result", ++ 2, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_UINT32, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__NotificationAck, result), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "error", ++ 3, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__NotificationAck, error), ++ &sr__error__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "do_not_send_abort", ++ 4, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_BOOL, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__NotificationAck, do_not_send_abort), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__notification_ack__field_indices_by_name[] = { ++ 3, /* field[3] = do_not_send_abort */ ++ 2, /* field[2] = error */ ++ 0, /* field[0] = notif */ ++ 1, /* field[1] = result */ ++}; ++static const ProtobufCIntRange sr__notification_ack__number_ranges[1 + 1] = ++{ ++ { 1, 0 }, ++ { 0, 4 } ++}; ++const ProtobufCMessageDescriptor sr__notification_ack__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.NotificationAck", ++ "NotificationAck", ++ "Sr__NotificationAck", ++ "sr", ++ sizeof(Sr__NotificationAck), ++ 4, ++ sr__notification_ack__field_descriptors, ++ sr__notification_ack__field_indices_by_name, ++ 1, sr__notification_ack__number_ranges, ++ (ProtobufCMessageInit) sr__notification_ack__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCFieldDescriptor sr__internal_request__field_descriptors[9] = ++{ ++ { ++ "operation", ++ 1, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_ENUM, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__InternalRequest, operation), ++ &sr__operation__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "postpone_timeout", ++ 2, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_UINT32, ++ offsetof(Sr__InternalRequest, has_postpone_timeout), ++ offsetof(Sr__InternalRequest, postpone_timeout), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "unsubscribe_dst_req", ++ 10, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__InternalRequest, unsubscribe_dst_req), ++ &sr__unsubscribe_destination_req__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "commit_timeout_req", ++ 11, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__InternalRequest, commit_timeout_req), ++ &sr__commit_timeout_req__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "oper_data_timeout_req", ++ 12, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__InternalRequest, oper_data_timeout_req), ++ &sr__oper_data_timeout_req__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "internal_state_data_req", ++ 13, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__InternalRequest, internal_state_data_req), ++ &sr__internal_state_data_req__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "notif_store_cleanup_req", ++ 14, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__InternalRequest, notif_store_cleanup_req), ++ &sr__notif_store_cleanup_req__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "delayed_msg_req", ++ 15, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__InternalRequest, delayed_msg_req), ++ &sr__delayed_msg_req__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "nacm_reload_req", ++ 16, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__InternalRequest, nacm_reload_req), ++ &sr__nacm_reload_req__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__internal_request__field_indices_by_name[] = { ++ 3, /* field[3] = commit_timeout_req */ ++ 7, /* field[7] = delayed_msg_req */ ++ 5, /* field[5] = internal_state_data_req */ ++ 8, /* field[8] = nacm_reload_req */ ++ 6, /* field[6] = notif_store_cleanup_req */ ++ 4, /* field[4] = oper_data_timeout_req */ ++ 0, /* field[0] = operation */ ++ 1, /* field[1] = postpone_timeout */ ++ 2, /* field[2] = unsubscribe_dst_req */ ++}; ++static const ProtobufCIntRange sr__internal_request__number_ranges[2 + 1] = ++{ ++ { 1, 0 }, ++ { 10, 2 }, ++ { 0, 9 } ++}; ++const ProtobufCMessageDescriptor sr__internal_request__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.InternalRequest", ++ "InternalRequest", ++ "Sr__InternalRequest", ++ "sr", ++ sizeof(Sr__InternalRequest), ++ 9, ++ sr__internal_request__field_descriptors, ++ sr__internal_request__field_indices_by_name, ++ 2, sr__internal_request__number_ranges, ++ (ProtobufCMessageInit) sr__internal_request__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCEnumValue sr__msg__msg_type__enum_values_by_number[5] = ++{ ++ { "REQUEST", "SR__MSG__MSG_TYPE__REQUEST", 1 }, ++ { "RESPONSE", "SR__MSG__MSG_TYPE__RESPONSE", 2 }, ++ { "NOTIFICATION", "SR__MSG__MSG_TYPE__NOTIFICATION", 3 }, ++ { "NOTIFICATION_ACK", "SR__MSG__MSG_TYPE__NOTIFICATION_ACK", 4 }, ++ { "INTERNAL_REQUEST", "SR__MSG__MSG_TYPE__INTERNAL_REQUEST", 5 }, ++}; ++static const ProtobufCIntRange sr__msg__msg_type__value_ranges[] = { ++{1, 0},{0, 5} ++}; ++static const ProtobufCEnumValueIndex sr__msg__msg_type__enum_values_by_name[5] = ++{ ++ { "INTERNAL_REQUEST", 4 }, ++ { "NOTIFICATION", 2 }, ++ { "NOTIFICATION_ACK", 3 }, ++ { "REQUEST", 0 }, ++ { "RESPONSE", 1 }, ++}; ++const ProtobufCEnumDescriptor sr__msg__msg_type__descriptor = ++{ ++ PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC, ++ "sr.Msg.MsgType", ++ "MsgType", ++ "Sr__Msg__MsgType", ++ "sr", ++ 5, ++ sr__msg__msg_type__enum_values_by_number, ++ 5, ++ sr__msg__msg_type__enum_values_by_name, ++ 1, ++ sr__msg__msg_type__value_ranges, ++ NULL,NULL,NULL,NULL /* reserved[1234] */ ++}; ++static const ProtobufCFieldDescriptor sr__msg__field_descriptors[8] = ++{ ++ { ++ "type", ++ 1, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_ENUM, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Msg, type), ++ &sr__msg__msg_type__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "session_id", ++ 2, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_UINT32, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Msg, session_id), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "request", ++ 3, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Msg, request), ++ &sr__request__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "response", ++ 4, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Msg, response), ++ &sr__response__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "notification", ++ 5, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Msg, notification), ++ &sr__notification__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "notification_ack", ++ 6, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Msg, notification_ack), ++ &sr__notification_ack__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "internal_request", ++ 7, ++ PROTOBUF_C_LABEL_OPTIONAL, ++ PROTOBUF_C_TYPE_MESSAGE, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Msg, internal_request), ++ &sr__internal_request__descriptor, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++ { ++ "_sysrepo_mem_ctx", ++ 20, ++ PROTOBUF_C_LABEL_REQUIRED, ++ PROTOBUF_C_TYPE_UINT64, ++ 0, /* quantifier_offset */ ++ offsetof(Sr__Msg, _sysrepo_mem_ctx), ++ NULL, ++ NULL, ++ 0, /* flags */ ++ 0,NULL,NULL /* reserved1,reserved2, etc */ ++ }, ++}; ++static const unsigned sr__msg__field_indices_by_name[] = { ++ 7, /* field[7] = _sysrepo_mem_ctx */ ++ 6, /* field[6] = internal_request */ ++ 4, /* field[4] = notification */ ++ 5, /* field[5] = notification_ack */ ++ 2, /* field[2] = request */ ++ 3, /* field[3] = response */ ++ 1, /* field[1] = session_id */ ++ 0, /* field[0] = type */ ++}; ++static const ProtobufCIntRange sr__msg__number_ranges[2 + 1] = ++{ ++ { 1, 0 }, ++ { 20, 7 }, ++ { 0, 8 } ++}; ++const ProtobufCMessageDescriptor sr__msg__descriptor = ++{ ++ PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC, ++ "sr.Msg", ++ "Msg", ++ "Sr__Msg", ++ "sr", ++ sizeof(Sr__Msg), ++ 8, ++ sr__msg__field_descriptors, ++ sr__msg__field_indices_by_name, ++ 2, sr__msg__number_ranges, ++ (ProtobufCMessageInit) sr__msg__init, ++ NULL,NULL,NULL /* reserved[123] */ ++}; ++static const ProtobufCEnumValue sr__api_variant__enum_values_by_number[2] = ++{ ++ { "VALUES", "SR__API_VARIANT__VALUES", 1 }, ++ { "TREES", "SR__API_VARIANT__TREES", 2 }, ++}; ++static const ProtobufCIntRange sr__api_variant__value_ranges[] = { ++{1, 0},{0, 2} ++}; ++static const ProtobufCEnumValueIndex sr__api_variant__enum_values_by_name[2] = ++{ ++ { "TREES", 1 }, ++ { "VALUES", 0 }, ++}; ++const ProtobufCEnumDescriptor sr__api_variant__descriptor = ++{ ++ PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC, ++ "sr.ApiVariant", ++ "ApiVariant", ++ "Sr__ApiVariant", ++ "sr", ++ 2, ++ sr__api_variant__enum_values_by_number, ++ 2, ++ sr__api_variant__enum_values_by_name, ++ 1, ++ sr__api_variant__value_ranges, ++ NULL,NULL,NULL,NULL /* reserved[1234] */ ++}; ++static const ProtobufCEnumValue sr__data_store__enum_values_by_number[3] = ++{ ++ { "STARTUP", "SR__DATA_STORE__STARTUP", 1 }, ++ { "RUNNING", "SR__DATA_STORE__RUNNING", 2 }, ++ { "CANDIDATE", "SR__DATA_STORE__CANDIDATE", 3 }, ++}; ++static const ProtobufCIntRange sr__data_store__value_ranges[] = { ++{1, 0},{0, 3} ++}; ++static const ProtobufCEnumValueIndex sr__data_store__enum_values_by_name[3] = ++{ ++ { "CANDIDATE", 2 }, ++ { "RUNNING", 1 }, ++ { "STARTUP", 0 }, ++}; ++const ProtobufCEnumDescriptor sr__data_store__descriptor = ++{ ++ PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC, ++ "sr.DataStore", ++ "DataStore", ++ "Sr__DataStore", ++ "sr", ++ 3, ++ sr__data_store__enum_values_by_number, ++ 3, ++ sr__data_store__enum_values_by_name, ++ 1, ++ sr__data_store__value_ranges, ++ NULL,NULL,NULL,NULL /* reserved[1234] */ ++}; ++static const ProtobufCEnumValue sr__session_flags__enum_values_by_number[4] = ++{ ++ { "SESS_DEFAULT", "SR__SESSION_FLAGS__SESS_DEFAULT", 0 }, ++ { "SESS_CONFIG_ONLY", "SR__SESSION_FLAGS__SESS_CONFIG_ONLY", 1 }, ++ { "SESS_ENABLE_NACM", "SR__SESSION_FLAGS__SESS_ENABLE_NACM", 2 }, ++ { "SESS_NOTIFICATION", "SR__SESSION_FLAGS__SESS_NOTIFICATION", 1024 }, ++}; ++static const ProtobufCIntRange sr__session_flags__value_ranges[] = { ++{0, 0},{1024, 3},{0, 4} ++}; ++static const ProtobufCEnumValueIndex sr__session_flags__enum_values_by_name[4] = ++{ ++ { "SESS_CONFIG_ONLY", 1 }, ++ { "SESS_DEFAULT", 0 }, ++ { "SESS_ENABLE_NACM", 2 }, ++ { "SESS_NOTIFICATION", 3 }, ++}; ++const ProtobufCEnumDescriptor sr__session_flags__descriptor = ++{ ++ PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC, ++ "sr.SessionFlags", ++ "SessionFlags", ++ "Sr__SessionFlags", ++ "sr", ++ 4, ++ sr__session_flags__enum_values_by_number, ++ 4, ++ sr__session_flags__enum_values_by_name, ++ 2, ++ sr__session_flags__value_ranges, ++ NULL,NULL,NULL,NULL /* reserved[1234] */ ++}; ++static const ProtobufCEnumValue sr__edit_flags__enum_values_by_number[3] = ++{ ++ { "EDIT_DEFAULT", "SR__EDIT_FLAGS__EDIT_DEFAULT", 0 }, ++ { "EDIT_NON_RECURSIVE", "SR__EDIT_FLAGS__EDIT_NON_RECURSIVE", 1 }, ++ { "EDIT_STRICT", "SR__EDIT_FLAGS__EDIT_STRICT", 2 }, ++}; ++static const ProtobufCIntRange sr__edit_flags__value_ranges[] = { ++{0, 0},{0, 3} ++}; ++static const ProtobufCEnumValueIndex sr__edit_flags__enum_values_by_name[3] = ++{ ++ { "EDIT_DEFAULT", 0 }, ++ { "EDIT_NON_RECURSIVE", 1 }, ++ { "EDIT_STRICT", 2 }, ++}; ++const ProtobufCEnumDescriptor sr__edit_flags__descriptor = ++{ ++ PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC, ++ "sr.EditFlags", ++ "EditFlags", ++ "Sr__EditFlags", ++ "sr", ++ 3, ++ sr__edit_flags__enum_values_by_number, ++ 3, ++ sr__edit_flags__enum_values_by_name, ++ 1, ++ sr__edit_flags__value_ranges, ++ NULL,NULL,NULL,NULL /* reserved[1234] */ ++}; ++static const ProtobufCEnumValue sr__subscription_type__enum_values_by_number[10] = ++{ ++ { "MODULE_INSTALL_SUBS", "SR__SUBSCRIPTION_TYPE__MODULE_INSTALL_SUBS", 1 }, ++ { "FEATURE_ENABLE_SUBS", "SR__SUBSCRIPTION_TYPE__FEATURE_ENABLE_SUBS", 2 }, ++ { "MODULE_CHANGE_SUBS", "SR__SUBSCRIPTION_TYPE__MODULE_CHANGE_SUBS", 10 }, ++ { "SUBTREE_CHANGE_SUBS", "SR__SUBSCRIPTION_TYPE__SUBTREE_CHANGE_SUBS", 11 }, ++ { "DP_GET_ITEMS_SUBS", "SR__SUBSCRIPTION_TYPE__DP_GET_ITEMS_SUBS", 20 }, ++ { "RPC_SUBS", "SR__SUBSCRIPTION_TYPE__RPC_SUBS", 30 }, ++ { "ACTION_SUBS", "SR__SUBSCRIPTION_TYPE__ACTION_SUBS", 31 }, ++ { "EVENT_NOTIF_SUBS", "SR__SUBSCRIPTION_TYPE__EVENT_NOTIF_SUBS", 40 }, ++ { "HELLO_SUBS", "SR__SUBSCRIPTION_TYPE__HELLO_SUBS", 50 }, ++ { "COMMIT_END_SUBS", "SR__SUBSCRIPTION_TYPE__COMMIT_END_SUBS", 51 }, ++}; ++static const ProtobufCIntRange sr__subscription_type__value_ranges[] = { ++{1, 0},{10, 2},{20, 4},{30, 5},{40, 7},{50, 8},{0, 10} ++}; ++static const ProtobufCEnumValueIndex sr__subscription_type__enum_values_by_name[10] = ++{ ++ { "ACTION_SUBS", 6 }, ++ { "COMMIT_END_SUBS", 9 }, ++ { "DP_GET_ITEMS_SUBS", 4 }, ++ { "EVENT_NOTIF_SUBS", 7 }, ++ { "FEATURE_ENABLE_SUBS", 1 }, ++ { "HELLO_SUBS", 8 }, ++ { "MODULE_CHANGE_SUBS", 2 }, ++ { "MODULE_INSTALL_SUBS", 0 }, ++ { "RPC_SUBS", 5 }, ++ { "SUBTREE_CHANGE_SUBS", 3 }, ++}; ++const ProtobufCEnumDescriptor sr__subscription_type__descriptor = ++{ ++ PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC, ++ "sr.SubscriptionType", ++ "SubscriptionType", ++ "Sr__SubscriptionType", ++ "sr", ++ 10, ++ sr__subscription_type__enum_values_by_number, ++ 10, ++ sr__subscription_type__enum_values_by_name, ++ 6, ++ sr__subscription_type__value_ranges, ++ NULL,NULL,NULL,NULL /* reserved[1234] */ ++}; ++static const ProtobufCEnumValue sr__notification_event__enum_values_by_number[4] = ++{ ++ { "VERIFY_EV", "SR__NOTIFICATION_EVENT__VERIFY_EV", 1 }, ++ { "APPLY_EV", "SR__NOTIFICATION_EVENT__APPLY_EV", 2 }, ++ { "ABORT_EV", "SR__NOTIFICATION_EVENT__ABORT_EV", 3 }, ++ { "ENABLED_EV", "SR__NOTIFICATION_EVENT__ENABLED_EV", 4 }, ++}; ++static const ProtobufCIntRange sr__notification_event__value_ranges[] = { ++{1, 0},{0, 4} ++}; ++static const ProtobufCEnumValueIndex sr__notification_event__enum_values_by_name[4] = ++{ ++ { "ABORT_EV", 2 }, ++ { "APPLY_EV", 1 }, ++ { "ENABLED_EV", 3 }, ++ { "VERIFY_EV", 0 }, ++}; ++const ProtobufCEnumDescriptor sr__notification_event__descriptor = ++{ ++ PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC, ++ "sr.NotificationEvent", ++ "NotificationEvent", ++ "Sr__NotificationEvent", ++ "sr", ++ 4, ++ sr__notification_event__enum_values_by_number, ++ 4, ++ sr__notification_event__enum_values_by_name, ++ 1, ++ sr__notification_event__value_ranges, ++ NULL,NULL,NULL,NULL /* reserved[1234] */ ++}; ++static const ProtobufCEnumValue sr__module_state__enum_values_by_number[3] = ++{ ++ { "UNINSTALLED", "SR__MODULE_STATE__UNINSTALLED", 1 }, ++ { "IMPORTED", "SR__MODULE_STATE__IMPORTED", 2 }, ++ { "IMPLEMENTED", "SR__MODULE_STATE__IMPLEMENTED", 3 }, ++}; ++static const ProtobufCIntRange sr__module_state__value_ranges[] = { ++{1, 0},{0, 3} ++}; ++static const ProtobufCEnumValueIndex sr__module_state__enum_values_by_name[3] = ++{ ++ { "IMPLEMENTED", 2 }, ++ { "IMPORTED", 1 }, ++ { "UNINSTALLED", 0 }, ++}; ++const ProtobufCEnumDescriptor sr__module_state__descriptor = ++{ ++ PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC, ++ "sr.ModuleState", ++ "ModuleState", ++ "Sr__ModuleState", ++ "sr", ++ 3, ++ sr__module_state__enum_values_by_number, ++ 3, ++ sr__module_state__enum_values_by_name, ++ 1, ++ sr__module_state__value_ranges, ++ NULL,NULL,NULL,NULL /* reserved[1234] */ ++}; ++static const ProtobufCEnumValue sr__change_operation__enum_values_by_number[4] = ++{ ++ { "CREATED", "SR__CHANGE_OPERATION__CREATED", 1 }, ++ { "MODIFIED", "SR__CHANGE_OPERATION__MODIFIED", 2 }, ++ { "DELETED", "SR__CHANGE_OPERATION__DELETED", 3 }, ++ { "MOVED", "SR__CHANGE_OPERATION__MOVED", 4 }, ++}; ++static const ProtobufCIntRange sr__change_operation__value_ranges[] = { ++{1, 0},{0, 4} ++}; ++static const ProtobufCEnumValueIndex sr__change_operation__enum_values_by_name[4] = ++{ ++ { "CREATED", 0 }, ++ { "DELETED", 2 }, ++ { "MODIFIED", 1 }, ++ { "MOVED", 3 }, ++}; ++const ProtobufCEnumDescriptor sr__change_operation__descriptor = ++{ ++ PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC, ++ "sr.ChangeOperation", ++ "ChangeOperation", ++ "Sr__ChangeOperation", ++ "sr", ++ 4, ++ sr__change_operation__enum_values_by_number, ++ 4, ++ sr__change_operation__enum_values_by_name, ++ 1, ++ sr__change_operation__value_ranges, ++ NULL,NULL,NULL,NULL /* reserved[1234] */ ++}; ++static const ProtobufCEnumValue sr__operation__enum_values_by_number[43] = ++{ ++ { "SESSION_START", "SR__OPERATION__SESSION_START", 10 }, ++ { "SESSION_STOP", "SR__OPERATION__SESSION_STOP", 11 }, ++ { "SESSION_REFRESH", "SR__OPERATION__SESSION_REFRESH", 12 }, ++ { "SESSION_CHECK", "SR__OPERATION__SESSION_CHECK", 13 }, ++ { "SESSION_SWITCH_DS", "SR__OPERATION__SESSION_SWITCH_DS", 14 }, ++ { "SESSION_SET_OPTS", "SR__OPERATION__SESSION_SET_OPTS", 15 }, ++ { "VERSION_VERIFY", "SR__OPERATION__VERSION_VERIFY", 16 }, ++ { "LIST_SCHEMAS", "SR__OPERATION__LIST_SCHEMAS", 20 }, ++ { "GET_SCHEMA", "SR__OPERATION__GET_SCHEMA", 21 }, ++ { "MODULE_INSTALL", "SR__OPERATION__MODULE_INSTALL", 22 }, ++ { "FEATURE_ENABLE", "SR__OPERATION__FEATURE_ENABLE", 23 }, ++ { "GET_ITEM", "SR__OPERATION__GET_ITEM", 30 }, ++ { "GET_ITEMS", "SR__OPERATION__GET_ITEMS", 31 }, ++ { "GET_SUBTREE", "SR__OPERATION__GET_SUBTREE", 32 }, ++ { "GET_SUBTREES", "SR__OPERATION__GET_SUBTREES", 33 }, ++ { "GET_SUBTREE_CHUNK", "SR__OPERATION__GET_SUBTREE_CHUNK", 34 }, ++ { "SET_ITEM", "SR__OPERATION__SET_ITEM", 40 }, ++ { "DELETE_ITEM", "SR__OPERATION__DELETE_ITEM", 41 }, ++ { "MOVE_ITEM", "SR__OPERATION__MOVE_ITEM", 42 }, ++ { "SET_ITEM_STR", "SR__OPERATION__SET_ITEM_STR", 43 }, ++ { "VALIDATE", "SR__OPERATION__VALIDATE", 50 }, ++ { "COMMIT", "SR__OPERATION__COMMIT", 51 }, ++ { "DISCARD_CHANGES", "SR__OPERATION__DISCARD_CHANGES", 52 }, ++ { "COPY_CONFIG", "SR__OPERATION__COPY_CONFIG", 53 }, ++ { "LOCK", "SR__OPERATION__LOCK", 60 }, ++ { "UNLOCK", "SR__OPERATION__UNLOCK", 61 }, ++ { "SUBSCRIBE", "SR__OPERATION__SUBSCRIBE", 70 }, ++ { "UNSUBSCRIBE", "SR__OPERATION__UNSUBSCRIBE", 71 }, ++ { "CHECK_ENABLED_RUNNING", "SR__OPERATION__CHECK_ENABLED_RUNNING", 72 }, ++ { "GET_CHANGES", "SR__OPERATION__GET_CHANGES", 73 }, ++ { "DATA_PROVIDE", "SR__OPERATION__DATA_PROVIDE", 80 }, ++ { "CHECK_EXEC_PERMISSION", "SR__OPERATION__CHECK_EXEC_PERMISSION", 81 }, ++ { "RPC", "SR__OPERATION__RPC", 82 }, ++ { "ACTION", "SR__OPERATION__ACTION", 83 }, ++ { "EVENT_NOTIF", "SR__OPERATION__EVENT_NOTIF", 84 }, ++ { "EVENT_NOTIF_REPLAY", "SR__OPERATION__EVENT_NOTIF_REPLAY", 85 }, ++ { "UNSUBSCRIBE_DESTINATION", "SR__OPERATION__UNSUBSCRIBE_DESTINATION", 101 }, ++ { "COMMIT_TIMEOUT", "SR__OPERATION__COMMIT_TIMEOUT", 102 }, ++ { "OPER_DATA_TIMEOUT", "SR__OPERATION__OPER_DATA_TIMEOUT", 103 }, ++ { "INTERNAL_STATE_DATA", "SR__OPERATION__INTERNAL_STATE_DATA", 104 }, ++ { "NOTIF_STORE_CLEANUP", "SR__OPERATION__NOTIF_STORE_CLEANUP", 105 }, ++ { "DELAYED_MSG", "SR__OPERATION__DELAYED_MSG", 106 }, ++ { "NACM_RELOAD", "SR__OPERATION__NACM_RELOAD", 107 }, ++}; ++static const ProtobufCIntRange sr__operation__value_ranges[] = { ++{10, 0},{20, 7},{30, 11},{40, 16},{50, 20},{60, 24},{70, 26},{80, 30},{101, 36},{0, 43} ++}; ++static const ProtobufCEnumValueIndex sr__operation__enum_values_by_name[43] = ++{ ++ { "ACTION", 33 }, ++ { "CHECK_ENABLED_RUNNING", 28 }, ++ { "CHECK_EXEC_PERMISSION", 31 }, ++ { "COMMIT", 21 }, ++ { "COMMIT_TIMEOUT", 37 }, ++ { "COPY_CONFIG", 23 }, ++ { "DATA_PROVIDE", 30 }, ++ { "DELAYED_MSG", 41 }, ++ { "DELETE_ITEM", 17 }, ++ { "DISCARD_CHANGES", 22 }, ++ { "EVENT_NOTIF", 34 }, ++ { "EVENT_NOTIF_REPLAY", 35 }, ++ { "FEATURE_ENABLE", 10 }, ++ { "GET_CHANGES", 29 }, ++ { "GET_ITEM", 11 }, ++ { "GET_ITEMS", 12 }, ++ { "GET_SCHEMA", 8 }, ++ { "GET_SUBTREE", 13 }, ++ { "GET_SUBTREES", 14 }, ++ { "GET_SUBTREE_CHUNK", 15 }, ++ { "INTERNAL_STATE_DATA", 39 }, ++ { "LIST_SCHEMAS", 7 }, ++ { "LOCK", 24 }, ++ { "MODULE_INSTALL", 9 }, ++ { "MOVE_ITEM", 18 }, ++ { "NACM_RELOAD", 42 }, ++ { "NOTIF_STORE_CLEANUP", 40 }, ++ { "OPER_DATA_TIMEOUT", 38 }, ++ { "RPC", 32 }, ++ { "SESSION_CHECK", 3 }, ++ { "SESSION_REFRESH", 2 }, ++ { "SESSION_SET_OPTS", 5 }, ++ { "SESSION_START", 0 }, ++ { "SESSION_STOP", 1 }, ++ { "SESSION_SWITCH_DS", 4 }, ++ { "SET_ITEM", 16 }, ++ { "SET_ITEM_STR", 19 }, ++ { "SUBSCRIBE", 26 }, ++ { "UNLOCK", 25 }, ++ { "UNSUBSCRIBE", 27 }, ++ { "UNSUBSCRIBE_DESTINATION", 36 }, ++ { "VALIDATE", 20 }, ++ { "VERSION_VERIFY", 6 }, ++}; ++const ProtobufCEnumDescriptor sr__operation__descriptor = ++{ ++ PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC, ++ "sr.Operation", ++ "Operation", ++ "Sr__Operation", ++ "sr", ++ 43, ++ sr__operation__enum_values_by_number, ++ 43, ++ sr__operation__enum_values_by_name, ++ 9, ++ sr__operation__value_ranges, ++ NULL,NULL,NULL,NULL /* reserved[1234] */ ++}; +Index: sysrepo-e4a5705a4c5293ba121048c71899b98243d99edf/src/common/sysrepo.pb-c.h +=================================================================== +--- /dev/null ++++ sysrepo-e4a5705a4c5293ba121048c71899b98243d99edf/src/common/sysrepo.pb-c.h +@@ -0,0 +1,4236 @@ ++/* Generated by the protocol buffer compiler. DO NOT EDIT! */ ++/* Generated from: sysrepo.proto */ ++ ++#ifndef PROTOBUF_C_sysrepo_2eproto__INCLUDED ++#define PROTOBUF_C_sysrepo_2eproto__INCLUDED ++ ++#include ++ ++PROTOBUF_C__BEGIN_DECLS ++ ++#if PROTOBUF_C_VERSION_NUMBER < 1000000 ++# error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers. ++#elif 1001001 < PROTOBUF_C_MIN_COMPILER_VERSION ++# error This file was generated by an older version of protoc-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protoc-c. ++#endif ++ ++ ++typedef struct _Sr__Value Sr__Value; ++typedef struct _Sr__Node Sr__Node; ++typedef struct _Sr__Error Sr__Error; ++typedef struct _Sr__SessionStartReq Sr__SessionStartReq; ++typedef struct _Sr__SessionStartResp Sr__SessionStartResp; ++typedef struct _Sr__SessionStopReq Sr__SessionStopReq; ++typedef struct _Sr__SessionStopResp Sr__SessionStopResp; ++typedef struct _Sr__SessionRefreshReq Sr__SessionRefreshReq; ++typedef struct _Sr__SessionRefreshResp Sr__SessionRefreshResp; ++typedef struct _Sr__SessionCheckReq Sr__SessionCheckReq; ++typedef struct _Sr__SessionCheckResp Sr__SessionCheckResp; ++typedef struct _Sr__SessionSwitchDsReq Sr__SessionSwitchDsReq; ++typedef struct _Sr__SessionSwitchDsResp Sr__SessionSwitchDsResp; ++typedef struct _Sr__SessionSetOptsReq Sr__SessionSetOptsReq; ++typedef struct _Sr__SessionSetOptsResp Sr__SessionSetOptsResp; ++typedef struct _Sr__VersionVerifyReq Sr__VersionVerifyReq; ++typedef struct _Sr__VersionVerifyResp Sr__VersionVerifyResp; ++typedef struct _Sr__SchemaRevision Sr__SchemaRevision; ++typedef struct _Sr__SchemaSubmodule Sr__SchemaSubmodule; ++typedef struct _Sr__Schema Sr__Schema; ++typedef struct _Sr__ListSchemasReq Sr__ListSchemasReq; ++typedef struct _Sr__ListSchemasResp Sr__ListSchemasResp; ++typedef struct _Sr__GetSchemaReq Sr__GetSchemaReq; ++typedef struct _Sr__GetSchemaResp Sr__GetSchemaResp; ++typedef struct _Sr__GetItemReq Sr__GetItemReq; ++typedef struct _Sr__GetItemResp Sr__GetItemResp; ++typedef struct _Sr__GetItemsReq Sr__GetItemsReq; ++typedef struct _Sr__GetItemsResp Sr__GetItemsResp; ++typedef struct _Sr__GetSubtreeReq Sr__GetSubtreeReq; ++typedef struct _Sr__GetSubtreeResp Sr__GetSubtreeResp; ++typedef struct _Sr__GetSubtreesReq Sr__GetSubtreesReq; ++typedef struct _Sr__GetSubtreesResp Sr__GetSubtreesResp; ++typedef struct _Sr__GetSubtreeChunkReq Sr__GetSubtreeChunkReq; ++typedef struct _Sr__GetSubtreeChunkResp Sr__GetSubtreeChunkResp; ++typedef struct _Sr__SetItemReq Sr__SetItemReq; ++typedef struct _Sr__SetItemResp Sr__SetItemResp; ++typedef struct _Sr__SetItemStrReq Sr__SetItemStrReq; ++typedef struct _Sr__SetItemStrResp Sr__SetItemStrResp; ++typedef struct _Sr__DeleteItemReq Sr__DeleteItemReq; ++typedef struct _Sr__DeleteItemResp Sr__DeleteItemResp; ++typedef struct _Sr__MoveItemReq Sr__MoveItemReq; ++typedef struct _Sr__MoveItemResp Sr__MoveItemResp; ++typedef struct _Sr__ValidateReq Sr__ValidateReq; ++typedef struct _Sr__ValidateResp Sr__ValidateResp; ++typedef struct _Sr__CommitReq Sr__CommitReq; ++typedef struct _Sr__CommitResp Sr__CommitResp; ++typedef struct _Sr__DiscardChangesReq Sr__DiscardChangesReq; ++typedef struct _Sr__DiscardChangesResp Sr__DiscardChangesResp; ++typedef struct _Sr__CopyConfigReq Sr__CopyConfigReq; ++typedef struct _Sr__CopyConfigResp Sr__CopyConfigResp; ++typedef struct _Sr__LockReq Sr__LockReq; ++typedef struct _Sr__LockResp Sr__LockResp; ++typedef struct _Sr__UnlockReq Sr__UnlockReq; ++typedef struct _Sr__UnlockResp Sr__UnlockResp; ++typedef struct _Sr__SubscribeReq Sr__SubscribeReq; ++typedef struct _Sr__SubscribeResp Sr__SubscribeResp; ++typedef struct _Sr__UnsubscribeReq Sr__UnsubscribeReq; ++typedef struct _Sr__UnsubscribeResp Sr__UnsubscribeResp; ++typedef struct _Sr__CheckEnabledRunningReq Sr__CheckEnabledRunningReq; ++typedef struct _Sr__CheckEnabledRunningResp Sr__CheckEnabledRunningResp; ++typedef struct _Sr__ModuleInstallNotification Sr__ModuleInstallNotification; ++typedef struct _Sr__FeatureEnableNotification Sr__FeatureEnableNotification; ++typedef struct _Sr__ModuleChangeNotification Sr__ModuleChangeNotification; ++typedef struct _Sr__SubtreeChangeNotification Sr__SubtreeChangeNotification; ++typedef struct _Sr__Change Sr__Change; ++typedef struct _Sr__GetChangesReq Sr__GetChangesReq; ++typedef struct _Sr__GetChangesResp Sr__GetChangesResp; ++typedef struct _Sr__CheckExecPermReq Sr__CheckExecPermReq; ++typedef struct _Sr__CheckExecPermResp Sr__CheckExecPermResp; ++typedef struct _Sr__RPCReq Sr__RPCReq; ++typedef struct _Sr__RPCResp Sr__RPCResp; ++typedef struct _Sr__EventNotifReq Sr__EventNotifReq; ++typedef struct _Sr__EventNotifResp Sr__EventNotifResp; ++typedef struct _Sr__EventNotifReplayReq Sr__EventNotifReplayReq; ++typedef struct _Sr__EventNotifReplayResp Sr__EventNotifReplayResp; ++typedef struct _Sr__DataProvideReq Sr__DataProvideReq; ++typedef struct _Sr__DataProvideResp Sr__DataProvideResp; ++typedef struct _Sr__ModuleInstallReq Sr__ModuleInstallReq; ++typedef struct _Sr__ModuleInstallResp Sr__ModuleInstallResp; ++typedef struct _Sr__FeatureEnableReq Sr__FeatureEnableReq; ++typedef struct _Sr__FeatureEnableResp Sr__FeatureEnableResp; ++typedef struct _Sr__UnsubscribeDestinationReq Sr__UnsubscribeDestinationReq; ++typedef struct _Sr__CommitTimeoutReq Sr__CommitTimeoutReq; ++typedef struct _Sr__OperDataTimeoutReq Sr__OperDataTimeoutReq; ++typedef struct _Sr__InternalStateDataReq Sr__InternalStateDataReq; ++typedef struct _Sr__NotifStoreCleanupReq Sr__NotifStoreCleanupReq; ++typedef struct _Sr__DelayedMsgReq Sr__DelayedMsgReq; ++typedef struct _Sr__NacmReloadReq Sr__NacmReloadReq; ++typedef struct _Sr__Request Sr__Request; ++typedef struct _Sr__Response Sr__Response; ++typedef struct _Sr__Notification Sr__Notification; ++typedef struct _Sr__NotificationAck Sr__NotificationAck; ++typedef struct _Sr__InternalRequest Sr__InternalRequest; ++typedef struct _Sr__Msg Sr__Msg; ++ ++ ++/* --- enums --- */ ++ ++typedef enum _Sr__Value__Types { ++ SR__VALUE__TYPES__LIST = 1, ++ SR__VALUE__TYPES__CONTAINER = 2, ++ SR__VALUE__TYPES__CONTAINER_PRESENCE = 3, ++ SR__VALUE__TYPES__LEAF_EMPTY = 4, ++ SR__VALUE__TYPES__BINARY = 10, ++ SR__VALUE__TYPES__BITS = 11, ++ SR__VALUE__TYPES__BOOL = 12, ++ SR__VALUE__TYPES__DECIMAL64 = 13, ++ SR__VALUE__TYPES__ENUM = 14, ++ SR__VALUE__TYPES__IDENTITYREF = 15, ++ SR__VALUE__TYPES__INSTANCEID = 16, ++ SR__VALUE__TYPES__INT8 = 17, ++ SR__VALUE__TYPES__INT16 = 18, ++ SR__VALUE__TYPES__INT32 = 19, ++ SR__VALUE__TYPES__INT64 = 20, ++ SR__VALUE__TYPES__STRING = 21, ++ SR__VALUE__TYPES__UINT8 = 22, ++ SR__VALUE__TYPES__UINT16 = 23, ++ SR__VALUE__TYPES__UINT32 = 24, ++ SR__VALUE__TYPES__UINT64 = 25, ++ SR__VALUE__TYPES__ANYXML = 26, ++ SR__VALUE__TYPES__ANYDATA = 27 ++ PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SR__VALUE__TYPES) ++} Sr__Value__Types; ++typedef enum _Sr__MoveItemReq__MovePosition { ++ SR__MOVE_ITEM_REQ__MOVE_POSITION__BEFORE = 1, ++ SR__MOVE_ITEM_REQ__MOVE_POSITION__AFTER = 2, ++ SR__MOVE_ITEM_REQ__MOVE_POSITION__FIRST = 3, ++ SR__MOVE_ITEM_REQ__MOVE_POSITION__LAST = 4 ++ PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SR__MOVE_ITEM_REQ__MOVE_POSITION) ++} Sr__MoveItemReq__MovePosition; ++/* ++ ** ++ * @brief Type of the event notification. ++ */ ++typedef enum _Sr__EventNotifReq__NotifType { ++ SR__EVENT_NOTIF_REQ__NOTIF_TYPE__REALTIME = 1, ++ SR__EVENT_NOTIF_REQ__NOTIF_TYPE__REPLAY = 2, ++ SR__EVENT_NOTIF_REQ__NOTIF_TYPE__REPLAY_COMPLETE = 3, ++ SR__EVENT_NOTIF_REQ__NOTIF_TYPE__REPLAY_STOP = 4 ++ PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SR__EVENT_NOTIF_REQ__NOTIF_TYPE) ++} Sr__EventNotifReq__NotifType; ++/* ++ ** ++ * @brief Flags used to override default session handling. ++ */ ++typedef enum _Sr__EventNotifReq__NotifFlags { ++ /* ++ **< Notification will be handled normally. ++ */ ++ SR__EVENT_NOTIF_REQ__NOTIF_FLAGS__DEFAULT = 0, ++ /* ++ **< Notification will not be stored in the notification store. ++ */ ++ SR__EVENT_NOTIF_REQ__NOTIF_FLAGS__EPHEMERAL = 1 ++ PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SR__EVENT_NOTIF_REQ__NOTIF_FLAGS) ++} Sr__EventNotifReq__NotifFlags; ++/* ++ ** ++ * @brief Type of the message. ++ */ ++typedef enum _Sr__Msg__MsgType { ++ /* ++ **< The message is a request. ++ */ ++ SR__MSG__MSG_TYPE__REQUEST = 1, ++ /* ++ **< The message is a response to the request. ++ */ ++ SR__MSG__MSG_TYPE__RESPONSE = 2, ++ /* ++ **< The message is a notification. ++ */ ++ SR__MSG__MSG_TYPE__NOTIFICATION = 3, ++ /* ++ **< The message is a notification acknowledgment. ++ */ ++ SR__MSG__MSG_TYPE__NOTIFICATION_ACK = 4, ++ /* ++ **< The message is an internal request, should not be used from the public API. ++ */ ++ SR__MSG__MSG_TYPE__INTERNAL_REQUEST = 5 ++ PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SR__MSG__MSG_TYPE) ++} Sr__Msg__MsgType; ++/* ++ ** ++ * @brief Variant of the API. Currently only values (sr_val_t) vs. trees (sr_node_t). ++ */ ++typedef enum _Sr__ApiVariant { ++ SR__API_VARIANT__VALUES = 1, ++ SR__API_VARIANT__TREES = 2 ++ PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SR__API_VARIANT) ++} Sr__ApiVariant; ++/* ++ ** ++ * @brief Datastore on which the configuration session will operate. ++ */ ++typedef enum _Sr__DataStore { ++ SR__DATA_STORE__STARTUP = 1, ++ SR__DATA_STORE__RUNNING = 2, ++ SR__DATA_STORE__CANDIDATE = 3 ++ PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SR__DATA_STORE) ++} Sr__DataStore; ++/* ++ ** ++ * @brief Flags used to override default session handling. ++ */ ++typedef enum _Sr__SessionFlags { ++ /* ++ **< Default (normal) session behavior. ++ */ ++ SR__SESSION_FLAGS__SESS_DEFAULT = 0, ++ /* ++ **< Session will process only configuration data (e.g. sysrepo won't ++ *return any state data by ::sr_get_items / ::sr_get_items_iter calls). ++ */ ++ SR__SESSION_FLAGS__SESS_CONFIG_ONLY = 1, ++ /* ++ **< Enable NETCONF access control for this session. ++ */ ++ SR__SESSION_FLAGS__SESS_ENABLE_NACM = 2, ++ /* ++ **< Notification session (internal type of session). ++ */ ++ SR__SESSION_FLAGS__SESS_NOTIFICATION = 1024 ++ PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SR__SESSION_FLAGS) ++} Sr__SessionFlags; ++/* ++ ** ++ * @brief Flags used to override default behavior of data manipulation calls. ++ */ ++typedef enum _Sr__EditFlags { ++ /* ++ **< Default behavior - recursive and non-strict. ++ */ ++ SR__EDIT_FLAGS__EDIT_DEFAULT = 0, ++ /* ++ **< Non-recursive behavior: ++ *by ::SetItemReq, all preceding nodes (parents) of the identified element must exist, ++ *by ::DeleteItemReq xpath must not identify an non-empty list or non-empty container. ++ */ ++ SR__EDIT_FLAGS__EDIT_NON_RECURSIVE = 1, ++ /* ++ **< Strict behavior: ++ *by ::SetItemReq the identified element must not exist (similar to netconf create operation), ++ *by ::DeleteItemReq the identified element must exist (similar to netconf delete operation). ++ */ ++ SR__EDIT_FLAGS__EDIT_STRICT = 2 ++ PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SR__EDIT_FLAGS) ++} Sr__EditFlags; ++typedef enum _Sr__SubscriptionType { ++ SR__SUBSCRIPTION_TYPE__MODULE_INSTALL_SUBS = 1, ++ SR__SUBSCRIPTION_TYPE__FEATURE_ENABLE_SUBS = 2, ++ SR__SUBSCRIPTION_TYPE__MODULE_CHANGE_SUBS = 10, ++ SR__SUBSCRIPTION_TYPE__SUBTREE_CHANGE_SUBS = 11, ++ SR__SUBSCRIPTION_TYPE__DP_GET_ITEMS_SUBS = 20, ++ SR__SUBSCRIPTION_TYPE__RPC_SUBS = 30, ++ SR__SUBSCRIPTION_TYPE__ACTION_SUBS = 31, ++ SR__SUBSCRIPTION_TYPE__EVENT_NOTIF_SUBS = 40, ++ /* ++ **< Used only internally to test for inactive notification subscriptions. ++ */ ++ SR__SUBSCRIPTION_TYPE__HELLO_SUBS = 50, ++ /* ++ **< Used only internally to notify about the end of the commit process. ++ */ ++ SR__SUBSCRIPTION_TYPE__COMMIT_END_SUBS = 51 ++ PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SR__SUBSCRIPTION_TYPE) ++} Sr__SubscriptionType; ++typedef enum _Sr__NotificationEvent { ++ SR__NOTIFICATION_EVENT__VERIFY_EV = 1, ++ SR__NOTIFICATION_EVENT__APPLY_EV = 2, ++ SR__NOTIFICATION_EVENT__ABORT_EV = 3, ++ SR__NOTIFICATION_EVENT__ENABLED_EV = 4 ++ PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SR__NOTIFICATION_EVENT) ++} Sr__NotificationEvent; ++typedef enum _Sr__ModuleState { ++ SR__MODULE_STATE__UNINSTALLED = 1, ++ SR__MODULE_STATE__IMPORTED = 2, ++ SR__MODULE_STATE__IMPLEMENTED = 3 ++ PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SR__MODULE_STATE) ++} Sr__ModuleState; ++typedef enum _Sr__ChangeOperation { ++ SR__CHANGE_OPERATION__CREATED = 1, ++ SR__CHANGE_OPERATION__MODIFIED = 2, ++ SR__CHANGE_OPERATION__DELETED = 3, ++ SR__CHANGE_OPERATION__MOVED = 4 ++ PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SR__CHANGE_OPERATION) ++} Sr__ChangeOperation; ++/* ++ ** ++ * @brief Requested operation. ++ */ ++typedef enum _Sr__Operation { ++ SR__OPERATION__SESSION_START = 10, ++ SR__OPERATION__SESSION_STOP = 11, ++ SR__OPERATION__SESSION_REFRESH = 12, ++ SR__OPERATION__SESSION_CHECK = 13, ++ SR__OPERATION__SESSION_SWITCH_DS = 14, ++ SR__OPERATION__SESSION_SET_OPTS = 15, ++ SR__OPERATION__VERSION_VERIFY = 16, ++ SR__OPERATION__LIST_SCHEMAS = 20, ++ SR__OPERATION__GET_SCHEMA = 21, ++ SR__OPERATION__MODULE_INSTALL = 22, ++ SR__OPERATION__FEATURE_ENABLE = 23, ++ SR__OPERATION__GET_ITEM = 30, ++ SR__OPERATION__GET_ITEMS = 31, ++ SR__OPERATION__GET_SUBTREE = 32, ++ SR__OPERATION__GET_SUBTREES = 33, ++ SR__OPERATION__GET_SUBTREE_CHUNK = 34, ++ SR__OPERATION__SET_ITEM = 40, ++ SR__OPERATION__DELETE_ITEM = 41, ++ SR__OPERATION__MOVE_ITEM = 42, ++ SR__OPERATION__SET_ITEM_STR = 43, ++ SR__OPERATION__VALIDATE = 50, ++ SR__OPERATION__COMMIT = 51, ++ SR__OPERATION__DISCARD_CHANGES = 52, ++ SR__OPERATION__COPY_CONFIG = 53, ++ SR__OPERATION__LOCK = 60, ++ SR__OPERATION__UNLOCK = 61, ++ SR__OPERATION__SUBSCRIBE = 70, ++ SR__OPERATION__UNSUBSCRIBE = 71, ++ SR__OPERATION__CHECK_ENABLED_RUNNING = 72, ++ SR__OPERATION__GET_CHANGES = 73, ++ SR__OPERATION__DATA_PROVIDE = 80, ++ SR__OPERATION__CHECK_EXEC_PERMISSION = 81, ++ SR__OPERATION__RPC = 82, ++ SR__OPERATION__ACTION = 83, ++ SR__OPERATION__EVENT_NOTIF = 84, ++ SR__OPERATION__EVENT_NOTIF_REPLAY = 85, ++ SR__OPERATION__UNSUBSCRIBE_DESTINATION = 101, ++ SR__OPERATION__COMMIT_TIMEOUT = 102, ++ SR__OPERATION__OPER_DATA_TIMEOUT = 103, ++ SR__OPERATION__INTERNAL_STATE_DATA = 104, ++ SR__OPERATION__NOTIF_STORE_CLEANUP = 105, ++ SR__OPERATION__DELAYED_MSG = 106, ++ SR__OPERATION__NACM_RELOAD = 107 ++ PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SR__OPERATION) ++} Sr__Operation; ++ ++/* --- messages --- */ ++ ++/* ++ ** ++ * @brief Value of an item stored (or to be stored) in the datastore. ++ * Can be mapped to sr_val_t data structure from sysrepo library API. ++ */ ++struct _Sr__Value ++{ ++ ProtobufCMessage base; ++ char *xpath; ++ Sr__Value__Types type; ++ protobuf_c_boolean dflt; ++ char *binary_val; ++ char *bits_val; ++ protobuf_c_boolean has_bool_val; ++ protobuf_c_boolean bool_val; ++ protobuf_c_boolean has_decimal64_val; ++ double decimal64_val; ++ char *enum_val; ++ char *identityref_val; ++ char *instanceid_val; ++ protobuf_c_boolean has_int8_val; ++ int32_t int8_val; ++ protobuf_c_boolean has_int16_val; ++ int32_t int16_val; ++ protobuf_c_boolean has_int32_val; ++ int32_t int32_val; ++ protobuf_c_boolean has_int64_val; ++ int64_t int64_val; ++ char *string_val; ++ protobuf_c_boolean has_uint8_val; ++ uint32_t uint8_val; ++ protobuf_c_boolean has_uint16_val; ++ uint32_t uint16_val; ++ protobuf_c_boolean has_uint32_val; ++ uint32_t uint32_val; ++ protobuf_c_boolean has_uint64_val; ++ uint64_t uint64_val; ++ char *anyxml_val; ++ char *anydata_val; ++}; ++#define SR__VALUE__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__value__descriptor) \ ++ , NULL, 0, 0, NULL, NULL, 0,0, 0,0, NULL, NULL, NULL, 0,0, 0,0, 0,0, 0,0, NULL, 0,0, 0,0, 0,0, 0,0, NULL, NULL } ++ ++ ++/* ++ ** ++ * @brief Item stored (or to be stored) in the datastore represented as a tree node ++ * reflecting module schema. Can be mapped to sr_node_t data structure from sysrepo library API. ++ */ ++struct _Sr__Node ++{ ++ ProtobufCMessage base; ++ /* ++ **< Value of the node; member *xpath* is used to store node's name. ++ */ ++ Sr__Value *value; ++ /* ++ **< Name of the module that defines scheme of this node. ++ */ ++ char *module_name; ++ /* ++ **< Direct descendands of this node. ++ */ ++ size_t n_children; ++ Sr__Node **children; ++}; ++#define SR__NODE__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__node__descriptor) \ ++ , NULL, NULL, 0,NULL } ++ ++ ++/* ++ ** ++ * @brief Error message retuned from the Sysrepo Engine. ++ */ ++struct _Sr__Error ++{ ++ ProtobufCMessage base; ++ char *message; ++ char *xpath; ++}; ++#define SR__ERROR__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__error__descriptor) \ ++ , NULL, NULL } ++ ++ ++/* ++ ** ++ * @brief Request for starting a session. Sent by sr_session_start API call. ++ */ ++struct _Sr__SessionStartReq ++{ ++ ProtobufCMessage base; ++ Sr__DataStore datastore; ++ char *user_name; ++ /* ++ **< Bitwise OR of SessionFlags. ++ */ ++ uint32_t options; ++ /* ++ **< Applicable if SESS_NOTIFICATION was specified. ++ */ ++ protobuf_c_boolean has_commit_id; ++ uint32_t commit_id; ++}; ++#define SR__SESSION_START_REQ__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__session_start_req__descriptor) \ ++ , 0, NULL, 0, 0,0 } ++ ++ ++/* ++ ** ++ * @brief Response to session_start request. ++ */ ++struct _Sr__SessionStartResp ++{ ++ ProtobufCMessage base; ++ uint32_t session_id; ++}; ++#define SR__SESSION_START_RESP__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__session_start_resp__descriptor) \ ++ , 0 } ++ ++ ++/* ++ ** ++ * @brief Request for stopping the session. Sent by sr_session_stop API call. ++ */ ++struct _Sr__SessionStopReq ++{ ++ ProtobufCMessage base; ++ uint32_t session_id; ++}; ++#define SR__SESSION_STOP_REQ__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__session_stop_req__descriptor) \ ++ , 0 } ++ ++ ++/* ++ ** ++ * @brief Response to session_stop request. ++ */ ++struct _Sr__SessionStopResp ++{ ++ ProtobufCMessage base; ++ uint32_t session_id; ++}; ++#define SR__SESSION_STOP_RESP__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__session_stop_resp__descriptor) \ ++ , 0 } ++ ++ ++/* ++ ** ++ * @brief Refreshes configuration data cached within the session. ++ * Sent by sr_session_refresh API call. ++ */ ++struct _Sr__SessionRefreshReq ++{ ++ ProtobufCMessage base; ++}; ++#define SR__SESSION_REFRESH_REQ__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__session_refresh_req__descriptor) \ ++ } ++ ++ ++/* ++ ** ++ * @brief Response to sr_session_refresh request. ++ */ ++struct _Sr__SessionRefreshResp ++{ ++ ProtobufCMessage base; ++ size_t n_errors; ++ Sr__Error **errors; ++}; ++#define SR__SESSION_REFRESH_RESP__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__session_refresh_resp__descriptor) \ ++ , 0,NULL } ++ ++ ++/* ++ ** ++ * @brief Checks aliveness and validity of the session & connection tied to it. ++ * Sent by sr_session_check API call. ++ */ ++struct _Sr__SessionCheckReq ++{ ++ ProtobufCMessage base; ++}; ++#define SR__SESSION_CHECK_REQ__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__session_check_req__descriptor) \ ++ } ++ ++ ++/* ++ ** ++ * @brief Response to sr_session_check request. ++ */ ++struct _Sr__SessionCheckResp ++{ ++ ProtobufCMessage base; ++ size_t n_errors; ++ Sr__Error **errors; ++}; ++#define SR__SESSION_CHECK_RESP__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__session_check_resp__descriptor) \ ++ , 0,NULL } ++ ++ ++/* ++ ** ++ * @brief Changes the datastore to which the session is tied to. ++ */ ++struct _Sr__SessionSwitchDsReq ++{ ++ ProtobufCMessage base; ++ Sr__DataStore datastore; ++}; ++#define SR__SESSION_SWITCH_DS_REQ__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__session_switch_ds_req__descriptor) \ ++ , 0 } ++ ++ ++/* ++ ** ++ * @brief Response to sr_session_switch_ds request. ++ */ ++struct _Sr__SessionSwitchDsResp ++{ ++ ProtobufCMessage base; ++}; ++#define SR__SESSION_SWITCH_DS_RESP__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__session_switch_ds_resp__descriptor) \ ++ } ++ ++ ++/* ++ ** ++ * @brief Request for modification of session options. ++ */ ++struct _Sr__SessionSetOptsReq ++{ ++ ProtobufCMessage base; ++ uint32_t options; ++}; ++#define SR__SESSION_SET_OPTS_REQ__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__session_set_opts_req__descriptor) \ ++ , 0 } ++ ++ ++/* ++ ** ++ * @brief Response to sr_session_set_options. ++ */ ++struct _Sr__SessionSetOptsResp ++{ ++ ProtobufCMessage base; ++}; ++#define SR__SESSION_SET_OPTS_RESP__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__session_set_opts_resp__descriptor) \ ++ } ++ ++ ++/* ++ ** ++ * @brief Request to verify version compatibility. ++ */ ++struct _Sr__VersionVerifyReq ++{ ++ ProtobufCMessage base; ++ char *soname; ++}; ++#define SR__VERSION_VERIFY_REQ__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__version_verify_req__descriptor) \ ++ , NULL } ++ ++ ++/* ++ ** ++ * @brief Response to version verification. ++ */ ++struct _Sr__VersionVerifyResp ++{ ++ ProtobufCMessage base; ++ /* ++ **< server-side SONAME version in case of versions incompatibility. ++ */ ++ char *soname; ++}; ++#define SR__VERSION_VERIFY_RESP__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__version_verify_resp__descriptor) \ ++ , NULL } ++ ++ ++/* ++ ** ++ * @brief Schema revision details. ++ */ ++struct _Sr__SchemaRevision ++{ ++ ProtobufCMessage base; ++ /* ++ **< Latest revision date of the module. ++ */ ++ char *revision; ++ /* ++ **< Absolute path to file where the schema is stored (YANG format). ++ */ ++ char *file_path_yang; ++ /* ++ **< Absolute path to file where the schema is stored (.yin format). ++ */ ++ char *file_path_yin; ++}; ++#define SR__SCHEMA_REVISION__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__schema_revision__descriptor) \ ++ , NULL, NULL, NULL } ++ ++ ++/* ++ ** ++ * @brief Schema submodule information. ++ */ ++struct _Sr__SchemaSubmodule ++{ ++ ProtobufCMessage base; ++ /* ++ **< Submodule name ++ */ ++ char *submodule_name; ++ /* ++ **< Revision of the submodule ++ */ ++ Sr__SchemaRevision *revision; ++}; ++#define SR__SCHEMA_SUBMODULE__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__schema_submodule__descriptor) \ ++ , NULL, NULL } ++ ++ ++/* ++ ** ++ * @brief Information about a schema installed in sysrepo datastore. ++ */ ++struct _Sr__Schema ++{ ++ ProtobufCMessage base; ++ /* ++ **< Name of the module. ++ */ ++ char *module_name; ++ /* ++ **< Namespace of the module. ++ */ ++ char *ns; ++ /* ++ **< Prefix of he module. ++ */ ++ char *prefix; ++ /* ++ **< TRUE only for explicitly installed modules (those are always implemented). ++ */ ++ protobuf_c_boolean installed; ++ /* ++ **< TRUE for implemented modules (do not have to be installed if they have augments, ++ *deviations or are targets for leafrefs of other implemented modules). ++ */ ++ protobuf_c_boolean implemented; ++ /* ++ **< Revision of the module ++ */ ++ Sr__SchemaRevision *revision; ++ /* ++ **< Submodules ++ */ ++ size_t n_submodules; ++ Sr__SchemaSubmodule **submodules; ++ /* ++ **< Features enabled for the module ++ */ ++ size_t n_enabled_features; ++ char **enabled_features; ++}; ++#define SR__SCHEMA__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__schema__descriptor) \ ++ , NULL, NULL, NULL, 0, 0, NULL, 0,NULL, 0,NULL } ++ ++ ++/* ++ ** ++ * @brief Retrieves an array of schemas installed in the sysrepo datastore. ++ * Sent by sr_list_schemas API call. ++ */ ++struct _Sr__ListSchemasReq ++{ ++ ProtobufCMessage base; ++}; ++#define SR__LIST_SCHEMAS_REQ__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__list_schemas_req__descriptor) \ ++ } ++ ++ ++/* ++ ** ++ * @brief Response to sr_list_schemas request. ++ */ ++struct _Sr__ListSchemasResp ++{ ++ ProtobufCMessage base; ++ size_t n_schemas; ++ Sr__Schema **schemas; ++}; ++#define SR__LIST_SCHEMAS_RESP__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__list_schemas_resp__descriptor) \ ++ , 0,NULL } ++ ++ ++/* ++ ** ++ * @brief Retrieves the content of specified schema file. ++ * Sent by sr_get_schema API call. ++ */ ++struct _Sr__GetSchemaReq ++{ ++ ProtobufCMessage base; ++ char *module_name; ++ char *revision; ++ char *submodule_name; ++ char *submodule_revision; ++ protobuf_c_boolean yang_format; ++}; ++#define SR__GET_SCHEMA_REQ__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__get_schema_req__descriptor) \ ++ , NULL, NULL, NULL, NULL, 0 } ++ ++ ++/* ++ ** ++ * @brief Response to sr_get_schema request. ++ */ ++struct _Sr__GetSchemaResp ++{ ++ ProtobufCMessage base; ++ char *schema_content; ++}; ++#define SR__GET_SCHEMA_RESP__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__get_schema_resp__descriptor) \ ++ , NULL } ++ ++ ++/* ++ ** ++ * @brief Retrieves a single data element stored under provided path. ++ * Sent by sr_get_item API call. ++ */ ++struct _Sr__GetItemReq ++{ ++ ProtobufCMessage base; ++ char *xpath; ++}; ++#define SR__GET_ITEM_REQ__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__get_item_req__descriptor) \ ++ , NULL } ++ ++ ++/* ++ ** ++ * @brief Response to get_item request. ++ */ ++struct _Sr__GetItemResp ++{ ++ ProtobufCMessage base; ++ Sr__Value *value; ++}; ++#define SR__GET_ITEM_RESP__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__get_item_resp__descriptor) \ ++ , NULL } ++ ++ ++/* ++ ** ++ * @brief Retrieves an array of data elements stored under provided path. ++ * Sent by sr_get_items and sr_get_items_iter API calls. ++ */ ++struct _Sr__GetItemsReq ++{ ++ ProtobufCMessage base; ++ char *xpath; ++ /* ++ * The options below are applicable only for sr_get_items_iter ++ * (not set by sr_get_items). ++ */ ++ protobuf_c_boolean has_limit; ++ uint32_t limit; ++ protobuf_c_boolean has_offset; ++ uint32_t offset; ++}; ++#define SR__GET_ITEMS_REQ__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__get_items_req__descriptor) \ ++ , NULL, 0,0, 0,0 } ++ ++ ++/* ++ ** ++ * @brief Response to get_items / sr_get_items_iter request. ++ */ ++struct _Sr__GetItemsResp ++{ ++ ProtobufCMessage base; ++ size_t n_values; ++ Sr__Value **values; ++}; ++#define SR__GET_ITEMS_RESP__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__get_items_resp__descriptor) \ ++ , 0,NULL } ++ ++ ++/* ++ ** ++ * @brief Retrieves a single subtree whose root is stored under provided path. ++ * Sent by sr_get_subtree API call. ++ */ ++struct _Sr__GetSubtreeReq ++{ ++ ProtobufCMessage base; ++ char *xpath; ++}; ++#define SR__GET_SUBTREE_REQ__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__get_subtree_req__descriptor) \ ++ , NULL } ++ ++ ++/* ++ ** ++ * @brief Response to sr_get_subtree request. ++ */ ++struct _Sr__GetSubtreeResp ++{ ++ ProtobufCMessage base; ++ Sr__Node *tree; ++}; ++#define SR__GET_SUBTREE_RESP__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__get_subtree_resp__descriptor) \ ++ , NULL } ++ ++ ++/* ++ ** ++ * @brief Retrieves an array of subtrees whose root nodes match provided path. ++ * Sent by sr_get_subtrees API call. ++ */ ++struct _Sr__GetSubtreesReq ++{ ++ ProtobufCMessage base; ++ char *xpath; ++}; ++#define SR__GET_SUBTREES_REQ__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__get_subtrees_req__descriptor) \ ++ , NULL } ++ ++ ++/* ++ ** ++ * @brief Response to sr_get_subtrees request. ++ */ ++struct _Sr__GetSubtreesResp ++{ ++ ProtobufCMessage base; ++ size_t n_trees; ++ Sr__Node **trees; ++}; ++#define SR__GET_SUBTREES_RESP__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__get_subtrees_resp__descriptor) \ ++ , 0,NULL } ++ ++ ++/* ++ ** ++ * @brief Retrieves a chunk of a single or multiple subtrees. ++ * A subtree chunk is also a tree, where the root node is the node referenced by XPath, ++ * the next level consists of its children skipping the first "slice_offset" nodes and including ++ * at most "slice_limit" nodes, while the remaining (depth_limit-2) levels always start with ++ * the first child (slice_offset is ignored) and include at most "child_limit" nodes. ++ * The chunk consists of at most "depth_limit" levels. ++ * @note Order of child nodes depends on the libyang implementation. ++ */ ++struct _Sr__GetSubtreeChunkReq ++{ ++ ProtobufCMessage base; ++ char *xpath; ++ protobuf_c_boolean single; ++ uint32_t slice_offset; ++ uint32_t slice_width; ++ uint32_t child_limit; ++ uint32_t depth_limit; ++}; ++#define SR__GET_SUBTREE_CHUNK_REQ__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__get_subtree_chunk_req__descriptor) \ ++ , NULL, 0, 0, 0, 0, 0 } ++ ++ ++/* ++ ** ++ * @brief Response to sr_get_subtree_chunk request. ++ */ ++struct _Sr__GetSubtreeChunkResp ++{ ++ ProtobufCMessage base; ++ /* ++ **< JSON node-id of the root node for each subtree chunk ++ */ ++ size_t n_xpath; ++ char **xpath; ++ /* ++ **< first chunk may carry mutliple trees ++ */ ++ size_t n_chunk; ++ Sr__Node **chunk; ++}; ++#define SR__GET_SUBTREE_CHUNK_RESP__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__get_subtree_chunk_resp__descriptor) \ ++ , 0,NULL, 0,NULL } ++ ++ ++/* ++ ** ++ * @brief Sets the value of the leaf, leaf-list or presence container. ++ * Sent by sr_set_item API call. ++ */ ++struct _Sr__SetItemReq ++{ ++ ProtobufCMessage base; ++ char *xpath; ++ Sr__Value *value; ++ /* ++ **< Bitwise OR of EditFlags ++ */ ++ uint32_t options; ++}; ++#define SR__SET_ITEM_REQ__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__set_item_req__descriptor) \ ++ , NULL, NULL, 0 } ++ ++ ++/* ++ ** ++ * @brief Response to sr_set_item request. ++ */ ++struct _Sr__SetItemResp ++{ ++ ProtobufCMessage base; ++}; ++#define SR__SET_ITEM_RESP__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__set_item_resp__descriptor) \ ++ } ++ ++ ++/* ++ ** ++ * @brief Sets the value of the leaf, leaf-list or presence container. ++ * The value is transferred as string. ++ * Sent by sr_set_item_str API call. ++ */ ++struct _Sr__SetItemStrReq ++{ ++ ProtobufCMessage base; ++ char *xpath; ++ char *value; ++ /* ++ **< Bitwise OR of EditFlags ++ */ ++ uint32_t options; ++}; ++#define SR__SET_ITEM_STR_REQ__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__set_item_str_req__descriptor) \ ++ , NULL, NULL, 0 } ++ ++ ++/* ++ ** ++ * @brief Response to sr_set_item_str request. ++ */ ++struct _Sr__SetItemStrResp ++{ ++ ProtobufCMessage base; ++}; ++#define SR__SET_ITEM_STR_RESP__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__set_item_str_resp__descriptor) \ ++ } ++ ++ ++/* ++ ** ++ * @brief Deletes the nodes under the specified xpath. ++ * Sent by sr_delete_item API call. ++ */ ++struct _Sr__DeleteItemReq ++{ ++ ProtobufCMessage base; ++ char *xpath; ++ /* ++ **< Bitwise OR of EditFlags ++ */ ++ uint32_t options; ++}; ++#define SR__DELETE_ITEM_REQ__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__delete_item_req__descriptor) \ ++ , NULL, 0 } ++ ++ ++/* ++ ** ++ * @brief Response to sr_delete_item request. ++ */ ++struct _Sr__DeleteItemResp ++{ ++ ProtobufCMessage base; ++}; ++#define SR__DELETE_ITEM_RESP__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__delete_item_resp__descriptor) \ ++ } ++ ++ ++/* ++ ** ++ * @brief Move the instance of an ordered list in specified direction. ++ * Sent by sr_move_item API call. ++ */ ++struct _Sr__MoveItemReq ++{ ++ ProtobufCMessage base; ++ char *xpath; ++ Sr__MoveItemReq__MovePosition position; ++ char *relative_item; ++}; ++#define SR__MOVE_ITEM_REQ__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__move_item_req__descriptor) \ ++ , NULL, 0, NULL } ++ ++ ++/* ++ ** ++ * @brief Response to sr_move_item request. ++ */ ++struct _Sr__MoveItemResp ++{ ++ ProtobufCMessage base; ++}; ++#define SR__MOVE_ITEM_RESP__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__move_item_resp__descriptor) \ ++ } ++ ++ ++/* ++ ** ++ * @brief Perform the validation of changes made in current session, but do not ++ * commit nor discard them. Sent by sr_validate API call. ++ */ ++struct _Sr__ValidateReq ++{ ++ ProtobufCMessage base; ++}; ++#define SR__VALIDATE_REQ__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__validate_req__descriptor) \ ++ } ++ ++ ++/* ++ ** ++ * @brief Response to sr_validate request. ++ */ ++struct _Sr__ValidateResp ++{ ++ ProtobufCMessage base; ++ size_t n_errors; ++ Sr__Error **errors; ++}; ++#define SR__VALIDATE_RESP__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__validate_resp__descriptor) \ ++ , 0,NULL } ++ ++ ++/* ++ ** ++ * @brief Apply changes made in current session. ++ * Sent by sr_commit API call. ++ */ ++struct _Sr__CommitReq ++{ ++ ProtobufCMessage base; ++}; ++#define SR__COMMIT_REQ__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__commit_req__descriptor) \ ++ } ++ ++ ++/* ++ ** ++ * @brief Response to sr_commit request. ++ */ ++struct _Sr__CommitResp ++{ ++ ProtobufCMessage base; ++ size_t n_errors; ++ Sr__Error **errors; ++}; ++#define SR__COMMIT_RESP__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__commit_resp__descriptor) \ ++ , 0,NULL } ++ ++ ++/* ++ ** ++ * @brief Discard non-committed changes made in current session. ++ * Sent by sr_discard_changes API call. ++ */ ++struct _Sr__DiscardChangesReq ++{ ++ ProtobufCMessage base; ++}; ++#define SR__DISCARD_CHANGES_REQ__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__discard_changes_req__descriptor) \ ++ } ++ ++ ++/* ++ ** ++ * @brief Response to sr_discard_changes request. ++ */ ++struct _Sr__DiscardChangesResp ++{ ++ ProtobufCMessage base; ++}; ++#define SR__DISCARD_CHANGES_RESP__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__discard_changes_resp__descriptor) \ ++ } ++ ++ ++/* ++ ** ++ * @brief Replaces an entire configuration datastore with the contents of ++ * another complete configuration datastore. Sent by sr_copy_config request. ++ */ ++struct _Sr__CopyConfigReq ++{ ++ ProtobufCMessage base; ++ Sr__DataStore src_datastore; ++ Sr__DataStore dst_datastore; ++ /* ++ **< If not specified, the operation is performed on all ++ *modules that are currently active in the source datastore ++ */ ++ char *module_name; ++}; ++#define SR__COPY_CONFIG_REQ__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__copy_config_req__descriptor) \ ++ , 0, 0, NULL } ++ ++ ++/* ++ ** ++ * @brief Response to sr_copy_config request. ++ */ ++struct _Sr__CopyConfigResp ++{ ++ ProtobufCMessage base; ++}; ++#define SR__COPY_CONFIG_RESP__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__copy_config_resp__descriptor) \ ++ } ++ ++ ++/* ++ ** ++ * @brief Locks specified data model or the datastore which the session is tied to. ++ * Sent by sr_lock_datastore and sr_lock_model API calls. ++ */ ++struct _Sr__LockReq ++{ ++ ProtobufCMessage base; ++ /* ++ **< If module name is not set, LockReq locks whole datastore. ++ */ ++ char *module_name; ++}; ++#define SR__LOCK_REQ__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__lock_req__descriptor) \ ++ , NULL } ++ ++ ++/* ++ ** ++ * @brief Response to sr_lock_datastore or sr_lock_model request. ++ */ ++struct _Sr__LockResp ++{ ++ ProtobufCMessage base; ++}; ++#define SR__LOCK_RESP__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__lock_resp__descriptor) \ ++ } ++ ++ ++/* ++ ** ++ * @brief Unlocks specified data model or the datastore which the session is tied to. ++ * Sent by sr_unlock_datastore and sr_unlock_model API calls. ++ */ ++struct _Sr__UnlockReq ++{ ++ ProtobufCMessage base; ++ /* ++ **< If module name is not set, UnlockReq unlocks whole datastore. ++ */ ++ char *module_name; ++}; ++#define SR__UNLOCK_REQ__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__unlock_req__descriptor) \ ++ , NULL } ++ ++ ++/* ++ ** ++ * @brief Response to sr_lock_datastore or sr_lock_model request. ++ */ ++struct _Sr__UnlockResp ++{ ++ ProtobufCMessage base; ++}; ++#define SR__UNLOCK_RESP__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__unlock_resp__descriptor) \ ++ } ++ ++ ++struct _Sr__SubscribeReq ++{ ++ ProtobufCMessage base; ++ Sr__SubscriptionType type; ++ char *destination; ++ uint32_t subscription_id; ++ char *module_name; ++ char *xpath; ++ protobuf_c_boolean has_notif_event; ++ Sr__NotificationEvent notif_event; ++ protobuf_c_boolean has_priority; ++ uint32_t priority; ++ protobuf_c_boolean has_enable_running; ++ protobuf_c_boolean enable_running; ++ protobuf_c_boolean has_enable_event; ++ protobuf_c_boolean enable_event; ++ Sr__ApiVariant api_variant; ++}; ++#define SR__SUBSCRIBE_REQ__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__subscribe_req__descriptor) \ ++ , 0, NULL, 0, NULL, NULL, 0,0, 0,0, 0,0, 0,0, 0 } ++ ++ ++struct _Sr__SubscribeResp ++{ ++ ProtobufCMessage base; ++}; ++#define SR__SUBSCRIBE_RESP__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__subscribe_resp__descriptor) \ ++ } ++ ++ ++struct _Sr__UnsubscribeReq ++{ ++ ProtobufCMessage base; ++ Sr__SubscriptionType type; ++ char *destination; ++ uint32_t subscription_id; ++ char *module_name; ++}; ++#define SR__UNSUBSCRIBE_REQ__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__unsubscribe_req__descriptor) \ ++ , 0, NULL, 0, NULL } ++ ++ ++struct _Sr__UnsubscribeResp ++{ ++ ProtobufCMessage base; ++}; ++#define SR__UNSUBSCRIBE_RESP__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__unsubscribe_resp__descriptor) \ ++ } ++ ++ ++/* ++ ** ++ * @brief Checks whether the module has any enabled subtree. ++ * Sent by sr_check_enabled_running. ++ */ ++struct _Sr__CheckEnabledRunningReq ++{ ++ ProtobufCMessage base; ++ char *module_name; ++}; ++#define SR__CHECK_ENABLED_RUNNING_REQ__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__check_enabled_running_req__descriptor) \ ++ , NULL } ++ ++ ++struct _Sr__CheckEnabledRunningResp ++{ ++ ProtobufCMessage base; ++ protobuf_c_boolean enabled; ++}; ++#define SR__CHECK_ENABLED_RUNNING_RESP__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__check_enabled_running_resp__descriptor) \ ++ , 0 } ++ ++ ++struct _Sr__ModuleInstallNotification ++{ ++ ProtobufCMessage base; ++ char *module_name; ++ char *revision; ++ Sr__ModuleState state; ++}; ++#define SR__MODULE_INSTALL_NOTIFICATION__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__module_install_notification__descriptor) \ ++ , NULL, NULL, 0 } ++ ++ ++struct _Sr__FeatureEnableNotification ++{ ++ ProtobufCMessage base; ++ char *module_name; ++ char *feature_name; ++ protobuf_c_boolean enabled; ++}; ++#define SR__FEATURE_ENABLE_NOTIFICATION__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__feature_enable_notification__descriptor) \ ++ , NULL, NULL, 0 } ++ ++ ++struct _Sr__ModuleChangeNotification ++{ ++ ProtobufCMessage base; ++ Sr__NotificationEvent event; ++ char *module_name; ++}; ++#define SR__MODULE_CHANGE_NOTIFICATION__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__module_change_notification__descriptor) \ ++ , 0, NULL } ++ ++ ++struct _Sr__SubtreeChangeNotification ++{ ++ ProtobufCMessage base; ++ Sr__NotificationEvent event; ++ char *xpath; ++}; ++#define SR__SUBTREE_CHANGE_NOTIFICATION__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__subtree_change_notification__descriptor) \ ++ , 0, NULL } ++ ++ ++struct _Sr__Change ++{ ++ ProtobufCMessage base; ++ Sr__ChangeOperation changeoperation; ++ Sr__Value *new_value; ++ Sr__Value *old_value; ++}; ++#define SR__CHANGE__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__change__descriptor) \ ++ , 0, NULL, NULL } ++ ++ ++/* ++ ** ++ * @brief Retrieves an array of changes made under provided path. ++ * Sent by sr_get_changes_iter or sr_get_change_next API calls. ++ */ ++struct _Sr__GetChangesReq ++{ ++ ProtobufCMessage base; ++ char *xpath; ++ uint32_t limit; ++ uint32_t offset; ++}; ++#define SR__GET_CHANGES_REQ__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__get_changes_req__descriptor) \ ++ , NULL, 0, 0 } ++ ++ ++/* ++ ** ++ * @brief Response to get_changes request. ++ */ ++struct _Sr__GetChangesResp ++{ ++ ProtobufCMessage base; ++ size_t n_changes; ++ Sr__Change **changes; ++}; ++#define SR__GET_CHANGES_RESP__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__get_changes_resp__descriptor) \ ++ , 0,NULL } ++ ++ ++/* ++ ** ++ * @brief Sends a request to check if the owner of this session is authorized to invoke ++ * the protocol operation referenced by the xpath. ++ * Sent by sr_check_exec_permission. ++ */ ++struct _Sr__CheckExecPermReq ++{ ++ ProtobufCMessage base; ++ char *xpath; ++}; ++#define SR__CHECK_EXEC_PERM_REQ__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__check_exec_perm_req__descriptor) \ ++ , NULL } ++ ++ ++/* ++ ** ++ * @brief Response to sr_check_exec_permission request. ++ */ ++struct _Sr__CheckExecPermResp ++{ ++ ProtobufCMessage base; ++ protobuf_c_boolean permitted; ++}; ++#define SR__CHECK_EXEC_PERM_RESP__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__check_exec_perm_resp__descriptor) \ ++ , 0 } ++ ++ ++/* ++ ** ++ * @brief Sends a RPC / action request into the datastore, will be delivered to the RPC subscriber. ++ * Sent by sr_rpc_send / sr_rpc_send_tree and sr_action_send / sr_action_send_tree API calls. ++ */ ++struct _Sr__RPCReq ++{ ++ ProtobufCMessage base; ++ protobuf_c_boolean action; ++ char *xpath; ++ /* ++ **< which API variant was used to send RPC req. ++ */ ++ Sr__ApiVariant orig_api_variant; ++ size_t n_input; ++ Sr__Value **input; ++ size_t n_input_tree; ++ Sr__Node **input_tree; ++ char *subscriber_address; ++ protobuf_c_boolean has_subscription_id; ++ uint32_t subscription_id; ++}; ++#define SR__RPCREQ__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__rpcreq__descriptor) \ ++ , 0, NULL, 0, 0,NULL, 0,NULL, NULL, 0,0 } ++ ++ ++/* ++ ** ++ * @brief Response to sr_rpc_send / sr_rpc_send_tree or sr_action_send / sr_action_send_tree request. ++ */ ++struct _Sr__RPCResp ++{ ++ ProtobufCMessage base; ++ protobuf_c_boolean action; ++ char *xpath; ++ /* ++ **< which API variant was used to send RPC req. ++ */ ++ Sr__ApiVariant orig_api_variant; ++ size_t n_output; ++ Sr__Value **output; ++ size_t n_output_tree; ++ Sr__Node **output_tree; ++}; ++#define SR__RPCRESP__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__rpcresp__descriptor) \ ++ , 0, NULL, 0, 0,NULL, 0,NULL } ++ ++ ++/* ++ ** ++ * @brief Sends an event notification into the datastore, will be delivered to all notification subscribers. ++ * Sent by sr_event_notif_send API call. ++ */ ++struct _Sr__EventNotifReq ++{ ++ ProtobufCMessage base; ++ Sr__EventNotifReq__NotifType type; ++ /* ++ **< Bitwise OR of NotifFlags. ++ */ ++ uint32_t options; ++ char *xpath; ++ size_t n_values; ++ Sr__Value **values; ++ size_t n_trees; ++ Sr__Node **trees; ++ uint64_t timestamp; ++ char *subscriber_address; ++ protobuf_c_boolean has_subscription_id; ++ uint32_t subscription_id; ++ protobuf_c_boolean do_not_send_reply; ++}; ++#define SR__EVENT_NOTIF_REQ__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__event_notif_req__descriptor) \ ++ , 0, 0, NULL, 0,NULL, 0,NULL, 0, NULL, 0,0, 0 } ++ ++ ++/* ++ ** ++ * @brief Response to sr_event_notif_send request. ++ */ ++struct _Sr__EventNotifResp ++{ ++ ProtobufCMessage base; ++}; ++#define SR__EVENT_NOTIF_RESP__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__event_notif_resp__descriptor) \ ++ } ++ ++ ++/* ++ ** ++ * @brief Sends a request to replay event notifications stored in the datastore. ++ * Sent by sr_event_notif_replay API call. ++ */ ++struct _Sr__EventNotifReplayReq ++{ ++ ProtobufCMessage base; ++ char *xpath; ++ uint64_t start_time; ++ uint64_t stop_time; ++ char *subscriber_address; ++ uint32_t subscription_id; ++ Sr__ApiVariant api_variant; ++}; ++#define SR__EVENT_NOTIF_REPLAY_REQ__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__event_notif_replay_req__descriptor) \ ++ , NULL, 0, 0, NULL, 0, 0 } ++ ++ ++/* ++ ** ++ * @brief Response to sr_event_notif_replay request. ++ */ ++struct _Sr__EventNotifReplayResp ++{ ++ ProtobufCMessage base; ++}; ++#define SR__EVENT_NOTIF_REPLAY_RESP__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__event_notif_replay_resp__descriptor) \ ++ } ++ ++ ++/* ++ ** ++ * @brief Requests operational data under given path form an operational data ++ * provider. ++ */ ++struct _Sr__DataProvideReq ++{ ++ ProtobufCMessage base; ++ char *xpath; ++ char *subscriber_address; ++ uint32_t subscription_id; ++ uint64_t request_id; ++}; ++#define SR__DATA_PROVIDE_REQ__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__data_provide_req__descriptor) \ ++ , NULL, NULL, 0, 0 } ++ ++ ++/* ++ ** ++ * @brief Response to a request of operational data under given path form an ++ * operational data provider. ++ */ ++struct _Sr__DataProvideResp ++{ ++ ProtobufCMessage base; ++ char *xpath; ++ size_t n_values; ++ Sr__Value **values; ++ uint64_t request_id; ++}; ++#define SR__DATA_PROVIDE_RESP__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__data_provide_resp__descriptor) \ ++ , NULL, 0,NULL, 0 } ++ ++ ++/* ++ ** ++ * @brief Requests installation / uinstallation of specified YANG model. ++ * Sent by sr_module_install internal API calls. ++ */ ++struct _Sr__ModuleInstallReq ++{ ++ ProtobufCMessage base; ++ char *module_name; ++ char *revision; ++ char *file_name; ++ protobuf_c_boolean installed; ++}; ++#define SR__MODULE_INSTALL_REQ__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__module_install_req__descriptor) \ ++ , NULL, NULL, NULL, 0 } ++ ++ ++/* ++ ** ++ * @brief Response to sr_module_install request. ++ */ ++struct _Sr__ModuleInstallResp ++{ ++ ProtobufCMessage base; ++}; ++#define SR__MODULE_INSTALL_RESP__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__module_install_resp__descriptor) \ ++ } ++ ++ ++/* ++ ** ++ * @brief Requests enabling / disabling of specified YANG feature within the ++ * YANG model. Sent by sr_feature_enable internal API calls. ++ */ ++struct _Sr__FeatureEnableReq ++{ ++ ProtobufCMessage base; ++ char *module_name; ++ char *feature_name; ++ protobuf_c_boolean enabled; ++}; ++#define SR__FEATURE_ENABLE_REQ__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__feature_enable_req__descriptor) \ ++ , NULL, NULL, 0 } ++ ++ ++/* ++ ** ++ * @brief Response to sr_feature_enable request. ++ */ ++struct _Sr__FeatureEnableResp ++{ ++ ProtobufCMessage base; ++}; ++#define SR__FEATURE_ENABLE_RESP__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__feature_enable_resp__descriptor) \ ++ } ++ ++ ++/* ++ ** ++ * @brief Internal request to unsubscribe all subscriptions of a subscriber on given destination address. ++ */ ++struct _Sr__UnsubscribeDestinationReq ++{ ++ ProtobufCMessage base; ++ char *destination; ++}; ++#define SR__UNSUBSCRIBE_DESTINATION_REQ__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__unsubscribe_destination_req__descriptor) \ ++ , NULL } ++ ++ ++/* ++ ** ++ * @brief Internal request to timeout a commit, if it hasn't been terminated yet. ++ */ ++struct _Sr__CommitTimeoutReq ++{ ++ ProtobufCMessage base; ++ uint32_t commit_id; ++ protobuf_c_boolean expired; ++}; ++#define SR__COMMIT_TIMEOUT_REQ__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__commit_timeout_req__descriptor) \ ++ , 0, 0 } ++ ++ ++/* ++ ** ++ * @brief Internal request to timeout a request for operational data, if it hasn't been terminated yet. ++ */ ++struct _Sr__OperDataTimeoutReq ++{ ++ ProtobufCMessage base; ++ uint64_t request_id; ++}; ++#define SR__OPER_DATA_TIMEOUT_REQ__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__oper_data_timeout_req__descriptor) \ ++ , 0 } ++ ++ ++/* ++ ** ++ * @brief Internal request for internal state data (state data provided by Sysrepo Engine itself). ++ */ ++struct _Sr__InternalStateDataReq ++{ ++ ProtobufCMessage base; ++ uint64_t request_id; ++ char *xpath; ++}; ++#define SR__INTERNAL_STATE_DATA_REQ__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__internal_state_data_req__descriptor) \ ++ , 0, NULL } ++ ++ ++/* ++ ** ++ * @brief Internal request to cleanup aged notifications in the Notification Store. ++ */ ++struct _Sr__NotifStoreCleanupReq ++{ ++ ProtobufCMessage base; ++}; ++#define SR__NOTIF_STORE_CLEANUP_REQ__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__notif_store_cleanup_req__descriptor) \ ++ } ++ ++ ++/* ++ ** ++ * @brief Message to be delivered to the client after some timeout. ++ */ ++struct _Sr__DelayedMsgReq ++{ ++ ProtobufCMessage base; ++ Sr__Msg *message; ++}; ++#define SR__DELAYED_MSG_REQ__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__delayed_msg_req__descriptor) \ ++ , NULL } ++ ++ ++/* ++ ** ++ * @brief Internal request to reload NACM configuration from the running datastore. ++ */ ++struct _Sr__NacmReloadReq ++{ ++ ProtobufCMessage base; ++}; ++#define SR__NACM_RELOAD_REQ__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__nacm_reload_req__descriptor) \ ++ } ++ ++ ++/* ++ ** ++ * @brief Request for an operation. ++ */ ++struct _Sr__Request ++{ ++ ProtobufCMessage base; ++ /* ++ * Request ID used internally by sysrepo ++ */ ++ uint64_t _id; ++ Sr__Operation operation; ++ Sr__SessionStartReq *session_start_req; ++ Sr__SessionStopReq *session_stop_req; ++ Sr__SessionRefreshReq *session_refresh_req; ++ Sr__SessionCheckReq *session_check_req; ++ Sr__SessionSwitchDsReq *session_switch_ds_req; ++ Sr__SessionSetOptsReq *session_set_opts_req; ++ Sr__VersionVerifyReq *version_verify_req; ++ Sr__ListSchemasReq *list_schemas_req; ++ Sr__GetSchemaReq *get_schema_req; ++ Sr__ModuleInstallReq *module_install_req; ++ Sr__FeatureEnableReq *feature_enable_req; ++ Sr__GetItemReq *get_item_req; ++ Sr__GetItemsReq *get_items_req; ++ Sr__GetSubtreeReq *get_subtree_req; ++ Sr__GetSubtreesReq *get_subtrees_req; ++ Sr__GetSubtreeChunkReq *get_subtree_chunk_req; ++ Sr__SetItemReq *set_item_req; ++ Sr__DeleteItemReq *delete_item_req; ++ Sr__MoveItemReq *move_item_req; ++ Sr__SetItemStrReq *set_item_str_req; ++ Sr__ValidateReq *validate_req; ++ Sr__CommitReq *commit_req; ++ Sr__DiscardChangesReq *discard_changes_req; ++ Sr__CopyConfigReq *copy_config_req; ++ Sr__LockReq *lock_req; ++ Sr__UnlockReq *unlock_req; ++ Sr__SubscribeReq *subscribe_req; ++ Sr__UnsubscribeReq *unsubscribe_req; ++ Sr__CheckEnabledRunningReq *check_enabled_running_req; ++ Sr__GetChangesReq *get_changes_req; ++ Sr__DataProvideReq *data_provide_req; ++ Sr__CheckExecPermReq *check_exec_perm_req; ++ Sr__RPCReq *rpc_req; ++ Sr__EventNotifReq *event_notif_req; ++ Sr__EventNotifReplayReq *event_notif_replay_req; ++}; ++#define SR__REQUEST__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__request__descriptor) \ ++ , 0, 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL } ++ ++ ++/* ++ ** ++ * @brief Response to the received request. ++ */ ++struct _Sr__Response ++{ ++ ProtobufCMessage base; ++ Sr__Operation operation; ++ /* ++ **< Result of the operation. 0 on success, non-zero values map to sr_error_t enum in sysrepo.h. ++ */ ++ uint32_t result; ++ /* ++ **< Additional error information. ++ */ ++ Sr__Error *error; ++ Sr__SessionStartResp *session_start_resp; ++ Sr__SessionStopResp *session_stop_resp; ++ Sr__SessionRefreshResp *session_refresh_resp; ++ Sr__SessionCheckResp *session_check_resp; ++ Sr__SessionSwitchDsResp *session_switch_ds_resp; ++ Sr__SessionSetOptsResp *session_set_opts_resp; ++ Sr__VersionVerifyResp *version_verify_resp; ++ Sr__ListSchemasResp *list_schemas_resp; ++ Sr__GetSchemaResp *get_schema_resp; ++ Sr__ModuleInstallResp *module_install_resp; ++ Sr__FeatureEnableResp *feature_enable_resp; ++ Sr__GetItemResp *get_item_resp; ++ Sr__GetItemsResp *get_items_resp; ++ Sr__GetSubtreeResp *get_subtree_resp; ++ Sr__GetSubtreesResp *get_subtrees_resp; ++ Sr__GetSubtreeChunkResp *get_subtree_chunk_resp; ++ Sr__SetItemResp *set_item_resp; ++ Sr__DeleteItemResp *delete_item_resp; ++ Sr__MoveItemResp *move_item_resp; ++ Sr__SetItemStrResp *set_item_str_resp; ++ Sr__ValidateResp *validate_resp; ++ Sr__CommitResp *commit_resp; ++ Sr__DiscardChangesResp *discard_changes_resp; ++ Sr__CopyConfigResp *copy_config_resp; ++ Sr__LockResp *lock_resp; ++ Sr__UnlockResp *unlock_resp; ++ Sr__SubscribeResp *subscribe_resp; ++ Sr__UnsubscribeResp *unsubscribe_resp; ++ Sr__CheckEnabledRunningResp *check_enabled_running_resp; ++ Sr__GetChangesResp *get_changes_resp; ++ Sr__DataProvideResp *data_provide_resp; ++ Sr__CheckExecPermResp *check_exec_perm_resp; ++ Sr__RPCResp *rpc_resp; ++ Sr__EventNotifResp *event_notif_resp; ++ Sr__EventNotifReplayResp *event_notif_replay_resp; ++}; ++#define SR__RESPONSE__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__response__descriptor) \ ++ , 0, 0, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL } ++ ++ ++/* ++ ** ++ * @brief Notification about an event that occurred in the datastore. ++ */ ++struct _Sr__Notification ++{ ++ ProtobufCMessage base; ++ Sr__SubscriptionType type; ++ char *destination_address; ++ char *source_address; ++ uint32_t source_pid; ++ uint32_t subscription_id; ++ protobuf_c_boolean has_commit_id; ++ uint32_t commit_id; ++ Sr__ModuleInstallNotification *module_install_notif; ++ Sr__FeatureEnableNotification *feature_enable_notif; ++ Sr__ModuleChangeNotification *module_change_notif; ++ Sr__SubtreeChangeNotification *subtree_change_notif; ++}; ++#define SR__NOTIFICATION__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__notification__descriptor) \ ++ , 0, NULL, NULL, 0, 0, 0,0, NULL, NULL, NULL, NULL } ++ ++ ++/* ++ ** ++ * @brief Notification Acknowledgment. ++ */ ++struct _Sr__NotificationAck ++{ ++ ProtobufCMessage base; ++ /* ++ **< Original notification. ++ */ ++ Sr__Notification *notif; ++ /* ++ **< Result of the notification (success / error code). ++ */ ++ uint32_t result; ++ /* ++ **< Additional error information. ++ */ ++ Sr__Error *error; ++ /* ++ **< If the result is error and this flag is set to true abort notification ++ * will not be delivered to this subscriber ++ * (Subscriber doesn't want notification about changes that he refused). ++ */ ++ protobuf_c_boolean do_not_send_abort; ++}; ++#define SR__NOTIFICATION_ACK__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__notification_ack__descriptor) \ ++ , NULL, 0, NULL, 0 } ++ ++ ++/* ++ ** ++ * @brief Internal request sent by sysrepo. Should not be used from the public API. ++ */ ++struct _Sr__InternalRequest ++{ ++ ProtobufCMessage base; ++ Sr__Operation operation; ++ protobuf_c_boolean has_postpone_timeout; ++ uint32_t postpone_timeout; ++ Sr__UnsubscribeDestinationReq *unsubscribe_dst_req; ++ Sr__CommitTimeoutReq *commit_timeout_req; ++ Sr__OperDataTimeoutReq *oper_data_timeout_req; ++ Sr__InternalStateDataReq *internal_state_data_req; ++ Sr__NotifStoreCleanupReq *notif_store_cleanup_req; ++ Sr__DelayedMsgReq *delayed_msg_req; ++ Sr__NacmReloadReq *nacm_reload_req; ++}; ++#define SR__INTERNAL_REQUEST__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__internal_request__descriptor) \ ++ , 0, 0,0, NULL, NULL, NULL, NULL, NULL, NULL, NULL } ++ ++ ++/* ++ ** ++ * @brief Umbrella sysrepo message used for communication between sysrepo ++ * engine and client library. ++ */ ++struct _Sr__Msg ++{ ++ ProtobufCMessage base; ++ /* ++ **< Indicates type of the message. ++ */ ++ Sr__Msg__MsgType type; ++ /* ++ **< Session identifier. Can be 0 (value is ignored) for session_start and version_verify requests. ++ */ ++ uint32_t session_id; ++ /* ++ **< Filled in in case of type == REQUEST. ++ */ ++ Sr__Request *request; ++ /* ++ **< Filled in in case of type == RESPONSE. ++ */ ++ Sr__Response *response; ++ /* ++ **< Filled in in case of type == NOTIFICATION. ++ */ ++ Sr__Notification *notification; ++ /* ++ **< Filled in in case of type == NOTIFICATION_ACK ++ */ ++ Sr__NotificationAck *notification_ack; ++ /* ++ **< Filled in in case of type == INTERNAL. ++ */ ++ Sr__InternalRequest *internal_request; ++ /* ++ **< Not part of the protocol. Used internally by Sysrepo to store a pointer to memory context. ++ */ ++ uint64_t _sysrepo_mem_ctx; ++}; ++#define SR__MSG__INIT \ ++ { PROTOBUF_C_MESSAGE_INIT (&sr__msg__descriptor) \ ++ , 0, 0, NULL, NULL, NULL, NULL, NULL, 0 } ++ ++ ++/* Sr__Value methods */ ++void sr__value__init ++ (Sr__Value *message); ++size_t sr__value__get_packed_size ++ (const Sr__Value *message); ++size_t sr__value__pack ++ (const Sr__Value *message, ++ uint8_t *out); ++size_t sr__value__pack_to_buffer ++ (const Sr__Value *message, ++ ProtobufCBuffer *buffer); ++Sr__Value * ++ sr__value__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__value__free_unpacked ++ (Sr__Value *message, ++ ProtobufCAllocator *allocator); ++/* Sr__Node methods */ ++void sr__node__init ++ (Sr__Node *message); ++size_t sr__node__get_packed_size ++ (const Sr__Node *message); ++size_t sr__node__pack ++ (const Sr__Node *message, ++ uint8_t *out); ++size_t sr__node__pack_to_buffer ++ (const Sr__Node *message, ++ ProtobufCBuffer *buffer); ++Sr__Node * ++ sr__node__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__node__free_unpacked ++ (Sr__Node *message, ++ ProtobufCAllocator *allocator); ++/* Sr__Error methods */ ++void sr__error__init ++ (Sr__Error *message); ++size_t sr__error__get_packed_size ++ (const Sr__Error *message); ++size_t sr__error__pack ++ (const Sr__Error *message, ++ uint8_t *out); ++size_t sr__error__pack_to_buffer ++ (const Sr__Error *message, ++ ProtobufCBuffer *buffer); ++Sr__Error * ++ sr__error__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__error__free_unpacked ++ (Sr__Error *message, ++ ProtobufCAllocator *allocator); ++/* Sr__SessionStartReq methods */ ++void sr__session_start_req__init ++ (Sr__SessionStartReq *message); ++size_t sr__session_start_req__get_packed_size ++ (const Sr__SessionStartReq *message); ++size_t sr__session_start_req__pack ++ (const Sr__SessionStartReq *message, ++ uint8_t *out); ++size_t sr__session_start_req__pack_to_buffer ++ (const Sr__SessionStartReq *message, ++ ProtobufCBuffer *buffer); ++Sr__SessionStartReq * ++ sr__session_start_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__session_start_req__free_unpacked ++ (Sr__SessionStartReq *message, ++ ProtobufCAllocator *allocator); ++/* Sr__SessionStartResp methods */ ++void sr__session_start_resp__init ++ (Sr__SessionStartResp *message); ++size_t sr__session_start_resp__get_packed_size ++ (const Sr__SessionStartResp *message); ++size_t sr__session_start_resp__pack ++ (const Sr__SessionStartResp *message, ++ uint8_t *out); ++size_t sr__session_start_resp__pack_to_buffer ++ (const Sr__SessionStartResp *message, ++ ProtobufCBuffer *buffer); ++Sr__SessionStartResp * ++ sr__session_start_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__session_start_resp__free_unpacked ++ (Sr__SessionStartResp *message, ++ ProtobufCAllocator *allocator); ++/* Sr__SessionStopReq methods */ ++void sr__session_stop_req__init ++ (Sr__SessionStopReq *message); ++size_t sr__session_stop_req__get_packed_size ++ (const Sr__SessionStopReq *message); ++size_t sr__session_stop_req__pack ++ (const Sr__SessionStopReq *message, ++ uint8_t *out); ++size_t sr__session_stop_req__pack_to_buffer ++ (const Sr__SessionStopReq *message, ++ ProtobufCBuffer *buffer); ++Sr__SessionStopReq * ++ sr__session_stop_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__session_stop_req__free_unpacked ++ (Sr__SessionStopReq *message, ++ ProtobufCAllocator *allocator); ++/* Sr__SessionStopResp methods */ ++void sr__session_stop_resp__init ++ (Sr__SessionStopResp *message); ++size_t sr__session_stop_resp__get_packed_size ++ (const Sr__SessionStopResp *message); ++size_t sr__session_stop_resp__pack ++ (const Sr__SessionStopResp *message, ++ uint8_t *out); ++size_t sr__session_stop_resp__pack_to_buffer ++ (const Sr__SessionStopResp *message, ++ ProtobufCBuffer *buffer); ++Sr__SessionStopResp * ++ sr__session_stop_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__session_stop_resp__free_unpacked ++ (Sr__SessionStopResp *message, ++ ProtobufCAllocator *allocator); ++/* Sr__SessionRefreshReq methods */ ++void sr__session_refresh_req__init ++ (Sr__SessionRefreshReq *message); ++size_t sr__session_refresh_req__get_packed_size ++ (const Sr__SessionRefreshReq *message); ++size_t sr__session_refresh_req__pack ++ (const Sr__SessionRefreshReq *message, ++ uint8_t *out); ++size_t sr__session_refresh_req__pack_to_buffer ++ (const Sr__SessionRefreshReq *message, ++ ProtobufCBuffer *buffer); ++Sr__SessionRefreshReq * ++ sr__session_refresh_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__session_refresh_req__free_unpacked ++ (Sr__SessionRefreshReq *message, ++ ProtobufCAllocator *allocator); ++/* Sr__SessionRefreshResp methods */ ++void sr__session_refresh_resp__init ++ (Sr__SessionRefreshResp *message); ++size_t sr__session_refresh_resp__get_packed_size ++ (const Sr__SessionRefreshResp *message); ++size_t sr__session_refresh_resp__pack ++ (const Sr__SessionRefreshResp *message, ++ uint8_t *out); ++size_t sr__session_refresh_resp__pack_to_buffer ++ (const Sr__SessionRefreshResp *message, ++ ProtobufCBuffer *buffer); ++Sr__SessionRefreshResp * ++ sr__session_refresh_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__session_refresh_resp__free_unpacked ++ (Sr__SessionRefreshResp *message, ++ ProtobufCAllocator *allocator); ++/* Sr__SessionCheckReq methods */ ++void sr__session_check_req__init ++ (Sr__SessionCheckReq *message); ++size_t sr__session_check_req__get_packed_size ++ (const Sr__SessionCheckReq *message); ++size_t sr__session_check_req__pack ++ (const Sr__SessionCheckReq *message, ++ uint8_t *out); ++size_t sr__session_check_req__pack_to_buffer ++ (const Sr__SessionCheckReq *message, ++ ProtobufCBuffer *buffer); ++Sr__SessionCheckReq * ++ sr__session_check_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__session_check_req__free_unpacked ++ (Sr__SessionCheckReq *message, ++ ProtobufCAllocator *allocator); ++/* Sr__SessionCheckResp methods */ ++void sr__session_check_resp__init ++ (Sr__SessionCheckResp *message); ++size_t sr__session_check_resp__get_packed_size ++ (const Sr__SessionCheckResp *message); ++size_t sr__session_check_resp__pack ++ (const Sr__SessionCheckResp *message, ++ uint8_t *out); ++size_t sr__session_check_resp__pack_to_buffer ++ (const Sr__SessionCheckResp *message, ++ ProtobufCBuffer *buffer); ++Sr__SessionCheckResp * ++ sr__session_check_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__session_check_resp__free_unpacked ++ (Sr__SessionCheckResp *message, ++ ProtobufCAllocator *allocator); ++/* Sr__SessionSwitchDsReq methods */ ++void sr__session_switch_ds_req__init ++ (Sr__SessionSwitchDsReq *message); ++size_t sr__session_switch_ds_req__get_packed_size ++ (const Sr__SessionSwitchDsReq *message); ++size_t sr__session_switch_ds_req__pack ++ (const Sr__SessionSwitchDsReq *message, ++ uint8_t *out); ++size_t sr__session_switch_ds_req__pack_to_buffer ++ (const Sr__SessionSwitchDsReq *message, ++ ProtobufCBuffer *buffer); ++Sr__SessionSwitchDsReq * ++ sr__session_switch_ds_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__session_switch_ds_req__free_unpacked ++ (Sr__SessionSwitchDsReq *message, ++ ProtobufCAllocator *allocator); ++/* Sr__SessionSwitchDsResp methods */ ++void sr__session_switch_ds_resp__init ++ (Sr__SessionSwitchDsResp *message); ++size_t sr__session_switch_ds_resp__get_packed_size ++ (const Sr__SessionSwitchDsResp *message); ++size_t sr__session_switch_ds_resp__pack ++ (const Sr__SessionSwitchDsResp *message, ++ uint8_t *out); ++size_t sr__session_switch_ds_resp__pack_to_buffer ++ (const Sr__SessionSwitchDsResp *message, ++ ProtobufCBuffer *buffer); ++Sr__SessionSwitchDsResp * ++ sr__session_switch_ds_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__session_switch_ds_resp__free_unpacked ++ (Sr__SessionSwitchDsResp *message, ++ ProtobufCAllocator *allocator); ++/* Sr__SessionSetOptsReq methods */ ++void sr__session_set_opts_req__init ++ (Sr__SessionSetOptsReq *message); ++size_t sr__session_set_opts_req__get_packed_size ++ (const Sr__SessionSetOptsReq *message); ++size_t sr__session_set_opts_req__pack ++ (const Sr__SessionSetOptsReq *message, ++ uint8_t *out); ++size_t sr__session_set_opts_req__pack_to_buffer ++ (const Sr__SessionSetOptsReq *message, ++ ProtobufCBuffer *buffer); ++Sr__SessionSetOptsReq * ++ sr__session_set_opts_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__session_set_opts_req__free_unpacked ++ (Sr__SessionSetOptsReq *message, ++ ProtobufCAllocator *allocator); ++/* Sr__SessionSetOptsResp methods */ ++void sr__session_set_opts_resp__init ++ (Sr__SessionSetOptsResp *message); ++size_t sr__session_set_opts_resp__get_packed_size ++ (const Sr__SessionSetOptsResp *message); ++size_t sr__session_set_opts_resp__pack ++ (const Sr__SessionSetOptsResp *message, ++ uint8_t *out); ++size_t sr__session_set_opts_resp__pack_to_buffer ++ (const Sr__SessionSetOptsResp *message, ++ ProtobufCBuffer *buffer); ++Sr__SessionSetOptsResp * ++ sr__session_set_opts_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__session_set_opts_resp__free_unpacked ++ (Sr__SessionSetOptsResp *message, ++ ProtobufCAllocator *allocator); ++/* Sr__VersionVerifyReq methods */ ++void sr__version_verify_req__init ++ (Sr__VersionVerifyReq *message); ++size_t sr__version_verify_req__get_packed_size ++ (const Sr__VersionVerifyReq *message); ++size_t sr__version_verify_req__pack ++ (const Sr__VersionVerifyReq *message, ++ uint8_t *out); ++size_t sr__version_verify_req__pack_to_buffer ++ (const Sr__VersionVerifyReq *message, ++ ProtobufCBuffer *buffer); ++Sr__VersionVerifyReq * ++ sr__version_verify_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__version_verify_req__free_unpacked ++ (Sr__VersionVerifyReq *message, ++ ProtobufCAllocator *allocator); ++/* Sr__VersionVerifyResp methods */ ++void sr__version_verify_resp__init ++ (Sr__VersionVerifyResp *message); ++size_t sr__version_verify_resp__get_packed_size ++ (const Sr__VersionVerifyResp *message); ++size_t sr__version_verify_resp__pack ++ (const Sr__VersionVerifyResp *message, ++ uint8_t *out); ++size_t sr__version_verify_resp__pack_to_buffer ++ (const Sr__VersionVerifyResp *message, ++ ProtobufCBuffer *buffer); ++Sr__VersionVerifyResp * ++ sr__version_verify_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__version_verify_resp__free_unpacked ++ (Sr__VersionVerifyResp *message, ++ ProtobufCAllocator *allocator); ++/* Sr__SchemaRevision methods */ ++void sr__schema_revision__init ++ (Sr__SchemaRevision *message); ++size_t sr__schema_revision__get_packed_size ++ (const Sr__SchemaRevision *message); ++size_t sr__schema_revision__pack ++ (const Sr__SchemaRevision *message, ++ uint8_t *out); ++size_t sr__schema_revision__pack_to_buffer ++ (const Sr__SchemaRevision *message, ++ ProtobufCBuffer *buffer); ++Sr__SchemaRevision * ++ sr__schema_revision__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__schema_revision__free_unpacked ++ (Sr__SchemaRevision *message, ++ ProtobufCAllocator *allocator); ++/* Sr__SchemaSubmodule methods */ ++void sr__schema_submodule__init ++ (Sr__SchemaSubmodule *message); ++size_t sr__schema_submodule__get_packed_size ++ (const Sr__SchemaSubmodule *message); ++size_t sr__schema_submodule__pack ++ (const Sr__SchemaSubmodule *message, ++ uint8_t *out); ++size_t sr__schema_submodule__pack_to_buffer ++ (const Sr__SchemaSubmodule *message, ++ ProtobufCBuffer *buffer); ++Sr__SchemaSubmodule * ++ sr__schema_submodule__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__schema_submodule__free_unpacked ++ (Sr__SchemaSubmodule *message, ++ ProtobufCAllocator *allocator); ++/* Sr__Schema methods */ ++void sr__schema__init ++ (Sr__Schema *message); ++size_t sr__schema__get_packed_size ++ (const Sr__Schema *message); ++size_t sr__schema__pack ++ (const Sr__Schema *message, ++ uint8_t *out); ++size_t sr__schema__pack_to_buffer ++ (const Sr__Schema *message, ++ ProtobufCBuffer *buffer); ++Sr__Schema * ++ sr__schema__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__schema__free_unpacked ++ (Sr__Schema *message, ++ ProtobufCAllocator *allocator); ++/* Sr__ListSchemasReq methods */ ++void sr__list_schemas_req__init ++ (Sr__ListSchemasReq *message); ++size_t sr__list_schemas_req__get_packed_size ++ (const Sr__ListSchemasReq *message); ++size_t sr__list_schemas_req__pack ++ (const Sr__ListSchemasReq *message, ++ uint8_t *out); ++size_t sr__list_schemas_req__pack_to_buffer ++ (const Sr__ListSchemasReq *message, ++ ProtobufCBuffer *buffer); ++Sr__ListSchemasReq * ++ sr__list_schemas_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__list_schemas_req__free_unpacked ++ (Sr__ListSchemasReq *message, ++ ProtobufCAllocator *allocator); ++/* Sr__ListSchemasResp methods */ ++void sr__list_schemas_resp__init ++ (Sr__ListSchemasResp *message); ++size_t sr__list_schemas_resp__get_packed_size ++ (const Sr__ListSchemasResp *message); ++size_t sr__list_schemas_resp__pack ++ (const Sr__ListSchemasResp *message, ++ uint8_t *out); ++size_t sr__list_schemas_resp__pack_to_buffer ++ (const Sr__ListSchemasResp *message, ++ ProtobufCBuffer *buffer); ++Sr__ListSchemasResp * ++ sr__list_schemas_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__list_schemas_resp__free_unpacked ++ (Sr__ListSchemasResp *message, ++ ProtobufCAllocator *allocator); ++/* Sr__GetSchemaReq methods */ ++void sr__get_schema_req__init ++ (Sr__GetSchemaReq *message); ++size_t sr__get_schema_req__get_packed_size ++ (const Sr__GetSchemaReq *message); ++size_t sr__get_schema_req__pack ++ (const Sr__GetSchemaReq *message, ++ uint8_t *out); ++size_t sr__get_schema_req__pack_to_buffer ++ (const Sr__GetSchemaReq *message, ++ ProtobufCBuffer *buffer); ++Sr__GetSchemaReq * ++ sr__get_schema_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__get_schema_req__free_unpacked ++ (Sr__GetSchemaReq *message, ++ ProtobufCAllocator *allocator); ++/* Sr__GetSchemaResp methods */ ++void sr__get_schema_resp__init ++ (Sr__GetSchemaResp *message); ++size_t sr__get_schema_resp__get_packed_size ++ (const Sr__GetSchemaResp *message); ++size_t sr__get_schema_resp__pack ++ (const Sr__GetSchemaResp *message, ++ uint8_t *out); ++size_t sr__get_schema_resp__pack_to_buffer ++ (const Sr__GetSchemaResp *message, ++ ProtobufCBuffer *buffer); ++Sr__GetSchemaResp * ++ sr__get_schema_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__get_schema_resp__free_unpacked ++ (Sr__GetSchemaResp *message, ++ ProtobufCAllocator *allocator); ++/* Sr__GetItemReq methods */ ++void sr__get_item_req__init ++ (Sr__GetItemReq *message); ++size_t sr__get_item_req__get_packed_size ++ (const Sr__GetItemReq *message); ++size_t sr__get_item_req__pack ++ (const Sr__GetItemReq *message, ++ uint8_t *out); ++size_t sr__get_item_req__pack_to_buffer ++ (const Sr__GetItemReq *message, ++ ProtobufCBuffer *buffer); ++Sr__GetItemReq * ++ sr__get_item_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__get_item_req__free_unpacked ++ (Sr__GetItemReq *message, ++ ProtobufCAllocator *allocator); ++/* Sr__GetItemResp methods */ ++void sr__get_item_resp__init ++ (Sr__GetItemResp *message); ++size_t sr__get_item_resp__get_packed_size ++ (const Sr__GetItemResp *message); ++size_t sr__get_item_resp__pack ++ (const Sr__GetItemResp *message, ++ uint8_t *out); ++size_t sr__get_item_resp__pack_to_buffer ++ (const Sr__GetItemResp *message, ++ ProtobufCBuffer *buffer); ++Sr__GetItemResp * ++ sr__get_item_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__get_item_resp__free_unpacked ++ (Sr__GetItemResp *message, ++ ProtobufCAllocator *allocator); ++/* Sr__GetItemsReq methods */ ++void sr__get_items_req__init ++ (Sr__GetItemsReq *message); ++size_t sr__get_items_req__get_packed_size ++ (const Sr__GetItemsReq *message); ++size_t sr__get_items_req__pack ++ (const Sr__GetItemsReq *message, ++ uint8_t *out); ++size_t sr__get_items_req__pack_to_buffer ++ (const Sr__GetItemsReq *message, ++ ProtobufCBuffer *buffer); ++Sr__GetItemsReq * ++ sr__get_items_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__get_items_req__free_unpacked ++ (Sr__GetItemsReq *message, ++ ProtobufCAllocator *allocator); ++/* Sr__GetItemsResp methods */ ++void sr__get_items_resp__init ++ (Sr__GetItemsResp *message); ++size_t sr__get_items_resp__get_packed_size ++ (const Sr__GetItemsResp *message); ++size_t sr__get_items_resp__pack ++ (const Sr__GetItemsResp *message, ++ uint8_t *out); ++size_t sr__get_items_resp__pack_to_buffer ++ (const Sr__GetItemsResp *message, ++ ProtobufCBuffer *buffer); ++Sr__GetItemsResp * ++ sr__get_items_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__get_items_resp__free_unpacked ++ (Sr__GetItemsResp *message, ++ ProtobufCAllocator *allocator); ++/* Sr__GetSubtreeReq methods */ ++void sr__get_subtree_req__init ++ (Sr__GetSubtreeReq *message); ++size_t sr__get_subtree_req__get_packed_size ++ (const Sr__GetSubtreeReq *message); ++size_t sr__get_subtree_req__pack ++ (const Sr__GetSubtreeReq *message, ++ uint8_t *out); ++size_t sr__get_subtree_req__pack_to_buffer ++ (const Sr__GetSubtreeReq *message, ++ ProtobufCBuffer *buffer); ++Sr__GetSubtreeReq * ++ sr__get_subtree_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__get_subtree_req__free_unpacked ++ (Sr__GetSubtreeReq *message, ++ ProtobufCAllocator *allocator); ++/* Sr__GetSubtreeResp methods */ ++void sr__get_subtree_resp__init ++ (Sr__GetSubtreeResp *message); ++size_t sr__get_subtree_resp__get_packed_size ++ (const Sr__GetSubtreeResp *message); ++size_t sr__get_subtree_resp__pack ++ (const Sr__GetSubtreeResp *message, ++ uint8_t *out); ++size_t sr__get_subtree_resp__pack_to_buffer ++ (const Sr__GetSubtreeResp *message, ++ ProtobufCBuffer *buffer); ++Sr__GetSubtreeResp * ++ sr__get_subtree_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__get_subtree_resp__free_unpacked ++ (Sr__GetSubtreeResp *message, ++ ProtobufCAllocator *allocator); ++/* Sr__GetSubtreesReq methods */ ++void sr__get_subtrees_req__init ++ (Sr__GetSubtreesReq *message); ++size_t sr__get_subtrees_req__get_packed_size ++ (const Sr__GetSubtreesReq *message); ++size_t sr__get_subtrees_req__pack ++ (const Sr__GetSubtreesReq *message, ++ uint8_t *out); ++size_t sr__get_subtrees_req__pack_to_buffer ++ (const Sr__GetSubtreesReq *message, ++ ProtobufCBuffer *buffer); ++Sr__GetSubtreesReq * ++ sr__get_subtrees_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__get_subtrees_req__free_unpacked ++ (Sr__GetSubtreesReq *message, ++ ProtobufCAllocator *allocator); ++/* Sr__GetSubtreesResp methods */ ++void sr__get_subtrees_resp__init ++ (Sr__GetSubtreesResp *message); ++size_t sr__get_subtrees_resp__get_packed_size ++ (const Sr__GetSubtreesResp *message); ++size_t sr__get_subtrees_resp__pack ++ (const Sr__GetSubtreesResp *message, ++ uint8_t *out); ++size_t sr__get_subtrees_resp__pack_to_buffer ++ (const Sr__GetSubtreesResp *message, ++ ProtobufCBuffer *buffer); ++Sr__GetSubtreesResp * ++ sr__get_subtrees_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__get_subtrees_resp__free_unpacked ++ (Sr__GetSubtreesResp *message, ++ ProtobufCAllocator *allocator); ++/* Sr__GetSubtreeChunkReq methods */ ++void sr__get_subtree_chunk_req__init ++ (Sr__GetSubtreeChunkReq *message); ++size_t sr__get_subtree_chunk_req__get_packed_size ++ (const Sr__GetSubtreeChunkReq *message); ++size_t sr__get_subtree_chunk_req__pack ++ (const Sr__GetSubtreeChunkReq *message, ++ uint8_t *out); ++size_t sr__get_subtree_chunk_req__pack_to_buffer ++ (const Sr__GetSubtreeChunkReq *message, ++ ProtobufCBuffer *buffer); ++Sr__GetSubtreeChunkReq * ++ sr__get_subtree_chunk_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__get_subtree_chunk_req__free_unpacked ++ (Sr__GetSubtreeChunkReq *message, ++ ProtobufCAllocator *allocator); ++/* Sr__GetSubtreeChunkResp methods */ ++void sr__get_subtree_chunk_resp__init ++ (Sr__GetSubtreeChunkResp *message); ++size_t sr__get_subtree_chunk_resp__get_packed_size ++ (const Sr__GetSubtreeChunkResp *message); ++size_t sr__get_subtree_chunk_resp__pack ++ (const Sr__GetSubtreeChunkResp *message, ++ uint8_t *out); ++size_t sr__get_subtree_chunk_resp__pack_to_buffer ++ (const Sr__GetSubtreeChunkResp *message, ++ ProtobufCBuffer *buffer); ++Sr__GetSubtreeChunkResp * ++ sr__get_subtree_chunk_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__get_subtree_chunk_resp__free_unpacked ++ (Sr__GetSubtreeChunkResp *message, ++ ProtobufCAllocator *allocator); ++/* Sr__SetItemReq methods */ ++void sr__set_item_req__init ++ (Sr__SetItemReq *message); ++size_t sr__set_item_req__get_packed_size ++ (const Sr__SetItemReq *message); ++size_t sr__set_item_req__pack ++ (const Sr__SetItemReq *message, ++ uint8_t *out); ++size_t sr__set_item_req__pack_to_buffer ++ (const Sr__SetItemReq *message, ++ ProtobufCBuffer *buffer); ++Sr__SetItemReq * ++ sr__set_item_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__set_item_req__free_unpacked ++ (Sr__SetItemReq *message, ++ ProtobufCAllocator *allocator); ++/* Sr__SetItemResp methods */ ++void sr__set_item_resp__init ++ (Sr__SetItemResp *message); ++size_t sr__set_item_resp__get_packed_size ++ (const Sr__SetItemResp *message); ++size_t sr__set_item_resp__pack ++ (const Sr__SetItemResp *message, ++ uint8_t *out); ++size_t sr__set_item_resp__pack_to_buffer ++ (const Sr__SetItemResp *message, ++ ProtobufCBuffer *buffer); ++Sr__SetItemResp * ++ sr__set_item_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__set_item_resp__free_unpacked ++ (Sr__SetItemResp *message, ++ ProtobufCAllocator *allocator); ++/* Sr__SetItemStrReq methods */ ++void sr__set_item_str_req__init ++ (Sr__SetItemStrReq *message); ++size_t sr__set_item_str_req__get_packed_size ++ (const Sr__SetItemStrReq *message); ++size_t sr__set_item_str_req__pack ++ (const Sr__SetItemStrReq *message, ++ uint8_t *out); ++size_t sr__set_item_str_req__pack_to_buffer ++ (const Sr__SetItemStrReq *message, ++ ProtobufCBuffer *buffer); ++Sr__SetItemStrReq * ++ sr__set_item_str_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__set_item_str_req__free_unpacked ++ (Sr__SetItemStrReq *message, ++ ProtobufCAllocator *allocator); ++/* Sr__SetItemStrResp methods */ ++void sr__set_item_str_resp__init ++ (Sr__SetItemStrResp *message); ++size_t sr__set_item_str_resp__get_packed_size ++ (const Sr__SetItemStrResp *message); ++size_t sr__set_item_str_resp__pack ++ (const Sr__SetItemStrResp *message, ++ uint8_t *out); ++size_t sr__set_item_str_resp__pack_to_buffer ++ (const Sr__SetItemStrResp *message, ++ ProtobufCBuffer *buffer); ++Sr__SetItemStrResp * ++ sr__set_item_str_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__set_item_str_resp__free_unpacked ++ (Sr__SetItemStrResp *message, ++ ProtobufCAllocator *allocator); ++/* Sr__DeleteItemReq methods */ ++void sr__delete_item_req__init ++ (Sr__DeleteItemReq *message); ++size_t sr__delete_item_req__get_packed_size ++ (const Sr__DeleteItemReq *message); ++size_t sr__delete_item_req__pack ++ (const Sr__DeleteItemReq *message, ++ uint8_t *out); ++size_t sr__delete_item_req__pack_to_buffer ++ (const Sr__DeleteItemReq *message, ++ ProtobufCBuffer *buffer); ++Sr__DeleteItemReq * ++ sr__delete_item_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__delete_item_req__free_unpacked ++ (Sr__DeleteItemReq *message, ++ ProtobufCAllocator *allocator); ++/* Sr__DeleteItemResp methods */ ++void sr__delete_item_resp__init ++ (Sr__DeleteItemResp *message); ++size_t sr__delete_item_resp__get_packed_size ++ (const Sr__DeleteItemResp *message); ++size_t sr__delete_item_resp__pack ++ (const Sr__DeleteItemResp *message, ++ uint8_t *out); ++size_t sr__delete_item_resp__pack_to_buffer ++ (const Sr__DeleteItemResp *message, ++ ProtobufCBuffer *buffer); ++Sr__DeleteItemResp * ++ sr__delete_item_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__delete_item_resp__free_unpacked ++ (Sr__DeleteItemResp *message, ++ ProtobufCAllocator *allocator); ++/* Sr__MoveItemReq methods */ ++void sr__move_item_req__init ++ (Sr__MoveItemReq *message); ++size_t sr__move_item_req__get_packed_size ++ (const Sr__MoveItemReq *message); ++size_t sr__move_item_req__pack ++ (const Sr__MoveItemReq *message, ++ uint8_t *out); ++size_t sr__move_item_req__pack_to_buffer ++ (const Sr__MoveItemReq *message, ++ ProtobufCBuffer *buffer); ++Sr__MoveItemReq * ++ sr__move_item_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__move_item_req__free_unpacked ++ (Sr__MoveItemReq *message, ++ ProtobufCAllocator *allocator); ++/* Sr__MoveItemResp methods */ ++void sr__move_item_resp__init ++ (Sr__MoveItemResp *message); ++size_t sr__move_item_resp__get_packed_size ++ (const Sr__MoveItemResp *message); ++size_t sr__move_item_resp__pack ++ (const Sr__MoveItemResp *message, ++ uint8_t *out); ++size_t sr__move_item_resp__pack_to_buffer ++ (const Sr__MoveItemResp *message, ++ ProtobufCBuffer *buffer); ++Sr__MoveItemResp * ++ sr__move_item_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__move_item_resp__free_unpacked ++ (Sr__MoveItemResp *message, ++ ProtobufCAllocator *allocator); ++/* Sr__ValidateReq methods */ ++void sr__validate_req__init ++ (Sr__ValidateReq *message); ++size_t sr__validate_req__get_packed_size ++ (const Sr__ValidateReq *message); ++size_t sr__validate_req__pack ++ (const Sr__ValidateReq *message, ++ uint8_t *out); ++size_t sr__validate_req__pack_to_buffer ++ (const Sr__ValidateReq *message, ++ ProtobufCBuffer *buffer); ++Sr__ValidateReq * ++ sr__validate_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__validate_req__free_unpacked ++ (Sr__ValidateReq *message, ++ ProtobufCAllocator *allocator); ++/* Sr__ValidateResp methods */ ++void sr__validate_resp__init ++ (Sr__ValidateResp *message); ++size_t sr__validate_resp__get_packed_size ++ (const Sr__ValidateResp *message); ++size_t sr__validate_resp__pack ++ (const Sr__ValidateResp *message, ++ uint8_t *out); ++size_t sr__validate_resp__pack_to_buffer ++ (const Sr__ValidateResp *message, ++ ProtobufCBuffer *buffer); ++Sr__ValidateResp * ++ sr__validate_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__validate_resp__free_unpacked ++ (Sr__ValidateResp *message, ++ ProtobufCAllocator *allocator); ++/* Sr__CommitReq methods */ ++void sr__commit_req__init ++ (Sr__CommitReq *message); ++size_t sr__commit_req__get_packed_size ++ (const Sr__CommitReq *message); ++size_t sr__commit_req__pack ++ (const Sr__CommitReq *message, ++ uint8_t *out); ++size_t sr__commit_req__pack_to_buffer ++ (const Sr__CommitReq *message, ++ ProtobufCBuffer *buffer); ++Sr__CommitReq * ++ sr__commit_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__commit_req__free_unpacked ++ (Sr__CommitReq *message, ++ ProtobufCAllocator *allocator); ++/* Sr__CommitResp methods */ ++void sr__commit_resp__init ++ (Sr__CommitResp *message); ++size_t sr__commit_resp__get_packed_size ++ (const Sr__CommitResp *message); ++size_t sr__commit_resp__pack ++ (const Sr__CommitResp *message, ++ uint8_t *out); ++size_t sr__commit_resp__pack_to_buffer ++ (const Sr__CommitResp *message, ++ ProtobufCBuffer *buffer); ++Sr__CommitResp * ++ sr__commit_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__commit_resp__free_unpacked ++ (Sr__CommitResp *message, ++ ProtobufCAllocator *allocator); ++/* Sr__DiscardChangesReq methods */ ++void sr__discard_changes_req__init ++ (Sr__DiscardChangesReq *message); ++size_t sr__discard_changes_req__get_packed_size ++ (const Sr__DiscardChangesReq *message); ++size_t sr__discard_changes_req__pack ++ (const Sr__DiscardChangesReq *message, ++ uint8_t *out); ++size_t sr__discard_changes_req__pack_to_buffer ++ (const Sr__DiscardChangesReq *message, ++ ProtobufCBuffer *buffer); ++Sr__DiscardChangesReq * ++ sr__discard_changes_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__discard_changes_req__free_unpacked ++ (Sr__DiscardChangesReq *message, ++ ProtobufCAllocator *allocator); ++/* Sr__DiscardChangesResp methods */ ++void sr__discard_changes_resp__init ++ (Sr__DiscardChangesResp *message); ++size_t sr__discard_changes_resp__get_packed_size ++ (const Sr__DiscardChangesResp *message); ++size_t sr__discard_changes_resp__pack ++ (const Sr__DiscardChangesResp *message, ++ uint8_t *out); ++size_t sr__discard_changes_resp__pack_to_buffer ++ (const Sr__DiscardChangesResp *message, ++ ProtobufCBuffer *buffer); ++Sr__DiscardChangesResp * ++ sr__discard_changes_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__discard_changes_resp__free_unpacked ++ (Sr__DiscardChangesResp *message, ++ ProtobufCAllocator *allocator); ++/* Sr__CopyConfigReq methods */ ++void sr__copy_config_req__init ++ (Sr__CopyConfigReq *message); ++size_t sr__copy_config_req__get_packed_size ++ (const Sr__CopyConfigReq *message); ++size_t sr__copy_config_req__pack ++ (const Sr__CopyConfigReq *message, ++ uint8_t *out); ++size_t sr__copy_config_req__pack_to_buffer ++ (const Sr__CopyConfigReq *message, ++ ProtobufCBuffer *buffer); ++Sr__CopyConfigReq * ++ sr__copy_config_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__copy_config_req__free_unpacked ++ (Sr__CopyConfigReq *message, ++ ProtobufCAllocator *allocator); ++/* Sr__CopyConfigResp methods */ ++void sr__copy_config_resp__init ++ (Sr__CopyConfigResp *message); ++size_t sr__copy_config_resp__get_packed_size ++ (const Sr__CopyConfigResp *message); ++size_t sr__copy_config_resp__pack ++ (const Sr__CopyConfigResp *message, ++ uint8_t *out); ++size_t sr__copy_config_resp__pack_to_buffer ++ (const Sr__CopyConfigResp *message, ++ ProtobufCBuffer *buffer); ++Sr__CopyConfigResp * ++ sr__copy_config_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__copy_config_resp__free_unpacked ++ (Sr__CopyConfigResp *message, ++ ProtobufCAllocator *allocator); ++/* Sr__LockReq methods */ ++void sr__lock_req__init ++ (Sr__LockReq *message); ++size_t sr__lock_req__get_packed_size ++ (const Sr__LockReq *message); ++size_t sr__lock_req__pack ++ (const Sr__LockReq *message, ++ uint8_t *out); ++size_t sr__lock_req__pack_to_buffer ++ (const Sr__LockReq *message, ++ ProtobufCBuffer *buffer); ++Sr__LockReq * ++ sr__lock_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__lock_req__free_unpacked ++ (Sr__LockReq *message, ++ ProtobufCAllocator *allocator); ++/* Sr__LockResp methods */ ++void sr__lock_resp__init ++ (Sr__LockResp *message); ++size_t sr__lock_resp__get_packed_size ++ (const Sr__LockResp *message); ++size_t sr__lock_resp__pack ++ (const Sr__LockResp *message, ++ uint8_t *out); ++size_t sr__lock_resp__pack_to_buffer ++ (const Sr__LockResp *message, ++ ProtobufCBuffer *buffer); ++Sr__LockResp * ++ sr__lock_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__lock_resp__free_unpacked ++ (Sr__LockResp *message, ++ ProtobufCAllocator *allocator); ++/* Sr__UnlockReq methods */ ++void sr__unlock_req__init ++ (Sr__UnlockReq *message); ++size_t sr__unlock_req__get_packed_size ++ (const Sr__UnlockReq *message); ++size_t sr__unlock_req__pack ++ (const Sr__UnlockReq *message, ++ uint8_t *out); ++size_t sr__unlock_req__pack_to_buffer ++ (const Sr__UnlockReq *message, ++ ProtobufCBuffer *buffer); ++Sr__UnlockReq * ++ sr__unlock_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__unlock_req__free_unpacked ++ (Sr__UnlockReq *message, ++ ProtobufCAllocator *allocator); ++/* Sr__UnlockResp methods */ ++void sr__unlock_resp__init ++ (Sr__UnlockResp *message); ++size_t sr__unlock_resp__get_packed_size ++ (const Sr__UnlockResp *message); ++size_t sr__unlock_resp__pack ++ (const Sr__UnlockResp *message, ++ uint8_t *out); ++size_t sr__unlock_resp__pack_to_buffer ++ (const Sr__UnlockResp *message, ++ ProtobufCBuffer *buffer); ++Sr__UnlockResp * ++ sr__unlock_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__unlock_resp__free_unpacked ++ (Sr__UnlockResp *message, ++ ProtobufCAllocator *allocator); ++/* Sr__SubscribeReq methods */ ++void sr__subscribe_req__init ++ (Sr__SubscribeReq *message); ++size_t sr__subscribe_req__get_packed_size ++ (const Sr__SubscribeReq *message); ++size_t sr__subscribe_req__pack ++ (const Sr__SubscribeReq *message, ++ uint8_t *out); ++size_t sr__subscribe_req__pack_to_buffer ++ (const Sr__SubscribeReq *message, ++ ProtobufCBuffer *buffer); ++Sr__SubscribeReq * ++ sr__subscribe_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__subscribe_req__free_unpacked ++ (Sr__SubscribeReq *message, ++ ProtobufCAllocator *allocator); ++/* Sr__SubscribeResp methods */ ++void sr__subscribe_resp__init ++ (Sr__SubscribeResp *message); ++size_t sr__subscribe_resp__get_packed_size ++ (const Sr__SubscribeResp *message); ++size_t sr__subscribe_resp__pack ++ (const Sr__SubscribeResp *message, ++ uint8_t *out); ++size_t sr__subscribe_resp__pack_to_buffer ++ (const Sr__SubscribeResp *message, ++ ProtobufCBuffer *buffer); ++Sr__SubscribeResp * ++ sr__subscribe_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__subscribe_resp__free_unpacked ++ (Sr__SubscribeResp *message, ++ ProtobufCAllocator *allocator); ++/* Sr__UnsubscribeReq methods */ ++void sr__unsubscribe_req__init ++ (Sr__UnsubscribeReq *message); ++size_t sr__unsubscribe_req__get_packed_size ++ (const Sr__UnsubscribeReq *message); ++size_t sr__unsubscribe_req__pack ++ (const Sr__UnsubscribeReq *message, ++ uint8_t *out); ++size_t sr__unsubscribe_req__pack_to_buffer ++ (const Sr__UnsubscribeReq *message, ++ ProtobufCBuffer *buffer); ++Sr__UnsubscribeReq * ++ sr__unsubscribe_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__unsubscribe_req__free_unpacked ++ (Sr__UnsubscribeReq *message, ++ ProtobufCAllocator *allocator); ++/* Sr__UnsubscribeResp methods */ ++void sr__unsubscribe_resp__init ++ (Sr__UnsubscribeResp *message); ++size_t sr__unsubscribe_resp__get_packed_size ++ (const Sr__UnsubscribeResp *message); ++size_t sr__unsubscribe_resp__pack ++ (const Sr__UnsubscribeResp *message, ++ uint8_t *out); ++size_t sr__unsubscribe_resp__pack_to_buffer ++ (const Sr__UnsubscribeResp *message, ++ ProtobufCBuffer *buffer); ++Sr__UnsubscribeResp * ++ sr__unsubscribe_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__unsubscribe_resp__free_unpacked ++ (Sr__UnsubscribeResp *message, ++ ProtobufCAllocator *allocator); ++/* Sr__CheckEnabledRunningReq methods */ ++void sr__check_enabled_running_req__init ++ (Sr__CheckEnabledRunningReq *message); ++size_t sr__check_enabled_running_req__get_packed_size ++ (const Sr__CheckEnabledRunningReq *message); ++size_t sr__check_enabled_running_req__pack ++ (const Sr__CheckEnabledRunningReq *message, ++ uint8_t *out); ++size_t sr__check_enabled_running_req__pack_to_buffer ++ (const Sr__CheckEnabledRunningReq *message, ++ ProtobufCBuffer *buffer); ++Sr__CheckEnabledRunningReq * ++ sr__check_enabled_running_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__check_enabled_running_req__free_unpacked ++ (Sr__CheckEnabledRunningReq *message, ++ ProtobufCAllocator *allocator); ++/* Sr__CheckEnabledRunningResp methods */ ++void sr__check_enabled_running_resp__init ++ (Sr__CheckEnabledRunningResp *message); ++size_t sr__check_enabled_running_resp__get_packed_size ++ (const Sr__CheckEnabledRunningResp *message); ++size_t sr__check_enabled_running_resp__pack ++ (const Sr__CheckEnabledRunningResp *message, ++ uint8_t *out); ++size_t sr__check_enabled_running_resp__pack_to_buffer ++ (const Sr__CheckEnabledRunningResp *message, ++ ProtobufCBuffer *buffer); ++Sr__CheckEnabledRunningResp * ++ sr__check_enabled_running_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__check_enabled_running_resp__free_unpacked ++ (Sr__CheckEnabledRunningResp *message, ++ ProtobufCAllocator *allocator); ++/* Sr__ModuleInstallNotification methods */ ++void sr__module_install_notification__init ++ (Sr__ModuleInstallNotification *message); ++size_t sr__module_install_notification__get_packed_size ++ (const Sr__ModuleInstallNotification *message); ++size_t sr__module_install_notification__pack ++ (const Sr__ModuleInstallNotification *message, ++ uint8_t *out); ++size_t sr__module_install_notification__pack_to_buffer ++ (const Sr__ModuleInstallNotification *message, ++ ProtobufCBuffer *buffer); ++Sr__ModuleInstallNotification * ++ sr__module_install_notification__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__module_install_notification__free_unpacked ++ (Sr__ModuleInstallNotification *message, ++ ProtobufCAllocator *allocator); ++/* Sr__FeatureEnableNotification methods */ ++void sr__feature_enable_notification__init ++ (Sr__FeatureEnableNotification *message); ++size_t sr__feature_enable_notification__get_packed_size ++ (const Sr__FeatureEnableNotification *message); ++size_t sr__feature_enable_notification__pack ++ (const Sr__FeatureEnableNotification *message, ++ uint8_t *out); ++size_t sr__feature_enable_notification__pack_to_buffer ++ (const Sr__FeatureEnableNotification *message, ++ ProtobufCBuffer *buffer); ++Sr__FeatureEnableNotification * ++ sr__feature_enable_notification__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__feature_enable_notification__free_unpacked ++ (Sr__FeatureEnableNotification *message, ++ ProtobufCAllocator *allocator); ++/* Sr__ModuleChangeNotification methods */ ++void sr__module_change_notification__init ++ (Sr__ModuleChangeNotification *message); ++size_t sr__module_change_notification__get_packed_size ++ (const Sr__ModuleChangeNotification *message); ++size_t sr__module_change_notification__pack ++ (const Sr__ModuleChangeNotification *message, ++ uint8_t *out); ++size_t sr__module_change_notification__pack_to_buffer ++ (const Sr__ModuleChangeNotification *message, ++ ProtobufCBuffer *buffer); ++Sr__ModuleChangeNotification * ++ sr__module_change_notification__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__module_change_notification__free_unpacked ++ (Sr__ModuleChangeNotification *message, ++ ProtobufCAllocator *allocator); ++/* Sr__SubtreeChangeNotification methods */ ++void sr__subtree_change_notification__init ++ (Sr__SubtreeChangeNotification *message); ++size_t sr__subtree_change_notification__get_packed_size ++ (const Sr__SubtreeChangeNotification *message); ++size_t sr__subtree_change_notification__pack ++ (const Sr__SubtreeChangeNotification *message, ++ uint8_t *out); ++size_t sr__subtree_change_notification__pack_to_buffer ++ (const Sr__SubtreeChangeNotification *message, ++ ProtobufCBuffer *buffer); ++Sr__SubtreeChangeNotification * ++ sr__subtree_change_notification__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__subtree_change_notification__free_unpacked ++ (Sr__SubtreeChangeNotification *message, ++ ProtobufCAllocator *allocator); ++/* Sr__Change methods */ ++void sr__change__init ++ (Sr__Change *message); ++size_t sr__change__get_packed_size ++ (const Sr__Change *message); ++size_t sr__change__pack ++ (const Sr__Change *message, ++ uint8_t *out); ++size_t sr__change__pack_to_buffer ++ (const Sr__Change *message, ++ ProtobufCBuffer *buffer); ++Sr__Change * ++ sr__change__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__change__free_unpacked ++ (Sr__Change *message, ++ ProtobufCAllocator *allocator); ++/* Sr__GetChangesReq methods */ ++void sr__get_changes_req__init ++ (Sr__GetChangesReq *message); ++size_t sr__get_changes_req__get_packed_size ++ (const Sr__GetChangesReq *message); ++size_t sr__get_changes_req__pack ++ (const Sr__GetChangesReq *message, ++ uint8_t *out); ++size_t sr__get_changes_req__pack_to_buffer ++ (const Sr__GetChangesReq *message, ++ ProtobufCBuffer *buffer); ++Sr__GetChangesReq * ++ sr__get_changes_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__get_changes_req__free_unpacked ++ (Sr__GetChangesReq *message, ++ ProtobufCAllocator *allocator); ++/* Sr__GetChangesResp methods */ ++void sr__get_changes_resp__init ++ (Sr__GetChangesResp *message); ++size_t sr__get_changes_resp__get_packed_size ++ (const Sr__GetChangesResp *message); ++size_t sr__get_changes_resp__pack ++ (const Sr__GetChangesResp *message, ++ uint8_t *out); ++size_t sr__get_changes_resp__pack_to_buffer ++ (const Sr__GetChangesResp *message, ++ ProtobufCBuffer *buffer); ++Sr__GetChangesResp * ++ sr__get_changes_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__get_changes_resp__free_unpacked ++ (Sr__GetChangesResp *message, ++ ProtobufCAllocator *allocator); ++/* Sr__CheckExecPermReq methods */ ++void sr__check_exec_perm_req__init ++ (Sr__CheckExecPermReq *message); ++size_t sr__check_exec_perm_req__get_packed_size ++ (const Sr__CheckExecPermReq *message); ++size_t sr__check_exec_perm_req__pack ++ (const Sr__CheckExecPermReq *message, ++ uint8_t *out); ++size_t sr__check_exec_perm_req__pack_to_buffer ++ (const Sr__CheckExecPermReq *message, ++ ProtobufCBuffer *buffer); ++Sr__CheckExecPermReq * ++ sr__check_exec_perm_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__check_exec_perm_req__free_unpacked ++ (Sr__CheckExecPermReq *message, ++ ProtobufCAllocator *allocator); ++/* Sr__CheckExecPermResp methods */ ++void sr__check_exec_perm_resp__init ++ (Sr__CheckExecPermResp *message); ++size_t sr__check_exec_perm_resp__get_packed_size ++ (const Sr__CheckExecPermResp *message); ++size_t sr__check_exec_perm_resp__pack ++ (const Sr__CheckExecPermResp *message, ++ uint8_t *out); ++size_t sr__check_exec_perm_resp__pack_to_buffer ++ (const Sr__CheckExecPermResp *message, ++ ProtobufCBuffer *buffer); ++Sr__CheckExecPermResp * ++ sr__check_exec_perm_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__check_exec_perm_resp__free_unpacked ++ (Sr__CheckExecPermResp *message, ++ ProtobufCAllocator *allocator); ++/* Sr__RPCReq methods */ ++void sr__rpcreq__init ++ (Sr__RPCReq *message); ++size_t sr__rpcreq__get_packed_size ++ (const Sr__RPCReq *message); ++size_t sr__rpcreq__pack ++ (const Sr__RPCReq *message, ++ uint8_t *out); ++size_t sr__rpcreq__pack_to_buffer ++ (const Sr__RPCReq *message, ++ ProtobufCBuffer *buffer); ++Sr__RPCReq * ++ sr__rpcreq__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__rpcreq__free_unpacked ++ (Sr__RPCReq *message, ++ ProtobufCAllocator *allocator); ++/* Sr__RPCResp methods */ ++void sr__rpcresp__init ++ (Sr__RPCResp *message); ++size_t sr__rpcresp__get_packed_size ++ (const Sr__RPCResp *message); ++size_t sr__rpcresp__pack ++ (const Sr__RPCResp *message, ++ uint8_t *out); ++size_t sr__rpcresp__pack_to_buffer ++ (const Sr__RPCResp *message, ++ ProtobufCBuffer *buffer); ++Sr__RPCResp * ++ sr__rpcresp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__rpcresp__free_unpacked ++ (Sr__RPCResp *message, ++ ProtobufCAllocator *allocator); ++/* Sr__EventNotifReq methods */ ++void sr__event_notif_req__init ++ (Sr__EventNotifReq *message); ++size_t sr__event_notif_req__get_packed_size ++ (const Sr__EventNotifReq *message); ++size_t sr__event_notif_req__pack ++ (const Sr__EventNotifReq *message, ++ uint8_t *out); ++size_t sr__event_notif_req__pack_to_buffer ++ (const Sr__EventNotifReq *message, ++ ProtobufCBuffer *buffer); ++Sr__EventNotifReq * ++ sr__event_notif_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__event_notif_req__free_unpacked ++ (Sr__EventNotifReq *message, ++ ProtobufCAllocator *allocator); ++/* Sr__EventNotifResp methods */ ++void sr__event_notif_resp__init ++ (Sr__EventNotifResp *message); ++size_t sr__event_notif_resp__get_packed_size ++ (const Sr__EventNotifResp *message); ++size_t sr__event_notif_resp__pack ++ (const Sr__EventNotifResp *message, ++ uint8_t *out); ++size_t sr__event_notif_resp__pack_to_buffer ++ (const Sr__EventNotifResp *message, ++ ProtobufCBuffer *buffer); ++Sr__EventNotifResp * ++ sr__event_notif_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__event_notif_resp__free_unpacked ++ (Sr__EventNotifResp *message, ++ ProtobufCAllocator *allocator); ++/* Sr__EventNotifReplayReq methods */ ++void sr__event_notif_replay_req__init ++ (Sr__EventNotifReplayReq *message); ++size_t sr__event_notif_replay_req__get_packed_size ++ (const Sr__EventNotifReplayReq *message); ++size_t sr__event_notif_replay_req__pack ++ (const Sr__EventNotifReplayReq *message, ++ uint8_t *out); ++size_t sr__event_notif_replay_req__pack_to_buffer ++ (const Sr__EventNotifReplayReq *message, ++ ProtobufCBuffer *buffer); ++Sr__EventNotifReplayReq * ++ sr__event_notif_replay_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__event_notif_replay_req__free_unpacked ++ (Sr__EventNotifReplayReq *message, ++ ProtobufCAllocator *allocator); ++/* Sr__EventNotifReplayResp methods */ ++void sr__event_notif_replay_resp__init ++ (Sr__EventNotifReplayResp *message); ++size_t sr__event_notif_replay_resp__get_packed_size ++ (const Sr__EventNotifReplayResp *message); ++size_t sr__event_notif_replay_resp__pack ++ (const Sr__EventNotifReplayResp *message, ++ uint8_t *out); ++size_t sr__event_notif_replay_resp__pack_to_buffer ++ (const Sr__EventNotifReplayResp *message, ++ ProtobufCBuffer *buffer); ++Sr__EventNotifReplayResp * ++ sr__event_notif_replay_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__event_notif_replay_resp__free_unpacked ++ (Sr__EventNotifReplayResp *message, ++ ProtobufCAllocator *allocator); ++/* Sr__DataProvideReq methods */ ++void sr__data_provide_req__init ++ (Sr__DataProvideReq *message); ++size_t sr__data_provide_req__get_packed_size ++ (const Sr__DataProvideReq *message); ++size_t sr__data_provide_req__pack ++ (const Sr__DataProvideReq *message, ++ uint8_t *out); ++size_t sr__data_provide_req__pack_to_buffer ++ (const Sr__DataProvideReq *message, ++ ProtobufCBuffer *buffer); ++Sr__DataProvideReq * ++ sr__data_provide_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__data_provide_req__free_unpacked ++ (Sr__DataProvideReq *message, ++ ProtobufCAllocator *allocator); ++/* Sr__DataProvideResp methods */ ++void sr__data_provide_resp__init ++ (Sr__DataProvideResp *message); ++size_t sr__data_provide_resp__get_packed_size ++ (const Sr__DataProvideResp *message); ++size_t sr__data_provide_resp__pack ++ (const Sr__DataProvideResp *message, ++ uint8_t *out); ++size_t sr__data_provide_resp__pack_to_buffer ++ (const Sr__DataProvideResp *message, ++ ProtobufCBuffer *buffer); ++Sr__DataProvideResp * ++ sr__data_provide_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__data_provide_resp__free_unpacked ++ (Sr__DataProvideResp *message, ++ ProtobufCAllocator *allocator); ++/* Sr__ModuleInstallReq methods */ ++void sr__module_install_req__init ++ (Sr__ModuleInstallReq *message); ++size_t sr__module_install_req__get_packed_size ++ (const Sr__ModuleInstallReq *message); ++size_t sr__module_install_req__pack ++ (const Sr__ModuleInstallReq *message, ++ uint8_t *out); ++size_t sr__module_install_req__pack_to_buffer ++ (const Sr__ModuleInstallReq *message, ++ ProtobufCBuffer *buffer); ++Sr__ModuleInstallReq * ++ sr__module_install_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__module_install_req__free_unpacked ++ (Sr__ModuleInstallReq *message, ++ ProtobufCAllocator *allocator); ++/* Sr__ModuleInstallResp methods */ ++void sr__module_install_resp__init ++ (Sr__ModuleInstallResp *message); ++size_t sr__module_install_resp__get_packed_size ++ (const Sr__ModuleInstallResp *message); ++size_t sr__module_install_resp__pack ++ (const Sr__ModuleInstallResp *message, ++ uint8_t *out); ++size_t sr__module_install_resp__pack_to_buffer ++ (const Sr__ModuleInstallResp *message, ++ ProtobufCBuffer *buffer); ++Sr__ModuleInstallResp * ++ sr__module_install_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__module_install_resp__free_unpacked ++ (Sr__ModuleInstallResp *message, ++ ProtobufCAllocator *allocator); ++/* Sr__FeatureEnableReq methods */ ++void sr__feature_enable_req__init ++ (Sr__FeatureEnableReq *message); ++size_t sr__feature_enable_req__get_packed_size ++ (const Sr__FeatureEnableReq *message); ++size_t sr__feature_enable_req__pack ++ (const Sr__FeatureEnableReq *message, ++ uint8_t *out); ++size_t sr__feature_enable_req__pack_to_buffer ++ (const Sr__FeatureEnableReq *message, ++ ProtobufCBuffer *buffer); ++Sr__FeatureEnableReq * ++ sr__feature_enable_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__feature_enable_req__free_unpacked ++ (Sr__FeatureEnableReq *message, ++ ProtobufCAllocator *allocator); ++/* Sr__FeatureEnableResp methods */ ++void sr__feature_enable_resp__init ++ (Sr__FeatureEnableResp *message); ++size_t sr__feature_enable_resp__get_packed_size ++ (const Sr__FeatureEnableResp *message); ++size_t sr__feature_enable_resp__pack ++ (const Sr__FeatureEnableResp *message, ++ uint8_t *out); ++size_t sr__feature_enable_resp__pack_to_buffer ++ (const Sr__FeatureEnableResp *message, ++ ProtobufCBuffer *buffer); ++Sr__FeatureEnableResp * ++ sr__feature_enable_resp__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__feature_enable_resp__free_unpacked ++ (Sr__FeatureEnableResp *message, ++ ProtobufCAllocator *allocator); ++/* Sr__UnsubscribeDestinationReq methods */ ++void sr__unsubscribe_destination_req__init ++ (Sr__UnsubscribeDestinationReq *message); ++size_t sr__unsubscribe_destination_req__get_packed_size ++ (const Sr__UnsubscribeDestinationReq *message); ++size_t sr__unsubscribe_destination_req__pack ++ (const Sr__UnsubscribeDestinationReq *message, ++ uint8_t *out); ++size_t sr__unsubscribe_destination_req__pack_to_buffer ++ (const Sr__UnsubscribeDestinationReq *message, ++ ProtobufCBuffer *buffer); ++Sr__UnsubscribeDestinationReq * ++ sr__unsubscribe_destination_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__unsubscribe_destination_req__free_unpacked ++ (Sr__UnsubscribeDestinationReq *message, ++ ProtobufCAllocator *allocator); ++/* Sr__CommitTimeoutReq methods */ ++void sr__commit_timeout_req__init ++ (Sr__CommitTimeoutReq *message); ++size_t sr__commit_timeout_req__get_packed_size ++ (const Sr__CommitTimeoutReq *message); ++size_t sr__commit_timeout_req__pack ++ (const Sr__CommitTimeoutReq *message, ++ uint8_t *out); ++size_t sr__commit_timeout_req__pack_to_buffer ++ (const Sr__CommitTimeoutReq *message, ++ ProtobufCBuffer *buffer); ++Sr__CommitTimeoutReq * ++ sr__commit_timeout_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__commit_timeout_req__free_unpacked ++ (Sr__CommitTimeoutReq *message, ++ ProtobufCAllocator *allocator); ++/* Sr__OperDataTimeoutReq methods */ ++void sr__oper_data_timeout_req__init ++ (Sr__OperDataTimeoutReq *message); ++size_t sr__oper_data_timeout_req__get_packed_size ++ (const Sr__OperDataTimeoutReq *message); ++size_t sr__oper_data_timeout_req__pack ++ (const Sr__OperDataTimeoutReq *message, ++ uint8_t *out); ++size_t sr__oper_data_timeout_req__pack_to_buffer ++ (const Sr__OperDataTimeoutReq *message, ++ ProtobufCBuffer *buffer); ++Sr__OperDataTimeoutReq * ++ sr__oper_data_timeout_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__oper_data_timeout_req__free_unpacked ++ (Sr__OperDataTimeoutReq *message, ++ ProtobufCAllocator *allocator); ++/* Sr__InternalStateDataReq methods */ ++void sr__internal_state_data_req__init ++ (Sr__InternalStateDataReq *message); ++size_t sr__internal_state_data_req__get_packed_size ++ (const Sr__InternalStateDataReq *message); ++size_t sr__internal_state_data_req__pack ++ (const Sr__InternalStateDataReq *message, ++ uint8_t *out); ++size_t sr__internal_state_data_req__pack_to_buffer ++ (const Sr__InternalStateDataReq *message, ++ ProtobufCBuffer *buffer); ++Sr__InternalStateDataReq * ++ sr__internal_state_data_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__internal_state_data_req__free_unpacked ++ (Sr__InternalStateDataReq *message, ++ ProtobufCAllocator *allocator); ++/* Sr__NotifStoreCleanupReq methods */ ++void sr__notif_store_cleanup_req__init ++ (Sr__NotifStoreCleanupReq *message); ++size_t sr__notif_store_cleanup_req__get_packed_size ++ (const Sr__NotifStoreCleanupReq *message); ++size_t sr__notif_store_cleanup_req__pack ++ (const Sr__NotifStoreCleanupReq *message, ++ uint8_t *out); ++size_t sr__notif_store_cleanup_req__pack_to_buffer ++ (const Sr__NotifStoreCleanupReq *message, ++ ProtobufCBuffer *buffer); ++Sr__NotifStoreCleanupReq * ++ sr__notif_store_cleanup_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__notif_store_cleanup_req__free_unpacked ++ (Sr__NotifStoreCleanupReq *message, ++ ProtobufCAllocator *allocator); ++/* Sr__DelayedMsgReq methods */ ++void sr__delayed_msg_req__init ++ (Sr__DelayedMsgReq *message); ++size_t sr__delayed_msg_req__get_packed_size ++ (const Sr__DelayedMsgReq *message); ++size_t sr__delayed_msg_req__pack ++ (const Sr__DelayedMsgReq *message, ++ uint8_t *out); ++size_t sr__delayed_msg_req__pack_to_buffer ++ (const Sr__DelayedMsgReq *message, ++ ProtobufCBuffer *buffer); ++Sr__DelayedMsgReq * ++ sr__delayed_msg_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__delayed_msg_req__free_unpacked ++ (Sr__DelayedMsgReq *message, ++ ProtobufCAllocator *allocator); ++/* Sr__NacmReloadReq methods */ ++void sr__nacm_reload_req__init ++ (Sr__NacmReloadReq *message); ++size_t sr__nacm_reload_req__get_packed_size ++ (const Sr__NacmReloadReq *message); ++size_t sr__nacm_reload_req__pack ++ (const Sr__NacmReloadReq *message, ++ uint8_t *out); ++size_t sr__nacm_reload_req__pack_to_buffer ++ (const Sr__NacmReloadReq *message, ++ ProtobufCBuffer *buffer); ++Sr__NacmReloadReq * ++ sr__nacm_reload_req__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__nacm_reload_req__free_unpacked ++ (Sr__NacmReloadReq *message, ++ ProtobufCAllocator *allocator); ++/* Sr__Request methods */ ++void sr__request__init ++ (Sr__Request *message); ++size_t sr__request__get_packed_size ++ (const Sr__Request *message); ++size_t sr__request__pack ++ (const Sr__Request *message, ++ uint8_t *out); ++size_t sr__request__pack_to_buffer ++ (const Sr__Request *message, ++ ProtobufCBuffer *buffer); ++Sr__Request * ++ sr__request__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__request__free_unpacked ++ (Sr__Request *message, ++ ProtobufCAllocator *allocator); ++/* Sr__Response methods */ ++void sr__response__init ++ (Sr__Response *message); ++size_t sr__response__get_packed_size ++ (const Sr__Response *message); ++size_t sr__response__pack ++ (const Sr__Response *message, ++ uint8_t *out); ++size_t sr__response__pack_to_buffer ++ (const Sr__Response *message, ++ ProtobufCBuffer *buffer); ++Sr__Response * ++ sr__response__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__response__free_unpacked ++ (Sr__Response *message, ++ ProtobufCAllocator *allocator); ++/* Sr__Notification methods */ ++void sr__notification__init ++ (Sr__Notification *message); ++size_t sr__notification__get_packed_size ++ (const Sr__Notification *message); ++size_t sr__notification__pack ++ (const Sr__Notification *message, ++ uint8_t *out); ++size_t sr__notification__pack_to_buffer ++ (const Sr__Notification *message, ++ ProtobufCBuffer *buffer); ++Sr__Notification * ++ sr__notification__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__notification__free_unpacked ++ (Sr__Notification *message, ++ ProtobufCAllocator *allocator); ++/* Sr__NotificationAck methods */ ++void sr__notification_ack__init ++ (Sr__NotificationAck *message); ++size_t sr__notification_ack__get_packed_size ++ (const Sr__NotificationAck *message); ++size_t sr__notification_ack__pack ++ (const Sr__NotificationAck *message, ++ uint8_t *out); ++size_t sr__notification_ack__pack_to_buffer ++ (const Sr__NotificationAck *message, ++ ProtobufCBuffer *buffer); ++Sr__NotificationAck * ++ sr__notification_ack__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__notification_ack__free_unpacked ++ (Sr__NotificationAck *message, ++ ProtobufCAllocator *allocator); ++/* Sr__InternalRequest methods */ ++void sr__internal_request__init ++ (Sr__InternalRequest *message); ++size_t sr__internal_request__get_packed_size ++ (const Sr__InternalRequest *message); ++size_t sr__internal_request__pack ++ (const Sr__InternalRequest *message, ++ uint8_t *out); ++size_t sr__internal_request__pack_to_buffer ++ (const Sr__InternalRequest *message, ++ ProtobufCBuffer *buffer); ++Sr__InternalRequest * ++ sr__internal_request__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__internal_request__free_unpacked ++ (Sr__InternalRequest *message, ++ ProtobufCAllocator *allocator); ++/* Sr__Msg methods */ ++void sr__msg__init ++ (Sr__Msg *message); ++size_t sr__msg__get_packed_size ++ (const Sr__Msg *message); ++size_t sr__msg__pack ++ (const Sr__Msg *message, ++ uint8_t *out); ++size_t sr__msg__pack_to_buffer ++ (const Sr__Msg *message, ++ ProtobufCBuffer *buffer); ++Sr__Msg * ++ sr__msg__unpack ++ (ProtobufCAllocator *allocator, ++ size_t len, ++ const uint8_t *data); ++void sr__msg__free_unpacked ++ (Sr__Msg *message, ++ ProtobufCAllocator *allocator); ++/* --- per-message closures --- */ ++ ++typedef void (*Sr__Value_Closure) ++ (const Sr__Value *message, ++ void *closure_data); ++typedef void (*Sr__Node_Closure) ++ (const Sr__Node *message, ++ void *closure_data); ++typedef void (*Sr__Error_Closure) ++ (const Sr__Error *message, ++ void *closure_data); ++typedef void (*Sr__SessionStartReq_Closure) ++ (const Sr__SessionStartReq *message, ++ void *closure_data); ++typedef void (*Sr__SessionStartResp_Closure) ++ (const Sr__SessionStartResp *message, ++ void *closure_data); ++typedef void (*Sr__SessionStopReq_Closure) ++ (const Sr__SessionStopReq *message, ++ void *closure_data); ++typedef void (*Sr__SessionStopResp_Closure) ++ (const Sr__SessionStopResp *message, ++ void *closure_data); ++typedef void (*Sr__SessionRefreshReq_Closure) ++ (const Sr__SessionRefreshReq *message, ++ void *closure_data); ++typedef void (*Sr__SessionRefreshResp_Closure) ++ (const Sr__SessionRefreshResp *message, ++ void *closure_data); ++typedef void (*Sr__SessionCheckReq_Closure) ++ (const Sr__SessionCheckReq *message, ++ void *closure_data); ++typedef void (*Sr__SessionCheckResp_Closure) ++ (const Sr__SessionCheckResp *message, ++ void *closure_data); ++typedef void (*Sr__SessionSwitchDsReq_Closure) ++ (const Sr__SessionSwitchDsReq *message, ++ void *closure_data); ++typedef void (*Sr__SessionSwitchDsResp_Closure) ++ (const Sr__SessionSwitchDsResp *message, ++ void *closure_data); ++typedef void (*Sr__SessionSetOptsReq_Closure) ++ (const Sr__SessionSetOptsReq *message, ++ void *closure_data); ++typedef void (*Sr__SessionSetOptsResp_Closure) ++ (const Sr__SessionSetOptsResp *message, ++ void *closure_data); ++typedef void (*Sr__VersionVerifyReq_Closure) ++ (const Sr__VersionVerifyReq *message, ++ void *closure_data); ++typedef void (*Sr__VersionVerifyResp_Closure) ++ (const Sr__VersionVerifyResp *message, ++ void *closure_data); ++typedef void (*Sr__SchemaRevision_Closure) ++ (const Sr__SchemaRevision *message, ++ void *closure_data); ++typedef void (*Sr__SchemaSubmodule_Closure) ++ (const Sr__SchemaSubmodule *message, ++ void *closure_data); ++typedef void (*Sr__Schema_Closure) ++ (const Sr__Schema *message, ++ void *closure_data); ++typedef void (*Sr__ListSchemasReq_Closure) ++ (const Sr__ListSchemasReq *message, ++ void *closure_data); ++typedef void (*Sr__ListSchemasResp_Closure) ++ (const Sr__ListSchemasResp *message, ++ void *closure_data); ++typedef void (*Sr__GetSchemaReq_Closure) ++ (const Sr__GetSchemaReq *message, ++ void *closure_data); ++typedef void (*Sr__GetSchemaResp_Closure) ++ (const Sr__GetSchemaResp *message, ++ void *closure_data); ++typedef void (*Sr__GetItemReq_Closure) ++ (const Sr__GetItemReq *message, ++ void *closure_data); ++typedef void (*Sr__GetItemResp_Closure) ++ (const Sr__GetItemResp *message, ++ void *closure_data); ++typedef void (*Sr__GetItemsReq_Closure) ++ (const Sr__GetItemsReq *message, ++ void *closure_data); ++typedef void (*Sr__GetItemsResp_Closure) ++ (const Sr__GetItemsResp *message, ++ void *closure_data); ++typedef void (*Sr__GetSubtreeReq_Closure) ++ (const Sr__GetSubtreeReq *message, ++ void *closure_data); ++typedef void (*Sr__GetSubtreeResp_Closure) ++ (const Sr__GetSubtreeResp *message, ++ void *closure_data); ++typedef void (*Sr__GetSubtreesReq_Closure) ++ (const Sr__GetSubtreesReq *message, ++ void *closure_data); ++typedef void (*Sr__GetSubtreesResp_Closure) ++ (const Sr__GetSubtreesResp *message, ++ void *closure_data); ++typedef void (*Sr__GetSubtreeChunkReq_Closure) ++ (const Sr__GetSubtreeChunkReq *message, ++ void *closure_data); ++typedef void (*Sr__GetSubtreeChunkResp_Closure) ++ (const Sr__GetSubtreeChunkResp *message, ++ void *closure_data); ++typedef void (*Sr__SetItemReq_Closure) ++ (const Sr__SetItemReq *message, ++ void *closure_data); ++typedef void (*Sr__SetItemResp_Closure) ++ (const Sr__SetItemResp *message, ++ void *closure_data); ++typedef void (*Sr__SetItemStrReq_Closure) ++ (const Sr__SetItemStrReq *message, ++ void *closure_data); ++typedef void (*Sr__SetItemStrResp_Closure) ++ (const Sr__SetItemStrResp *message, ++ void *closure_data); ++typedef void (*Sr__DeleteItemReq_Closure) ++ (const Sr__DeleteItemReq *message, ++ void *closure_data); ++typedef void (*Sr__DeleteItemResp_Closure) ++ (const Sr__DeleteItemResp *message, ++ void *closure_data); ++typedef void (*Sr__MoveItemReq_Closure) ++ (const Sr__MoveItemReq *message, ++ void *closure_data); ++typedef void (*Sr__MoveItemResp_Closure) ++ (const Sr__MoveItemResp *message, ++ void *closure_data); ++typedef void (*Sr__ValidateReq_Closure) ++ (const Sr__ValidateReq *message, ++ void *closure_data); ++typedef void (*Sr__ValidateResp_Closure) ++ (const Sr__ValidateResp *message, ++ void *closure_data); ++typedef void (*Sr__CommitReq_Closure) ++ (const Sr__CommitReq *message, ++ void *closure_data); ++typedef void (*Sr__CommitResp_Closure) ++ (const Sr__CommitResp *message, ++ void *closure_data); ++typedef void (*Sr__DiscardChangesReq_Closure) ++ (const Sr__DiscardChangesReq *message, ++ void *closure_data); ++typedef void (*Sr__DiscardChangesResp_Closure) ++ (const Sr__DiscardChangesResp *message, ++ void *closure_data); ++typedef void (*Sr__CopyConfigReq_Closure) ++ (const Sr__CopyConfigReq *message, ++ void *closure_data); ++typedef void (*Sr__CopyConfigResp_Closure) ++ (const Sr__CopyConfigResp *message, ++ void *closure_data); ++typedef void (*Sr__LockReq_Closure) ++ (const Sr__LockReq *message, ++ void *closure_data); ++typedef void (*Sr__LockResp_Closure) ++ (const Sr__LockResp *message, ++ void *closure_data); ++typedef void (*Sr__UnlockReq_Closure) ++ (const Sr__UnlockReq *message, ++ void *closure_data); ++typedef void (*Sr__UnlockResp_Closure) ++ (const Sr__UnlockResp *message, ++ void *closure_data); ++typedef void (*Sr__SubscribeReq_Closure) ++ (const Sr__SubscribeReq *message, ++ void *closure_data); ++typedef void (*Sr__SubscribeResp_Closure) ++ (const Sr__SubscribeResp *message, ++ void *closure_data); ++typedef void (*Sr__UnsubscribeReq_Closure) ++ (const Sr__UnsubscribeReq *message, ++ void *closure_data); ++typedef void (*Sr__UnsubscribeResp_Closure) ++ (const Sr__UnsubscribeResp *message, ++ void *closure_data); ++typedef void (*Sr__CheckEnabledRunningReq_Closure) ++ (const Sr__CheckEnabledRunningReq *message, ++ void *closure_data); ++typedef void (*Sr__CheckEnabledRunningResp_Closure) ++ (const Sr__CheckEnabledRunningResp *message, ++ void *closure_data); ++typedef void (*Sr__ModuleInstallNotification_Closure) ++ (const Sr__ModuleInstallNotification *message, ++ void *closure_data); ++typedef void (*Sr__FeatureEnableNotification_Closure) ++ (const Sr__FeatureEnableNotification *message, ++ void *closure_data); ++typedef void (*Sr__ModuleChangeNotification_Closure) ++ (const Sr__ModuleChangeNotification *message, ++ void *closure_data); ++typedef void (*Sr__SubtreeChangeNotification_Closure) ++ (const Sr__SubtreeChangeNotification *message, ++ void *closure_data); ++typedef void (*Sr__Change_Closure) ++ (const Sr__Change *message, ++ void *closure_data); ++typedef void (*Sr__GetChangesReq_Closure) ++ (const Sr__GetChangesReq *message, ++ void *closure_data); ++typedef void (*Sr__GetChangesResp_Closure) ++ (const Sr__GetChangesResp *message, ++ void *closure_data); ++typedef void (*Sr__CheckExecPermReq_Closure) ++ (const Sr__CheckExecPermReq *message, ++ void *closure_data); ++typedef void (*Sr__CheckExecPermResp_Closure) ++ (const Sr__CheckExecPermResp *message, ++ void *closure_data); ++typedef void (*Sr__RPCReq_Closure) ++ (const Sr__RPCReq *message, ++ void *closure_data); ++typedef void (*Sr__RPCResp_Closure) ++ (const Sr__RPCResp *message, ++ void *closure_data); ++typedef void (*Sr__EventNotifReq_Closure) ++ (const Sr__EventNotifReq *message, ++ void *closure_data); ++typedef void (*Sr__EventNotifResp_Closure) ++ (const Sr__EventNotifResp *message, ++ void *closure_data); ++typedef void (*Sr__EventNotifReplayReq_Closure) ++ (const Sr__EventNotifReplayReq *message, ++ void *closure_data); ++typedef void (*Sr__EventNotifReplayResp_Closure) ++ (const Sr__EventNotifReplayResp *message, ++ void *closure_data); ++typedef void (*Sr__DataProvideReq_Closure) ++ (const Sr__DataProvideReq *message, ++ void *closure_data); ++typedef void (*Sr__DataProvideResp_Closure) ++ (const Sr__DataProvideResp *message, ++ void *closure_data); ++typedef void (*Sr__ModuleInstallReq_Closure) ++ (const Sr__ModuleInstallReq *message, ++ void *closure_data); ++typedef void (*Sr__ModuleInstallResp_Closure) ++ (const Sr__ModuleInstallResp *message, ++ void *closure_data); ++typedef void (*Sr__FeatureEnableReq_Closure) ++ (const Sr__FeatureEnableReq *message, ++ void *closure_data); ++typedef void (*Sr__FeatureEnableResp_Closure) ++ (const Sr__FeatureEnableResp *message, ++ void *closure_data); ++typedef void (*Sr__UnsubscribeDestinationReq_Closure) ++ (const Sr__UnsubscribeDestinationReq *message, ++ void *closure_data); ++typedef void (*Sr__CommitTimeoutReq_Closure) ++ (const Sr__CommitTimeoutReq *message, ++ void *closure_data); ++typedef void (*Sr__OperDataTimeoutReq_Closure) ++ (const Sr__OperDataTimeoutReq *message, ++ void *closure_data); ++typedef void (*Sr__InternalStateDataReq_Closure) ++ (const Sr__InternalStateDataReq *message, ++ void *closure_data); ++typedef void (*Sr__NotifStoreCleanupReq_Closure) ++ (const Sr__NotifStoreCleanupReq *message, ++ void *closure_data); ++typedef void (*Sr__DelayedMsgReq_Closure) ++ (const Sr__DelayedMsgReq *message, ++ void *closure_data); ++typedef void (*Sr__NacmReloadReq_Closure) ++ (const Sr__NacmReloadReq *message, ++ void *closure_data); ++typedef void (*Sr__Request_Closure) ++ (const Sr__Request *message, ++ void *closure_data); ++typedef void (*Sr__Response_Closure) ++ (const Sr__Response *message, ++ void *closure_data); ++typedef void (*Sr__Notification_Closure) ++ (const Sr__Notification *message, ++ void *closure_data); ++typedef void (*Sr__NotificationAck_Closure) ++ (const Sr__NotificationAck *message, ++ void *closure_data); ++typedef void (*Sr__InternalRequest_Closure) ++ (const Sr__InternalRequest *message, ++ void *closure_data); ++typedef void (*Sr__Msg_Closure) ++ (const Sr__Msg *message, ++ void *closure_data); ++ ++/* --- services --- */ ++ ++ ++/* --- descriptors --- */ ++ ++extern const ProtobufCEnumDescriptor sr__api_variant__descriptor; ++extern const ProtobufCEnumDescriptor sr__data_store__descriptor; ++extern const ProtobufCEnumDescriptor sr__session_flags__descriptor; ++extern const ProtobufCEnumDescriptor sr__edit_flags__descriptor; ++extern const ProtobufCEnumDescriptor sr__subscription_type__descriptor; ++extern const ProtobufCEnumDescriptor sr__notification_event__descriptor; ++extern const ProtobufCEnumDescriptor sr__module_state__descriptor; ++extern const ProtobufCEnumDescriptor sr__change_operation__descriptor; ++extern const ProtobufCEnumDescriptor sr__operation__descriptor; ++extern const ProtobufCMessageDescriptor sr__value__descriptor; ++extern const ProtobufCEnumDescriptor sr__value__types__descriptor; ++extern const ProtobufCMessageDescriptor sr__node__descriptor; ++extern const ProtobufCMessageDescriptor sr__error__descriptor; ++extern const ProtobufCMessageDescriptor sr__session_start_req__descriptor; ++extern const ProtobufCMessageDescriptor sr__session_start_resp__descriptor; ++extern const ProtobufCMessageDescriptor sr__session_stop_req__descriptor; ++extern const ProtobufCMessageDescriptor sr__session_stop_resp__descriptor; ++extern const ProtobufCMessageDescriptor sr__session_refresh_req__descriptor; ++extern const ProtobufCMessageDescriptor sr__session_refresh_resp__descriptor; ++extern const ProtobufCMessageDescriptor sr__session_check_req__descriptor; ++extern const ProtobufCMessageDescriptor sr__session_check_resp__descriptor; ++extern const ProtobufCMessageDescriptor sr__session_switch_ds_req__descriptor; ++extern const ProtobufCMessageDescriptor sr__session_switch_ds_resp__descriptor; ++extern const ProtobufCMessageDescriptor sr__session_set_opts_req__descriptor; ++extern const ProtobufCMessageDescriptor sr__session_set_opts_resp__descriptor; ++extern const ProtobufCMessageDescriptor sr__version_verify_req__descriptor; ++extern const ProtobufCMessageDescriptor sr__version_verify_resp__descriptor; ++extern const ProtobufCMessageDescriptor sr__schema_revision__descriptor; ++extern const ProtobufCMessageDescriptor sr__schema_submodule__descriptor; ++extern const ProtobufCMessageDescriptor sr__schema__descriptor; ++extern const ProtobufCMessageDescriptor sr__list_schemas_req__descriptor; ++extern const ProtobufCMessageDescriptor sr__list_schemas_resp__descriptor; ++extern const ProtobufCMessageDescriptor sr__get_schema_req__descriptor; ++extern const ProtobufCMessageDescriptor sr__get_schema_resp__descriptor; ++extern const ProtobufCMessageDescriptor sr__get_item_req__descriptor; ++extern const ProtobufCMessageDescriptor sr__get_item_resp__descriptor; ++extern const ProtobufCMessageDescriptor sr__get_items_req__descriptor; ++extern const ProtobufCMessageDescriptor sr__get_items_resp__descriptor; ++extern const ProtobufCMessageDescriptor sr__get_subtree_req__descriptor; ++extern const ProtobufCMessageDescriptor sr__get_subtree_resp__descriptor; ++extern const ProtobufCMessageDescriptor sr__get_subtrees_req__descriptor; ++extern const ProtobufCMessageDescriptor sr__get_subtrees_resp__descriptor; ++extern const ProtobufCMessageDescriptor sr__get_subtree_chunk_req__descriptor; ++extern const ProtobufCMessageDescriptor sr__get_subtree_chunk_resp__descriptor; ++extern const ProtobufCMessageDescriptor sr__set_item_req__descriptor; ++extern const ProtobufCMessageDescriptor sr__set_item_resp__descriptor; ++extern const ProtobufCMessageDescriptor sr__set_item_str_req__descriptor; ++extern const ProtobufCMessageDescriptor sr__set_item_str_resp__descriptor; ++extern const ProtobufCMessageDescriptor sr__delete_item_req__descriptor; ++extern const ProtobufCMessageDescriptor sr__delete_item_resp__descriptor; ++extern const ProtobufCMessageDescriptor sr__move_item_req__descriptor; ++extern const ProtobufCEnumDescriptor sr__move_item_req__move_position__descriptor; ++extern const ProtobufCMessageDescriptor sr__move_item_resp__descriptor; ++extern const ProtobufCMessageDescriptor sr__validate_req__descriptor; ++extern const ProtobufCMessageDescriptor sr__validate_resp__descriptor; ++extern const ProtobufCMessageDescriptor sr__commit_req__descriptor; ++extern const ProtobufCMessageDescriptor sr__commit_resp__descriptor; ++extern const ProtobufCMessageDescriptor sr__discard_changes_req__descriptor; ++extern const ProtobufCMessageDescriptor sr__discard_changes_resp__descriptor; ++extern const ProtobufCMessageDescriptor sr__copy_config_req__descriptor; ++extern const ProtobufCMessageDescriptor sr__copy_config_resp__descriptor; ++extern const ProtobufCMessageDescriptor sr__lock_req__descriptor; ++extern const ProtobufCMessageDescriptor sr__lock_resp__descriptor; ++extern const ProtobufCMessageDescriptor sr__unlock_req__descriptor; ++extern const ProtobufCMessageDescriptor sr__unlock_resp__descriptor; ++extern const ProtobufCMessageDescriptor sr__subscribe_req__descriptor; ++extern const ProtobufCMessageDescriptor sr__subscribe_resp__descriptor; ++extern const ProtobufCMessageDescriptor sr__unsubscribe_req__descriptor; ++extern const ProtobufCMessageDescriptor sr__unsubscribe_resp__descriptor; ++extern const ProtobufCMessageDescriptor sr__check_enabled_running_req__descriptor; ++extern const ProtobufCMessageDescriptor sr__check_enabled_running_resp__descriptor; ++extern const ProtobufCMessageDescriptor sr__module_install_notification__descriptor; ++extern const ProtobufCMessageDescriptor sr__feature_enable_notification__descriptor; ++extern const ProtobufCMessageDescriptor sr__module_change_notification__descriptor; ++extern const ProtobufCMessageDescriptor sr__subtree_change_notification__descriptor; ++extern const ProtobufCMessageDescriptor sr__change__descriptor; ++extern const ProtobufCMessageDescriptor sr__get_changes_req__descriptor; ++extern const ProtobufCMessageDescriptor sr__get_changes_resp__descriptor; ++extern const ProtobufCMessageDescriptor sr__check_exec_perm_req__descriptor; ++extern const ProtobufCMessageDescriptor sr__check_exec_perm_resp__descriptor; ++extern const ProtobufCMessageDescriptor sr__rpcreq__descriptor; ++extern const ProtobufCMessageDescriptor sr__rpcresp__descriptor; ++extern const ProtobufCMessageDescriptor sr__event_notif_req__descriptor; ++extern const ProtobufCEnumDescriptor sr__event_notif_req__notif_type__descriptor; ++extern const ProtobufCEnumDescriptor sr__event_notif_req__notif_flags__descriptor; ++extern const ProtobufCMessageDescriptor sr__event_notif_resp__descriptor; ++extern const ProtobufCMessageDescriptor sr__event_notif_replay_req__descriptor; ++extern const ProtobufCMessageDescriptor sr__event_notif_replay_resp__descriptor; ++extern const ProtobufCMessageDescriptor sr__data_provide_req__descriptor; ++extern const ProtobufCMessageDescriptor sr__data_provide_resp__descriptor; ++extern const ProtobufCMessageDescriptor sr__module_install_req__descriptor; ++extern const ProtobufCMessageDescriptor sr__module_install_resp__descriptor; ++extern const ProtobufCMessageDescriptor sr__feature_enable_req__descriptor; ++extern const ProtobufCMessageDescriptor sr__feature_enable_resp__descriptor; ++extern const ProtobufCMessageDescriptor sr__unsubscribe_destination_req__descriptor; ++extern const ProtobufCMessageDescriptor sr__commit_timeout_req__descriptor; ++extern const ProtobufCMessageDescriptor sr__oper_data_timeout_req__descriptor; ++extern const ProtobufCMessageDescriptor sr__internal_state_data_req__descriptor; ++extern const ProtobufCMessageDescriptor sr__notif_store_cleanup_req__descriptor; ++extern const ProtobufCMessageDescriptor sr__delayed_msg_req__descriptor; ++extern const ProtobufCMessageDescriptor sr__nacm_reload_req__descriptor; ++extern const ProtobufCMessageDescriptor sr__request__descriptor; ++extern const ProtobufCMessageDescriptor sr__response__descriptor; ++extern const ProtobufCMessageDescriptor sr__notification__descriptor; ++extern const ProtobufCMessageDescriptor sr__notification_ack__descriptor; ++extern const ProtobufCMessageDescriptor sr__internal_request__descriptor; ++extern const ProtobufCMessageDescriptor sr__msg__descriptor; ++extern const ProtobufCEnumDescriptor sr__msg__msg_type__descriptor; ++ ++PROTOBUF_C__END_DECLS ++ ++ ++#endif /* PROTOBUF_C_sysrepo_2eproto__INCLUDED */ diff --git a/net/sysrepo/patches/002-remove-buildtime-module-install b/net/sysrepo/patches/002-remove-buildtime-module-install new file mode 100644 index 000000000..15bc77c96 --- /dev/null +++ b/net/sysrepo/patches/002-remove-buildtime-module-install @@ -0,0 +1,26 @@ +Index: sysrepo-e4a5705a4c5293ba121048c71899b98243d99edf/CMakeLists.txt +=================================================================== +--- sysrepo-e4a5705a4c5293ba121048c71899b98243d99edf.orig/CMakeLists.txt ++++ sysrepo-e4a5705a4c5293ba121048c71899b98243d99edf/CMakeLists.txt +@@ -280,7 +280,7 @@ install (FILES ${INTERNAL_YANGS} DESTINA + + # install NACM YANG module + if(ENABLE_NACM) +- INSTALL_YANG("ietf-netconf-acm" "@2012-02-22" "644") ++ # INSTALL_YANG("ietf-netconf-acm" "@2012-02-22" "644") + endif(ENABLE_NACM) + + find_package(PkgConfig QUIET) +@@ -304,9 +304,9 @@ if(WITH_SYSTEMD) + FILES_MATCHING PATTERN "*.service") + endif() + +-INSTALL_YANG("ietf-netconf-notifications" "" "666") +-INSTALL_YANG("nc-notifications" "" "666") +-INSTALL_YANG("notifications" "" "666") ++# INSTALL_YANG("ietf-netconf-notifications" "" "666") ++# INSTALL_YANG("nc-notifications" "" "666") ++# INSTALL_YANG("notifications" "" "666") + + if(GEN_LANGUAGE_BINDINGS) + add_subdirectory(swig) diff --git a/net/sysrepo/patches/003-missing-time-header b/net/sysrepo/patches/003-missing-time-header new file mode 100644 index 000000000..6ce54dea6 --- /dev/null +++ b/net/sysrepo/patches/003-missing-time-header @@ -0,0 +1,12 @@ +Index: sysrepo-e4a5705a4c5293ba121048c71899b98243d99edf/inc/sysrepo.h +=================================================================== +--- sysrepo-e4a5705a4c5293ba121048c71899b98243d99edf.orig/inc/sysrepo.h ++++ sysrepo-e4a5705a4c5293ba121048c71899b98243d99edf/inc/sysrepo.h +@@ -51,6 +51,7 @@ + * @ref xp_page "XPath Addressing" is used for node identification in data-related calls. + */ + ++#include + #include + #include + #include