projects / feed / packages.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
add sysrepo
[feed/packages.git] / net / sysrepo / patches / 001-protobuf-remove-protoc-command-from-cmake-file
1 Index: sysrepo-e4a5705a4c5293ba121048c71899b98243d99edf/src/CMakeLists.txt
2 ===================================================================
3 --- sysrepo-e4a5705a4c5293ba121048c71899b98243d99edf.orig/src/CMakeLists.txt
4 +++ sysrepo-e4a5705a4c5293ba121048c71899b98243d99edf/src/CMakeLists.txt
5 @@ -21,14 +21,6 @@ set(GENERATED_PROTO_H "${COMMON_BIN_DIR}
6 set(GENERATED_PROTO_C "${COMMON_BIN_DIR}/${PROTO_NAME}.pb-c.c")
7
8 get_filename_component(ABS_PATH ${PROTO_FILE} PATH)
9 -add_custom_command(
10 - OUTPUT "${GENERATED_PROTO_C}"
11 - "${GENERATED_PROTO_H}"
12 - COMMAND ${PROTOBUFC_PROTOC_EXECUTABLE}
13 - ARGS --c_out ${COMMON_BIN_DIR} -I ${ABS_PATH} ${PROTO_FILE}
14 - DEPENDS ${PROTO_FILE}
15 - COMMENT "Running C protocol buffer compiler on ${PROTO_FILE}"
16 - VERBATIM )
17
18 configure_file("${COMMON_DIR}/sr_constants.h.in" "${COMMON_BIN_DIR}/sr_constants.h" ESCAPE_QUOTES @ONLY)
19
20 Index: sysrepo-e4a5705a4c5293ba121048c71899b98243d99edf/src/common/sysrepo.pb-c.c
21 ===================================================================
22 --- /dev/null
23 +++ sysrepo-e4a5705a4c5293ba121048c71899b98243d99edf/src/common/sysrepo.pb-c.c
24 @@ -0,0 +1,10517 @@
25 +/* Generated by the protocol buffer compiler. DO NOT EDIT! */
26 +/* Generated from: sysrepo.proto */
27 +
28 +/* Do not generate deprecated warnings for self */
29 +#ifndef PROTOBUF_C__NO_DEPRECATED
30 +#define PROTOBUF_C__NO_DEPRECATED
31 +#endif
32 +
33 +#include "sysrepo.pb-c.h"
34 +void sr__value__init
35 + (Sr__Value *message)
36 +{
37 + static Sr__Value init_value = SR__VALUE__INIT;
38 + *message = init_value;
39 +}
40 +size_t sr__value__get_packed_size
41 + (const Sr__Value *message)
42 +{
43 + assert(message->base.descriptor == &sr__value__descriptor);
44 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
45 +}
46 +size_t sr__value__pack
47 + (const Sr__Value *message,
48 + uint8_t *out)
49 +{
50 + assert(message->base.descriptor == &sr__value__descriptor);
51 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
52 +}
53 +size_t sr__value__pack_to_buffer
54 + (const Sr__Value *message,
55 + ProtobufCBuffer *buffer)
56 +{
57 + assert(message->base.descriptor == &sr__value__descriptor);
58 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
59 +}
60 +Sr__Value *
61 + sr__value__unpack
62 + (ProtobufCAllocator *allocator,
63 + size_t len,
64 + const uint8_t *data)
65 +{
66 + return (Sr__Value *)
67 + protobuf_c_message_unpack (&sr__value__descriptor,
68 + allocator, len, data);
69 +}
70 +void sr__value__free_unpacked
71 + (Sr__Value *message,
72 + ProtobufCAllocator *allocator)
73 +{
74 + assert(message->base.descriptor == &sr__value__descriptor);
75 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
76 +}
77 +void sr__node__init
78 + (Sr__Node *message)
79 +{
80 + static Sr__Node init_value = SR__NODE__INIT;
81 + *message = init_value;
82 +}
83 +size_t sr__node__get_packed_size
84 + (const Sr__Node *message)
85 +{
86 + assert(message->base.descriptor == &sr__node__descriptor);
87 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
88 +}
89 +size_t sr__node__pack
90 + (const Sr__Node *message,
91 + uint8_t *out)
92 +{
93 + assert(message->base.descriptor == &sr__node__descriptor);
94 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
95 +}
96 +size_t sr__node__pack_to_buffer
97 + (const Sr__Node *message,
98 + ProtobufCBuffer *buffer)
99 +{
100 + assert(message->base.descriptor == &sr__node__descriptor);
101 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
102 +}
103 +Sr__Node *
104 + sr__node__unpack
105 + (ProtobufCAllocator *allocator,
106 + size_t len,
107 + const uint8_t *data)
108 +{
109 + return (Sr__Node *)
110 + protobuf_c_message_unpack (&sr__node__descriptor,
111 + allocator, len, data);
112 +}
113 +void sr__node__free_unpacked
114 + (Sr__Node *message,
115 + ProtobufCAllocator *allocator)
116 +{
117 + assert(message->base.descriptor == &sr__node__descriptor);
118 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
119 +}
120 +void sr__error__init
121 + (Sr__Error *message)
122 +{
123 + static Sr__Error init_value = SR__ERROR__INIT;
124 + *message = init_value;
125 +}
126 +size_t sr__error__get_packed_size
127 + (const Sr__Error *message)
128 +{
129 + assert(message->base.descriptor == &sr__error__descriptor);
130 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
131 +}
132 +size_t sr__error__pack
133 + (const Sr__Error *message,
134 + uint8_t *out)
135 +{
136 + assert(message->base.descriptor == &sr__error__descriptor);
137 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
138 +}
139 +size_t sr__error__pack_to_buffer
140 + (const Sr__Error *message,
141 + ProtobufCBuffer *buffer)
142 +{
143 + assert(message->base.descriptor == &sr__error__descriptor);
144 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
145 +}
146 +Sr__Error *
147 + sr__error__unpack
148 + (ProtobufCAllocator *allocator,
149 + size_t len,
150 + const uint8_t *data)
151 +{
152 + return (Sr__Error *)
153 + protobuf_c_message_unpack (&sr__error__descriptor,
154 + allocator, len, data);
155 +}
156 +void sr__error__free_unpacked
157 + (Sr__Error *message,
158 + ProtobufCAllocator *allocator)
159 +{
160 + assert(message->base.descriptor == &sr__error__descriptor);
161 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
162 +}
163 +void sr__session_start_req__init
164 + (Sr__SessionStartReq *message)
165 +{
166 + static Sr__SessionStartReq init_value = SR__SESSION_START_REQ__INIT;
167 + *message = init_value;
168 +}
169 +size_t sr__session_start_req__get_packed_size
170 + (const Sr__SessionStartReq *message)
171 +{
172 + assert(message->base.descriptor == &sr__session_start_req__descriptor);
173 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
174 +}
175 +size_t sr__session_start_req__pack
176 + (const Sr__SessionStartReq *message,
177 + uint8_t *out)
178 +{
179 + assert(message->base.descriptor == &sr__session_start_req__descriptor);
180 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
181 +}
182 +size_t sr__session_start_req__pack_to_buffer
183 + (const Sr__SessionStartReq *message,
184 + ProtobufCBuffer *buffer)
185 +{
186 + assert(message->base.descriptor == &sr__session_start_req__descriptor);
187 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
188 +}
189 +Sr__SessionStartReq *
190 + sr__session_start_req__unpack
191 + (ProtobufCAllocator *allocator,
192 + size_t len,
193 + const uint8_t *data)
194 +{
195 + return (Sr__SessionStartReq *)
196 + protobuf_c_message_unpack (&sr__session_start_req__descriptor,
197 + allocator, len, data);
198 +}
199 +void sr__session_start_req__free_unpacked
200 + (Sr__SessionStartReq *message,
201 + ProtobufCAllocator *allocator)
202 +{
203 + assert(message->base.descriptor == &sr__session_start_req__descriptor);
204 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
205 +}
206 +void sr__session_start_resp__init
207 + (Sr__SessionStartResp *message)
208 +{
209 + static Sr__SessionStartResp init_value = SR__SESSION_START_RESP__INIT;
210 + *message = init_value;
211 +}
212 +size_t sr__session_start_resp__get_packed_size
213 + (const Sr__SessionStartResp *message)
214 +{
215 + assert(message->base.descriptor == &sr__session_start_resp__descriptor);
216 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
217 +}
218 +size_t sr__session_start_resp__pack
219 + (const Sr__SessionStartResp *message,
220 + uint8_t *out)
221 +{
222 + assert(message->base.descriptor == &sr__session_start_resp__descriptor);
223 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
224 +}
225 +size_t sr__session_start_resp__pack_to_buffer
226 + (const Sr__SessionStartResp *message,
227 + ProtobufCBuffer *buffer)
228 +{
229 + assert(message->base.descriptor == &sr__session_start_resp__descriptor);
230 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
231 +}
232 +Sr__SessionStartResp *
233 + sr__session_start_resp__unpack
234 + (ProtobufCAllocator *allocator,
235 + size_t len,
236 + const uint8_t *data)
237 +{
238 + return (Sr__SessionStartResp *)
239 + protobuf_c_message_unpack (&sr__session_start_resp__descriptor,
240 + allocator, len, data);
241 +}
242 +void sr__session_start_resp__free_unpacked
243 + (Sr__SessionStartResp *message,
244 + ProtobufCAllocator *allocator)
245 +{
246 + assert(message->base.descriptor == &sr__session_start_resp__descriptor);
247 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
248 +}
249 +void sr__session_stop_req__init
250 + (Sr__SessionStopReq *message)
251 +{
252 + static Sr__SessionStopReq init_value = SR__SESSION_STOP_REQ__INIT;
253 + *message = init_value;
254 +}
255 +size_t sr__session_stop_req__get_packed_size
256 + (const Sr__SessionStopReq *message)
257 +{
258 + assert(message->base.descriptor == &sr__session_stop_req__descriptor);
259 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
260 +}
261 +size_t sr__session_stop_req__pack
262 + (const Sr__SessionStopReq *message,
263 + uint8_t *out)
264 +{
265 + assert(message->base.descriptor == &sr__session_stop_req__descriptor);
266 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
267 +}
268 +size_t sr__session_stop_req__pack_to_buffer
269 + (const Sr__SessionStopReq *message,
270 + ProtobufCBuffer *buffer)
271 +{
272 + assert(message->base.descriptor == &sr__session_stop_req__descriptor);
273 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
274 +}
275 +Sr__SessionStopReq *
276 + sr__session_stop_req__unpack
277 + (ProtobufCAllocator *allocator,
278 + size_t len,
279 + const uint8_t *data)
280 +{
281 + return (Sr__SessionStopReq *)
282 + protobuf_c_message_unpack (&sr__session_stop_req__descriptor,
283 + allocator, len, data);
284 +}
285 +void sr__session_stop_req__free_unpacked
286 + (Sr__SessionStopReq *message,
287 + ProtobufCAllocator *allocator)
288 +{
289 + assert(message->base.descriptor == &sr__session_stop_req__descriptor);
290 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
291 +}
292 +void sr__session_stop_resp__init
293 + (Sr__SessionStopResp *message)
294 +{
295 + static Sr__SessionStopResp init_value = SR__SESSION_STOP_RESP__INIT;
296 + *message = init_value;
297 +}
298 +size_t sr__session_stop_resp__get_packed_size
299 + (const Sr__SessionStopResp *message)
300 +{
301 + assert(message->base.descriptor == &sr__session_stop_resp__descriptor);
302 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
303 +}
304 +size_t sr__session_stop_resp__pack
305 + (const Sr__SessionStopResp *message,
306 + uint8_t *out)
307 +{
308 + assert(message->base.descriptor == &sr__session_stop_resp__descriptor);
309 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
310 +}
311 +size_t sr__session_stop_resp__pack_to_buffer
312 + (const Sr__SessionStopResp *message,
313 + ProtobufCBuffer *buffer)
314 +{
315 + assert(message->base.descriptor == &sr__session_stop_resp__descriptor);
316 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
317 +}
318 +Sr__SessionStopResp *
319 + sr__session_stop_resp__unpack
320 + (ProtobufCAllocator *allocator,
321 + size_t len,
322 + const uint8_t *data)
323 +{
324 + return (Sr__SessionStopResp *)
325 + protobuf_c_message_unpack (&sr__session_stop_resp__descriptor,
326 + allocator, len, data);
327 +}
328 +void sr__session_stop_resp__free_unpacked
329 + (Sr__SessionStopResp *message,
330 + ProtobufCAllocator *allocator)
331 +{
332 + assert(message->base.descriptor == &sr__session_stop_resp__descriptor);
333 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
334 +}
335 +void sr__session_refresh_req__init
336 + (Sr__SessionRefreshReq *message)
337 +{
338 + static Sr__SessionRefreshReq init_value = SR__SESSION_REFRESH_REQ__INIT;
339 + *message = init_value;
340 +}
341 +size_t sr__session_refresh_req__get_packed_size
342 + (const Sr__SessionRefreshReq *message)
343 +{
344 + assert(message->base.descriptor == &sr__session_refresh_req__descriptor);
345 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
346 +}
347 +size_t sr__session_refresh_req__pack
348 + (const Sr__SessionRefreshReq *message,
349 + uint8_t *out)
350 +{
351 + assert(message->base.descriptor == &sr__session_refresh_req__descriptor);
352 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
353 +}
354 +size_t sr__session_refresh_req__pack_to_buffer
355 + (const Sr__SessionRefreshReq *message,
356 + ProtobufCBuffer *buffer)
357 +{
358 + assert(message->base.descriptor == &sr__session_refresh_req__descriptor);
359 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
360 +}
361 +Sr__SessionRefreshReq *
362 + sr__session_refresh_req__unpack
363 + (ProtobufCAllocator *allocator,
364 + size_t len,
365 + const uint8_t *data)
366 +{
367 + return (Sr__SessionRefreshReq *)
368 + protobuf_c_message_unpack (&sr__session_refresh_req__descriptor,
369 + allocator, len, data);
370 +}
371 +void sr__session_refresh_req__free_unpacked
372 + (Sr__SessionRefreshReq *message,
373 + ProtobufCAllocator *allocator)
374 +{
375 + assert(message->base.descriptor == &sr__session_refresh_req__descriptor);
376 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
377 +}
378 +void sr__session_refresh_resp__init
379 + (Sr__SessionRefreshResp *message)
380 +{
381 + static Sr__SessionRefreshResp init_value = SR__SESSION_REFRESH_RESP__INIT;
382 + *message = init_value;
383 +}
384 +size_t sr__session_refresh_resp__get_packed_size
385 + (const Sr__SessionRefreshResp *message)
386 +{
387 + assert(message->base.descriptor == &sr__session_refresh_resp__descriptor);
388 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
389 +}
390 +size_t sr__session_refresh_resp__pack
391 + (const Sr__SessionRefreshResp *message,
392 + uint8_t *out)
393 +{
394 + assert(message->base.descriptor == &sr__session_refresh_resp__descriptor);
395 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
396 +}
397 +size_t sr__session_refresh_resp__pack_to_buffer
398 + (const Sr__SessionRefreshResp *message,
399 + ProtobufCBuffer *buffer)
400 +{
401 + assert(message->base.descriptor == &sr__session_refresh_resp__descriptor);
402 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
403 +}
404 +Sr__SessionRefreshResp *
405 + sr__session_refresh_resp__unpack
406 + (ProtobufCAllocator *allocator,
407 + size_t len,
408 + const uint8_t *data)
409 +{
410 + return (Sr__SessionRefreshResp *)
411 + protobuf_c_message_unpack (&sr__session_refresh_resp__descriptor,
412 + allocator, len, data);
413 +}
414 +void sr__session_refresh_resp__free_unpacked
415 + (Sr__SessionRefreshResp *message,
416 + ProtobufCAllocator *allocator)
417 +{
418 + assert(message->base.descriptor == &sr__session_refresh_resp__descriptor);
419 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
420 +}
421 +void sr__session_check_req__init
422 + (Sr__SessionCheckReq *message)
423 +{
424 + static Sr__SessionCheckReq init_value = SR__SESSION_CHECK_REQ__INIT;
425 + *message = init_value;
426 +}
427 +size_t sr__session_check_req__get_packed_size
428 + (const Sr__SessionCheckReq *message)
429 +{
430 + assert(message->base.descriptor == &sr__session_check_req__descriptor);
431 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
432 +}
433 +size_t sr__session_check_req__pack
434 + (const Sr__SessionCheckReq *message,
435 + uint8_t *out)
436 +{
437 + assert(message->base.descriptor == &sr__session_check_req__descriptor);
438 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
439 +}
440 +size_t sr__session_check_req__pack_to_buffer
441 + (const Sr__SessionCheckReq *message,
442 + ProtobufCBuffer *buffer)
443 +{
444 + assert(message->base.descriptor == &sr__session_check_req__descriptor);
445 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
446 +}
447 +Sr__SessionCheckReq *
448 + sr__session_check_req__unpack
449 + (ProtobufCAllocator *allocator,
450 + size_t len,
451 + const uint8_t *data)
452 +{
453 + return (Sr__SessionCheckReq *)
454 + protobuf_c_message_unpack (&sr__session_check_req__descriptor,
455 + allocator, len, data);
456 +}
457 +void sr__session_check_req__free_unpacked
458 + (Sr__SessionCheckReq *message,
459 + ProtobufCAllocator *allocator)
460 +{
461 + assert(message->base.descriptor == &sr__session_check_req__descriptor);
462 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
463 +}
464 +void sr__session_check_resp__init
465 + (Sr__SessionCheckResp *message)
466 +{
467 + static Sr__SessionCheckResp init_value = SR__SESSION_CHECK_RESP__INIT;
468 + *message = init_value;
469 +}
470 +size_t sr__session_check_resp__get_packed_size
471 + (const Sr__SessionCheckResp *message)
472 +{
473 + assert(message->base.descriptor == &sr__session_check_resp__descriptor);
474 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
475 +}
476 +size_t sr__session_check_resp__pack
477 + (const Sr__SessionCheckResp *message,
478 + uint8_t *out)
479 +{
480 + assert(message->base.descriptor == &sr__session_check_resp__descriptor);
481 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
482 +}
483 +size_t sr__session_check_resp__pack_to_buffer
484 + (const Sr__SessionCheckResp *message,
485 + ProtobufCBuffer *buffer)
486 +{
487 + assert(message->base.descriptor == &sr__session_check_resp__descriptor);
488 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
489 +}
490 +Sr__SessionCheckResp *
491 + sr__session_check_resp__unpack
492 + (ProtobufCAllocator *allocator,
493 + size_t len,
494 + const uint8_t *data)
495 +{
496 + return (Sr__SessionCheckResp *)
497 + protobuf_c_message_unpack (&sr__session_check_resp__descriptor,
498 + allocator, len, data);
499 +}
500 +void sr__session_check_resp__free_unpacked
501 + (Sr__SessionCheckResp *message,
502 + ProtobufCAllocator *allocator)
503 +{
504 + assert(message->base.descriptor == &sr__session_check_resp__descriptor);
505 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
506 +}
507 +void sr__session_switch_ds_req__init
508 + (Sr__SessionSwitchDsReq *message)
509 +{
510 + static Sr__SessionSwitchDsReq init_value = SR__SESSION_SWITCH_DS_REQ__INIT;
511 + *message = init_value;
512 +}
513 +size_t sr__session_switch_ds_req__get_packed_size
514 + (const Sr__SessionSwitchDsReq *message)
515 +{
516 + assert(message->base.descriptor == &sr__session_switch_ds_req__descriptor);
517 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
518 +}
519 +size_t sr__session_switch_ds_req__pack
520 + (const Sr__SessionSwitchDsReq *message,
521 + uint8_t *out)
522 +{
523 + assert(message->base.descriptor == &sr__session_switch_ds_req__descriptor);
524 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
525 +}
526 +size_t sr__session_switch_ds_req__pack_to_buffer
527 + (const Sr__SessionSwitchDsReq *message,
528 + ProtobufCBuffer *buffer)
529 +{
530 + assert(message->base.descriptor == &sr__session_switch_ds_req__descriptor);
531 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
532 +}
533 +Sr__SessionSwitchDsReq *
534 + sr__session_switch_ds_req__unpack
535 + (ProtobufCAllocator *allocator,
536 + size_t len,
537 + const uint8_t *data)
538 +{
539 + return (Sr__SessionSwitchDsReq *)
540 + protobuf_c_message_unpack (&sr__session_switch_ds_req__descriptor,
541 + allocator, len, data);
542 +}
543 +void sr__session_switch_ds_req__free_unpacked
544 + (Sr__SessionSwitchDsReq *message,
545 + ProtobufCAllocator *allocator)
546 +{
547 + assert(message->base.descriptor == &sr__session_switch_ds_req__descriptor);
548 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
549 +}
550 +void sr__session_switch_ds_resp__init
551 + (Sr__SessionSwitchDsResp *message)
552 +{
553 + static Sr__SessionSwitchDsResp init_value = SR__SESSION_SWITCH_DS_RESP__INIT;
554 + *message = init_value;
555 +}
556 +size_t sr__session_switch_ds_resp__get_packed_size
557 + (const Sr__SessionSwitchDsResp *message)
558 +{
559 + assert(message->base.descriptor == &sr__session_switch_ds_resp__descriptor);
560 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
561 +}
562 +size_t sr__session_switch_ds_resp__pack
563 + (const Sr__SessionSwitchDsResp *message,
564 + uint8_t *out)
565 +{
566 + assert(message->base.descriptor == &sr__session_switch_ds_resp__descriptor);
567 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
568 +}
569 +size_t sr__session_switch_ds_resp__pack_to_buffer
570 + (const Sr__SessionSwitchDsResp *message,
571 + ProtobufCBuffer *buffer)
572 +{
573 + assert(message->base.descriptor == &sr__session_switch_ds_resp__descriptor);
574 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
575 +}
576 +Sr__SessionSwitchDsResp *
577 + sr__session_switch_ds_resp__unpack
578 + (ProtobufCAllocator *allocator,
579 + size_t len,
580 + const uint8_t *data)
581 +{
582 + return (Sr__SessionSwitchDsResp *)
583 + protobuf_c_message_unpack (&sr__session_switch_ds_resp__descriptor,
584 + allocator, len, data);
585 +}
586 +void sr__session_switch_ds_resp__free_unpacked
587 + (Sr__SessionSwitchDsResp *message,
588 + ProtobufCAllocator *allocator)
589 +{
590 + assert(message->base.descriptor == &sr__session_switch_ds_resp__descriptor);
591 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
592 +}
593 +void sr__session_set_opts_req__init
594 + (Sr__SessionSetOptsReq *message)
595 +{
596 + static Sr__SessionSetOptsReq init_value = SR__SESSION_SET_OPTS_REQ__INIT;
597 + *message = init_value;
598 +}
599 +size_t sr__session_set_opts_req__get_packed_size
600 + (const Sr__SessionSetOptsReq *message)
601 +{
602 + assert(message->base.descriptor == &sr__session_set_opts_req__descriptor);
603 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
604 +}
605 +size_t sr__session_set_opts_req__pack
606 + (const Sr__SessionSetOptsReq *message,
607 + uint8_t *out)
608 +{
609 + assert(message->base.descriptor == &sr__session_set_opts_req__descriptor);
610 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
611 +}
612 +size_t sr__session_set_opts_req__pack_to_buffer
613 + (const Sr__SessionSetOptsReq *message,
614 + ProtobufCBuffer *buffer)
615 +{
616 + assert(message->base.descriptor == &sr__session_set_opts_req__descriptor);
617 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
618 +}
619 +Sr__SessionSetOptsReq *
620 + sr__session_set_opts_req__unpack
621 + (ProtobufCAllocator *allocator,
622 + size_t len,
623 + const uint8_t *data)
624 +{
625 + return (Sr__SessionSetOptsReq *)
626 + protobuf_c_message_unpack (&sr__session_set_opts_req__descriptor,
627 + allocator, len, data);
628 +}
629 +void sr__session_set_opts_req__free_unpacked
630 + (Sr__SessionSetOptsReq *message,
631 + ProtobufCAllocator *allocator)
632 +{
633 + assert(message->base.descriptor == &sr__session_set_opts_req__descriptor);
634 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
635 +}
636 +void sr__session_set_opts_resp__init
637 + (Sr__SessionSetOptsResp *message)
638 +{
639 + static Sr__SessionSetOptsResp init_value = SR__SESSION_SET_OPTS_RESP__INIT;
640 + *message = init_value;
641 +}
642 +size_t sr__session_set_opts_resp__get_packed_size
643 + (const Sr__SessionSetOptsResp *message)
644 +{
645 + assert(message->base.descriptor == &sr__session_set_opts_resp__descriptor);
646 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
647 +}
648 +size_t sr__session_set_opts_resp__pack
649 + (const Sr__SessionSetOptsResp *message,
650 + uint8_t *out)
651 +{
652 + assert(message->base.descriptor == &sr__session_set_opts_resp__descriptor);
653 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
654 +}
655 +size_t sr__session_set_opts_resp__pack_to_buffer
656 + (const Sr__SessionSetOptsResp *message,
657 + ProtobufCBuffer *buffer)
658 +{
659 + assert(message->base.descriptor == &sr__session_set_opts_resp__descriptor);
660 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
661 +}
662 +Sr__SessionSetOptsResp *
663 + sr__session_set_opts_resp__unpack
664 + (ProtobufCAllocator *allocator,
665 + size_t len,
666 + const uint8_t *data)
667 +{
668 + return (Sr__SessionSetOptsResp *)
669 + protobuf_c_message_unpack (&sr__session_set_opts_resp__descriptor,
670 + allocator, len, data);
671 +}
672 +void sr__session_set_opts_resp__free_unpacked
673 + (Sr__SessionSetOptsResp *message,
674 + ProtobufCAllocator *allocator)
675 +{
676 + assert(message->base.descriptor == &sr__session_set_opts_resp__descriptor);
677 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
678 +}
679 +void sr__version_verify_req__init
680 + (Sr__VersionVerifyReq *message)
681 +{
682 + static Sr__VersionVerifyReq init_value = SR__VERSION_VERIFY_REQ__INIT;
683 + *message = init_value;
684 +}
685 +size_t sr__version_verify_req__get_packed_size
686 + (const Sr__VersionVerifyReq *message)
687 +{
688 + assert(message->base.descriptor == &sr__version_verify_req__descriptor);
689 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
690 +}
691 +size_t sr__version_verify_req__pack
692 + (const Sr__VersionVerifyReq *message,
693 + uint8_t *out)
694 +{
695 + assert(message->base.descriptor == &sr__version_verify_req__descriptor);
696 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
697 +}
698 +size_t sr__version_verify_req__pack_to_buffer
699 + (const Sr__VersionVerifyReq *message,
700 + ProtobufCBuffer *buffer)
701 +{
702 + assert(message->base.descriptor == &sr__version_verify_req__descriptor);
703 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
704 +}
705 +Sr__VersionVerifyReq *
706 + sr__version_verify_req__unpack
707 + (ProtobufCAllocator *allocator,
708 + size_t len,
709 + const uint8_t *data)
710 +{
711 + return (Sr__VersionVerifyReq *)
712 + protobuf_c_message_unpack (&sr__version_verify_req__descriptor,
713 + allocator, len, data);
714 +}
715 +void sr__version_verify_req__free_unpacked
716 + (Sr__VersionVerifyReq *message,
717 + ProtobufCAllocator *allocator)
718 +{
719 + assert(message->base.descriptor == &sr__version_verify_req__descriptor);
720 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
721 +}
722 +void sr__version_verify_resp__init
723 + (Sr__VersionVerifyResp *message)
724 +{
725 + static Sr__VersionVerifyResp init_value = SR__VERSION_VERIFY_RESP__INIT;
726 + *message = init_value;
727 +}
728 +size_t sr__version_verify_resp__get_packed_size
729 + (const Sr__VersionVerifyResp *message)
730 +{
731 + assert(message->base.descriptor == &sr__version_verify_resp__descriptor);
732 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
733 +}
734 +size_t sr__version_verify_resp__pack
735 + (const Sr__VersionVerifyResp *message,
736 + uint8_t *out)
737 +{
738 + assert(message->base.descriptor == &sr__version_verify_resp__descriptor);
739 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
740 +}
741 +size_t sr__version_verify_resp__pack_to_buffer
742 + (const Sr__VersionVerifyResp *message,
743 + ProtobufCBuffer *buffer)
744 +{
745 + assert(message->base.descriptor == &sr__version_verify_resp__descriptor);
746 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
747 +}
748 +Sr__VersionVerifyResp *
749 + sr__version_verify_resp__unpack
750 + (ProtobufCAllocator *allocator,
751 + size_t len,
752 + const uint8_t *data)
753 +{
754 + return (Sr__VersionVerifyResp *)
755 + protobuf_c_message_unpack (&sr__version_verify_resp__descriptor,
756 + allocator, len, data);
757 +}
758 +void sr__version_verify_resp__free_unpacked
759 + (Sr__VersionVerifyResp *message,
760 + ProtobufCAllocator *allocator)
761 +{
762 + assert(message->base.descriptor == &sr__version_verify_resp__descriptor);
763 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
764 +}
765 +void sr__schema_revision__init
766 + (Sr__SchemaRevision *message)
767 +{
768 + static Sr__SchemaRevision init_value = SR__SCHEMA_REVISION__INIT;
769 + *message = init_value;
770 +}
771 +size_t sr__schema_revision__get_packed_size
772 + (const Sr__SchemaRevision *message)
773 +{
774 + assert(message->base.descriptor == &sr__schema_revision__descriptor);
775 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
776 +}
777 +size_t sr__schema_revision__pack
778 + (const Sr__SchemaRevision *message,
779 + uint8_t *out)
780 +{
781 + assert(message->base.descriptor == &sr__schema_revision__descriptor);
782 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
783 +}
784 +size_t sr__schema_revision__pack_to_buffer
785 + (const Sr__SchemaRevision *message,
786 + ProtobufCBuffer *buffer)
787 +{
788 + assert(message->base.descriptor == &sr__schema_revision__descriptor);
789 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
790 +}
791 +Sr__SchemaRevision *
792 + sr__schema_revision__unpack
793 + (ProtobufCAllocator *allocator,
794 + size_t len,
795 + const uint8_t *data)
796 +{
797 + return (Sr__SchemaRevision *)
798 + protobuf_c_message_unpack (&sr__schema_revision__descriptor,
799 + allocator, len, data);
800 +}
801 +void sr__schema_revision__free_unpacked
802 + (Sr__SchemaRevision *message,
803 + ProtobufCAllocator *allocator)
804 +{
805 + assert(message->base.descriptor == &sr__schema_revision__descriptor);
806 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
807 +}
808 +void sr__schema_submodule__init
809 + (Sr__SchemaSubmodule *message)
810 +{
811 + static Sr__SchemaSubmodule init_value = SR__SCHEMA_SUBMODULE__INIT;
812 + *message = init_value;
813 +}
814 +size_t sr__schema_submodule__get_packed_size
815 + (const Sr__SchemaSubmodule *message)
816 +{
817 + assert(message->base.descriptor == &sr__schema_submodule__descriptor);
818 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
819 +}
820 +size_t sr__schema_submodule__pack
821 + (const Sr__SchemaSubmodule *message,
822 + uint8_t *out)
823 +{
824 + assert(message->base.descriptor == &sr__schema_submodule__descriptor);
825 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
826 +}
827 +size_t sr__schema_submodule__pack_to_buffer
828 + (const Sr__SchemaSubmodule *message,
829 + ProtobufCBuffer *buffer)
830 +{
831 + assert(message->base.descriptor == &sr__schema_submodule__descriptor);
832 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
833 +}
834 +Sr__SchemaSubmodule *
835 + sr__schema_submodule__unpack
836 + (ProtobufCAllocator *allocator,
837 + size_t len,
838 + const uint8_t *data)
839 +{
840 + return (Sr__SchemaSubmodule *)
841 + protobuf_c_message_unpack (&sr__schema_submodule__descriptor,
842 + allocator, len, data);
843 +}
844 +void sr__schema_submodule__free_unpacked
845 + (Sr__SchemaSubmodule *message,
846 + ProtobufCAllocator *allocator)
847 +{
848 + assert(message->base.descriptor == &sr__schema_submodule__descriptor);
849 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
850 +}
851 +void sr__schema__init
852 + (Sr__Schema *message)
853 +{
854 + static Sr__Schema init_value = SR__SCHEMA__INIT;
855 + *message = init_value;
856 +}
857 +size_t sr__schema__get_packed_size
858 + (const Sr__Schema *message)
859 +{
860 + assert(message->base.descriptor == &sr__schema__descriptor);
861 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
862 +}
863 +size_t sr__schema__pack
864 + (const Sr__Schema *message,
865 + uint8_t *out)
866 +{
867 + assert(message->base.descriptor == &sr__schema__descriptor);
868 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
869 +}
870 +size_t sr__schema__pack_to_buffer
871 + (const Sr__Schema *message,
872 + ProtobufCBuffer *buffer)
873 +{
874 + assert(message->base.descriptor == &sr__schema__descriptor);
875 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
876 +}
877 +Sr__Schema *
878 + sr__schema__unpack
879 + (ProtobufCAllocator *allocator,
880 + size_t len,
881 + const uint8_t *data)
882 +{
883 + return (Sr__Schema *)
884 + protobuf_c_message_unpack (&sr__schema__descriptor,
885 + allocator, len, data);
886 +}
887 +void sr__schema__free_unpacked
888 + (Sr__Schema *message,
889 + ProtobufCAllocator *allocator)
890 +{
891 + assert(message->base.descriptor == &sr__schema__descriptor);
892 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
893 +}
894 +void sr__list_schemas_req__init
895 + (Sr__ListSchemasReq *message)
896 +{
897 + static Sr__ListSchemasReq init_value = SR__LIST_SCHEMAS_REQ__INIT;
898 + *message = init_value;
899 +}
900 +size_t sr__list_schemas_req__get_packed_size
901 + (const Sr__ListSchemasReq *message)
902 +{
903 + assert(message->base.descriptor == &sr__list_schemas_req__descriptor);
904 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
905 +}
906 +size_t sr__list_schemas_req__pack
907 + (const Sr__ListSchemasReq *message,
908 + uint8_t *out)
909 +{
910 + assert(message->base.descriptor == &sr__list_schemas_req__descriptor);
911 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
912 +}
913 +size_t sr__list_schemas_req__pack_to_buffer
914 + (const Sr__ListSchemasReq *message,
915 + ProtobufCBuffer *buffer)
916 +{
917 + assert(message->base.descriptor == &sr__list_schemas_req__descriptor);
918 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
919 +}
920 +Sr__ListSchemasReq *
921 + sr__list_schemas_req__unpack
922 + (ProtobufCAllocator *allocator,
923 + size_t len,
924 + const uint8_t *data)
925 +{
926 + return (Sr__ListSchemasReq *)
927 + protobuf_c_message_unpack (&sr__list_schemas_req__descriptor,
928 + allocator, len, data);
929 +}
930 +void sr__list_schemas_req__free_unpacked
931 + (Sr__ListSchemasReq *message,
932 + ProtobufCAllocator *allocator)
933 +{
934 + assert(message->base.descriptor == &sr__list_schemas_req__descriptor);
935 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
936 +}
937 +void sr__list_schemas_resp__init
938 + (Sr__ListSchemasResp *message)
939 +{
940 + static Sr__ListSchemasResp init_value = SR__LIST_SCHEMAS_RESP__INIT;
941 + *message = init_value;
942 +}
943 +size_t sr__list_schemas_resp__get_packed_size
944 + (const Sr__ListSchemasResp *message)
945 +{
946 + assert(message->base.descriptor == &sr__list_schemas_resp__descriptor);
947 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
948 +}
949 +size_t sr__list_schemas_resp__pack
950 + (const Sr__ListSchemasResp *message,
951 + uint8_t *out)
952 +{
953 + assert(message->base.descriptor == &sr__list_schemas_resp__descriptor);
954 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
955 +}
956 +size_t sr__list_schemas_resp__pack_to_buffer
957 + (const Sr__ListSchemasResp *message,
958 + ProtobufCBuffer *buffer)
959 +{
960 + assert(message->base.descriptor == &sr__list_schemas_resp__descriptor);
961 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
962 +}
963 +Sr__ListSchemasResp *
964 + sr__list_schemas_resp__unpack
965 + (ProtobufCAllocator *allocator,
966 + size_t len,
967 + const uint8_t *data)
968 +{
969 + return (Sr__ListSchemasResp *)
970 + protobuf_c_message_unpack (&sr__list_schemas_resp__descriptor,
971 + allocator, len, data);
972 +}
973 +void sr__list_schemas_resp__free_unpacked
974 + (Sr__ListSchemasResp *message,
975 + ProtobufCAllocator *allocator)
976 +{
977 + assert(message->base.descriptor == &sr__list_schemas_resp__descriptor);
978 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
979 +}
980 +void sr__get_schema_req__init
981 + (Sr__GetSchemaReq *message)
982 +{
983 + static Sr__GetSchemaReq init_value = SR__GET_SCHEMA_REQ__INIT;
984 + *message = init_value;
985 +}
986 +size_t sr__get_schema_req__get_packed_size
987 + (const Sr__GetSchemaReq *message)
988 +{
989 + assert(message->base.descriptor == &sr__get_schema_req__descriptor);
990 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
991 +}
992 +size_t sr__get_schema_req__pack
993 + (const Sr__GetSchemaReq *message,
994 + uint8_t *out)
995 +{
996 + assert(message->base.descriptor == &sr__get_schema_req__descriptor);
997 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
998 +}
999 +size_t sr__get_schema_req__pack_to_buffer
1000 + (const Sr__GetSchemaReq *message,
1001 + ProtobufCBuffer *buffer)
1002 +{
1003 + assert(message->base.descriptor == &sr__get_schema_req__descriptor);
1004 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1005 +}
1006 +Sr__GetSchemaReq *
1007 + sr__get_schema_req__unpack
1008 + (ProtobufCAllocator *allocator,
1009 + size_t len,
1010 + const uint8_t *data)
1011 +{
1012 + return (Sr__GetSchemaReq *)
1013 + protobuf_c_message_unpack (&sr__get_schema_req__descriptor,
1014 + allocator, len, data);
1015 +}
1016 +void sr__get_schema_req__free_unpacked
1017 + (Sr__GetSchemaReq *message,
1018 + ProtobufCAllocator *allocator)
1019 +{
1020 + assert(message->base.descriptor == &sr__get_schema_req__descriptor);
1021 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1022 +}
1023 +void sr__get_schema_resp__init
1024 + (Sr__GetSchemaResp *message)
1025 +{
1026 + static Sr__GetSchemaResp init_value = SR__GET_SCHEMA_RESP__INIT;
1027 + *message = init_value;
1028 +}
1029 +size_t sr__get_schema_resp__get_packed_size
1030 + (const Sr__GetSchemaResp *message)
1031 +{
1032 + assert(message->base.descriptor == &sr__get_schema_resp__descriptor);
1033 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1034 +}
1035 +size_t sr__get_schema_resp__pack
1036 + (const Sr__GetSchemaResp *message,
1037 + uint8_t *out)
1038 +{
1039 + assert(message->base.descriptor == &sr__get_schema_resp__descriptor);
1040 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1041 +}
1042 +size_t sr__get_schema_resp__pack_to_buffer
1043 + (const Sr__GetSchemaResp *message,
1044 + ProtobufCBuffer *buffer)
1045 +{
1046 + assert(message->base.descriptor == &sr__get_schema_resp__descriptor);
1047 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1048 +}
1049 +Sr__GetSchemaResp *
1050 + sr__get_schema_resp__unpack
1051 + (ProtobufCAllocator *allocator,
1052 + size_t len,
1053 + const uint8_t *data)
1054 +{
1055 + return (Sr__GetSchemaResp *)
1056 + protobuf_c_message_unpack (&sr__get_schema_resp__descriptor,
1057 + allocator, len, data);
1058 +}
1059 +void sr__get_schema_resp__free_unpacked
1060 + (Sr__GetSchemaResp *message,
1061 + ProtobufCAllocator *allocator)
1062 +{
1063 + assert(message->base.descriptor == &sr__get_schema_resp__descriptor);
1064 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1065 +}
1066 +void sr__get_item_req__init
1067 + (Sr__GetItemReq *message)
1068 +{
1069 + static Sr__GetItemReq init_value = SR__GET_ITEM_REQ__INIT;
1070 + *message = init_value;
1071 +}
1072 +size_t sr__get_item_req__get_packed_size
1073 + (const Sr__GetItemReq *message)
1074 +{
1075 + assert(message->base.descriptor == &sr__get_item_req__descriptor);
1076 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1077 +}
1078 +size_t sr__get_item_req__pack
1079 + (const Sr__GetItemReq *message,
1080 + uint8_t *out)
1081 +{
1082 + assert(message->base.descriptor == &sr__get_item_req__descriptor);
1083 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1084 +}
1085 +size_t sr__get_item_req__pack_to_buffer
1086 + (const Sr__GetItemReq *message,
1087 + ProtobufCBuffer *buffer)
1088 +{
1089 + assert(message->base.descriptor == &sr__get_item_req__descriptor);
1090 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1091 +}
1092 +Sr__GetItemReq *
1093 + sr__get_item_req__unpack
1094 + (ProtobufCAllocator *allocator,
1095 + size_t len,
1096 + const uint8_t *data)
1097 +{
1098 + return (Sr__GetItemReq *)
1099 + protobuf_c_message_unpack (&sr__get_item_req__descriptor,
1100 + allocator, len, data);
1101 +}
1102 +void sr__get_item_req__free_unpacked
1103 + (Sr__GetItemReq *message,
1104 + ProtobufCAllocator *allocator)
1105 +{
1106 + assert(message->base.descriptor == &sr__get_item_req__descriptor);
1107 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1108 +}
1109 +void sr__get_item_resp__init
1110 + (Sr__GetItemResp *message)
1111 +{
1112 + static Sr__GetItemResp init_value = SR__GET_ITEM_RESP__INIT;
1113 + *message = init_value;
1114 +}
1115 +size_t sr__get_item_resp__get_packed_size
1116 + (const Sr__GetItemResp *message)
1117 +{
1118 + assert(message->base.descriptor == &sr__get_item_resp__descriptor);
1119 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1120 +}
1121 +size_t sr__get_item_resp__pack
1122 + (const Sr__GetItemResp *message,
1123 + uint8_t *out)
1124 +{
1125 + assert(message->base.descriptor == &sr__get_item_resp__descriptor);
1126 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1127 +}
1128 +size_t sr__get_item_resp__pack_to_buffer
1129 + (const Sr__GetItemResp *message,
1130 + ProtobufCBuffer *buffer)
1131 +{
1132 + assert(message->base.descriptor == &sr__get_item_resp__descriptor);
1133 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1134 +}
1135 +Sr__GetItemResp *
1136 + sr__get_item_resp__unpack
1137 + (ProtobufCAllocator *allocator,
1138 + size_t len,
1139 + const uint8_t *data)
1140 +{
1141 + return (Sr__GetItemResp *)
1142 + protobuf_c_message_unpack (&sr__get_item_resp__descriptor,
1143 + allocator, len, data);
1144 +}
1145 +void sr__get_item_resp__free_unpacked
1146 + (Sr__GetItemResp *message,
1147 + ProtobufCAllocator *allocator)
1148 +{
1149 + assert(message->base.descriptor == &sr__get_item_resp__descriptor);
1150 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1151 +}
1152 +void sr__get_items_req__init
1153 + (Sr__GetItemsReq *message)
1154 +{
1155 + static Sr__GetItemsReq init_value = SR__GET_ITEMS_REQ__INIT;
1156 + *message = init_value;
1157 +}
1158 +size_t sr__get_items_req__get_packed_size
1159 + (const Sr__GetItemsReq *message)
1160 +{
1161 + assert(message->base.descriptor == &sr__get_items_req__descriptor);
1162 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1163 +}
1164 +size_t sr__get_items_req__pack
1165 + (const Sr__GetItemsReq *message,
1166 + uint8_t *out)
1167 +{
1168 + assert(message->base.descriptor == &sr__get_items_req__descriptor);
1169 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1170 +}
1171 +size_t sr__get_items_req__pack_to_buffer
1172 + (const Sr__GetItemsReq *message,
1173 + ProtobufCBuffer *buffer)
1174 +{
1175 + assert(message->base.descriptor == &sr__get_items_req__descriptor);
1176 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1177 +}
1178 +Sr__GetItemsReq *
1179 + sr__get_items_req__unpack
1180 + (ProtobufCAllocator *allocator,
1181 + size_t len,
1182 + const uint8_t *data)
1183 +{
1184 + return (Sr__GetItemsReq *)
1185 + protobuf_c_message_unpack (&sr__get_items_req__descriptor,
1186 + allocator, len, data);
1187 +}
1188 +void sr__get_items_req__free_unpacked
1189 + (Sr__GetItemsReq *message,
1190 + ProtobufCAllocator *allocator)
1191 +{
1192 + assert(message->base.descriptor == &sr__get_items_req__descriptor);
1193 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1194 +}
1195 +void sr__get_items_resp__init
1196 + (Sr__GetItemsResp *message)
1197 +{
1198 + static Sr__GetItemsResp init_value = SR__GET_ITEMS_RESP__INIT;
1199 + *message = init_value;
1200 +}
1201 +size_t sr__get_items_resp__get_packed_size
1202 + (const Sr__GetItemsResp *message)
1203 +{
1204 + assert(message->base.descriptor == &sr__get_items_resp__descriptor);
1205 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1206 +}
1207 +size_t sr__get_items_resp__pack
1208 + (const Sr__GetItemsResp *message,
1209 + uint8_t *out)
1210 +{
1211 + assert(message->base.descriptor == &sr__get_items_resp__descriptor);
1212 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1213 +}
1214 +size_t sr__get_items_resp__pack_to_buffer
1215 + (const Sr__GetItemsResp *message,
1216 + ProtobufCBuffer *buffer)
1217 +{
1218 + assert(message->base.descriptor == &sr__get_items_resp__descriptor);
1219 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1220 +}
1221 +Sr__GetItemsResp *
1222 + sr__get_items_resp__unpack
1223 + (ProtobufCAllocator *allocator,
1224 + size_t len,
1225 + const uint8_t *data)
1226 +{
1227 + return (Sr__GetItemsResp *)
1228 + protobuf_c_message_unpack (&sr__get_items_resp__descriptor,
1229 + allocator, len, data);
1230 +}
1231 +void sr__get_items_resp__free_unpacked
1232 + (Sr__GetItemsResp *message,
1233 + ProtobufCAllocator *allocator)
1234 +{
1235 + assert(message->base.descriptor == &sr__get_items_resp__descriptor);
1236 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1237 +}
1238 +void sr__get_subtree_req__init
1239 + (Sr__GetSubtreeReq *message)
1240 +{
1241 + static Sr__GetSubtreeReq init_value = SR__GET_SUBTREE_REQ__INIT;
1242 + *message = init_value;
1243 +}
1244 +size_t sr__get_subtree_req__get_packed_size
1245 + (const Sr__GetSubtreeReq *message)
1246 +{
1247 + assert(message->base.descriptor == &sr__get_subtree_req__descriptor);
1248 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1249 +}
1250 +size_t sr__get_subtree_req__pack
1251 + (const Sr__GetSubtreeReq *message,
1252 + uint8_t *out)
1253 +{
1254 + assert(message->base.descriptor == &sr__get_subtree_req__descriptor);
1255 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1256 +}
1257 +size_t sr__get_subtree_req__pack_to_buffer
1258 + (const Sr__GetSubtreeReq *message,
1259 + ProtobufCBuffer *buffer)
1260 +{
1261 + assert(message->base.descriptor == &sr__get_subtree_req__descriptor);
1262 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1263 +}
1264 +Sr__GetSubtreeReq *
1265 + sr__get_subtree_req__unpack
1266 + (ProtobufCAllocator *allocator,
1267 + size_t len,
1268 + const uint8_t *data)
1269 +{
1270 + return (Sr__GetSubtreeReq *)
1271 + protobuf_c_message_unpack (&sr__get_subtree_req__descriptor,
1272 + allocator, len, data);
1273 +}
1274 +void sr__get_subtree_req__free_unpacked
1275 + (Sr__GetSubtreeReq *message,
1276 + ProtobufCAllocator *allocator)
1277 +{
1278 + assert(message->base.descriptor == &sr__get_subtree_req__descriptor);
1279 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1280 +}
1281 +void sr__get_subtree_resp__init
1282 + (Sr__GetSubtreeResp *message)
1283 +{
1284 + static Sr__GetSubtreeResp init_value = SR__GET_SUBTREE_RESP__INIT;
1285 + *message = init_value;
1286 +}
1287 +size_t sr__get_subtree_resp__get_packed_size
1288 + (const Sr__GetSubtreeResp *message)
1289 +{
1290 + assert(message->base.descriptor == &sr__get_subtree_resp__descriptor);
1291 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1292 +}
1293 +size_t sr__get_subtree_resp__pack
1294 + (const Sr__GetSubtreeResp *message,
1295 + uint8_t *out)
1296 +{
1297 + assert(message->base.descriptor == &sr__get_subtree_resp__descriptor);
1298 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1299 +}
1300 +size_t sr__get_subtree_resp__pack_to_buffer
1301 + (const Sr__GetSubtreeResp *message,
1302 + ProtobufCBuffer *buffer)
1303 +{
1304 + assert(message->base.descriptor == &sr__get_subtree_resp__descriptor);
1305 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1306 +}
1307 +Sr__GetSubtreeResp *
1308 + sr__get_subtree_resp__unpack
1309 + (ProtobufCAllocator *allocator,
1310 + size_t len,
1311 + const uint8_t *data)
1312 +{
1313 + return (Sr__GetSubtreeResp *)
1314 + protobuf_c_message_unpack (&sr__get_subtree_resp__descriptor,
1315 + allocator, len, data);
1316 +}
1317 +void sr__get_subtree_resp__free_unpacked
1318 + (Sr__GetSubtreeResp *message,
1319 + ProtobufCAllocator *allocator)
1320 +{
1321 + assert(message->base.descriptor == &sr__get_subtree_resp__descriptor);
1322 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1323 +}
1324 +void sr__get_subtrees_req__init
1325 + (Sr__GetSubtreesReq *message)
1326 +{
1327 + static Sr__GetSubtreesReq init_value = SR__GET_SUBTREES_REQ__INIT;
1328 + *message = init_value;
1329 +}
1330 +size_t sr__get_subtrees_req__get_packed_size
1331 + (const Sr__GetSubtreesReq *message)
1332 +{
1333 + assert(message->base.descriptor == &sr__get_subtrees_req__descriptor);
1334 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1335 +}
1336 +size_t sr__get_subtrees_req__pack
1337 + (const Sr__GetSubtreesReq *message,
1338 + uint8_t *out)
1339 +{
1340 + assert(message->base.descriptor == &sr__get_subtrees_req__descriptor);
1341 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1342 +}
1343 +size_t sr__get_subtrees_req__pack_to_buffer
1344 + (const Sr__GetSubtreesReq *message,
1345 + ProtobufCBuffer *buffer)
1346 +{
1347 + assert(message->base.descriptor == &sr__get_subtrees_req__descriptor);
1348 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1349 +}
1350 +Sr__GetSubtreesReq *
1351 + sr__get_subtrees_req__unpack
1352 + (ProtobufCAllocator *allocator,
1353 + size_t len,
1354 + const uint8_t *data)
1355 +{
1356 + return (Sr__GetSubtreesReq *)
1357 + protobuf_c_message_unpack (&sr__get_subtrees_req__descriptor,
1358 + allocator, len, data);
1359 +}
1360 +void sr__get_subtrees_req__free_unpacked
1361 + (Sr__GetSubtreesReq *message,
1362 + ProtobufCAllocator *allocator)
1363 +{
1364 + assert(message->base.descriptor == &sr__get_subtrees_req__descriptor);
1365 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1366 +}
1367 +void sr__get_subtrees_resp__init
1368 + (Sr__GetSubtreesResp *message)
1369 +{
1370 + static Sr__GetSubtreesResp init_value = SR__GET_SUBTREES_RESP__INIT;
1371 + *message = init_value;
1372 +}
1373 +size_t sr__get_subtrees_resp__get_packed_size
1374 + (const Sr__GetSubtreesResp *message)
1375 +{
1376 + assert(message->base.descriptor == &sr__get_subtrees_resp__descriptor);
1377 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1378 +}
1379 +size_t sr__get_subtrees_resp__pack
1380 + (const Sr__GetSubtreesResp *message,
1381 + uint8_t *out)
1382 +{
1383 + assert(message->base.descriptor == &sr__get_subtrees_resp__descriptor);
1384 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1385 +}
1386 +size_t sr__get_subtrees_resp__pack_to_buffer
1387 + (const Sr__GetSubtreesResp *message,
1388 + ProtobufCBuffer *buffer)
1389 +{
1390 + assert(message->base.descriptor == &sr__get_subtrees_resp__descriptor);
1391 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1392 +}
1393 +Sr__GetSubtreesResp *
1394 + sr__get_subtrees_resp__unpack
1395 + (ProtobufCAllocator *allocator,
1396 + size_t len,
1397 + const uint8_t *data)
1398 +{
1399 + return (Sr__GetSubtreesResp *)
1400 + protobuf_c_message_unpack (&sr__get_subtrees_resp__descriptor,
1401 + allocator, len, data);
1402 +}
1403 +void sr__get_subtrees_resp__free_unpacked
1404 + (Sr__GetSubtreesResp *message,
1405 + ProtobufCAllocator *allocator)
1406 +{
1407 + assert(message->base.descriptor == &sr__get_subtrees_resp__descriptor);
1408 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1409 +}
1410 +void sr__get_subtree_chunk_req__init
1411 + (Sr__GetSubtreeChunkReq *message)
1412 +{
1413 + static Sr__GetSubtreeChunkReq init_value = SR__GET_SUBTREE_CHUNK_REQ__INIT;
1414 + *message = init_value;
1415 +}
1416 +size_t sr__get_subtree_chunk_req__get_packed_size
1417 + (const Sr__GetSubtreeChunkReq *message)
1418 +{
1419 + assert(message->base.descriptor == &sr__get_subtree_chunk_req__descriptor);
1420 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1421 +}
1422 +size_t sr__get_subtree_chunk_req__pack
1423 + (const Sr__GetSubtreeChunkReq *message,
1424 + uint8_t *out)
1425 +{
1426 + assert(message->base.descriptor == &sr__get_subtree_chunk_req__descriptor);
1427 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1428 +}
1429 +size_t sr__get_subtree_chunk_req__pack_to_buffer
1430 + (const Sr__GetSubtreeChunkReq *message,
1431 + ProtobufCBuffer *buffer)
1432 +{
1433 + assert(message->base.descriptor == &sr__get_subtree_chunk_req__descriptor);
1434 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1435 +}
1436 +Sr__GetSubtreeChunkReq *
1437 + sr__get_subtree_chunk_req__unpack
1438 + (ProtobufCAllocator *allocator,
1439 + size_t len,
1440 + const uint8_t *data)
1441 +{
1442 + return (Sr__GetSubtreeChunkReq *)
1443 + protobuf_c_message_unpack (&sr__get_subtree_chunk_req__descriptor,
1444 + allocator, len, data);
1445 +}
1446 +void sr__get_subtree_chunk_req__free_unpacked
1447 + (Sr__GetSubtreeChunkReq *message,
1448 + ProtobufCAllocator *allocator)
1449 +{
1450 + assert(message->base.descriptor == &sr__get_subtree_chunk_req__descriptor);
1451 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1452 +}
1453 +void sr__get_subtree_chunk_resp__init
1454 + (Sr__GetSubtreeChunkResp *message)
1455 +{
1456 + static Sr__GetSubtreeChunkResp init_value = SR__GET_SUBTREE_CHUNK_RESP__INIT;
1457 + *message = init_value;
1458 +}
1459 +size_t sr__get_subtree_chunk_resp__get_packed_size
1460 + (const Sr__GetSubtreeChunkResp *message)
1461 +{
1462 + assert(message->base.descriptor == &sr__get_subtree_chunk_resp__descriptor);
1463 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1464 +}
1465 +size_t sr__get_subtree_chunk_resp__pack
1466 + (const Sr__GetSubtreeChunkResp *message,
1467 + uint8_t *out)
1468 +{
1469 + assert(message->base.descriptor == &sr__get_subtree_chunk_resp__descriptor);
1470 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1471 +}
1472 +size_t sr__get_subtree_chunk_resp__pack_to_buffer
1473 + (const Sr__GetSubtreeChunkResp *message,
1474 + ProtobufCBuffer *buffer)
1475 +{
1476 + assert(message->base.descriptor == &sr__get_subtree_chunk_resp__descriptor);
1477 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1478 +}
1479 +Sr__GetSubtreeChunkResp *
1480 + sr__get_subtree_chunk_resp__unpack
1481 + (ProtobufCAllocator *allocator,
1482 + size_t len,
1483 + const uint8_t *data)
1484 +{
1485 + return (Sr__GetSubtreeChunkResp *)
1486 + protobuf_c_message_unpack (&sr__get_subtree_chunk_resp__descriptor,
1487 + allocator, len, data);
1488 +}
1489 +void sr__get_subtree_chunk_resp__free_unpacked
1490 + (Sr__GetSubtreeChunkResp *message,
1491 + ProtobufCAllocator *allocator)
1492 +{
1493 + assert(message->base.descriptor == &sr__get_subtree_chunk_resp__descriptor);
1494 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1495 +}
1496 +void sr__set_item_req__init
1497 + (Sr__SetItemReq *message)
1498 +{
1499 + static Sr__SetItemReq init_value = SR__SET_ITEM_REQ__INIT;
1500 + *message = init_value;
1501 +}
1502 +size_t sr__set_item_req__get_packed_size
1503 + (const Sr__SetItemReq *message)
1504 +{
1505 + assert(message->base.descriptor == &sr__set_item_req__descriptor);
1506 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1507 +}
1508 +size_t sr__set_item_req__pack
1509 + (const Sr__SetItemReq *message,
1510 + uint8_t *out)
1511 +{
1512 + assert(message->base.descriptor == &sr__set_item_req__descriptor);
1513 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1514 +}
1515 +size_t sr__set_item_req__pack_to_buffer
1516 + (const Sr__SetItemReq *message,
1517 + ProtobufCBuffer *buffer)
1518 +{
1519 + assert(message->base.descriptor == &sr__set_item_req__descriptor);
1520 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1521 +}
1522 +Sr__SetItemReq *
1523 + sr__set_item_req__unpack
1524 + (ProtobufCAllocator *allocator,
1525 + size_t len,
1526 + const uint8_t *data)
1527 +{
1528 + return (Sr__SetItemReq *)
1529 + protobuf_c_message_unpack (&sr__set_item_req__descriptor,
1530 + allocator, len, data);
1531 +}
1532 +void sr__set_item_req__free_unpacked
1533 + (Sr__SetItemReq *message,
1534 + ProtobufCAllocator *allocator)
1535 +{
1536 + assert(message->base.descriptor == &sr__set_item_req__descriptor);
1537 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1538 +}
1539 +void sr__set_item_resp__init
1540 + (Sr__SetItemResp *message)
1541 +{
1542 + static Sr__SetItemResp init_value = SR__SET_ITEM_RESP__INIT;
1543 + *message = init_value;
1544 +}
1545 +size_t sr__set_item_resp__get_packed_size
1546 + (const Sr__SetItemResp *message)
1547 +{
1548 + assert(message->base.descriptor == &sr__set_item_resp__descriptor);
1549 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1550 +}
1551 +size_t sr__set_item_resp__pack
1552 + (const Sr__SetItemResp *message,
1553 + uint8_t *out)
1554 +{
1555 + assert(message->base.descriptor == &sr__set_item_resp__descriptor);
1556 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1557 +}
1558 +size_t sr__set_item_resp__pack_to_buffer
1559 + (const Sr__SetItemResp *message,
1560 + ProtobufCBuffer *buffer)
1561 +{
1562 + assert(message->base.descriptor == &sr__set_item_resp__descriptor);
1563 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1564 +}
1565 +Sr__SetItemResp *
1566 + sr__set_item_resp__unpack
1567 + (ProtobufCAllocator *allocator,
1568 + size_t len,
1569 + const uint8_t *data)
1570 +{
1571 + return (Sr__SetItemResp *)
1572 + protobuf_c_message_unpack (&sr__set_item_resp__descriptor,
1573 + allocator, len, data);
1574 +}
1575 +void sr__set_item_resp__free_unpacked
1576 + (Sr__SetItemResp *message,
1577 + ProtobufCAllocator *allocator)
1578 +{
1579 + assert(message->base.descriptor == &sr__set_item_resp__descriptor);
1580 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1581 +}
1582 +void sr__set_item_str_req__init
1583 + (Sr__SetItemStrReq *message)
1584 +{
1585 + static Sr__SetItemStrReq init_value = SR__SET_ITEM_STR_REQ__INIT;
1586 + *message = init_value;
1587 +}
1588 +size_t sr__set_item_str_req__get_packed_size
1589 + (const Sr__SetItemStrReq *message)
1590 +{
1591 + assert(message->base.descriptor == &sr__set_item_str_req__descriptor);
1592 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1593 +}
1594 +size_t sr__set_item_str_req__pack
1595 + (const Sr__SetItemStrReq *message,
1596 + uint8_t *out)
1597 +{
1598 + assert(message->base.descriptor == &sr__set_item_str_req__descriptor);
1599 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1600 +}
1601 +size_t sr__set_item_str_req__pack_to_buffer
1602 + (const Sr__SetItemStrReq *message,
1603 + ProtobufCBuffer *buffer)
1604 +{
1605 + assert(message->base.descriptor == &sr__set_item_str_req__descriptor);
1606 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1607 +}
1608 +Sr__SetItemStrReq *
1609 + sr__set_item_str_req__unpack
1610 + (ProtobufCAllocator *allocator,
1611 + size_t len,
1612 + const uint8_t *data)
1613 +{
1614 + return (Sr__SetItemStrReq *)
1615 + protobuf_c_message_unpack (&sr__set_item_str_req__descriptor,
1616 + allocator, len, data);
1617 +}
1618 +void sr__set_item_str_req__free_unpacked
1619 + (Sr__SetItemStrReq *message,
1620 + ProtobufCAllocator *allocator)
1621 +{
1622 + assert(message->base.descriptor == &sr__set_item_str_req__descriptor);
1623 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1624 +}
1625 +void sr__set_item_str_resp__init
1626 + (Sr__SetItemStrResp *message)
1627 +{
1628 + static Sr__SetItemStrResp init_value = SR__SET_ITEM_STR_RESP__INIT;
1629 + *message = init_value;
1630 +}
1631 +size_t sr__set_item_str_resp__get_packed_size
1632 + (const Sr__SetItemStrResp *message)
1633 +{
1634 + assert(message->base.descriptor == &sr__set_item_str_resp__descriptor);
1635 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1636 +}
1637 +size_t sr__set_item_str_resp__pack
1638 + (const Sr__SetItemStrResp *message,
1639 + uint8_t *out)
1640 +{
1641 + assert(message->base.descriptor == &sr__set_item_str_resp__descriptor);
1642 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1643 +}
1644 +size_t sr__set_item_str_resp__pack_to_buffer
1645 + (const Sr__SetItemStrResp *message,
1646 + ProtobufCBuffer *buffer)
1647 +{
1648 + assert(message->base.descriptor == &sr__set_item_str_resp__descriptor);
1649 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1650 +}
1651 +Sr__SetItemStrResp *
1652 + sr__set_item_str_resp__unpack
1653 + (ProtobufCAllocator *allocator,
1654 + size_t len,
1655 + const uint8_t *data)
1656 +{
1657 + return (Sr__SetItemStrResp *)
1658 + protobuf_c_message_unpack (&sr__set_item_str_resp__descriptor,
1659 + allocator, len, data);
1660 +}
1661 +void sr__set_item_str_resp__free_unpacked
1662 + (Sr__SetItemStrResp *message,
1663 + ProtobufCAllocator *allocator)
1664 +{
1665 + assert(message->base.descriptor == &sr__set_item_str_resp__descriptor);
1666 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1667 +}
1668 +void sr__delete_item_req__init
1669 + (Sr__DeleteItemReq *message)
1670 +{
1671 + static Sr__DeleteItemReq init_value = SR__DELETE_ITEM_REQ__INIT;
1672 + *message = init_value;
1673 +}
1674 +size_t sr__delete_item_req__get_packed_size
1675 + (const Sr__DeleteItemReq *message)
1676 +{
1677 + assert(message->base.descriptor == &sr__delete_item_req__descriptor);
1678 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1679 +}
1680 +size_t sr__delete_item_req__pack
1681 + (const Sr__DeleteItemReq *message,
1682 + uint8_t *out)
1683 +{
1684 + assert(message->base.descriptor == &sr__delete_item_req__descriptor);
1685 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1686 +}
1687 +size_t sr__delete_item_req__pack_to_buffer
1688 + (const Sr__DeleteItemReq *message,
1689 + ProtobufCBuffer *buffer)
1690 +{
1691 + assert(message->base.descriptor == &sr__delete_item_req__descriptor);
1692 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1693 +}
1694 +Sr__DeleteItemReq *
1695 + sr__delete_item_req__unpack
1696 + (ProtobufCAllocator *allocator,
1697 + size_t len,
1698 + const uint8_t *data)
1699 +{
1700 + return (Sr__DeleteItemReq *)
1701 + protobuf_c_message_unpack (&sr__delete_item_req__descriptor,
1702 + allocator, len, data);
1703 +}
1704 +void sr__delete_item_req__free_unpacked
1705 + (Sr__DeleteItemReq *message,
1706 + ProtobufCAllocator *allocator)
1707 +{
1708 + assert(message->base.descriptor == &sr__delete_item_req__descriptor);
1709 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1710 +}
1711 +void sr__delete_item_resp__init
1712 + (Sr__DeleteItemResp *message)
1713 +{
1714 + static Sr__DeleteItemResp init_value = SR__DELETE_ITEM_RESP__INIT;
1715 + *message = init_value;
1716 +}
1717 +size_t sr__delete_item_resp__get_packed_size
1718 + (const Sr__DeleteItemResp *message)
1719 +{
1720 + assert(message->base.descriptor == &sr__delete_item_resp__descriptor);
1721 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1722 +}
1723 +size_t sr__delete_item_resp__pack
1724 + (const Sr__DeleteItemResp *message,
1725 + uint8_t *out)
1726 +{
1727 + assert(message->base.descriptor == &sr__delete_item_resp__descriptor);
1728 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1729 +}
1730 +size_t sr__delete_item_resp__pack_to_buffer
1731 + (const Sr__DeleteItemResp *message,
1732 + ProtobufCBuffer *buffer)
1733 +{
1734 + assert(message->base.descriptor == &sr__delete_item_resp__descriptor);
1735 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1736 +}
1737 +Sr__DeleteItemResp *
1738 + sr__delete_item_resp__unpack
1739 + (ProtobufCAllocator *allocator,
1740 + size_t len,
1741 + const uint8_t *data)
1742 +{
1743 + return (Sr__DeleteItemResp *)
1744 + protobuf_c_message_unpack (&sr__delete_item_resp__descriptor,
1745 + allocator, len, data);
1746 +}
1747 +void sr__delete_item_resp__free_unpacked
1748 + (Sr__DeleteItemResp *message,
1749 + ProtobufCAllocator *allocator)
1750 +{
1751 + assert(message->base.descriptor == &sr__delete_item_resp__descriptor);
1752 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1753 +}
1754 +void sr__move_item_req__init
1755 + (Sr__MoveItemReq *message)
1756 +{
1757 + static Sr__MoveItemReq init_value = SR__MOVE_ITEM_REQ__INIT;
1758 + *message = init_value;
1759 +}
1760 +size_t sr__move_item_req__get_packed_size
1761 + (const Sr__MoveItemReq *message)
1762 +{
1763 + assert(message->base.descriptor == &sr__move_item_req__descriptor);
1764 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1765 +}
1766 +size_t sr__move_item_req__pack
1767 + (const Sr__MoveItemReq *message,
1768 + uint8_t *out)
1769 +{
1770 + assert(message->base.descriptor == &sr__move_item_req__descriptor);
1771 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1772 +}
1773 +size_t sr__move_item_req__pack_to_buffer
1774 + (const Sr__MoveItemReq *message,
1775 + ProtobufCBuffer *buffer)
1776 +{
1777 + assert(message->base.descriptor == &sr__move_item_req__descriptor);
1778 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1779 +}
1780 +Sr__MoveItemReq *
1781 + sr__move_item_req__unpack
1782 + (ProtobufCAllocator *allocator,
1783 + size_t len,
1784 + const uint8_t *data)
1785 +{
1786 + return (Sr__MoveItemReq *)
1787 + protobuf_c_message_unpack (&sr__move_item_req__descriptor,
1788 + allocator, len, data);
1789 +}
1790 +void sr__move_item_req__free_unpacked
1791 + (Sr__MoveItemReq *message,
1792 + ProtobufCAllocator *allocator)
1793 +{
1794 + assert(message->base.descriptor == &sr__move_item_req__descriptor);
1795 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1796 +}
1797 +void sr__move_item_resp__init
1798 + (Sr__MoveItemResp *message)
1799 +{
1800 + static Sr__MoveItemResp init_value = SR__MOVE_ITEM_RESP__INIT;
1801 + *message = init_value;
1802 +}
1803 +size_t sr__move_item_resp__get_packed_size
1804 + (const Sr__MoveItemResp *message)
1805 +{
1806 + assert(message->base.descriptor == &sr__move_item_resp__descriptor);
1807 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1808 +}
1809 +size_t sr__move_item_resp__pack
1810 + (const Sr__MoveItemResp *message,
1811 + uint8_t *out)
1812 +{
1813 + assert(message->base.descriptor == &sr__move_item_resp__descriptor);
1814 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1815 +}
1816 +size_t sr__move_item_resp__pack_to_buffer
1817 + (const Sr__MoveItemResp *message,
1818 + ProtobufCBuffer *buffer)
1819 +{
1820 + assert(message->base.descriptor == &sr__move_item_resp__descriptor);
1821 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1822 +}
1823 +Sr__MoveItemResp *
1824 + sr__move_item_resp__unpack
1825 + (ProtobufCAllocator *allocator,
1826 + size_t len,
1827 + const uint8_t *data)
1828 +{
1829 + return (Sr__MoveItemResp *)
1830 + protobuf_c_message_unpack (&sr__move_item_resp__descriptor,
1831 + allocator, len, data);
1832 +}
1833 +void sr__move_item_resp__free_unpacked
1834 + (Sr__MoveItemResp *message,
1835 + ProtobufCAllocator *allocator)
1836 +{
1837 + assert(message->base.descriptor == &sr__move_item_resp__descriptor);
1838 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1839 +}
1840 +void sr__validate_req__init
1841 + (Sr__ValidateReq *message)
1842 +{
1843 + static Sr__ValidateReq init_value = SR__VALIDATE_REQ__INIT;
1844 + *message = init_value;
1845 +}
1846 +size_t sr__validate_req__get_packed_size
1847 + (const Sr__ValidateReq *message)
1848 +{
1849 + assert(message->base.descriptor == &sr__validate_req__descriptor);
1850 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1851 +}
1852 +size_t sr__validate_req__pack
1853 + (const Sr__ValidateReq *message,
1854 + uint8_t *out)
1855 +{
1856 + assert(message->base.descriptor == &sr__validate_req__descriptor);
1857 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1858 +}
1859 +size_t sr__validate_req__pack_to_buffer
1860 + (const Sr__ValidateReq *message,
1861 + ProtobufCBuffer *buffer)
1862 +{
1863 + assert(message->base.descriptor == &sr__validate_req__descriptor);
1864 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1865 +}
1866 +Sr__ValidateReq *
1867 + sr__validate_req__unpack
1868 + (ProtobufCAllocator *allocator,
1869 + size_t len,
1870 + const uint8_t *data)
1871 +{
1872 + return (Sr__ValidateReq *)
1873 + protobuf_c_message_unpack (&sr__validate_req__descriptor,
1874 + allocator, len, data);
1875 +}
1876 +void sr__validate_req__free_unpacked
1877 + (Sr__ValidateReq *message,
1878 + ProtobufCAllocator *allocator)
1879 +{
1880 + assert(message->base.descriptor == &sr__validate_req__descriptor);
1881 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1882 +}
1883 +void sr__validate_resp__init
1884 + (Sr__ValidateResp *message)
1885 +{
1886 + static Sr__ValidateResp init_value = SR__VALIDATE_RESP__INIT;
1887 + *message = init_value;
1888 +}
1889 +size_t sr__validate_resp__get_packed_size
1890 + (const Sr__ValidateResp *message)
1891 +{
1892 + assert(message->base.descriptor == &sr__validate_resp__descriptor);
1893 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1894 +}
1895 +size_t sr__validate_resp__pack
1896 + (const Sr__ValidateResp *message,
1897 + uint8_t *out)
1898 +{
1899 + assert(message->base.descriptor == &sr__validate_resp__descriptor);
1900 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1901 +}
1902 +size_t sr__validate_resp__pack_to_buffer
1903 + (const Sr__ValidateResp *message,
1904 + ProtobufCBuffer *buffer)
1905 +{
1906 + assert(message->base.descriptor == &sr__validate_resp__descriptor);
1907 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1908 +}
1909 +Sr__ValidateResp *
1910 + sr__validate_resp__unpack
1911 + (ProtobufCAllocator *allocator,
1912 + size_t len,
1913 + const uint8_t *data)
1914 +{
1915 + return (Sr__ValidateResp *)
1916 + protobuf_c_message_unpack (&sr__validate_resp__descriptor,
1917 + allocator, len, data);
1918 +}
1919 +void sr__validate_resp__free_unpacked
1920 + (Sr__ValidateResp *message,
1921 + ProtobufCAllocator *allocator)
1922 +{
1923 + assert(message->base.descriptor == &sr__validate_resp__descriptor);
1924 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1925 +}
1926 +void sr__commit_req__init
1927 + (Sr__CommitReq *message)
1928 +{
1929 + static Sr__CommitReq init_value = SR__COMMIT_REQ__INIT;
1930 + *message = init_value;
1931 +}
1932 +size_t sr__commit_req__get_packed_size
1933 + (const Sr__CommitReq *message)
1934 +{
1935 + assert(message->base.descriptor == &sr__commit_req__descriptor);
1936 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1937 +}
1938 +size_t sr__commit_req__pack
1939 + (const Sr__CommitReq *message,
1940 + uint8_t *out)
1941 +{
1942 + assert(message->base.descriptor == &sr__commit_req__descriptor);
1943 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1944 +}
1945 +size_t sr__commit_req__pack_to_buffer
1946 + (const Sr__CommitReq *message,
1947 + ProtobufCBuffer *buffer)
1948 +{
1949 + assert(message->base.descriptor == &sr__commit_req__descriptor);
1950 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1951 +}
1952 +Sr__CommitReq *
1953 + sr__commit_req__unpack
1954 + (ProtobufCAllocator *allocator,
1955 + size_t len,
1956 + const uint8_t *data)
1957 +{
1958 + return (Sr__CommitReq *)
1959 + protobuf_c_message_unpack (&sr__commit_req__descriptor,
1960 + allocator, len, data);
1961 +}
1962 +void sr__commit_req__free_unpacked
1963 + (Sr__CommitReq *message,
1964 + ProtobufCAllocator *allocator)
1965 +{
1966 + assert(message->base.descriptor == &sr__commit_req__descriptor);
1967 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
1968 +}
1969 +void sr__commit_resp__init
1970 + (Sr__CommitResp *message)
1971 +{
1972 + static Sr__CommitResp init_value = SR__COMMIT_RESP__INIT;
1973 + *message = init_value;
1974 +}
1975 +size_t sr__commit_resp__get_packed_size
1976 + (const Sr__CommitResp *message)
1977 +{
1978 + assert(message->base.descriptor == &sr__commit_resp__descriptor);
1979 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
1980 +}
1981 +size_t sr__commit_resp__pack
1982 + (const Sr__CommitResp *message,
1983 + uint8_t *out)
1984 +{
1985 + assert(message->base.descriptor == &sr__commit_resp__descriptor);
1986 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
1987 +}
1988 +size_t sr__commit_resp__pack_to_buffer
1989 + (const Sr__CommitResp *message,
1990 + ProtobufCBuffer *buffer)
1991 +{
1992 + assert(message->base.descriptor == &sr__commit_resp__descriptor);
1993 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
1994 +}
1995 +Sr__CommitResp *
1996 + sr__commit_resp__unpack
1997 + (ProtobufCAllocator *allocator,
1998 + size_t len,
1999 + const uint8_t *data)
2000 +{
2001 + return (Sr__CommitResp *)
2002 + protobuf_c_message_unpack (&sr__commit_resp__descriptor,
2003 + allocator, len, data);
2004 +}
2005 +void sr__commit_resp__free_unpacked
2006 + (Sr__CommitResp *message,
2007 + ProtobufCAllocator *allocator)
2008 +{
2009 + assert(message->base.descriptor == &sr__commit_resp__descriptor);
2010 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2011 +}
2012 +void sr__discard_changes_req__init
2013 + (Sr__DiscardChangesReq *message)
2014 +{
2015 + static Sr__DiscardChangesReq init_value = SR__DISCARD_CHANGES_REQ__INIT;
2016 + *message = init_value;
2017 +}
2018 +size_t sr__discard_changes_req__get_packed_size
2019 + (const Sr__DiscardChangesReq *message)
2020 +{
2021 + assert(message->base.descriptor == &sr__discard_changes_req__descriptor);
2022 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2023 +}
2024 +size_t sr__discard_changes_req__pack
2025 + (const Sr__DiscardChangesReq *message,
2026 + uint8_t *out)
2027 +{
2028 + assert(message->base.descriptor == &sr__discard_changes_req__descriptor);
2029 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2030 +}
2031 +size_t sr__discard_changes_req__pack_to_buffer
2032 + (const Sr__DiscardChangesReq *message,
2033 + ProtobufCBuffer *buffer)
2034 +{
2035 + assert(message->base.descriptor == &sr__discard_changes_req__descriptor);
2036 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2037 +}
2038 +Sr__DiscardChangesReq *
2039 + sr__discard_changes_req__unpack
2040 + (ProtobufCAllocator *allocator,
2041 + size_t len,
2042 + const uint8_t *data)
2043 +{
2044 + return (Sr__DiscardChangesReq *)
2045 + protobuf_c_message_unpack (&sr__discard_changes_req__descriptor,
2046 + allocator, len, data);
2047 +}
2048 +void sr__discard_changes_req__free_unpacked
2049 + (Sr__DiscardChangesReq *message,
2050 + ProtobufCAllocator *allocator)
2051 +{
2052 + assert(message->base.descriptor == &sr__discard_changes_req__descriptor);
2053 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2054 +}
2055 +void sr__discard_changes_resp__init
2056 + (Sr__DiscardChangesResp *message)
2057 +{
2058 + static Sr__DiscardChangesResp init_value = SR__DISCARD_CHANGES_RESP__INIT;
2059 + *message = init_value;
2060 +}
2061 +size_t sr__discard_changes_resp__get_packed_size
2062 + (const Sr__DiscardChangesResp *message)
2063 +{
2064 + assert(message->base.descriptor == &sr__discard_changes_resp__descriptor);
2065 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2066 +}
2067 +size_t sr__discard_changes_resp__pack
2068 + (const Sr__DiscardChangesResp *message,
2069 + uint8_t *out)
2070 +{
2071 + assert(message->base.descriptor == &sr__discard_changes_resp__descriptor);
2072 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2073 +}
2074 +size_t sr__discard_changes_resp__pack_to_buffer
2075 + (const Sr__DiscardChangesResp *message,
2076 + ProtobufCBuffer *buffer)
2077 +{
2078 + assert(message->base.descriptor == &sr__discard_changes_resp__descriptor);
2079 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2080 +}
2081 +Sr__DiscardChangesResp *
2082 + sr__discard_changes_resp__unpack
2083 + (ProtobufCAllocator *allocator,
2084 + size_t len,
2085 + const uint8_t *data)
2086 +{
2087 + return (Sr__DiscardChangesResp *)
2088 + protobuf_c_message_unpack (&sr__discard_changes_resp__descriptor,
2089 + allocator, len, data);
2090 +}
2091 +void sr__discard_changes_resp__free_unpacked
2092 + (Sr__DiscardChangesResp *message,
2093 + ProtobufCAllocator *allocator)
2094 +{
2095 + assert(message->base.descriptor == &sr__discard_changes_resp__descriptor);
2096 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2097 +}
2098 +void sr__copy_config_req__init
2099 + (Sr__CopyConfigReq *message)
2100 +{
2101 + static Sr__CopyConfigReq init_value = SR__COPY_CONFIG_REQ__INIT;
2102 + *message = init_value;
2103 +}
2104 +size_t sr__copy_config_req__get_packed_size
2105 + (const Sr__CopyConfigReq *message)
2106 +{
2107 + assert(message->base.descriptor == &sr__copy_config_req__descriptor);
2108 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2109 +}
2110 +size_t sr__copy_config_req__pack
2111 + (const Sr__CopyConfigReq *message,
2112 + uint8_t *out)
2113 +{
2114 + assert(message->base.descriptor == &sr__copy_config_req__descriptor);
2115 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2116 +}
2117 +size_t sr__copy_config_req__pack_to_buffer
2118 + (const Sr__CopyConfigReq *message,
2119 + ProtobufCBuffer *buffer)
2120 +{
2121 + assert(message->base.descriptor == &sr__copy_config_req__descriptor);
2122 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2123 +}
2124 +Sr__CopyConfigReq *
2125 + sr__copy_config_req__unpack
2126 + (ProtobufCAllocator *allocator,
2127 + size_t len,
2128 + const uint8_t *data)
2129 +{
2130 + return (Sr__CopyConfigReq *)
2131 + protobuf_c_message_unpack (&sr__copy_config_req__descriptor,
2132 + allocator, len, data);
2133 +}
2134 +void sr__copy_config_req__free_unpacked
2135 + (Sr__CopyConfigReq *message,
2136 + ProtobufCAllocator *allocator)
2137 +{
2138 + assert(message->base.descriptor == &sr__copy_config_req__descriptor);
2139 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2140 +}
2141 +void sr__copy_config_resp__init
2142 + (Sr__CopyConfigResp *message)
2143 +{
2144 + static Sr__CopyConfigResp init_value = SR__COPY_CONFIG_RESP__INIT;
2145 + *message = init_value;
2146 +}
2147 +size_t sr__copy_config_resp__get_packed_size
2148 + (const Sr__CopyConfigResp *message)
2149 +{
2150 + assert(message->base.descriptor == &sr__copy_config_resp__descriptor);
2151 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2152 +}
2153 +size_t sr__copy_config_resp__pack
2154 + (const Sr__CopyConfigResp *message,
2155 + uint8_t *out)
2156 +{
2157 + assert(message->base.descriptor == &sr__copy_config_resp__descriptor);
2158 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2159 +}
2160 +size_t sr__copy_config_resp__pack_to_buffer
2161 + (const Sr__CopyConfigResp *message,
2162 + ProtobufCBuffer *buffer)
2163 +{
2164 + assert(message->base.descriptor == &sr__copy_config_resp__descriptor);
2165 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2166 +}
2167 +Sr__CopyConfigResp *
2168 + sr__copy_config_resp__unpack
2169 + (ProtobufCAllocator *allocator,
2170 + size_t len,
2171 + const uint8_t *data)
2172 +{
2173 + return (Sr__CopyConfigResp *)
2174 + protobuf_c_message_unpack (&sr__copy_config_resp__descriptor,
2175 + allocator, len, data);
2176 +}
2177 +void sr__copy_config_resp__free_unpacked
2178 + (Sr__CopyConfigResp *message,
2179 + ProtobufCAllocator *allocator)
2180 +{
2181 + assert(message->base.descriptor == &sr__copy_config_resp__descriptor);
2182 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2183 +}
2184 +void sr__lock_req__init
2185 + (Sr__LockReq *message)
2186 +{
2187 + static Sr__LockReq init_value = SR__LOCK_REQ__INIT;
2188 + *message = init_value;
2189 +}
2190 +size_t sr__lock_req__get_packed_size
2191 + (const Sr__LockReq *message)
2192 +{
2193 + assert(message->base.descriptor == &sr__lock_req__descriptor);
2194 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2195 +}
2196 +size_t sr__lock_req__pack
2197 + (const Sr__LockReq *message,
2198 + uint8_t *out)
2199 +{
2200 + assert(message->base.descriptor == &sr__lock_req__descriptor);
2201 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2202 +}
2203 +size_t sr__lock_req__pack_to_buffer
2204 + (const Sr__LockReq *message,
2205 + ProtobufCBuffer *buffer)
2206 +{
2207 + assert(message->base.descriptor == &sr__lock_req__descriptor);
2208 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2209 +}
2210 +Sr__LockReq *
2211 + sr__lock_req__unpack
2212 + (ProtobufCAllocator *allocator,
2213 + size_t len,
2214 + const uint8_t *data)
2215 +{
2216 + return (Sr__LockReq *)
2217 + protobuf_c_message_unpack (&sr__lock_req__descriptor,
2218 + allocator, len, data);
2219 +}
2220 +void sr__lock_req__free_unpacked
2221 + (Sr__LockReq *message,
2222 + ProtobufCAllocator *allocator)
2223 +{
2224 + assert(message->base.descriptor == &sr__lock_req__descriptor);
2225 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2226 +}
2227 +void sr__lock_resp__init
2228 + (Sr__LockResp *message)
2229 +{
2230 + static Sr__LockResp init_value = SR__LOCK_RESP__INIT;
2231 + *message = init_value;
2232 +}
2233 +size_t sr__lock_resp__get_packed_size
2234 + (const Sr__LockResp *message)
2235 +{
2236 + assert(message->base.descriptor == &sr__lock_resp__descriptor);
2237 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2238 +}
2239 +size_t sr__lock_resp__pack
2240 + (const Sr__LockResp *message,
2241 + uint8_t *out)
2242 +{
2243 + assert(message->base.descriptor == &sr__lock_resp__descriptor);
2244 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2245 +}
2246 +size_t sr__lock_resp__pack_to_buffer
2247 + (const Sr__LockResp *message,
2248 + ProtobufCBuffer *buffer)
2249 +{
2250 + assert(message->base.descriptor == &sr__lock_resp__descriptor);
2251 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2252 +}
2253 +Sr__LockResp *
2254 + sr__lock_resp__unpack
2255 + (ProtobufCAllocator *allocator,
2256 + size_t len,
2257 + const uint8_t *data)
2258 +{
2259 + return (Sr__LockResp *)
2260 + protobuf_c_message_unpack (&sr__lock_resp__descriptor,
2261 + allocator, len, data);
2262 +}
2263 +void sr__lock_resp__free_unpacked
2264 + (Sr__LockResp *message,
2265 + ProtobufCAllocator *allocator)
2266 +{
2267 + assert(message->base.descriptor == &sr__lock_resp__descriptor);
2268 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2269 +}
2270 +void sr__unlock_req__init
2271 + (Sr__UnlockReq *message)
2272 +{
2273 + static Sr__UnlockReq init_value = SR__UNLOCK_REQ__INIT;
2274 + *message = init_value;
2275 +}
2276 +size_t sr__unlock_req__get_packed_size
2277 + (const Sr__UnlockReq *message)
2278 +{
2279 + assert(message->base.descriptor == &sr__unlock_req__descriptor);
2280 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2281 +}
2282 +size_t sr__unlock_req__pack
2283 + (const Sr__UnlockReq *message,
2284 + uint8_t *out)
2285 +{
2286 + assert(message->base.descriptor == &sr__unlock_req__descriptor);
2287 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2288 +}
2289 +size_t sr__unlock_req__pack_to_buffer
2290 + (const Sr__UnlockReq *message,
2291 + ProtobufCBuffer *buffer)
2292 +{
2293 + assert(message->base.descriptor == &sr__unlock_req__descriptor);
2294 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2295 +}
2296 +Sr__UnlockReq *
2297 + sr__unlock_req__unpack
2298 + (ProtobufCAllocator *allocator,
2299 + size_t len,
2300 + const uint8_t *data)
2301 +{
2302 + return (Sr__UnlockReq *)
2303 + protobuf_c_message_unpack (&sr__unlock_req__descriptor,
2304 + allocator, len, data);
2305 +}
2306 +void sr__unlock_req__free_unpacked
2307 + (Sr__UnlockReq *message,
2308 + ProtobufCAllocator *allocator)
2309 +{
2310 + assert(message->base.descriptor == &sr__unlock_req__descriptor);
2311 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2312 +}
2313 +void sr__unlock_resp__init
2314 + (Sr__UnlockResp *message)
2315 +{
2316 + static Sr__UnlockResp init_value = SR__UNLOCK_RESP__INIT;
2317 + *message = init_value;
2318 +}
2319 +size_t sr__unlock_resp__get_packed_size
2320 + (const Sr__UnlockResp *message)
2321 +{
2322 + assert(message->base.descriptor == &sr__unlock_resp__descriptor);
2323 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2324 +}
2325 +size_t sr__unlock_resp__pack
2326 + (const Sr__UnlockResp *message,
2327 + uint8_t *out)
2328 +{
2329 + assert(message->base.descriptor == &sr__unlock_resp__descriptor);
2330 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2331 +}
2332 +size_t sr__unlock_resp__pack_to_buffer
2333 + (const Sr__UnlockResp *message,
2334 + ProtobufCBuffer *buffer)
2335 +{
2336 + assert(message->base.descriptor == &sr__unlock_resp__descriptor);
2337 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2338 +}
2339 +Sr__UnlockResp *
2340 + sr__unlock_resp__unpack
2341 + (ProtobufCAllocator *allocator,
2342 + size_t len,
2343 + const uint8_t *data)
2344 +{
2345 + return (Sr__UnlockResp *)
2346 + protobuf_c_message_unpack (&sr__unlock_resp__descriptor,
2347 + allocator, len, data);
2348 +}
2349 +void sr__unlock_resp__free_unpacked
2350 + (Sr__UnlockResp *message,
2351 + ProtobufCAllocator *allocator)
2352 +{
2353 + assert(message->base.descriptor == &sr__unlock_resp__descriptor);
2354 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2355 +}
2356 +void sr__subscribe_req__init
2357 + (Sr__SubscribeReq *message)
2358 +{
2359 + static Sr__SubscribeReq init_value = SR__SUBSCRIBE_REQ__INIT;
2360 + *message = init_value;
2361 +}
2362 +size_t sr__subscribe_req__get_packed_size
2363 + (const Sr__SubscribeReq *message)
2364 +{
2365 + assert(message->base.descriptor == &sr__subscribe_req__descriptor);
2366 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2367 +}
2368 +size_t sr__subscribe_req__pack
2369 + (const Sr__SubscribeReq *message,
2370 + uint8_t *out)
2371 +{
2372 + assert(message->base.descriptor == &sr__subscribe_req__descriptor);
2373 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2374 +}
2375 +size_t sr__subscribe_req__pack_to_buffer
2376 + (const Sr__SubscribeReq *message,
2377 + ProtobufCBuffer *buffer)
2378 +{
2379 + assert(message->base.descriptor == &sr__subscribe_req__descriptor);
2380 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2381 +}
2382 +Sr__SubscribeReq *
2383 + sr__subscribe_req__unpack
2384 + (ProtobufCAllocator *allocator,
2385 + size_t len,
2386 + const uint8_t *data)
2387 +{
2388 + return (Sr__SubscribeReq *)
2389 + protobuf_c_message_unpack (&sr__subscribe_req__descriptor,
2390 + allocator, len, data);
2391 +}
2392 +void sr__subscribe_req__free_unpacked
2393 + (Sr__SubscribeReq *message,
2394 + ProtobufCAllocator *allocator)
2395 +{
2396 + assert(message->base.descriptor == &sr__subscribe_req__descriptor);
2397 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2398 +}
2399 +void sr__subscribe_resp__init
2400 + (Sr__SubscribeResp *message)
2401 +{
2402 + static Sr__SubscribeResp init_value = SR__SUBSCRIBE_RESP__INIT;
2403 + *message = init_value;
2404 +}
2405 +size_t sr__subscribe_resp__get_packed_size
2406 + (const Sr__SubscribeResp *message)
2407 +{
2408 + assert(message->base.descriptor == &sr__subscribe_resp__descriptor);
2409 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2410 +}
2411 +size_t sr__subscribe_resp__pack
2412 + (const Sr__SubscribeResp *message,
2413 + uint8_t *out)
2414 +{
2415 + assert(message->base.descriptor == &sr__subscribe_resp__descriptor);
2416 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2417 +}
2418 +size_t sr__subscribe_resp__pack_to_buffer
2419 + (const Sr__SubscribeResp *message,
2420 + ProtobufCBuffer *buffer)
2421 +{
2422 + assert(message->base.descriptor == &sr__subscribe_resp__descriptor);
2423 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2424 +}
2425 +Sr__SubscribeResp *
2426 + sr__subscribe_resp__unpack
2427 + (ProtobufCAllocator *allocator,
2428 + size_t len,
2429 + const uint8_t *data)
2430 +{
2431 + return (Sr__SubscribeResp *)
2432 + protobuf_c_message_unpack (&sr__subscribe_resp__descriptor,
2433 + allocator, len, data);
2434 +}
2435 +void sr__subscribe_resp__free_unpacked
2436 + (Sr__SubscribeResp *message,
2437 + ProtobufCAllocator *allocator)
2438 +{
2439 + assert(message->base.descriptor == &sr__subscribe_resp__descriptor);
2440 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2441 +}
2442 +void sr__unsubscribe_req__init
2443 + (Sr__UnsubscribeReq *message)
2444 +{
2445 + static Sr__UnsubscribeReq init_value = SR__UNSUBSCRIBE_REQ__INIT;
2446 + *message = init_value;
2447 +}
2448 +size_t sr__unsubscribe_req__get_packed_size
2449 + (const Sr__UnsubscribeReq *message)
2450 +{
2451 + assert(message->base.descriptor == &sr__unsubscribe_req__descriptor);
2452 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2453 +}
2454 +size_t sr__unsubscribe_req__pack
2455 + (const Sr__UnsubscribeReq *message,
2456 + uint8_t *out)
2457 +{
2458 + assert(message->base.descriptor == &sr__unsubscribe_req__descriptor);
2459 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2460 +}
2461 +size_t sr__unsubscribe_req__pack_to_buffer
2462 + (const Sr__UnsubscribeReq *message,
2463 + ProtobufCBuffer *buffer)
2464 +{
2465 + assert(message->base.descriptor == &sr__unsubscribe_req__descriptor);
2466 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2467 +}
2468 +Sr__UnsubscribeReq *
2469 + sr__unsubscribe_req__unpack
2470 + (ProtobufCAllocator *allocator,
2471 + size_t len,
2472 + const uint8_t *data)
2473 +{
2474 + return (Sr__UnsubscribeReq *)
2475 + protobuf_c_message_unpack (&sr__unsubscribe_req__descriptor,
2476 + allocator, len, data);
2477 +}
2478 +void sr__unsubscribe_req__free_unpacked
2479 + (Sr__UnsubscribeReq *message,
2480 + ProtobufCAllocator *allocator)
2481 +{
2482 + assert(message->base.descriptor == &sr__unsubscribe_req__descriptor);
2483 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2484 +}
2485 +void sr__unsubscribe_resp__init
2486 + (Sr__UnsubscribeResp *message)
2487 +{
2488 + static Sr__UnsubscribeResp init_value = SR__UNSUBSCRIBE_RESP__INIT;
2489 + *message = init_value;
2490 +}
2491 +size_t sr__unsubscribe_resp__get_packed_size
2492 + (const Sr__UnsubscribeResp *message)
2493 +{
2494 + assert(message->base.descriptor == &sr__unsubscribe_resp__descriptor);
2495 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2496 +}
2497 +size_t sr__unsubscribe_resp__pack
2498 + (const Sr__UnsubscribeResp *message,
2499 + uint8_t *out)
2500 +{
2501 + assert(message->base.descriptor == &sr__unsubscribe_resp__descriptor);
2502 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2503 +}
2504 +size_t sr__unsubscribe_resp__pack_to_buffer
2505 + (const Sr__UnsubscribeResp *message,
2506 + ProtobufCBuffer *buffer)
2507 +{
2508 + assert(message->base.descriptor == &sr__unsubscribe_resp__descriptor);
2509 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2510 +}
2511 +Sr__UnsubscribeResp *
2512 + sr__unsubscribe_resp__unpack
2513 + (ProtobufCAllocator *allocator,
2514 + size_t len,
2515 + const uint8_t *data)
2516 +{
2517 + return (Sr__UnsubscribeResp *)
2518 + protobuf_c_message_unpack (&sr__unsubscribe_resp__descriptor,
2519 + allocator, len, data);
2520 +}
2521 +void sr__unsubscribe_resp__free_unpacked
2522 + (Sr__UnsubscribeResp *message,
2523 + ProtobufCAllocator *allocator)
2524 +{
2525 + assert(message->base.descriptor == &sr__unsubscribe_resp__descriptor);
2526 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2527 +}
2528 +void sr__check_enabled_running_req__init
2529 + (Sr__CheckEnabledRunningReq *message)
2530 +{
2531 + static Sr__CheckEnabledRunningReq init_value = SR__CHECK_ENABLED_RUNNING_REQ__INIT;
2532 + *message = init_value;
2533 +}
2534 +size_t sr__check_enabled_running_req__get_packed_size
2535 + (const Sr__CheckEnabledRunningReq *message)
2536 +{
2537 + assert(message->base.descriptor == &sr__check_enabled_running_req__descriptor);
2538 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2539 +}
2540 +size_t sr__check_enabled_running_req__pack
2541 + (const Sr__CheckEnabledRunningReq *message,
2542 + uint8_t *out)
2543 +{
2544 + assert(message->base.descriptor == &sr__check_enabled_running_req__descriptor);
2545 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2546 +}
2547 +size_t sr__check_enabled_running_req__pack_to_buffer
2548 + (const Sr__CheckEnabledRunningReq *message,
2549 + ProtobufCBuffer *buffer)
2550 +{
2551 + assert(message->base.descriptor == &sr__check_enabled_running_req__descriptor);
2552 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2553 +}
2554 +Sr__CheckEnabledRunningReq *
2555 + sr__check_enabled_running_req__unpack
2556 + (ProtobufCAllocator *allocator,
2557 + size_t len,
2558 + const uint8_t *data)
2559 +{
2560 + return (Sr__CheckEnabledRunningReq *)
2561 + protobuf_c_message_unpack (&sr__check_enabled_running_req__descriptor,
2562 + allocator, len, data);
2563 +}
2564 +void sr__check_enabled_running_req__free_unpacked
2565 + (Sr__CheckEnabledRunningReq *message,
2566 + ProtobufCAllocator *allocator)
2567 +{
2568 + assert(message->base.descriptor == &sr__check_enabled_running_req__descriptor);
2569 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2570 +}
2571 +void sr__check_enabled_running_resp__init
2572 + (Sr__CheckEnabledRunningResp *message)
2573 +{
2574 + static Sr__CheckEnabledRunningResp init_value = SR__CHECK_ENABLED_RUNNING_RESP__INIT;
2575 + *message = init_value;
2576 +}
2577 +size_t sr__check_enabled_running_resp__get_packed_size
2578 + (const Sr__CheckEnabledRunningResp *message)
2579 +{
2580 + assert(message->base.descriptor == &sr__check_enabled_running_resp__descriptor);
2581 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2582 +}
2583 +size_t sr__check_enabled_running_resp__pack
2584 + (const Sr__CheckEnabledRunningResp *message,
2585 + uint8_t *out)
2586 +{
2587 + assert(message->base.descriptor == &sr__check_enabled_running_resp__descriptor);
2588 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2589 +}
2590 +size_t sr__check_enabled_running_resp__pack_to_buffer
2591 + (const Sr__CheckEnabledRunningResp *message,
2592 + ProtobufCBuffer *buffer)
2593 +{
2594 + assert(message->base.descriptor == &sr__check_enabled_running_resp__descriptor);
2595 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2596 +}
2597 +Sr__CheckEnabledRunningResp *
2598 + sr__check_enabled_running_resp__unpack
2599 + (ProtobufCAllocator *allocator,
2600 + size_t len,
2601 + const uint8_t *data)
2602 +{
2603 + return (Sr__CheckEnabledRunningResp *)
2604 + protobuf_c_message_unpack (&sr__check_enabled_running_resp__descriptor,
2605 + allocator, len, data);
2606 +}
2607 +void sr__check_enabled_running_resp__free_unpacked
2608 + (Sr__CheckEnabledRunningResp *message,
2609 + ProtobufCAllocator *allocator)
2610 +{
2611 + assert(message->base.descriptor == &sr__check_enabled_running_resp__descriptor);
2612 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2613 +}
2614 +void sr__module_install_notification__init
2615 + (Sr__ModuleInstallNotification *message)
2616 +{
2617 + static Sr__ModuleInstallNotification init_value = SR__MODULE_INSTALL_NOTIFICATION__INIT;
2618 + *message = init_value;
2619 +}
2620 +size_t sr__module_install_notification__get_packed_size
2621 + (const Sr__ModuleInstallNotification *message)
2622 +{
2623 + assert(message->base.descriptor == &sr__module_install_notification__descriptor);
2624 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2625 +}
2626 +size_t sr__module_install_notification__pack
2627 + (const Sr__ModuleInstallNotification *message,
2628 + uint8_t *out)
2629 +{
2630 + assert(message->base.descriptor == &sr__module_install_notification__descriptor);
2631 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2632 +}
2633 +size_t sr__module_install_notification__pack_to_buffer
2634 + (const Sr__ModuleInstallNotification *message,
2635 + ProtobufCBuffer *buffer)
2636 +{
2637 + assert(message->base.descriptor == &sr__module_install_notification__descriptor);
2638 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2639 +}
2640 +Sr__ModuleInstallNotification *
2641 + sr__module_install_notification__unpack
2642 + (ProtobufCAllocator *allocator,
2643 + size_t len,
2644 + const uint8_t *data)
2645 +{
2646 + return (Sr__ModuleInstallNotification *)
2647 + protobuf_c_message_unpack (&sr__module_install_notification__descriptor,
2648 + allocator, len, data);
2649 +}
2650 +void sr__module_install_notification__free_unpacked
2651 + (Sr__ModuleInstallNotification *message,
2652 + ProtobufCAllocator *allocator)
2653 +{
2654 + assert(message->base.descriptor == &sr__module_install_notification__descriptor);
2655 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2656 +}
2657 +void sr__feature_enable_notification__init
2658 + (Sr__FeatureEnableNotification *message)
2659 +{
2660 + static Sr__FeatureEnableNotification init_value = SR__FEATURE_ENABLE_NOTIFICATION__INIT;
2661 + *message = init_value;
2662 +}
2663 +size_t sr__feature_enable_notification__get_packed_size
2664 + (const Sr__FeatureEnableNotification *message)
2665 +{
2666 + assert(message->base.descriptor == &sr__feature_enable_notification__descriptor);
2667 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2668 +}
2669 +size_t sr__feature_enable_notification__pack
2670 + (const Sr__FeatureEnableNotification *message,
2671 + uint8_t *out)
2672 +{
2673 + assert(message->base.descriptor == &sr__feature_enable_notification__descriptor);
2674 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2675 +}
2676 +size_t sr__feature_enable_notification__pack_to_buffer
2677 + (const Sr__FeatureEnableNotification *message,
2678 + ProtobufCBuffer *buffer)
2679 +{
2680 + assert(message->base.descriptor == &sr__feature_enable_notification__descriptor);
2681 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2682 +}
2683 +Sr__FeatureEnableNotification *
2684 + sr__feature_enable_notification__unpack
2685 + (ProtobufCAllocator *allocator,
2686 + size_t len,
2687 + const uint8_t *data)
2688 +{
2689 + return (Sr__FeatureEnableNotification *)
2690 + protobuf_c_message_unpack (&sr__feature_enable_notification__descriptor,
2691 + allocator, len, data);
2692 +}
2693 +void sr__feature_enable_notification__free_unpacked
2694 + (Sr__FeatureEnableNotification *message,
2695 + ProtobufCAllocator *allocator)
2696 +{
2697 + assert(message->base.descriptor == &sr__feature_enable_notification__descriptor);
2698 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2699 +}
2700 +void sr__module_change_notification__init
2701 + (Sr__ModuleChangeNotification *message)
2702 +{
2703 + static Sr__ModuleChangeNotification init_value = SR__MODULE_CHANGE_NOTIFICATION__INIT;
2704 + *message = init_value;
2705 +}
2706 +size_t sr__module_change_notification__get_packed_size
2707 + (const Sr__ModuleChangeNotification *message)
2708 +{
2709 + assert(message->base.descriptor == &sr__module_change_notification__descriptor);
2710 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2711 +}
2712 +size_t sr__module_change_notification__pack
2713 + (const Sr__ModuleChangeNotification *message,
2714 + uint8_t *out)
2715 +{
2716 + assert(message->base.descriptor == &sr__module_change_notification__descriptor);
2717 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2718 +}
2719 +size_t sr__module_change_notification__pack_to_buffer
2720 + (const Sr__ModuleChangeNotification *message,
2721 + ProtobufCBuffer *buffer)
2722 +{
2723 + assert(message->base.descriptor == &sr__module_change_notification__descriptor);
2724 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2725 +}
2726 +Sr__ModuleChangeNotification *
2727 + sr__module_change_notification__unpack
2728 + (ProtobufCAllocator *allocator,
2729 + size_t len,
2730 + const uint8_t *data)
2731 +{
2732 + return (Sr__ModuleChangeNotification *)
2733 + protobuf_c_message_unpack (&sr__module_change_notification__descriptor,
2734 + allocator, len, data);
2735 +}
2736 +void sr__module_change_notification__free_unpacked
2737 + (Sr__ModuleChangeNotification *message,
2738 + ProtobufCAllocator *allocator)
2739 +{
2740 + assert(message->base.descriptor == &sr__module_change_notification__descriptor);
2741 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2742 +}
2743 +void sr__subtree_change_notification__init
2744 + (Sr__SubtreeChangeNotification *message)
2745 +{
2746 + static Sr__SubtreeChangeNotification init_value = SR__SUBTREE_CHANGE_NOTIFICATION__INIT;
2747 + *message = init_value;
2748 +}
2749 +size_t sr__subtree_change_notification__get_packed_size
2750 + (const Sr__SubtreeChangeNotification *message)
2751 +{
2752 + assert(message->base.descriptor == &sr__subtree_change_notification__descriptor);
2753 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2754 +}
2755 +size_t sr__subtree_change_notification__pack
2756 + (const Sr__SubtreeChangeNotification *message,
2757 + uint8_t *out)
2758 +{
2759 + assert(message->base.descriptor == &sr__subtree_change_notification__descriptor);
2760 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2761 +}
2762 +size_t sr__subtree_change_notification__pack_to_buffer
2763 + (const Sr__SubtreeChangeNotification *message,
2764 + ProtobufCBuffer *buffer)
2765 +{
2766 + assert(message->base.descriptor == &sr__subtree_change_notification__descriptor);
2767 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2768 +}
2769 +Sr__SubtreeChangeNotification *
2770 + sr__subtree_change_notification__unpack
2771 + (ProtobufCAllocator *allocator,
2772 + size_t len,
2773 + const uint8_t *data)
2774 +{
2775 + return (Sr__SubtreeChangeNotification *)
2776 + protobuf_c_message_unpack (&sr__subtree_change_notification__descriptor,
2777 + allocator, len, data);
2778 +}
2779 +void sr__subtree_change_notification__free_unpacked
2780 + (Sr__SubtreeChangeNotification *message,
2781 + ProtobufCAllocator *allocator)
2782 +{
2783 + assert(message->base.descriptor == &sr__subtree_change_notification__descriptor);
2784 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2785 +}
2786 +void sr__change__init
2787 + (Sr__Change *message)
2788 +{
2789 + static Sr__Change init_value = SR__CHANGE__INIT;
2790 + *message = init_value;
2791 +}
2792 +size_t sr__change__get_packed_size
2793 + (const Sr__Change *message)
2794 +{
2795 + assert(message->base.descriptor == &sr__change__descriptor);
2796 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2797 +}
2798 +size_t sr__change__pack
2799 + (const Sr__Change *message,
2800 + uint8_t *out)
2801 +{
2802 + assert(message->base.descriptor == &sr__change__descriptor);
2803 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2804 +}
2805 +size_t sr__change__pack_to_buffer
2806 + (const Sr__Change *message,
2807 + ProtobufCBuffer *buffer)
2808 +{
2809 + assert(message->base.descriptor == &sr__change__descriptor);
2810 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2811 +}
2812 +Sr__Change *
2813 + sr__change__unpack
2814 + (ProtobufCAllocator *allocator,
2815 + size_t len,
2816 + const uint8_t *data)
2817 +{
2818 + return (Sr__Change *)
2819 + protobuf_c_message_unpack (&sr__change__descriptor,
2820 + allocator, len, data);
2821 +}
2822 +void sr__change__free_unpacked
2823 + (Sr__Change *message,
2824 + ProtobufCAllocator *allocator)
2825 +{
2826 + assert(message->base.descriptor == &sr__change__descriptor);
2827 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2828 +}
2829 +void sr__get_changes_req__init
2830 + (Sr__GetChangesReq *message)
2831 +{
2832 + static Sr__GetChangesReq init_value = SR__GET_CHANGES_REQ__INIT;
2833 + *message = init_value;
2834 +}
2835 +size_t sr__get_changes_req__get_packed_size
2836 + (const Sr__GetChangesReq *message)
2837 +{
2838 + assert(message->base.descriptor == &sr__get_changes_req__descriptor);
2839 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2840 +}
2841 +size_t sr__get_changes_req__pack
2842 + (const Sr__GetChangesReq *message,
2843 + uint8_t *out)
2844 +{
2845 + assert(message->base.descriptor == &sr__get_changes_req__descriptor);
2846 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2847 +}
2848 +size_t sr__get_changes_req__pack_to_buffer
2849 + (const Sr__GetChangesReq *message,
2850 + ProtobufCBuffer *buffer)
2851 +{
2852 + assert(message->base.descriptor == &sr__get_changes_req__descriptor);
2853 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2854 +}
2855 +Sr__GetChangesReq *
2856 + sr__get_changes_req__unpack
2857 + (ProtobufCAllocator *allocator,
2858 + size_t len,
2859 + const uint8_t *data)
2860 +{
2861 + return (Sr__GetChangesReq *)
2862 + protobuf_c_message_unpack (&sr__get_changes_req__descriptor,
2863 + allocator, len, data);
2864 +}
2865 +void sr__get_changes_req__free_unpacked
2866 + (Sr__GetChangesReq *message,
2867 + ProtobufCAllocator *allocator)
2868 +{
2869 + assert(message->base.descriptor == &sr__get_changes_req__descriptor);
2870 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2871 +}
2872 +void sr__get_changes_resp__init
2873 + (Sr__GetChangesResp *message)
2874 +{
2875 + static Sr__GetChangesResp init_value = SR__GET_CHANGES_RESP__INIT;
2876 + *message = init_value;
2877 +}
2878 +size_t sr__get_changes_resp__get_packed_size
2879 + (const Sr__GetChangesResp *message)
2880 +{
2881 + assert(message->base.descriptor == &sr__get_changes_resp__descriptor);
2882 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2883 +}
2884 +size_t sr__get_changes_resp__pack
2885 + (const Sr__GetChangesResp *message,
2886 + uint8_t *out)
2887 +{
2888 + assert(message->base.descriptor == &sr__get_changes_resp__descriptor);
2889 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2890 +}
2891 +size_t sr__get_changes_resp__pack_to_buffer
2892 + (const Sr__GetChangesResp *message,
2893 + ProtobufCBuffer *buffer)
2894 +{
2895 + assert(message->base.descriptor == &sr__get_changes_resp__descriptor);
2896 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2897 +}
2898 +Sr__GetChangesResp *
2899 + sr__get_changes_resp__unpack
2900 + (ProtobufCAllocator *allocator,
2901 + size_t len,
2902 + const uint8_t *data)
2903 +{
2904 + return (Sr__GetChangesResp *)
2905 + protobuf_c_message_unpack (&sr__get_changes_resp__descriptor,
2906 + allocator, len, data);
2907 +}
2908 +void sr__get_changes_resp__free_unpacked
2909 + (Sr__GetChangesResp *message,
2910 + ProtobufCAllocator *allocator)
2911 +{
2912 + assert(message->base.descriptor == &sr__get_changes_resp__descriptor);
2913 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2914 +}
2915 +void sr__check_exec_perm_req__init
2916 + (Sr__CheckExecPermReq *message)
2917 +{
2918 + static Sr__CheckExecPermReq init_value = SR__CHECK_EXEC_PERM_REQ__INIT;
2919 + *message = init_value;
2920 +}
2921 +size_t sr__check_exec_perm_req__get_packed_size
2922 + (const Sr__CheckExecPermReq *message)
2923 +{
2924 + assert(message->base.descriptor == &sr__check_exec_perm_req__descriptor);
2925 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2926 +}
2927 +size_t sr__check_exec_perm_req__pack
2928 + (const Sr__CheckExecPermReq *message,
2929 + uint8_t *out)
2930 +{
2931 + assert(message->base.descriptor == &sr__check_exec_perm_req__descriptor);
2932 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2933 +}
2934 +size_t sr__check_exec_perm_req__pack_to_buffer
2935 + (const Sr__CheckExecPermReq *message,
2936 + ProtobufCBuffer *buffer)
2937 +{
2938 + assert(message->base.descriptor == &sr__check_exec_perm_req__descriptor);
2939 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2940 +}
2941 +Sr__CheckExecPermReq *
2942 + sr__check_exec_perm_req__unpack
2943 + (ProtobufCAllocator *allocator,
2944 + size_t len,
2945 + const uint8_t *data)
2946 +{
2947 + return (Sr__CheckExecPermReq *)
2948 + protobuf_c_message_unpack (&sr__check_exec_perm_req__descriptor,
2949 + allocator, len, data);
2950 +}
2951 +void sr__check_exec_perm_req__free_unpacked
2952 + (Sr__CheckExecPermReq *message,
2953 + ProtobufCAllocator *allocator)
2954 +{
2955 + assert(message->base.descriptor == &sr__check_exec_perm_req__descriptor);
2956 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
2957 +}
2958 +void sr__check_exec_perm_resp__init
2959 + (Sr__CheckExecPermResp *message)
2960 +{
2961 + static Sr__CheckExecPermResp init_value = SR__CHECK_EXEC_PERM_RESP__INIT;
2962 + *message = init_value;
2963 +}
2964 +size_t sr__check_exec_perm_resp__get_packed_size
2965 + (const Sr__CheckExecPermResp *message)
2966 +{
2967 + assert(message->base.descriptor == &sr__check_exec_perm_resp__descriptor);
2968 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
2969 +}
2970 +size_t sr__check_exec_perm_resp__pack
2971 + (const Sr__CheckExecPermResp *message,
2972 + uint8_t *out)
2973 +{
2974 + assert(message->base.descriptor == &sr__check_exec_perm_resp__descriptor);
2975 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
2976 +}
2977 +size_t sr__check_exec_perm_resp__pack_to_buffer
2978 + (const Sr__CheckExecPermResp *message,
2979 + ProtobufCBuffer *buffer)
2980 +{
2981 + assert(message->base.descriptor == &sr__check_exec_perm_resp__descriptor);
2982 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
2983 +}
2984 +Sr__CheckExecPermResp *
2985 + sr__check_exec_perm_resp__unpack
2986 + (ProtobufCAllocator *allocator,
2987 + size_t len,
2988 + const uint8_t *data)
2989 +{
2990 + return (Sr__CheckExecPermResp *)
2991 + protobuf_c_message_unpack (&sr__check_exec_perm_resp__descriptor,
2992 + allocator, len, data);
2993 +}
2994 +void sr__check_exec_perm_resp__free_unpacked
2995 + (Sr__CheckExecPermResp *message,
2996 + ProtobufCAllocator *allocator)
2997 +{
2998 + assert(message->base.descriptor == &sr__check_exec_perm_resp__descriptor);
2999 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
3000 +}
3001 +void sr__rpcreq__init
3002 + (Sr__RPCReq *message)
3003 +{
3004 + static Sr__RPCReq init_value = SR__RPCREQ__INIT;
3005 + *message = init_value;
3006 +}
3007 +size_t sr__rpcreq__get_packed_size
3008 + (const Sr__RPCReq *message)
3009 +{
3010 + assert(message->base.descriptor == &sr__rpcreq__descriptor);
3011 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
3012 +}
3013 +size_t sr__rpcreq__pack
3014 + (const Sr__RPCReq *message,
3015 + uint8_t *out)
3016 +{
3017 + assert(message->base.descriptor == &sr__rpcreq__descriptor);
3018 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
3019 +}
3020 +size_t sr__rpcreq__pack_to_buffer
3021 + (const Sr__RPCReq *message,
3022 + ProtobufCBuffer *buffer)
3023 +{
3024 + assert(message->base.descriptor == &sr__rpcreq__descriptor);
3025 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
3026 +}
3027 +Sr__RPCReq *
3028 + sr__rpcreq__unpack
3029 + (ProtobufCAllocator *allocator,
3030 + size_t len,
3031 + const uint8_t *data)
3032 +{
3033 + return (Sr__RPCReq *)
3034 + protobuf_c_message_unpack (&sr__rpcreq__descriptor,
3035 + allocator, len, data);
3036 +}
3037 +void sr__rpcreq__free_unpacked
3038 + (Sr__RPCReq *message,
3039 + ProtobufCAllocator *allocator)
3040 +{
3041 + assert(message->base.descriptor == &sr__rpcreq__descriptor);
3042 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
3043 +}
3044 +void sr__rpcresp__init
3045 + (Sr__RPCResp *message)
3046 +{
3047 + static Sr__RPCResp init_value = SR__RPCRESP__INIT;
3048 + *message = init_value;
3049 +}
3050 +size_t sr__rpcresp__get_packed_size
3051 + (const Sr__RPCResp *message)
3052 +{
3053 + assert(message->base.descriptor == &sr__rpcresp__descriptor);
3054 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
3055 +}
3056 +size_t sr__rpcresp__pack
3057 + (const Sr__RPCResp *message,
3058 + uint8_t *out)
3059 +{
3060 + assert(message->base.descriptor == &sr__rpcresp__descriptor);
3061 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
3062 +}
3063 +size_t sr__rpcresp__pack_to_buffer
3064 + (const Sr__RPCResp *message,
3065 + ProtobufCBuffer *buffer)
3066 +{
3067 + assert(message->base.descriptor == &sr__rpcresp__descriptor);
3068 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
3069 +}
3070 +Sr__RPCResp *
3071 + sr__rpcresp__unpack
3072 + (ProtobufCAllocator *allocator,
3073 + size_t len,
3074 + const uint8_t *data)
3075 +{
3076 + return (Sr__RPCResp *)
3077 + protobuf_c_message_unpack (&sr__rpcresp__descriptor,
3078 + allocator, len, data);
3079 +}
3080 +void sr__rpcresp__free_unpacked
3081 + (Sr__RPCResp *message,
3082 + ProtobufCAllocator *allocator)
3083 +{
3084 + assert(message->base.descriptor == &sr__rpcresp__descriptor);
3085 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
3086 +}
3087 +void sr__event_notif_req__init
3088 + (Sr__EventNotifReq *message)
3089 +{
3090 + static Sr__EventNotifReq init_value = SR__EVENT_NOTIF_REQ__INIT;
3091 + *message = init_value;
3092 +}
3093 +size_t sr__event_notif_req__get_packed_size
3094 + (const Sr__EventNotifReq *message)
3095 +{
3096 + assert(message->base.descriptor == &sr__event_notif_req__descriptor);
3097 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
3098 +}
3099 +size_t sr__event_notif_req__pack
3100 + (const Sr__EventNotifReq *message,
3101 + uint8_t *out)
3102 +{
3103 + assert(message->base.descriptor == &sr__event_notif_req__descriptor);
3104 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
3105 +}
3106 +size_t sr__event_notif_req__pack_to_buffer
3107 + (const Sr__EventNotifReq *message,
3108 + ProtobufCBuffer *buffer)
3109 +{
3110 + assert(message->base.descriptor == &sr__event_notif_req__descriptor);
3111 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
3112 +}
3113 +Sr__EventNotifReq *
3114 + sr__event_notif_req__unpack
3115 + (ProtobufCAllocator *allocator,
3116 + size_t len,
3117 + const uint8_t *data)
3118 +{
3119 + return (Sr__EventNotifReq *)
3120 + protobuf_c_message_unpack (&sr__event_notif_req__descriptor,
3121 + allocator, len, data);
3122 +}
3123 +void sr__event_notif_req__free_unpacked
3124 + (Sr__EventNotifReq *message,
3125 + ProtobufCAllocator *allocator)
3126 +{
3127 + assert(message->base.descriptor == &sr__event_notif_req__descriptor);
3128 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
3129 +}
3130 +void sr__event_notif_resp__init
3131 + (Sr__EventNotifResp *message)
3132 +{
3133 + static Sr__EventNotifResp init_value = SR__EVENT_NOTIF_RESP__INIT;
3134 + *message = init_value;
3135 +}
3136 +size_t sr__event_notif_resp__get_packed_size
3137 + (const Sr__EventNotifResp *message)
3138 +{
3139 + assert(message->base.descriptor == &sr__event_notif_resp__descriptor);
3140 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
3141 +}
3142 +size_t sr__event_notif_resp__pack
3143 + (const Sr__EventNotifResp *message,
3144 + uint8_t *out)
3145 +{
3146 + assert(message->base.descriptor == &sr__event_notif_resp__descriptor);
3147 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
3148 +}
3149 +size_t sr__event_notif_resp__pack_to_buffer
3150 + (const Sr__EventNotifResp *message,
3151 + ProtobufCBuffer *buffer)
3152 +{
3153 + assert(message->base.descriptor == &sr__event_notif_resp__descriptor);
3154 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
3155 +}
3156 +Sr__EventNotifResp *
3157 + sr__event_notif_resp__unpack
3158 + (ProtobufCAllocator *allocator,
3159 + size_t len,
3160 + const uint8_t *data)
3161 +{
3162 + return (Sr__EventNotifResp *)
3163 + protobuf_c_message_unpack (&sr__event_notif_resp__descriptor,
3164 + allocator, len, data);
3165 +}
3166 +void sr__event_notif_resp__free_unpacked
3167 + (Sr__EventNotifResp *message,
3168 + ProtobufCAllocator *allocator)
3169 +{
3170 + assert(message->base.descriptor == &sr__event_notif_resp__descriptor);
3171 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
3172 +}
3173 +void sr__event_notif_replay_req__init
3174 + (Sr__EventNotifReplayReq *message)
3175 +{
3176 + static Sr__EventNotifReplayReq init_value = SR__EVENT_NOTIF_REPLAY_REQ__INIT;
3177 + *message = init_value;
3178 +}
3179 +size_t sr__event_notif_replay_req__get_packed_size
3180 + (const Sr__EventNotifReplayReq *message)
3181 +{
3182 + assert(message->base.descriptor == &sr__event_notif_replay_req__descriptor);
3183 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
3184 +}
3185 +size_t sr__event_notif_replay_req__pack
3186 + (const Sr__EventNotifReplayReq *message,
3187 + uint8_t *out)
3188 +{
3189 + assert(message->base.descriptor == &sr__event_notif_replay_req__descriptor);
3190 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
3191 +}
3192 +size_t sr__event_notif_replay_req__pack_to_buffer
3193 + (const Sr__EventNotifReplayReq *message,
3194 + ProtobufCBuffer *buffer)
3195 +{
3196 + assert(message->base.descriptor == &sr__event_notif_replay_req__descriptor);
3197 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
3198 +}
3199 +Sr__EventNotifReplayReq *
3200 + sr__event_notif_replay_req__unpack
3201 + (ProtobufCAllocator *allocator,
3202 + size_t len,
3203 + const uint8_t *data)
3204 +{
3205 + return (Sr__EventNotifReplayReq *)
3206 + protobuf_c_message_unpack (&sr__event_notif_replay_req__descriptor,
3207 + allocator, len, data);
3208 +}
3209 +void sr__event_notif_replay_req__free_unpacked
3210 + (Sr__EventNotifReplayReq *message,
3211 + ProtobufCAllocator *allocator)
3212 +{
3213 + assert(message->base.descriptor == &sr__event_notif_replay_req__descriptor);
3214 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
3215 +}
3216 +void sr__event_notif_replay_resp__init
3217 + (Sr__EventNotifReplayResp *message)
3218 +{
3219 + static Sr__EventNotifReplayResp init_value = SR__EVENT_NOTIF_REPLAY_RESP__INIT;
3220 + *message = init_value;
3221 +}
3222 +size_t sr__event_notif_replay_resp__get_packed_size
3223 + (const Sr__EventNotifReplayResp *message)
3224 +{
3225 + assert(message->base.descriptor == &sr__event_notif_replay_resp__descriptor);
3226 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
3227 +}
3228 +size_t sr__event_notif_replay_resp__pack
3229 + (const Sr__EventNotifReplayResp *message,
3230 + uint8_t *out)
3231 +{
3232 + assert(message->base.descriptor == &sr__event_notif_replay_resp__descriptor);
3233 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
3234 +}
3235 +size_t sr__event_notif_replay_resp__pack_to_buffer
3236 + (const Sr__EventNotifReplayResp *message,
3237 + ProtobufCBuffer *buffer)
3238 +{
3239 + assert(message->base.descriptor == &sr__event_notif_replay_resp__descriptor);
3240 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
3241 +}
3242 +Sr__EventNotifReplayResp *
3243 + sr__event_notif_replay_resp__unpack
3244 + (ProtobufCAllocator *allocator,
3245 + size_t len,
3246 + const uint8_t *data)
3247 +{
3248 + return (Sr__EventNotifReplayResp *)
3249 + protobuf_c_message_unpack (&sr__event_notif_replay_resp__descriptor,
3250 + allocator, len, data);
3251 +}
3252 +void sr__event_notif_replay_resp__free_unpacked
3253 + (Sr__EventNotifReplayResp *message,
3254 + ProtobufCAllocator *allocator)
3255 +{
3256 + assert(message->base.descriptor == &sr__event_notif_replay_resp__descriptor);
3257 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
3258 +}
3259 +void sr__data_provide_req__init
3260 + (Sr__DataProvideReq *message)
3261 +{
3262 + static Sr__DataProvideReq init_value = SR__DATA_PROVIDE_REQ__INIT;
3263 + *message = init_value;
3264 +}
3265 +size_t sr__data_provide_req__get_packed_size
3266 + (const Sr__DataProvideReq *message)
3267 +{
3268 + assert(message->base.descriptor == &sr__data_provide_req__descriptor);
3269 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
3270 +}
3271 +size_t sr__data_provide_req__pack
3272 + (const Sr__DataProvideReq *message,
3273 + uint8_t *out)
3274 +{
3275 + assert(message->base.descriptor == &sr__data_provide_req__descriptor);
3276 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
3277 +}
3278 +size_t sr__data_provide_req__pack_to_buffer
3279 + (const Sr__DataProvideReq *message,
3280 + ProtobufCBuffer *buffer)
3281 +{
3282 + assert(message->base.descriptor == &sr__data_provide_req__descriptor);
3283 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
3284 +}
3285 +Sr__DataProvideReq *
3286 + sr__data_provide_req__unpack
3287 + (ProtobufCAllocator *allocator,
3288 + size_t len,
3289 + const uint8_t *data)
3290 +{
3291 + return (Sr__DataProvideReq *)
3292 + protobuf_c_message_unpack (&sr__data_provide_req__descriptor,
3293 + allocator, len, data);
3294 +}
3295 +void sr__data_provide_req__free_unpacked
3296 + (Sr__DataProvideReq *message,
3297 + ProtobufCAllocator *allocator)
3298 +{
3299 + assert(message->base.descriptor == &sr__data_provide_req__descriptor);
3300 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
3301 +}
3302 +void sr__data_provide_resp__init
3303 + (Sr__DataProvideResp *message)
3304 +{
3305 + static Sr__DataProvideResp init_value = SR__DATA_PROVIDE_RESP__INIT;
3306 + *message = init_value;
3307 +}
3308 +size_t sr__data_provide_resp__get_packed_size
3309 + (const Sr__DataProvideResp *message)
3310 +{
3311 + assert(message->base.descriptor == &sr__data_provide_resp__descriptor);
3312 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
3313 +}
3314 +size_t sr__data_provide_resp__pack
3315 + (const Sr__DataProvideResp *message,
3316 + uint8_t *out)
3317 +{
3318 + assert(message->base.descriptor == &sr__data_provide_resp__descriptor);
3319 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
3320 +}
3321 +size_t sr__data_provide_resp__pack_to_buffer
3322 + (const Sr__DataProvideResp *message,
3323 + ProtobufCBuffer *buffer)
3324 +{
3325 + assert(message->base.descriptor == &sr__data_provide_resp__descriptor);
3326 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
3327 +}
3328 +Sr__DataProvideResp *
3329 + sr__data_provide_resp__unpack
3330 + (ProtobufCAllocator *allocator,
3331 + size_t len,
3332 + const uint8_t *data)
3333 +{
3334 + return (Sr__DataProvideResp *)
3335 + protobuf_c_message_unpack (&sr__data_provide_resp__descriptor,
3336 + allocator, len, data);
3337 +}
3338 +void sr__data_provide_resp__free_unpacked
3339 + (Sr__DataProvideResp *message,
3340 + ProtobufCAllocator *allocator)
3341 +{
3342 + assert(message->base.descriptor == &sr__data_provide_resp__descriptor);
3343 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
3344 +}
3345 +void sr__module_install_req__init
3346 + (Sr__ModuleInstallReq *message)
3347 +{
3348 + static Sr__ModuleInstallReq init_value = SR__MODULE_INSTALL_REQ__INIT;
3349 + *message = init_value;
3350 +}
3351 +size_t sr__module_install_req__get_packed_size
3352 + (const Sr__ModuleInstallReq *message)
3353 +{
3354 + assert(message->base.descriptor == &sr__module_install_req__descriptor);
3355 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
3356 +}
3357 +size_t sr__module_install_req__pack
3358 + (const Sr__ModuleInstallReq *message,
3359 + uint8_t *out)
3360 +{
3361 + assert(message->base.descriptor == &sr__module_install_req__descriptor);
3362 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
3363 +}
3364 +size_t sr__module_install_req__pack_to_buffer
3365 + (const Sr__ModuleInstallReq *message,
3366 + ProtobufCBuffer *buffer)
3367 +{
3368 + assert(message->base.descriptor == &sr__module_install_req__descriptor);
3369 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
3370 +}
3371 +Sr__ModuleInstallReq *
3372 + sr__module_install_req__unpack
3373 + (ProtobufCAllocator *allocator,
3374 + size_t len,
3375 + const uint8_t *data)
3376 +{
3377 + return (Sr__ModuleInstallReq *)
3378 + protobuf_c_message_unpack (&sr__module_install_req__descriptor,
3379 + allocator, len, data);
3380 +}
3381 +void sr__module_install_req__free_unpacked
3382 + (Sr__ModuleInstallReq *message,
3383 + ProtobufCAllocator *allocator)
3384 +{
3385 + assert(message->base.descriptor == &sr__module_install_req__descriptor);
3386 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
3387 +}
3388 +void sr__module_install_resp__init
3389 + (Sr__ModuleInstallResp *message)
3390 +{
3391 + static Sr__ModuleInstallResp init_value = SR__MODULE_INSTALL_RESP__INIT;
3392 + *message = init_value;
3393 +}
3394 +size_t sr__module_install_resp__get_packed_size
3395 + (const Sr__ModuleInstallResp *message)
3396 +{
3397 + assert(message->base.descriptor == &sr__module_install_resp__descriptor);
3398 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
3399 +}
3400 +size_t sr__module_install_resp__pack
3401 + (const Sr__ModuleInstallResp *message,
3402 + uint8_t *out)
3403 +{
3404 + assert(message->base.descriptor == &sr__module_install_resp__descriptor);
3405 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
3406 +}
3407 +size_t sr__module_install_resp__pack_to_buffer
3408 + (const Sr__ModuleInstallResp *message,
3409 + ProtobufCBuffer *buffer)
3410 +{
3411 + assert(message->base.descriptor == &sr__module_install_resp__descriptor);
3412 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
3413 +}
3414 +Sr__ModuleInstallResp *
3415 + sr__module_install_resp__unpack
3416 + (ProtobufCAllocator *allocator,
3417 + size_t len,
3418 + const uint8_t *data)
3419 +{
3420 + return (Sr__ModuleInstallResp *)
3421 + protobuf_c_message_unpack (&sr__module_install_resp__descriptor,
3422 + allocator, len, data);
3423 +}
3424 +void sr__module_install_resp__free_unpacked
3425 + (Sr__ModuleInstallResp *message,
3426 + ProtobufCAllocator *allocator)
3427 +{
3428 + assert(message->base.descriptor == &sr__module_install_resp__descriptor);
3429 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
3430 +}
3431 +void sr__feature_enable_req__init
3432 + (Sr__FeatureEnableReq *message)
3433 +{
3434 + static Sr__FeatureEnableReq init_value = SR__FEATURE_ENABLE_REQ__INIT;
3435 + *message = init_value;
3436 +}
3437 +size_t sr__feature_enable_req__get_packed_size
3438 + (const Sr__FeatureEnableReq *message)
3439 +{
3440 + assert(message->base.descriptor == &sr__feature_enable_req__descriptor);
3441 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
3442 +}
3443 +size_t sr__feature_enable_req__pack
3444 + (const Sr__FeatureEnableReq *message,
3445 + uint8_t *out)
3446 +{
3447 + assert(message->base.descriptor == &sr__feature_enable_req__descriptor);
3448 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
3449 +}
3450 +size_t sr__feature_enable_req__pack_to_buffer
3451 + (const Sr__FeatureEnableReq *message,
3452 + ProtobufCBuffer *buffer)
3453 +{
3454 + assert(message->base.descriptor == &sr__feature_enable_req__descriptor);
3455 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
3456 +}
3457 +Sr__FeatureEnableReq *
3458 + sr__feature_enable_req__unpack
3459 + (ProtobufCAllocator *allocator,
3460 + size_t len,
3461 + const uint8_t *data)
3462 +{
3463 + return (Sr__FeatureEnableReq *)
3464 + protobuf_c_message_unpack (&sr__feature_enable_req__descriptor,
3465 + allocator, len, data);
3466 +}
3467 +void sr__feature_enable_req__free_unpacked
3468 + (Sr__FeatureEnableReq *message,
3469 + ProtobufCAllocator *allocator)
3470 +{
3471 + assert(message->base.descriptor == &sr__feature_enable_req__descriptor);
3472 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
3473 +}
3474 +void sr__feature_enable_resp__init
3475 + (Sr__FeatureEnableResp *message)
3476 +{
3477 + static Sr__FeatureEnableResp init_value = SR__FEATURE_ENABLE_RESP__INIT;
3478 + *message = init_value;
3479 +}
3480 +size_t sr__feature_enable_resp__get_packed_size
3481 + (const Sr__FeatureEnableResp *message)
3482 +{
3483 + assert(message->base.descriptor == &sr__feature_enable_resp__descriptor);
3484 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
3485 +}
3486 +size_t sr__feature_enable_resp__pack
3487 + (const Sr__FeatureEnableResp *message,
3488 + uint8_t *out)
3489 +{
3490 + assert(message->base.descriptor == &sr__feature_enable_resp__descriptor);
3491 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
3492 +}
3493 +size_t sr__feature_enable_resp__pack_to_buffer
3494 + (const Sr__FeatureEnableResp *message,
3495 + ProtobufCBuffer *buffer)
3496 +{
3497 + assert(message->base.descriptor == &sr__feature_enable_resp__descriptor);
3498 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
3499 +}
3500 +Sr__FeatureEnableResp *
3501 + sr__feature_enable_resp__unpack
3502 + (ProtobufCAllocator *allocator,
3503 + size_t len,
3504 + const uint8_t *data)
3505 +{
3506 + return (Sr__FeatureEnableResp *)
3507 + protobuf_c_message_unpack (&sr__feature_enable_resp__descriptor,
3508 + allocator, len, data);
3509 +}
3510 +void sr__feature_enable_resp__free_unpacked
3511 + (Sr__FeatureEnableResp *message,
3512 + ProtobufCAllocator *allocator)
3513 +{
3514 + assert(message->base.descriptor == &sr__feature_enable_resp__descriptor);
3515 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
3516 +}
3517 +void sr__unsubscribe_destination_req__init
3518 + (Sr__UnsubscribeDestinationReq *message)
3519 +{
3520 + static Sr__UnsubscribeDestinationReq init_value = SR__UNSUBSCRIBE_DESTINATION_REQ__INIT;
3521 + *message = init_value;
3522 +}
3523 +size_t sr__unsubscribe_destination_req__get_packed_size
3524 + (const Sr__UnsubscribeDestinationReq *message)
3525 +{
3526 + assert(message->base.descriptor == &sr__unsubscribe_destination_req__descriptor);
3527 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
3528 +}
3529 +size_t sr__unsubscribe_destination_req__pack
3530 + (const Sr__UnsubscribeDestinationReq *message,
3531 + uint8_t *out)
3532 +{
3533 + assert(message->base.descriptor == &sr__unsubscribe_destination_req__descriptor);
3534 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
3535 +}
3536 +size_t sr__unsubscribe_destination_req__pack_to_buffer
3537 + (const Sr__UnsubscribeDestinationReq *message,
3538 + ProtobufCBuffer *buffer)
3539 +{
3540 + assert(message->base.descriptor == &sr__unsubscribe_destination_req__descriptor);
3541 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
3542 +}
3543 +Sr__UnsubscribeDestinationReq *
3544 + sr__unsubscribe_destination_req__unpack
3545 + (ProtobufCAllocator *allocator,
3546 + size_t len,
3547 + const uint8_t *data)
3548 +{
3549 + return (Sr__UnsubscribeDestinationReq *)
3550 + protobuf_c_message_unpack (&sr__unsubscribe_destination_req__descriptor,
3551 + allocator, len, data);
3552 +}
3553 +void sr__unsubscribe_destination_req__free_unpacked
3554 + (Sr__UnsubscribeDestinationReq *message,
3555 + ProtobufCAllocator *allocator)
3556 +{
3557 + assert(message->base.descriptor == &sr__unsubscribe_destination_req__descriptor);
3558 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
3559 +}
3560 +void sr__commit_timeout_req__init
3561 + (Sr__CommitTimeoutReq *message)
3562 +{
3563 + static Sr__CommitTimeoutReq init_value = SR__COMMIT_TIMEOUT_REQ__INIT;
3564 + *message = init_value;
3565 +}
3566 +size_t sr__commit_timeout_req__get_packed_size
3567 + (const Sr__CommitTimeoutReq *message)
3568 +{
3569 + assert(message->base.descriptor == &sr__commit_timeout_req__descriptor);
3570 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
3571 +}
3572 +size_t sr__commit_timeout_req__pack
3573 + (const Sr__CommitTimeoutReq *message,
3574 + uint8_t *out)
3575 +{
3576 + assert(message->base.descriptor == &sr__commit_timeout_req__descriptor);
3577 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
3578 +}
3579 +size_t sr__commit_timeout_req__pack_to_buffer
3580 + (const Sr__CommitTimeoutReq *message,
3581 + ProtobufCBuffer *buffer)
3582 +{
3583 + assert(message->base.descriptor == &sr__commit_timeout_req__descriptor);
3584 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
3585 +}
3586 +Sr__CommitTimeoutReq *
3587 + sr__commit_timeout_req__unpack
3588 + (ProtobufCAllocator *allocator,
3589 + size_t len,
3590 + const uint8_t *data)
3591 +{
3592 + return (Sr__CommitTimeoutReq *)
3593 + protobuf_c_message_unpack (&sr__commit_timeout_req__descriptor,
3594 + allocator, len, data);
3595 +}
3596 +void sr__commit_timeout_req__free_unpacked
3597 + (Sr__CommitTimeoutReq *message,
3598 + ProtobufCAllocator *allocator)
3599 +{
3600 + assert(message->base.descriptor == &sr__commit_timeout_req__descriptor);
3601 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
3602 +}
3603 +void sr__oper_data_timeout_req__init
3604 + (Sr__OperDataTimeoutReq *message)
3605 +{
3606 + static Sr__OperDataTimeoutReq init_value = SR__OPER_DATA_TIMEOUT_REQ__INIT;
3607 + *message = init_value;
3608 +}
3609 +size_t sr__oper_data_timeout_req__get_packed_size
3610 + (const Sr__OperDataTimeoutReq *message)
3611 +{
3612 + assert(message->base.descriptor == &sr__oper_data_timeout_req__descriptor);
3613 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
3614 +}
3615 +size_t sr__oper_data_timeout_req__pack
3616 + (const Sr__OperDataTimeoutReq *message,
3617 + uint8_t *out)
3618 +{
3619 + assert(message->base.descriptor == &sr__oper_data_timeout_req__descriptor);
3620 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
3621 +}
3622 +size_t sr__oper_data_timeout_req__pack_to_buffer
3623 + (const Sr__OperDataTimeoutReq *message,
3624 + ProtobufCBuffer *buffer)
3625 +{
3626 + assert(message->base.descriptor == &sr__oper_data_timeout_req__descriptor);
3627 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
3628 +}
3629 +Sr__OperDataTimeoutReq *
3630 + sr__oper_data_timeout_req__unpack
3631 + (ProtobufCAllocator *allocator,
3632 + size_t len,
3633 + const uint8_t *data)
3634 +{
3635 + return (Sr__OperDataTimeoutReq *)
3636 + protobuf_c_message_unpack (&sr__oper_data_timeout_req__descriptor,
3637 + allocator, len, data);
3638 +}
3639 +void sr__oper_data_timeout_req__free_unpacked
3640 + (Sr__OperDataTimeoutReq *message,
3641 + ProtobufCAllocator *allocator)
3642 +{
3643 + assert(message->base.descriptor == &sr__oper_data_timeout_req__descriptor);
3644 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
3645 +}
3646 +void sr__internal_state_data_req__init
3647 + (Sr__InternalStateDataReq *message)
3648 +{
3649 + static Sr__InternalStateDataReq init_value = SR__INTERNAL_STATE_DATA_REQ__INIT;
3650 + *message = init_value;
3651 +}
3652 +size_t sr__internal_state_data_req__get_packed_size
3653 + (const Sr__InternalStateDataReq *message)
3654 +{
3655 + assert(message->base.descriptor == &sr__internal_state_data_req__descriptor);
3656 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
3657 +}
3658 +size_t sr__internal_state_data_req__pack
3659 + (const Sr__InternalStateDataReq *message,
3660 + uint8_t *out)
3661 +{
3662 + assert(message->base.descriptor == &sr__internal_state_data_req__descriptor);
3663 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
3664 +}
3665 +size_t sr__internal_state_data_req__pack_to_buffer
3666 + (const Sr__InternalStateDataReq *message,
3667 + ProtobufCBuffer *buffer)
3668 +{
3669 + assert(message->base.descriptor == &sr__internal_state_data_req__descriptor);
3670 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
3671 +}
3672 +Sr__InternalStateDataReq *
3673 + sr__internal_state_data_req__unpack
3674 + (ProtobufCAllocator *allocator,
3675 + size_t len,
3676 + const uint8_t *data)
3677 +{
3678 + return (Sr__InternalStateDataReq *)
3679 + protobuf_c_message_unpack (&sr__internal_state_data_req__descriptor,
3680 + allocator, len, data);
3681 +}
3682 +void sr__internal_state_data_req__free_unpacked
3683 + (Sr__InternalStateDataReq *message,
3684 + ProtobufCAllocator *allocator)
3685 +{
3686 + assert(message->base.descriptor == &sr__internal_state_data_req__descriptor);
3687 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
3688 +}
3689 +void sr__notif_store_cleanup_req__init
3690 + (Sr__NotifStoreCleanupReq *message)
3691 +{
3692 + static Sr__NotifStoreCleanupReq init_value = SR__NOTIF_STORE_CLEANUP_REQ__INIT;
3693 + *message = init_value;
3694 +}
3695 +size_t sr__notif_store_cleanup_req__get_packed_size
3696 + (const Sr__NotifStoreCleanupReq *message)
3697 +{
3698 + assert(message->base.descriptor == &sr__notif_store_cleanup_req__descriptor);
3699 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
3700 +}
3701 +size_t sr__notif_store_cleanup_req__pack
3702 + (const Sr__NotifStoreCleanupReq *message,
3703 + uint8_t *out)
3704 +{
3705 + assert(message->base.descriptor == &sr__notif_store_cleanup_req__descriptor);
3706 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
3707 +}
3708 +size_t sr__notif_store_cleanup_req__pack_to_buffer
3709 + (const Sr__NotifStoreCleanupReq *message,
3710 + ProtobufCBuffer *buffer)
3711 +{
3712 + assert(message->base.descriptor == &sr__notif_store_cleanup_req__descriptor);
3713 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
3714 +}
3715 +Sr__NotifStoreCleanupReq *
3716 + sr__notif_store_cleanup_req__unpack
3717 + (ProtobufCAllocator *allocator,
3718 + size_t len,
3719 + const uint8_t *data)
3720 +{
3721 + return (Sr__NotifStoreCleanupReq *)
3722 + protobuf_c_message_unpack (&sr__notif_store_cleanup_req__descriptor,
3723 + allocator, len, data);
3724 +}
3725 +void sr__notif_store_cleanup_req__free_unpacked
3726 + (Sr__NotifStoreCleanupReq *message,
3727 + ProtobufCAllocator *allocator)
3728 +{
3729 + assert(message->base.descriptor == &sr__notif_store_cleanup_req__descriptor);
3730 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
3731 +}
3732 +void sr__delayed_msg_req__init
3733 + (Sr__DelayedMsgReq *message)
3734 +{
3735 + static Sr__DelayedMsgReq init_value = SR__DELAYED_MSG_REQ__INIT;
3736 + *message = init_value;
3737 +}
3738 +size_t sr__delayed_msg_req__get_packed_size
3739 + (const Sr__DelayedMsgReq *message)
3740 +{
3741 + assert(message->base.descriptor == &sr__delayed_msg_req__descriptor);
3742 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
3743 +}
3744 +size_t sr__delayed_msg_req__pack
3745 + (const Sr__DelayedMsgReq *message,
3746 + uint8_t *out)
3747 +{
3748 + assert(message->base.descriptor == &sr__delayed_msg_req__descriptor);
3749 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
3750 +}
3751 +size_t sr__delayed_msg_req__pack_to_buffer
3752 + (const Sr__DelayedMsgReq *message,
3753 + ProtobufCBuffer *buffer)
3754 +{
3755 + assert(message->base.descriptor == &sr__delayed_msg_req__descriptor);
3756 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
3757 +}
3758 +Sr__DelayedMsgReq *
3759 + sr__delayed_msg_req__unpack
3760 + (ProtobufCAllocator *allocator,
3761 + size_t len,
3762 + const uint8_t *data)
3763 +{
3764 + return (Sr__DelayedMsgReq *)
3765 + protobuf_c_message_unpack (&sr__delayed_msg_req__descriptor,
3766 + allocator, len, data);
3767 +}
3768 +void sr__delayed_msg_req__free_unpacked
3769 + (Sr__DelayedMsgReq *message,
3770 + ProtobufCAllocator *allocator)
3771 +{
3772 + assert(message->base.descriptor == &sr__delayed_msg_req__descriptor);
3773 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
3774 +}
3775 +void sr__nacm_reload_req__init
3776 + (Sr__NacmReloadReq *message)
3777 +{
3778 + static Sr__NacmReloadReq init_value = SR__NACM_RELOAD_REQ__INIT;
3779 + *message = init_value;
3780 +}
3781 +size_t sr__nacm_reload_req__get_packed_size
3782 + (const Sr__NacmReloadReq *message)
3783 +{
3784 + assert(message->base.descriptor == &sr__nacm_reload_req__descriptor);
3785 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
3786 +}
3787 +size_t sr__nacm_reload_req__pack
3788 + (const Sr__NacmReloadReq *message,
3789 + uint8_t *out)
3790 +{
3791 + assert(message->base.descriptor == &sr__nacm_reload_req__descriptor);
3792 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
3793 +}
3794 +size_t sr__nacm_reload_req__pack_to_buffer
3795 + (const Sr__NacmReloadReq *message,
3796 + ProtobufCBuffer *buffer)
3797 +{
3798 + assert(message->base.descriptor == &sr__nacm_reload_req__descriptor);
3799 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
3800 +}
3801 +Sr__NacmReloadReq *
3802 + sr__nacm_reload_req__unpack
3803 + (ProtobufCAllocator *allocator,
3804 + size_t len,
3805 + const uint8_t *data)
3806 +{
3807 + return (Sr__NacmReloadReq *)
3808 + protobuf_c_message_unpack (&sr__nacm_reload_req__descriptor,
3809 + allocator, len, data);
3810 +}
3811 +void sr__nacm_reload_req__free_unpacked
3812 + (Sr__NacmReloadReq *message,
3813 + ProtobufCAllocator *allocator)
3814 +{
3815 + assert(message->base.descriptor == &sr__nacm_reload_req__descriptor);
3816 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
3817 +}
3818 +void sr__request__init
3819 + (Sr__Request *message)
3820 +{
3821 + static Sr__Request init_value = SR__REQUEST__INIT;
3822 + *message = init_value;
3823 +}
3824 +size_t sr__request__get_packed_size
3825 + (const Sr__Request *message)
3826 +{
3827 + assert(message->base.descriptor == &sr__request__descriptor);
3828 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
3829 +}
3830 +size_t sr__request__pack
3831 + (const Sr__Request *message,
3832 + uint8_t *out)
3833 +{
3834 + assert(message->base.descriptor == &sr__request__descriptor);
3835 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
3836 +}
3837 +size_t sr__request__pack_to_buffer
3838 + (const Sr__Request *message,
3839 + ProtobufCBuffer *buffer)
3840 +{
3841 + assert(message->base.descriptor == &sr__request__descriptor);
3842 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
3843 +}
3844 +Sr__Request *
3845 + sr__request__unpack
3846 + (ProtobufCAllocator *allocator,
3847 + size_t len,
3848 + const uint8_t *data)
3849 +{
3850 + return (Sr__Request *)
3851 + protobuf_c_message_unpack (&sr__request__descriptor,
3852 + allocator, len, data);
3853 +}
3854 +void sr__request__free_unpacked
3855 + (Sr__Request *message,
3856 + ProtobufCAllocator *allocator)
3857 +{
3858 + assert(message->base.descriptor == &sr__request__descriptor);
3859 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
3860 +}
3861 +void sr__response__init
3862 + (Sr__Response *message)
3863 +{
3864 + static Sr__Response init_value = SR__RESPONSE__INIT;
3865 + *message = init_value;
3866 +}
3867 +size_t sr__response__get_packed_size
3868 + (const Sr__Response *message)
3869 +{
3870 + assert(message->base.descriptor == &sr__response__descriptor);
3871 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
3872 +}
3873 +size_t sr__response__pack
3874 + (const Sr__Response *message,
3875 + uint8_t *out)
3876 +{
3877 + assert(message->base.descriptor == &sr__response__descriptor);
3878 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
3879 +}
3880 +size_t sr__response__pack_to_buffer
3881 + (const Sr__Response *message,
3882 + ProtobufCBuffer *buffer)
3883 +{
3884 + assert(message->base.descriptor == &sr__response__descriptor);
3885 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
3886 +}
3887 +Sr__Response *
3888 + sr__response__unpack
3889 + (ProtobufCAllocator *allocator,
3890 + size_t len,
3891 + const uint8_t *data)
3892 +{
3893 + return (Sr__Response *)
3894 + protobuf_c_message_unpack (&sr__response__descriptor,
3895 + allocator, len, data);
3896 +}
3897 +void sr__response__free_unpacked
3898 + (Sr__Response *message,
3899 + ProtobufCAllocator *allocator)
3900 +{
3901 + assert(message->base.descriptor == &sr__response__descriptor);
3902 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
3903 +}
3904 +void sr__notification__init
3905 + (Sr__Notification *message)
3906 +{
3907 + static Sr__Notification init_value = SR__NOTIFICATION__INIT;
3908 + *message = init_value;
3909 +}
3910 +size_t sr__notification__get_packed_size
3911 + (const Sr__Notification *message)
3912 +{
3913 + assert(message->base.descriptor == &sr__notification__descriptor);
3914 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
3915 +}
3916 +size_t sr__notification__pack
3917 + (const Sr__Notification *message,
3918 + uint8_t *out)
3919 +{
3920 + assert(message->base.descriptor == &sr__notification__descriptor);
3921 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
3922 +}
3923 +size_t sr__notification__pack_to_buffer
3924 + (const Sr__Notification *message,
3925 + ProtobufCBuffer *buffer)
3926 +{
3927 + assert(message->base.descriptor == &sr__notification__descriptor);
3928 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
3929 +}
3930 +Sr__Notification *
3931 + sr__notification__unpack
3932 + (ProtobufCAllocator *allocator,
3933 + size_t len,
3934 + const uint8_t *data)
3935 +{
3936 + return (Sr__Notification *)
3937 + protobuf_c_message_unpack (&sr__notification__descriptor,
3938 + allocator, len, data);
3939 +}
3940 +void sr__notification__free_unpacked
3941 + (Sr__Notification *message,
3942 + ProtobufCAllocator *allocator)
3943 +{
3944 + assert(message->base.descriptor == &sr__notification__descriptor);
3945 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
3946 +}
3947 +void sr__notification_ack__init
3948 + (Sr__NotificationAck *message)
3949 +{
3950 + static Sr__NotificationAck init_value = SR__NOTIFICATION_ACK__INIT;
3951 + *message = init_value;
3952 +}
3953 +size_t sr__notification_ack__get_packed_size
3954 + (const Sr__NotificationAck *message)
3955 +{
3956 + assert(message->base.descriptor == &sr__notification_ack__descriptor);
3957 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
3958 +}
3959 +size_t sr__notification_ack__pack
3960 + (const Sr__NotificationAck *message,
3961 + uint8_t *out)
3962 +{
3963 + assert(message->base.descriptor == &sr__notification_ack__descriptor);
3964 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
3965 +}
3966 +size_t sr__notification_ack__pack_to_buffer
3967 + (const Sr__NotificationAck *message,
3968 + ProtobufCBuffer *buffer)
3969 +{
3970 + assert(message->base.descriptor == &sr__notification_ack__descriptor);
3971 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
3972 +}
3973 +Sr__NotificationAck *
3974 + sr__notification_ack__unpack
3975 + (ProtobufCAllocator *allocator,
3976 + size_t len,
3977 + const uint8_t *data)
3978 +{
3979 + return (Sr__NotificationAck *)
3980 + protobuf_c_message_unpack (&sr__notification_ack__descriptor,
3981 + allocator, len, data);
3982 +}
3983 +void sr__notification_ack__free_unpacked
3984 + (Sr__NotificationAck *message,
3985 + ProtobufCAllocator *allocator)
3986 +{
3987 + assert(message->base.descriptor == &sr__notification_ack__descriptor);
3988 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
3989 +}
3990 +void sr__internal_request__init
3991 + (Sr__InternalRequest *message)
3992 +{
3993 + static Sr__InternalRequest init_value = SR__INTERNAL_REQUEST__INIT;
3994 + *message = init_value;
3995 +}
3996 +size_t sr__internal_request__get_packed_size
3997 + (const Sr__InternalRequest *message)
3998 +{
3999 + assert(message->base.descriptor == &sr__internal_request__descriptor);
4000 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
4001 +}
4002 +size_t sr__internal_request__pack
4003 + (const Sr__InternalRequest *message,
4004 + uint8_t *out)
4005 +{
4006 + assert(message->base.descriptor == &sr__internal_request__descriptor);
4007 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
4008 +}
4009 +size_t sr__internal_request__pack_to_buffer
4010 + (const Sr__InternalRequest *message,
4011 + ProtobufCBuffer *buffer)
4012 +{
4013 + assert(message->base.descriptor == &sr__internal_request__descriptor);
4014 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
4015 +}
4016 +Sr__InternalRequest *
4017 + sr__internal_request__unpack
4018 + (ProtobufCAllocator *allocator,
4019 + size_t len,
4020 + const uint8_t *data)
4021 +{
4022 + return (Sr__InternalRequest *)
4023 + protobuf_c_message_unpack (&sr__internal_request__descriptor,
4024 + allocator, len, data);
4025 +}
4026 +void sr__internal_request__free_unpacked
4027 + (Sr__InternalRequest *message,
4028 + ProtobufCAllocator *allocator)
4029 +{
4030 + assert(message->base.descriptor == &sr__internal_request__descriptor);
4031 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
4032 +}
4033 +void sr__msg__init
4034 + (Sr__Msg *message)
4035 +{
4036 + static Sr__Msg init_value = SR__MSG__INIT;
4037 + *message = init_value;
4038 +}
4039 +size_t sr__msg__get_packed_size
4040 + (const Sr__Msg *message)
4041 +{
4042 + assert(message->base.descriptor == &sr__msg__descriptor);
4043 + return protobuf_c_message_get_packed_size ((const ProtobufCMessage*)(message));
4044 +}
4045 +size_t sr__msg__pack
4046 + (const Sr__Msg *message,
4047 + uint8_t *out)
4048 +{
4049 + assert(message->base.descriptor == &sr__msg__descriptor);
4050 + return protobuf_c_message_pack ((const ProtobufCMessage*)message, out);
4051 +}
4052 +size_t sr__msg__pack_to_buffer
4053 + (const Sr__Msg *message,
4054 + ProtobufCBuffer *buffer)
4055 +{
4056 + assert(message->base.descriptor == &sr__msg__descriptor);
4057 + return protobuf_c_message_pack_to_buffer ((const ProtobufCMessage*)message, buffer);
4058 +}
4059 +Sr__Msg *
4060 + sr__msg__unpack
4061 + (ProtobufCAllocator *allocator,
4062 + size_t len,
4063 + const uint8_t *data)
4064 +{
4065 + return (Sr__Msg *)
4066 + protobuf_c_message_unpack (&sr__msg__descriptor,
4067 + allocator, len, data);
4068 +}
4069 +void sr__msg__free_unpacked
4070 + (Sr__Msg *message,
4071 + ProtobufCAllocator *allocator)
4072 +{
4073 + assert(message->base.descriptor == &sr__msg__descriptor);
4074 + protobuf_c_message_free_unpacked ((ProtobufCMessage*)message, allocator);
4075 +}
4076 +static const ProtobufCEnumValue sr__value__types__enum_values_by_number[22] =
4077 +{
4078 + { "LIST", "SR__VALUE__TYPES__LIST", 1 },
4079 + { "CONTAINER", "SR__VALUE__TYPES__CONTAINER", 2 },
4080 + { "CONTAINER_PRESENCE", "SR__VALUE__TYPES__CONTAINER_PRESENCE", 3 },
4081 + { "LEAF_EMPTY", "SR__VALUE__TYPES__LEAF_EMPTY", 4 },
4082 + { "BINARY", "SR__VALUE__TYPES__BINARY", 10 },
4083 + { "BITS", "SR__VALUE__TYPES__BITS", 11 },
4084 + { "BOOL", "SR__VALUE__TYPES__BOOL", 12 },
4085 + { "DECIMAL64", "SR__VALUE__TYPES__DECIMAL64", 13 },
4086 + { "ENUM", "SR__VALUE__TYPES__ENUM", 14 },
4087 + { "IDENTITYREF", "SR__VALUE__TYPES__IDENTITYREF", 15 },
4088 + { "INSTANCEID", "SR__VALUE__TYPES__INSTANCEID", 16 },
4089 + { "INT8", "SR__VALUE__TYPES__INT8", 17 },
4090 + { "INT16", "SR__VALUE__TYPES__INT16", 18 },
4091 + { "INT32", "SR__VALUE__TYPES__INT32", 19 },
4092 + { "INT64", "SR__VALUE__TYPES__INT64", 20 },
4093 + { "STRING", "SR__VALUE__TYPES__STRING", 21 },
4094 + { "UINT8", "SR__VALUE__TYPES__UINT8", 22 },
4095 + { "UINT16", "SR__VALUE__TYPES__UINT16", 23 },
4096 + { "UINT32", "SR__VALUE__TYPES__UINT32", 24 },
4097 + { "UINT64", "SR__VALUE__TYPES__UINT64", 25 },
4098 + { "ANYXML", "SR__VALUE__TYPES__ANYXML", 26 },
4099 + { "ANYDATA", "SR__VALUE__TYPES__ANYDATA", 27 },
4100 +};
4101 +static const ProtobufCIntRange sr__value__types__value_ranges[] = {
4102 +{1, 0},{10, 4},{0, 22}
4103 +};
4104 +static const ProtobufCEnumValueIndex sr__value__types__enum_values_by_name[22] =
4105 +{
4106 + { "ANYDATA", 21 },
4107 + { "ANYXML", 20 },
4108 + { "BINARY", 4 },
4109 + { "BITS", 5 },
4110 + { "BOOL", 6 },
4111 + { "CONTAINER", 1 },
4112 + { "CONTAINER_PRESENCE", 2 },
4113 + { "DECIMAL64", 7 },
4114 + { "ENUM", 8 },
4115 + { "IDENTITYREF", 9 },
4116 + { "INSTANCEID", 10 },
4117 + { "INT16", 12 },
4118 + { "INT32", 13 },
4119 + { "INT64", 14 },
4120 + { "INT8", 11 },
4121 + { "LEAF_EMPTY", 3 },
4122 + { "LIST", 0 },
4123 + { "STRING", 15 },
4124 + { "UINT16", 17 },
4125 + { "UINT32", 18 },
4126 + { "UINT64", 19 },
4127 + { "UINT8", 16 },
4128 +};
4129 +const ProtobufCEnumDescriptor sr__value__types__descriptor =
4130 +{
4131 + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
4132 + "sr.Value.Types",
4133 + "Types",
4134 + "Sr__Value__Types",
4135 + "sr",
4136 + 22,
4137 + sr__value__types__enum_values_by_number,
4138 + 22,
4139 + sr__value__types__enum_values_by_name,
4140 + 2,
4141 + sr__value__types__value_ranges,
4142 + NULL,NULL,NULL,NULL /* reserved[1234] */
4143 +};
4144 +static const ProtobufCFieldDescriptor sr__value__field_descriptors[21] =
4145 +{
4146 + {
4147 + "xpath",
4148 + 1,
4149 + PROTOBUF_C_LABEL_REQUIRED,
4150 + PROTOBUF_C_TYPE_STRING,
4151 + 0, /* quantifier_offset */
4152 + offsetof(Sr__Value, xpath),
4153 + NULL,
4154 + NULL,
4155 + 0, /* flags */
4156 + 0,NULL,NULL /* reserved1,reserved2, etc */
4157 + },
4158 + {
4159 + "type",
4160 + 2,
4161 + PROTOBUF_C_LABEL_REQUIRED,
4162 + PROTOBUF_C_TYPE_ENUM,
4163 + 0, /* quantifier_offset */
4164 + offsetof(Sr__Value, type),
4165 + &sr__value__types__descriptor,
4166 + NULL,
4167 + 0, /* flags */
4168 + 0,NULL,NULL /* reserved1,reserved2, etc */
4169 + },
4170 + {
4171 + "dflt",
4172 + 3,
4173 + PROTOBUF_C_LABEL_REQUIRED,
4174 + PROTOBUF_C_TYPE_BOOL,
4175 + 0, /* quantifier_offset */
4176 + offsetof(Sr__Value, dflt),
4177 + NULL,
4178 + NULL,
4179 + 0, /* flags */
4180 + 0,NULL,NULL /* reserved1,reserved2, etc */
4181 + },
4182 + {
4183 + "binary_val",
4184 + 10,
4185 + PROTOBUF_C_LABEL_OPTIONAL,
4186 + PROTOBUF_C_TYPE_STRING,
4187 + 0, /* quantifier_offset */
4188 + offsetof(Sr__Value, binary_val),
4189 + NULL,
4190 + NULL,
4191 + 0, /* flags */
4192 + 0,NULL,NULL /* reserved1,reserved2, etc */
4193 + },
4194 + {
4195 + "bits_val",
4196 + 11,
4197 + PROTOBUF_C_LABEL_OPTIONAL,
4198 + PROTOBUF_C_TYPE_STRING,
4199 + 0, /* quantifier_offset */
4200 + offsetof(Sr__Value, bits_val),
4201 + NULL,
4202 + NULL,
4203 + 0, /* flags */
4204 + 0,NULL,NULL /* reserved1,reserved2, etc */
4205 + },
4206 + {
4207 + "bool_val",
4208 + 12,
4209 + PROTOBUF_C_LABEL_OPTIONAL,
4210 + PROTOBUF_C_TYPE_BOOL,
4211 + offsetof(Sr__Value, has_bool_val),
4212 + offsetof(Sr__Value, bool_val),
4213 + NULL,
4214 + NULL,
4215 + 0, /* flags */
4216 + 0,NULL,NULL /* reserved1,reserved2, etc */
4217 + },
4218 + {
4219 + "decimal64_val",
4220 + 13,
4221 + PROTOBUF_C_LABEL_OPTIONAL,
4222 + PROTOBUF_C_TYPE_DOUBLE,
4223 + offsetof(Sr__Value, has_decimal64_val),
4224 + offsetof(Sr__Value, decimal64_val),
4225 + NULL,
4226 + NULL,
4227 + 0, /* flags */
4228 + 0,NULL,NULL /* reserved1,reserved2, etc */
4229 + },
4230 + {
4231 + "enum_val",
4232 + 14,
4233 + PROTOBUF_C_LABEL_OPTIONAL,
4234 + PROTOBUF_C_TYPE_STRING,
4235 + 0, /* quantifier_offset */
4236 + offsetof(Sr__Value, enum_val),
4237 + NULL,
4238 + NULL,
4239 + 0, /* flags */
4240 + 0,NULL,NULL /* reserved1,reserved2, etc */
4241 + },
4242 + {
4243 + "identityref_val",
4244 + 15,
4245 + PROTOBUF_C_LABEL_OPTIONAL,
4246 + PROTOBUF_C_TYPE_STRING,
4247 + 0, /* quantifier_offset */
4248 + offsetof(Sr__Value, identityref_val),
4249 + NULL,
4250 + NULL,
4251 + 0, /* flags */
4252 + 0,NULL,NULL /* reserved1,reserved2, etc */
4253 + },
4254 + {
4255 + "instanceid_val",
4256 + 16,
4257 + PROTOBUF_C_LABEL_OPTIONAL,
4258 + PROTOBUF_C_TYPE_STRING,
4259 + 0, /* quantifier_offset */
4260 + offsetof(Sr__Value, instanceid_val),
4261 + NULL,
4262 + NULL,
4263 + 0, /* flags */
4264 + 0,NULL,NULL /* reserved1,reserved2, etc */
4265 + },
4266 + {
4267 + "int8_val",
4268 + 17,
4269 + PROTOBUF_C_LABEL_OPTIONAL,
4270 + PROTOBUF_C_TYPE_INT32,
4271 + offsetof(Sr__Value, has_int8_val),
4272 + offsetof(Sr__Value, int8_val),
4273 + NULL,
4274 + NULL,
4275 + 0, /* flags */
4276 + 0,NULL,NULL /* reserved1,reserved2, etc */
4277 + },
4278 + {
4279 + "int16_val",
4280 + 18,
4281 + PROTOBUF_C_LABEL_OPTIONAL,
4282 + PROTOBUF_C_TYPE_INT32,
4283 + offsetof(Sr__Value, has_int16_val),
4284 + offsetof(Sr__Value, int16_val),
4285 + NULL,
4286 + NULL,
4287 + 0, /* flags */
4288 + 0,NULL,NULL /* reserved1,reserved2, etc */
4289 + },
4290 + {
4291 + "int32_val",
4292 + 19,
4293 + PROTOBUF_C_LABEL_OPTIONAL,
4294 + PROTOBUF_C_TYPE_INT32,
4295 + offsetof(Sr__Value, has_int32_val),
4296 + offsetof(Sr__Value, int32_val),
4297 + NULL,
4298 + NULL,
4299 + 0, /* flags */
4300 + 0,NULL,NULL /* reserved1,reserved2, etc */
4301 + },
4302 + {
4303 + "int64_val",
4304 + 20,
4305 + PROTOBUF_C_LABEL_OPTIONAL,
4306 + PROTOBUF_C_TYPE_INT64,
4307 + offsetof(Sr__Value, has_int64_val),
4308 + offsetof(Sr__Value, int64_val),
4309 + NULL,
4310 + NULL,
4311 + 0, /* flags */
4312 + 0,NULL,NULL /* reserved1,reserved2, etc */
4313 + },
4314 + {
4315 + "string_val",
4316 + 21,
4317 + PROTOBUF_C_LABEL_OPTIONAL,
4318 + PROTOBUF_C_TYPE_STRING,
4319 + 0, /* quantifier_offset */
4320 + offsetof(Sr__Value, string_val),
4321 + NULL,
4322 + NULL,
4323 + 0, /* flags */
4324 + 0,NULL,NULL /* reserved1,reserved2, etc */
4325 + },
4326 + {
4327 + "uint8_val",
4328 + 22,
4329 + PROTOBUF_C_LABEL_OPTIONAL,
4330 + PROTOBUF_C_TYPE_UINT32,
4331 + offsetof(Sr__Value, has_uint8_val),
4332 + offsetof(Sr__Value, uint8_val),
4333 + NULL,
4334 + NULL,
4335 + 0, /* flags */
4336 + 0,NULL,NULL /* reserved1,reserved2, etc */
4337 + },
4338 + {
4339 + "uint16_val",
4340 + 23,
4341 + PROTOBUF_C_LABEL_OPTIONAL,
4342 + PROTOBUF_C_TYPE_UINT32,
4343 + offsetof(Sr__Value, has_uint16_val),
4344 + offsetof(Sr__Value, uint16_val),
4345 + NULL,
4346 + NULL,
4347 + 0, /* flags */
4348 + 0,NULL,NULL /* reserved1,reserved2, etc */
4349 + },
4350 + {
4351 + "uint32_val",
4352 + 24,
4353 + PROTOBUF_C_LABEL_OPTIONAL,
4354 + PROTOBUF_C_TYPE_UINT32,
4355 + offsetof(Sr__Value, has_uint32_val),
4356 + offsetof(Sr__Value, uint32_val),
4357 + NULL,
4358 + NULL,
4359 + 0, /* flags */
4360 + 0,NULL,NULL /* reserved1,reserved2, etc */
4361 + },
4362 + {
4363 + "uint64_val",
4364 + 25,
4365 + PROTOBUF_C_LABEL_OPTIONAL,
4366 + PROTOBUF_C_TYPE_UINT64,
4367 + offsetof(Sr__Value, has_uint64_val),
4368 + offsetof(Sr__Value, uint64_val),
4369 + NULL,
4370 + NULL,
4371 + 0, /* flags */
4372 + 0,NULL,NULL /* reserved1,reserved2, etc */
4373 + },
4374 + {
4375 + "anyxml_val",
4376 + 26,
4377 + PROTOBUF_C_LABEL_OPTIONAL,
4378 + PROTOBUF_C_TYPE_STRING,
4379 + 0, /* quantifier_offset */
4380 + offsetof(Sr__Value, anyxml_val),
4381 + NULL,
4382 + NULL,
4383 + 0, /* flags */
4384 + 0,NULL,NULL /* reserved1,reserved2, etc */
4385 + },
4386 + {
4387 + "anydata_val",
4388 + 27,
4389 + PROTOBUF_C_LABEL_OPTIONAL,
4390 + PROTOBUF_C_TYPE_STRING,
4391 + 0, /* quantifier_offset */
4392 + offsetof(Sr__Value, anydata_val),
4393 + NULL,
4394 + NULL,
4395 + 0, /* flags */
4396 + 0,NULL,NULL /* reserved1,reserved2, etc */
4397 + },
4398 +};
4399 +static const unsigned sr__value__field_indices_by_name[] = {
4400 + 20, /* field[20] = anydata_val */
4401 + 19, /* field[19] = anyxml_val */
4402 + 3, /* field[3] = binary_val */
4403 + 4, /* field[4] = bits_val */
4404 + 5, /* field[5] = bool_val */
4405 + 6, /* field[6] = decimal64_val */
4406 + 2, /* field[2] = dflt */
4407 + 7, /* field[7] = enum_val */
4408 + 8, /* field[8] = identityref_val */
4409 + 9, /* field[9] = instanceid_val */
4410 + 11, /* field[11] = int16_val */
4411 + 12, /* field[12] = int32_val */
4412 + 13, /* field[13] = int64_val */
4413 + 10, /* field[10] = int8_val */
4414 + 14, /* field[14] = string_val */
4415 + 1, /* field[1] = type */
4416 + 16, /* field[16] = uint16_val */
4417 + 17, /* field[17] = uint32_val */
4418 + 18, /* field[18] = uint64_val */
4419 + 15, /* field[15] = uint8_val */
4420 + 0, /* field[0] = xpath */
4421 +};
4422 +static const ProtobufCIntRange sr__value__number_ranges[2 + 1] =
4423 +{
4424 + { 1, 0 },
4425 + { 10, 3 },
4426 + { 0, 21 }
4427 +};
4428 +const ProtobufCMessageDescriptor sr__value__descriptor =
4429 +{
4430 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
4431 + "sr.Value",
4432 + "Value",
4433 + "Sr__Value",
4434 + "sr",
4435 + sizeof(Sr__Value),
4436 + 21,
4437 + sr__value__field_descriptors,
4438 + sr__value__field_indices_by_name,
4439 + 2, sr__value__number_ranges,
4440 + (ProtobufCMessageInit) sr__value__init,
4441 + NULL,NULL,NULL /* reserved[123] */
4442 +};
4443 +static const ProtobufCFieldDescriptor sr__node__field_descriptors[3] =
4444 +{
4445 + {
4446 + "value",
4447 + 1,
4448 + PROTOBUF_C_LABEL_REQUIRED,
4449 + PROTOBUF_C_TYPE_MESSAGE,
4450 + 0, /* quantifier_offset */
4451 + offsetof(Sr__Node, value),
4452 + &sr__value__descriptor,
4453 + NULL,
4454 + 0, /* flags */
4455 + 0,NULL,NULL /* reserved1,reserved2, etc */
4456 + },
4457 + {
4458 + "module_name",
4459 + 2,
4460 + PROTOBUF_C_LABEL_REQUIRED,
4461 + PROTOBUF_C_TYPE_STRING,
4462 + 0, /* quantifier_offset */
4463 + offsetof(Sr__Node, module_name),
4464 + NULL,
4465 + NULL,
4466 + 0, /* flags */
4467 + 0,NULL,NULL /* reserved1,reserved2, etc */
4468 + },
4469 + {
4470 + "children",
4471 + 3,
4472 + PROTOBUF_C_LABEL_REPEATED,
4473 + PROTOBUF_C_TYPE_MESSAGE,
4474 + offsetof(Sr__Node, n_children),
4475 + offsetof(Sr__Node, children),
4476 + &sr__node__descriptor,
4477 + NULL,
4478 + 0, /* flags */
4479 + 0,NULL,NULL /* reserved1,reserved2, etc */
4480 + },
4481 +};
4482 +static const unsigned sr__node__field_indices_by_name[] = {
4483 + 2, /* field[2] = children */
4484 + 1, /* field[1] = module_name */
4485 + 0, /* field[0] = value */
4486 +};
4487 +static const ProtobufCIntRange sr__node__number_ranges[1 + 1] =
4488 +{
4489 + { 1, 0 },
4490 + { 0, 3 }
4491 +};
4492 +const ProtobufCMessageDescriptor sr__node__descriptor =
4493 +{
4494 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
4495 + "sr.Node",
4496 + "Node",
4497 + "Sr__Node",
4498 + "sr",
4499 + sizeof(Sr__Node),
4500 + 3,
4501 + sr__node__field_descriptors,
4502 + sr__node__field_indices_by_name,
4503 + 1, sr__node__number_ranges,
4504 + (ProtobufCMessageInit) sr__node__init,
4505 + NULL,NULL,NULL /* reserved[123] */
4506 +};
4507 +static const ProtobufCFieldDescriptor sr__error__field_descriptors[2] =
4508 +{
4509 + {
4510 + "message",
4511 + 1,
4512 + PROTOBUF_C_LABEL_OPTIONAL,
4513 + PROTOBUF_C_TYPE_STRING,
4514 + 0, /* quantifier_offset */
4515 + offsetof(Sr__Error, message),
4516 + NULL,
4517 + NULL,
4518 + 0, /* flags */
4519 + 0,NULL,NULL /* reserved1,reserved2, etc */
4520 + },
4521 + {
4522 + "xpath",
4523 + 2,
4524 + PROTOBUF_C_LABEL_OPTIONAL,
4525 + PROTOBUF_C_TYPE_STRING,
4526 + 0, /* quantifier_offset */
4527 + offsetof(Sr__Error, xpath),
4528 + NULL,
4529 + NULL,
4530 + 0, /* flags */
4531 + 0,NULL,NULL /* reserved1,reserved2, etc */
4532 + },
4533 +};
4534 +static const unsigned sr__error__field_indices_by_name[] = {
4535 + 0, /* field[0] = message */
4536 + 1, /* field[1] = xpath */
4537 +};
4538 +static const ProtobufCIntRange sr__error__number_ranges[1 + 1] =
4539 +{
4540 + { 1, 0 },
4541 + { 0, 2 }
4542 +};
4543 +const ProtobufCMessageDescriptor sr__error__descriptor =
4544 +{
4545 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
4546 + "sr.Error",
4547 + "Error",
4548 + "Sr__Error",
4549 + "sr",
4550 + sizeof(Sr__Error),
4551 + 2,
4552 + sr__error__field_descriptors,
4553 + sr__error__field_indices_by_name,
4554 + 1, sr__error__number_ranges,
4555 + (ProtobufCMessageInit) sr__error__init,
4556 + NULL,NULL,NULL /* reserved[123] */
4557 +};
4558 +static const ProtobufCFieldDescriptor sr__session_start_req__field_descriptors[4] =
4559 +{
4560 + {
4561 + "datastore",
4562 + 1,
4563 + PROTOBUF_C_LABEL_REQUIRED,
4564 + PROTOBUF_C_TYPE_ENUM,
4565 + 0, /* quantifier_offset */
4566 + offsetof(Sr__SessionStartReq, datastore),
4567 + &sr__data_store__descriptor,
4568 + NULL,
4569 + 0, /* flags */
4570 + 0,NULL,NULL /* reserved1,reserved2, etc */
4571 + },
4572 + {
4573 + "user_name",
4574 + 2,
4575 + PROTOBUF_C_LABEL_OPTIONAL,
4576 + PROTOBUF_C_TYPE_STRING,
4577 + 0, /* quantifier_offset */
4578 + offsetof(Sr__SessionStartReq, user_name),
4579 + NULL,
4580 + NULL,
4581 + 0, /* flags */
4582 + 0,NULL,NULL /* reserved1,reserved2, etc */
4583 + },
4584 + {
4585 + "options",
4586 + 3,
4587 + PROTOBUF_C_LABEL_REQUIRED,
4588 + PROTOBUF_C_TYPE_UINT32,
4589 + 0, /* quantifier_offset */
4590 + offsetof(Sr__SessionStartReq, options),
4591 + NULL,
4592 + NULL,
4593 + 0, /* flags */
4594 + 0,NULL,NULL /* reserved1,reserved2, etc */
4595 + },
4596 + {
4597 + "commit_id",
4598 + 4,
4599 + PROTOBUF_C_LABEL_OPTIONAL,
4600 + PROTOBUF_C_TYPE_UINT32,
4601 + offsetof(Sr__SessionStartReq, has_commit_id),
4602 + offsetof(Sr__SessionStartReq, commit_id),
4603 + NULL,
4604 + NULL,
4605 + 0, /* flags */
4606 + 0,NULL,NULL /* reserved1,reserved2, etc */
4607 + },
4608 +};
4609 +static const unsigned sr__session_start_req__field_indices_by_name[] = {
4610 + 3, /* field[3] = commit_id */
4611 + 0, /* field[0] = datastore */
4612 + 2, /* field[2] = options */
4613 + 1, /* field[1] = user_name */
4614 +};
4615 +static const ProtobufCIntRange sr__session_start_req__number_ranges[1 + 1] =
4616 +{
4617 + { 1, 0 },
4618 + { 0, 4 }
4619 +};
4620 +const ProtobufCMessageDescriptor sr__session_start_req__descriptor =
4621 +{
4622 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
4623 + "sr.SessionStartReq",
4624 + "SessionStartReq",
4625 + "Sr__SessionStartReq",
4626 + "sr",
4627 + sizeof(Sr__SessionStartReq),
4628 + 4,
4629 + sr__session_start_req__field_descriptors,
4630 + sr__session_start_req__field_indices_by_name,
4631 + 1, sr__session_start_req__number_ranges,
4632 + (ProtobufCMessageInit) sr__session_start_req__init,
4633 + NULL,NULL,NULL /* reserved[123] */
4634 +};
4635 +static const ProtobufCFieldDescriptor sr__session_start_resp__field_descriptors[1] =
4636 +{
4637 + {
4638 + "session_id",
4639 + 1,
4640 + PROTOBUF_C_LABEL_REQUIRED,
4641 + PROTOBUF_C_TYPE_UINT32,
4642 + 0, /* quantifier_offset */
4643 + offsetof(Sr__SessionStartResp, session_id),
4644 + NULL,
4645 + NULL,
4646 + 0, /* flags */
4647 + 0,NULL,NULL /* reserved1,reserved2, etc */
4648 + },
4649 +};
4650 +static const unsigned sr__session_start_resp__field_indices_by_name[] = {
4651 + 0, /* field[0] = session_id */
4652 +};
4653 +static const ProtobufCIntRange sr__session_start_resp__number_ranges[1 + 1] =
4654 +{
4655 + { 1, 0 },
4656 + { 0, 1 }
4657 +};
4658 +const ProtobufCMessageDescriptor sr__session_start_resp__descriptor =
4659 +{
4660 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
4661 + "sr.SessionStartResp",
4662 + "SessionStartResp",
4663 + "Sr__SessionStartResp",
4664 + "sr",
4665 + sizeof(Sr__SessionStartResp),
4666 + 1,
4667 + sr__session_start_resp__field_descriptors,
4668 + sr__session_start_resp__field_indices_by_name,
4669 + 1, sr__session_start_resp__number_ranges,
4670 + (ProtobufCMessageInit) sr__session_start_resp__init,
4671 + NULL,NULL,NULL /* reserved[123] */
4672 +};
4673 +static const ProtobufCFieldDescriptor sr__session_stop_req__field_descriptors[1] =
4674 +{
4675 + {
4676 + "session_id",
4677 + 1,
4678 + PROTOBUF_C_LABEL_REQUIRED,
4679 + PROTOBUF_C_TYPE_UINT32,
4680 + 0, /* quantifier_offset */
4681 + offsetof(Sr__SessionStopReq, session_id),
4682 + NULL,
4683 + NULL,
4684 + 0, /* flags */
4685 + 0,NULL,NULL /* reserved1,reserved2, etc */
4686 + },
4687 +};
4688 +static const unsigned sr__session_stop_req__field_indices_by_name[] = {
4689 + 0, /* field[0] = session_id */
4690 +};
4691 +static const ProtobufCIntRange sr__session_stop_req__number_ranges[1 + 1] =
4692 +{
4693 + { 1, 0 },
4694 + { 0, 1 }
4695 +};
4696 +const ProtobufCMessageDescriptor sr__session_stop_req__descriptor =
4697 +{
4698 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
4699 + "sr.SessionStopReq",
4700 + "SessionStopReq",
4701 + "Sr__SessionStopReq",
4702 + "sr",
4703 + sizeof(Sr__SessionStopReq),
4704 + 1,
4705 + sr__session_stop_req__field_descriptors,
4706 + sr__session_stop_req__field_indices_by_name,
4707 + 1, sr__session_stop_req__number_ranges,
4708 + (ProtobufCMessageInit) sr__session_stop_req__init,
4709 + NULL,NULL,NULL /* reserved[123] */
4710 +};
4711 +static const ProtobufCFieldDescriptor sr__session_stop_resp__field_descriptors[1] =
4712 +{
4713 + {
4714 + "session_id",
4715 + 1,
4716 + PROTOBUF_C_LABEL_REQUIRED,
4717 + PROTOBUF_C_TYPE_UINT32,
4718 + 0, /* quantifier_offset */
4719 + offsetof(Sr__SessionStopResp, session_id),
4720 + NULL,
4721 + NULL,
4722 + 0, /* flags */
4723 + 0,NULL,NULL /* reserved1,reserved2, etc */
4724 + },
4725 +};
4726 +static const unsigned sr__session_stop_resp__field_indices_by_name[] = {
4727 + 0, /* field[0] = session_id */
4728 +};
4729 +static const ProtobufCIntRange sr__session_stop_resp__number_ranges[1 + 1] =
4730 +{
4731 + { 1, 0 },
4732 + { 0, 1 }
4733 +};
4734 +const ProtobufCMessageDescriptor sr__session_stop_resp__descriptor =
4735 +{
4736 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
4737 + "sr.SessionStopResp",
4738 + "SessionStopResp",
4739 + "Sr__SessionStopResp",
4740 + "sr",
4741 + sizeof(Sr__SessionStopResp),
4742 + 1,
4743 + sr__session_stop_resp__field_descriptors,
4744 + sr__session_stop_resp__field_indices_by_name,
4745 + 1, sr__session_stop_resp__number_ranges,
4746 + (ProtobufCMessageInit) sr__session_stop_resp__init,
4747 + NULL,NULL,NULL /* reserved[123] */
4748 +};
4749 +#define sr__session_refresh_req__field_descriptors NULL
4750 +#define sr__session_refresh_req__field_indices_by_name NULL
4751 +#define sr__session_refresh_req__number_ranges NULL
4752 +const ProtobufCMessageDescriptor sr__session_refresh_req__descriptor =
4753 +{
4754 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
4755 + "sr.SessionRefreshReq",
4756 + "SessionRefreshReq",
4757 + "Sr__SessionRefreshReq",
4758 + "sr",
4759 + sizeof(Sr__SessionRefreshReq),
4760 + 0,
4761 + sr__session_refresh_req__field_descriptors,
4762 + sr__session_refresh_req__field_indices_by_name,
4763 + 0, sr__session_refresh_req__number_ranges,
4764 + (ProtobufCMessageInit) sr__session_refresh_req__init,
4765 + NULL,NULL,NULL /* reserved[123] */
4766 +};
4767 +static const ProtobufCFieldDescriptor sr__session_refresh_resp__field_descriptors[1] =
4768 +{
4769 + {
4770 + "errors",
4771 + 1,
4772 + PROTOBUF_C_LABEL_REPEATED,
4773 + PROTOBUF_C_TYPE_MESSAGE,
4774 + offsetof(Sr__SessionRefreshResp, n_errors),
4775 + offsetof(Sr__SessionRefreshResp, errors),
4776 + &sr__error__descriptor,
4777 + NULL,
4778 + 0, /* flags */
4779 + 0,NULL,NULL /* reserved1,reserved2, etc */
4780 + },
4781 +};
4782 +static const unsigned sr__session_refresh_resp__field_indices_by_name[] = {
4783 + 0, /* field[0] = errors */
4784 +};
4785 +static const ProtobufCIntRange sr__session_refresh_resp__number_ranges[1 + 1] =
4786 +{
4787 + { 1, 0 },
4788 + { 0, 1 }
4789 +};
4790 +const ProtobufCMessageDescriptor sr__session_refresh_resp__descriptor =
4791 +{
4792 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
4793 + "sr.SessionRefreshResp",
4794 + "SessionRefreshResp",
4795 + "Sr__SessionRefreshResp",
4796 + "sr",
4797 + sizeof(Sr__SessionRefreshResp),
4798 + 1,
4799 + sr__session_refresh_resp__field_descriptors,
4800 + sr__session_refresh_resp__field_indices_by_name,
4801 + 1, sr__session_refresh_resp__number_ranges,
4802 + (ProtobufCMessageInit) sr__session_refresh_resp__init,
4803 + NULL,NULL,NULL /* reserved[123] */
4804 +};
4805 +#define sr__session_check_req__field_descriptors NULL
4806 +#define sr__session_check_req__field_indices_by_name NULL
4807 +#define sr__session_check_req__number_ranges NULL
4808 +const ProtobufCMessageDescriptor sr__session_check_req__descriptor =
4809 +{
4810 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
4811 + "sr.SessionCheckReq",
4812 + "SessionCheckReq",
4813 + "Sr__SessionCheckReq",
4814 + "sr",
4815 + sizeof(Sr__SessionCheckReq),
4816 + 0,
4817 + sr__session_check_req__field_descriptors,
4818 + sr__session_check_req__field_indices_by_name,
4819 + 0, sr__session_check_req__number_ranges,
4820 + (ProtobufCMessageInit) sr__session_check_req__init,
4821 + NULL,NULL,NULL /* reserved[123] */
4822 +};
4823 +static const ProtobufCFieldDescriptor sr__session_check_resp__field_descriptors[1] =
4824 +{
4825 + {
4826 + "errors",
4827 + 1,
4828 + PROTOBUF_C_LABEL_REPEATED,
4829 + PROTOBUF_C_TYPE_MESSAGE,
4830 + offsetof(Sr__SessionCheckResp, n_errors),
4831 + offsetof(Sr__SessionCheckResp, errors),
4832 + &sr__error__descriptor,
4833 + NULL,
4834 + 0, /* flags */
4835 + 0,NULL,NULL /* reserved1,reserved2, etc */
4836 + },
4837 +};
4838 +static const unsigned sr__session_check_resp__field_indices_by_name[] = {
4839 + 0, /* field[0] = errors */
4840 +};
4841 +static const ProtobufCIntRange sr__session_check_resp__number_ranges[1 + 1] =
4842 +{
4843 + { 1, 0 },
4844 + { 0, 1 }
4845 +};
4846 +const ProtobufCMessageDescriptor sr__session_check_resp__descriptor =
4847 +{
4848 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
4849 + "sr.SessionCheckResp",
4850 + "SessionCheckResp",
4851 + "Sr__SessionCheckResp",
4852 + "sr",
4853 + sizeof(Sr__SessionCheckResp),
4854 + 1,
4855 + sr__session_check_resp__field_descriptors,
4856 + sr__session_check_resp__field_indices_by_name,
4857 + 1, sr__session_check_resp__number_ranges,
4858 + (ProtobufCMessageInit) sr__session_check_resp__init,
4859 + NULL,NULL,NULL /* reserved[123] */
4860 +};
4861 +static const ProtobufCFieldDescriptor sr__session_switch_ds_req__field_descriptors[1] =
4862 +{
4863 + {
4864 + "datastore",
4865 + 1,
4866 + PROTOBUF_C_LABEL_REQUIRED,
4867 + PROTOBUF_C_TYPE_ENUM,
4868 + 0, /* quantifier_offset */
4869 + offsetof(Sr__SessionSwitchDsReq, datastore),
4870 + &sr__data_store__descriptor,
4871 + NULL,
4872 + 0, /* flags */
4873 + 0,NULL,NULL /* reserved1,reserved2, etc */
4874 + },
4875 +};
4876 +static const unsigned sr__session_switch_ds_req__field_indices_by_name[] = {
4877 + 0, /* field[0] = datastore */
4878 +};
4879 +static const ProtobufCIntRange sr__session_switch_ds_req__number_ranges[1 + 1] =
4880 +{
4881 + { 1, 0 },
4882 + { 0, 1 }
4883 +};
4884 +const ProtobufCMessageDescriptor sr__session_switch_ds_req__descriptor =
4885 +{
4886 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
4887 + "sr.SessionSwitchDsReq",
4888 + "SessionSwitchDsReq",
4889 + "Sr__SessionSwitchDsReq",
4890 + "sr",
4891 + sizeof(Sr__SessionSwitchDsReq),
4892 + 1,
4893 + sr__session_switch_ds_req__field_descriptors,
4894 + sr__session_switch_ds_req__field_indices_by_name,
4895 + 1, sr__session_switch_ds_req__number_ranges,
4896 + (ProtobufCMessageInit) sr__session_switch_ds_req__init,
4897 + NULL,NULL,NULL /* reserved[123] */
4898 +};
4899 +#define sr__session_switch_ds_resp__field_descriptors NULL
4900 +#define sr__session_switch_ds_resp__field_indices_by_name NULL
4901 +#define sr__session_switch_ds_resp__number_ranges NULL
4902 +const ProtobufCMessageDescriptor sr__session_switch_ds_resp__descriptor =
4903 +{
4904 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
4905 + "sr.SessionSwitchDsResp",
4906 + "SessionSwitchDsResp",
4907 + "Sr__SessionSwitchDsResp",
4908 + "sr",
4909 + sizeof(Sr__SessionSwitchDsResp),
4910 + 0,
4911 + sr__session_switch_ds_resp__field_descriptors,
4912 + sr__session_switch_ds_resp__field_indices_by_name,
4913 + 0, sr__session_switch_ds_resp__number_ranges,
4914 + (ProtobufCMessageInit) sr__session_switch_ds_resp__init,
4915 + NULL,NULL,NULL /* reserved[123] */
4916 +};
4917 +static const ProtobufCFieldDescriptor sr__session_set_opts_req__field_descriptors[1] =
4918 +{
4919 + {
4920 + "options",
4921 + 1,
4922 + PROTOBUF_C_LABEL_REQUIRED,
4923 + PROTOBUF_C_TYPE_UINT32,
4924 + 0, /* quantifier_offset */
4925 + offsetof(Sr__SessionSetOptsReq, options),
4926 + NULL,
4927 + NULL,
4928 + 0, /* flags */
4929 + 0,NULL,NULL /* reserved1,reserved2, etc */
4930 + },
4931 +};
4932 +static const unsigned sr__session_set_opts_req__field_indices_by_name[] = {
4933 + 0, /* field[0] = options */
4934 +};
4935 +static const ProtobufCIntRange sr__session_set_opts_req__number_ranges[1 + 1] =
4936 +{
4937 + { 1, 0 },
4938 + { 0, 1 }
4939 +};
4940 +const ProtobufCMessageDescriptor sr__session_set_opts_req__descriptor =
4941 +{
4942 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
4943 + "sr.SessionSetOptsReq",
4944 + "SessionSetOptsReq",
4945 + "Sr__SessionSetOptsReq",
4946 + "sr",
4947 + sizeof(Sr__SessionSetOptsReq),
4948 + 1,
4949 + sr__session_set_opts_req__field_descriptors,
4950 + sr__session_set_opts_req__field_indices_by_name,
4951 + 1, sr__session_set_opts_req__number_ranges,
4952 + (ProtobufCMessageInit) sr__session_set_opts_req__init,
4953 + NULL,NULL,NULL /* reserved[123] */
4954 +};
4955 +#define sr__session_set_opts_resp__field_descriptors NULL
4956 +#define sr__session_set_opts_resp__field_indices_by_name NULL
4957 +#define sr__session_set_opts_resp__number_ranges NULL
4958 +const ProtobufCMessageDescriptor sr__session_set_opts_resp__descriptor =
4959 +{
4960 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
4961 + "sr.SessionSetOptsResp",
4962 + "SessionSetOptsResp",
4963 + "Sr__SessionSetOptsResp",
4964 + "sr",
4965 + sizeof(Sr__SessionSetOptsResp),
4966 + 0,
4967 + sr__session_set_opts_resp__field_descriptors,
4968 + sr__session_set_opts_resp__field_indices_by_name,
4969 + 0, sr__session_set_opts_resp__number_ranges,
4970 + (ProtobufCMessageInit) sr__session_set_opts_resp__init,
4971 + NULL,NULL,NULL /* reserved[123] */
4972 +};
4973 +static const ProtobufCFieldDescriptor sr__version_verify_req__field_descriptors[1] =
4974 +{
4975 + {
4976 + "soname",
4977 + 1,
4978 + PROTOBUF_C_LABEL_REQUIRED,
4979 + PROTOBUF_C_TYPE_STRING,
4980 + 0, /* quantifier_offset */
4981 + offsetof(Sr__VersionVerifyReq, soname),
4982 + NULL,
4983 + NULL,
4984 + 0, /* flags */
4985 + 0,NULL,NULL /* reserved1,reserved2, etc */
4986 + },
4987 +};
4988 +static const unsigned sr__version_verify_req__field_indices_by_name[] = {
4989 + 0, /* field[0] = soname */
4990 +};
4991 +static const ProtobufCIntRange sr__version_verify_req__number_ranges[1 + 1] =
4992 +{
4993 + { 1, 0 },
4994 + { 0, 1 }
4995 +};
4996 +const ProtobufCMessageDescriptor sr__version_verify_req__descriptor =
4997 +{
4998 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
4999 + "sr.VersionVerifyReq",
5000 + "VersionVerifyReq",
5001 + "Sr__VersionVerifyReq",
5002 + "sr",
5003 + sizeof(Sr__VersionVerifyReq),
5004 + 1,
5005 + sr__version_verify_req__field_descriptors,
5006 + sr__version_verify_req__field_indices_by_name,
5007 + 1, sr__version_verify_req__number_ranges,
5008 + (ProtobufCMessageInit) sr__version_verify_req__init,
5009 + NULL,NULL,NULL /* reserved[123] */
5010 +};
5011 +static const ProtobufCFieldDescriptor sr__version_verify_resp__field_descriptors[1] =
5012 +{
5013 + {
5014 + "soname",
5015 + 1,
5016 + PROTOBUF_C_LABEL_OPTIONAL,
5017 + PROTOBUF_C_TYPE_STRING,
5018 + 0, /* quantifier_offset */
5019 + offsetof(Sr__VersionVerifyResp, soname),
5020 + NULL,
5021 + NULL,
5022 + 0, /* flags */
5023 + 0,NULL,NULL /* reserved1,reserved2, etc */
5024 + },
5025 +};
5026 +static const unsigned sr__version_verify_resp__field_indices_by_name[] = {
5027 + 0, /* field[0] = soname */
5028 +};
5029 +static const ProtobufCIntRange sr__version_verify_resp__number_ranges[1 + 1] =
5030 +{
5031 + { 1, 0 },
5032 + { 0, 1 }
5033 +};
5034 +const ProtobufCMessageDescriptor sr__version_verify_resp__descriptor =
5035 +{
5036 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
5037 + "sr.VersionVerifyResp",
5038 + "VersionVerifyResp",
5039 + "Sr__VersionVerifyResp",
5040 + "sr",
5041 + sizeof(Sr__VersionVerifyResp),
5042 + 1,
5043 + sr__version_verify_resp__field_descriptors,
5044 + sr__version_verify_resp__field_indices_by_name,
5045 + 1, sr__version_verify_resp__number_ranges,
5046 + (ProtobufCMessageInit) sr__version_verify_resp__init,
5047 + NULL,NULL,NULL /* reserved[123] */
5048 +};
5049 +static const ProtobufCFieldDescriptor sr__schema_revision__field_descriptors[3] =
5050 +{
5051 + {
5052 + "revision",
5053 + 1,
5054 + PROTOBUF_C_LABEL_OPTIONAL,
5055 + PROTOBUF_C_TYPE_STRING,
5056 + 0, /* quantifier_offset */
5057 + offsetof(Sr__SchemaRevision, revision),
5058 + NULL,
5059 + NULL,
5060 + 0, /* flags */
5061 + 0,NULL,NULL /* reserved1,reserved2, etc */
5062 + },
5063 + {
5064 + "file_path_yang",
5065 + 2,
5066 + PROTOBUF_C_LABEL_OPTIONAL,
5067 + PROTOBUF_C_TYPE_STRING,
5068 + 0, /* quantifier_offset */
5069 + offsetof(Sr__SchemaRevision, file_path_yang),
5070 + NULL,
5071 + NULL,
5072 + 0, /* flags */
5073 + 0,NULL,NULL /* reserved1,reserved2, etc */
5074 + },
5075 + {
5076 + "file_path_yin",
5077 + 3,
5078 + PROTOBUF_C_LABEL_OPTIONAL,
5079 + PROTOBUF_C_TYPE_STRING,
5080 + 0, /* quantifier_offset */
5081 + offsetof(Sr__SchemaRevision, file_path_yin),
5082 + NULL,
5083 + NULL,
5084 + 0, /* flags */
5085 + 0,NULL,NULL /* reserved1,reserved2, etc */
5086 + },
5087 +};
5088 +static const unsigned sr__schema_revision__field_indices_by_name[] = {
5089 + 1, /* field[1] = file_path_yang */
5090 + 2, /* field[2] = file_path_yin */
5091 + 0, /* field[0] = revision */
5092 +};
5093 +static const ProtobufCIntRange sr__schema_revision__number_ranges[1 + 1] =
5094 +{
5095 + { 1, 0 },
5096 + { 0, 3 }
5097 +};
5098 +const ProtobufCMessageDescriptor sr__schema_revision__descriptor =
5099 +{
5100 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
5101 + "sr.SchemaRevision",
5102 + "SchemaRevision",
5103 + "Sr__SchemaRevision",
5104 + "sr",
5105 + sizeof(Sr__SchemaRevision),
5106 + 3,
5107 + sr__schema_revision__field_descriptors,
5108 + sr__schema_revision__field_indices_by_name,
5109 + 1, sr__schema_revision__number_ranges,
5110 + (ProtobufCMessageInit) sr__schema_revision__init,
5111 + NULL,NULL,NULL /* reserved[123] */
5112 +};
5113 +static const ProtobufCFieldDescriptor sr__schema_submodule__field_descriptors[2] =
5114 +{
5115 + {
5116 + "submodule_name",
5117 + 1,
5118 + PROTOBUF_C_LABEL_REQUIRED,
5119 + PROTOBUF_C_TYPE_STRING,
5120 + 0, /* quantifier_offset */
5121 + offsetof(Sr__SchemaSubmodule, submodule_name),
5122 + NULL,
5123 + NULL,
5124 + 0, /* flags */
5125 + 0,NULL,NULL /* reserved1,reserved2, etc */
5126 + },
5127 + {
5128 + "revision",
5129 + 2,
5130 + PROTOBUF_C_LABEL_REQUIRED,
5131 + PROTOBUF_C_TYPE_MESSAGE,
5132 + 0, /* quantifier_offset */
5133 + offsetof(Sr__SchemaSubmodule, revision),
5134 + &sr__schema_revision__descriptor,
5135 + NULL,
5136 + 0, /* flags */
5137 + 0,NULL,NULL /* reserved1,reserved2, etc */
5138 + },
5139 +};
5140 +static const unsigned sr__schema_submodule__field_indices_by_name[] = {
5141 + 1, /* field[1] = revision */
5142 + 0, /* field[0] = submodule_name */
5143 +};
5144 +static const ProtobufCIntRange sr__schema_submodule__number_ranges[1 + 1] =
5145 +{
5146 + { 1, 0 },
5147 + { 0, 2 }
5148 +};
5149 +const ProtobufCMessageDescriptor sr__schema_submodule__descriptor =
5150 +{
5151 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
5152 + "sr.SchemaSubmodule",
5153 + "SchemaSubmodule",
5154 + "Sr__SchemaSubmodule",
5155 + "sr",
5156 + sizeof(Sr__SchemaSubmodule),
5157 + 2,
5158 + sr__schema_submodule__field_descriptors,
5159 + sr__schema_submodule__field_indices_by_name,
5160 + 1, sr__schema_submodule__number_ranges,
5161 + (ProtobufCMessageInit) sr__schema_submodule__init,
5162 + NULL,NULL,NULL /* reserved[123] */
5163 +};
5164 +static const ProtobufCFieldDescriptor sr__schema__field_descriptors[8] =
5165 +{
5166 + {
5167 + "module_name",
5168 + 1,
5169 + PROTOBUF_C_LABEL_REQUIRED,
5170 + PROTOBUF_C_TYPE_STRING,
5171 + 0, /* quantifier_offset */
5172 + offsetof(Sr__Schema, module_name),
5173 + NULL,
5174 + NULL,
5175 + 0, /* flags */
5176 + 0,NULL,NULL /* reserved1,reserved2, etc */
5177 + },
5178 + {
5179 + "ns",
5180 + 2,
5181 + PROTOBUF_C_LABEL_REQUIRED,
5182 + PROTOBUF_C_TYPE_STRING,
5183 + 0, /* quantifier_offset */
5184 + offsetof(Sr__Schema, ns),
5185 + NULL,
5186 + NULL,
5187 + 0, /* flags */
5188 + 0,NULL,NULL /* reserved1,reserved2, etc */
5189 + },
5190 + {
5191 + "prefix",
5192 + 3,
5193 + PROTOBUF_C_LABEL_REQUIRED,
5194 + PROTOBUF_C_TYPE_STRING,
5195 + 0, /* quantifier_offset */
5196 + offsetof(Sr__Schema, prefix),
5197 + NULL,
5198 + NULL,
5199 + 0, /* flags */
5200 + 0,NULL,NULL /* reserved1,reserved2, etc */
5201 + },
5202 + {
5203 + "installed",
5204 + 4,
5205 + PROTOBUF_C_LABEL_REQUIRED,
5206 + PROTOBUF_C_TYPE_BOOL,
5207 + 0, /* quantifier_offset */
5208 + offsetof(Sr__Schema, installed),
5209 + NULL,
5210 + NULL,
5211 + 0, /* flags */
5212 + 0,NULL,NULL /* reserved1,reserved2, etc */
5213 + },
5214 + {
5215 + "implemented",
5216 + 5,
5217 + PROTOBUF_C_LABEL_REQUIRED,
5218 + PROTOBUF_C_TYPE_BOOL,
5219 + 0, /* quantifier_offset */
5220 + offsetof(Sr__Schema, implemented),
5221 + NULL,
5222 + NULL,
5223 + 0, /* flags */
5224 + 0,NULL,NULL /* reserved1,reserved2, etc */
5225 + },
5226 + {
5227 + "revision",
5228 + 6,
5229 + PROTOBUF_C_LABEL_REQUIRED,
5230 + PROTOBUF_C_TYPE_MESSAGE,
5231 + 0, /* quantifier_offset */
5232 + offsetof(Sr__Schema, revision),
5233 + &sr__schema_revision__descriptor,
5234 + NULL,
5235 + 0, /* flags */
5236 + 0,NULL,NULL /* reserved1,reserved2, etc */
5237 + },
5238 + {
5239 + "submodules",
5240 + 7,
5241 + PROTOBUF_C_LABEL_REPEATED,
5242 + PROTOBUF_C_TYPE_MESSAGE,
5243 + offsetof(Sr__Schema, n_submodules),
5244 + offsetof(Sr__Schema, submodules),
5245 + &sr__schema_submodule__descriptor,
5246 + NULL,
5247 + 0, /* flags */
5248 + 0,NULL,NULL /* reserved1,reserved2, etc */
5249 + },
5250 + {
5251 + "enabled_features",
5252 + 8,
5253 + PROTOBUF_C_LABEL_REPEATED,
5254 + PROTOBUF_C_TYPE_STRING,
5255 + offsetof(Sr__Schema, n_enabled_features),
5256 + offsetof(Sr__Schema, enabled_features),
5257 + NULL,
5258 + NULL,
5259 + 0, /* flags */
5260 + 0,NULL,NULL /* reserved1,reserved2, etc */
5261 + },
5262 +};
5263 +static const unsigned sr__schema__field_indices_by_name[] = {
5264 + 7, /* field[7] = enabled_features */
5265 + 4, /* field[4] = implemented */
5266 + 3, /* field[3] = installed */
5267 + 0, /* field[0] = module_name */
5268 + 1, /* field[1] = ns */
5269 + 2, /* field[2] = prefix */
5270 + 5, /* field[5] = revision */
5271 + 6, /* field[6] = submodules */
5272 +};
5273 +static const ProtobufCIntRange sr__schema__number_ranges[1 + 1] =
5274 +{
5275 + { 1, 0 },
5276 + { 0, 8 }
5277 +};
5278 +const ProtobufCMessageDescriptor sr__schema__descriptor =
5279 +{
5280 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
5281 + "sr.Schema",
5282 + "Schema",
5283 + "Sr__Schema",
5284 + "sr",
5285 + sizeof(Sr__Schema),
5286 + 8,
5287 + sr__schema__field_descriptors,
5288 + sr__schema__field_indices_by_name,
5289 + 1, sr__schema__number_ranges,
5290 + (ProtobufCMessageInit) sr__schema__init,
5291 + NULL,NULL,NULL /* reserved[123] */
5292 +};
5293 +#define sr__list_schemas_req__field_descriptors NULL
5294 +#define sr__list_schemas_req__field_indices_by_name NULL
5295 +#define sr__list_schemas_req__number_ranges NULL
5296 +const ProtobufCMessageDescriptor sr__list_schemas_req__descriptor =
5297 +{
5298 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
5299 + "sr.ListSchemasReq",
5300 + "ListSchemasReq",
5301 + "Sr__ListSchemasReq",
5302 + "sr",
5303 + sizeof(Sr__ListSchemasReq),
5304 + 0,
5305 + sr__list_schemas_req__field_descriptors,
5306 + sr__list_schemas_req__field_indices_by_name,
5307 + 0, sr__list_schemas_req__number_ranges,
5308 + (ProtobufCMessageInit) sr__list_schemas_req__init,
5309 + NULL,NULL,NULL /* reserved[123] */
5310 +};
5311 +static const ProtobufCFieldDescriptor sr__list_schemas_resp__field_descriptors[1] =
5312 +{
5313 + {
5314 + "schemas",
5315 + 1,
5316 + PROTOBUF_C_LABEL_REPEATED,
5317 + PROTOBUF_C_TYPE_MESSAGE,
5318 + offsetof(Sr__ListSchemasResp, n_schemas),
5319 + offsetof(Sr__ListSchemasResp, schemas),
5320 + &sr__schema__descriptor,
5321 + NULL,
5322 + 0, /* flags */
5323 + 0,NULL,NULL /* reserved1,reserved2, etc */
5324 + },
5325 +};
5326 +static const unsigned sr__list_schemas_resp__field_indices_by_name[] = {
5327 + 0, /* field[0] = schemas */
5328 +};
5329 +static const ProtobufCIntRange sr__list_schemas_resp__number_ranges[1 + 1] =
5330 +{
5331 + { 1, 0 },
5332 + { 0, 1 }
5333 +};
5334 +const ProtobufCMessageDescriptor sr__list_schemas_resp__descriptor =
5335 +{
5336 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
5337 + "sr.ListSchemasResp",
5338 + "ListSchemasResp",
5339 + "Sr__ListSchemasResp",
5340 + "sr",
5341 + sizeof(Sr__ListSchemasResp),
5342 + 1,
5343 + sr__list_schemas_resp__field_descriptors,
5344 + sr__list_schemas_resp__field_indices_by_name,
5345 + 1, sr__list_schemas_resp__number_ranges,
5346 + (ProtobufCMessageInit) sr__list_schemas_resp__init,
5347 + NULL,NULL,NULL /* reserved[123] */
5348 +};
5349 +static const ProtobufCFieldDescriptor sr__get_schema_req__field_descriptors[5] =
5350 +{
5351 + {
5352 + "module_name",
5353 + 1,
5354 + PROTOBUF_C_LABEL_OPTIONAL,
5355 + PROTOBUF_C_TYPE_STRING,
5356 + 0, /* quantifier_offset */
5357 + offsetof(Sr__GetSchemaReq, module_name),
5358 + NULL,
5359 + NULL,
5360 + 0, /* flags */
5361 + 0,NULL,NULL /* reserved1,reserved2, etc */
5362 + },
5363 + {
5364 + "revision",
5365 + 2,
5366 + PROTOBUF_C_LABEL_OPTIONAL,
5367 + PROTOBUF_C_TYPE_STRING,
5368 + 0, /* quantifier_offset */
5369 + offsetof(Sr__GetSchemaReq, revision),
5370 + NULL,
5371 + NULL,
5372 + 0, /* flags */
5373 + 0,NULL,NULL /* reserved1,reserved2, etc */
5374 + },
5375 + {
5376 + "submodule_name",
5377 + 3,
5378 + PROTOBUF_C_LABEL_OPTIONAL,
5379 + PROTOBUF_C_TYPE_STRING,
5380 + 0, /* quantifier_offset */
5381 + offsetof(Sr__GetSchemaReq, submodule_name),
5382 + NULL,
5383 + NULL,
5384 + 0, /* flags */
5385 + 0,NULL,NULL /* reserved1,reserved2, etc */
5386 + },
5387 + {
5388 + "submodule_revision",
5389 + 4,
5390 + PROTOBUF_C_LABEL_OPTIONAL,
5391 + PROTOBUF_C_TYPE_STRING,
5392 + 0, /* quantifier_offset */
5393 + offsetof(Sr__GetSchemaReq, submodule_revision),
5394 + NULL,
5395 + NULL,
5396 + 0, /* flags */
5397 + 0,NULL,NULL /* reserved1,reserved2, etc */
5398 + },
5399 + {
5400 + "yang_format",
5401 + 5,
5402 + PROTOBUF_C_LABEL_REQUIRED,
5403 + PROTOBUF_C_TYPE_BOOL,
5404 + 0, /* quantifier_offset */
5405 + offsetof(Sr__GetSchemaReq, yang_format),
5406 + NULL,
5407 + NULL,
5408 + 0, /* flags */
5409 + 0,NULL,NULL /* reserved1,reserved2, etc */
5410 + },
5411 +};
5412 +static const unsigned sr__get_schema_req__field_indices_by_name[] = {
5413 + 0, /* field[0] = module_name */
5414 + 1, /* field[1] = revision */
5415 + 2, /* field[2] = submodule_name */
5416 + 3, /* field[3] = submodule_revision */
5417 + 4, /* field[4] = yang_format */
5418 +};
5419 +static const ProtobufCIntRange sr__get_schema_req__number_ranges[1 + 1] =
5420 +{
5421 + { 1, 0 },
5422 + { 0, 5 }
5423 +};
5424 +const ProtobufCMessageDescriptor sr__get_schema_req__descriptor =
5425 +{
5426 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
5427 + "sr.GetSchemaReq",
5428 + "GetSchemaReq",
5429 + "Sr__GetSchemaReq",
5430 + "sr",
5431 + sizeof(Sr__GetSchemaReq),
5432 + 5,
5433 + sr__get_schema_req__field_descriptors,
5434 + sr__get_schema_req__field_indices_by_name,
5435 + 1, sr__get_schema_req__number_ranges,
5436 + (ProtobufCMessageInit) sr__get_schema_req__init,
5437 + NULL,NULL,NULL /* reserved[123] */
5438 +};
5439 +static const ProtobufCFieldDescriptor sr__get_schema_resp__field_descriptors[1] =
5440 +{
5441 + {
5442 + "schema_content",
5443 + 1,
5444 + PROTOBUF_C_LABEL_REQUIRED,
5445 + PROTOBUF_C_TYPE_STRING,
5446 + 0, /* quantifier_offset */
5447 + offsetof(Sr__GetSchemaResp, schema_content),
5448 + NULL,
5449 + NULL,
5450 + 0, /* flags */
5451 + 0,NULL,NULL /* reserved1,reserved2, etc */
5452 + },
5453 +};
5454 +static const unsigned sr__get_schema_resp__field_indices_by_name[] = {
5455 + 0, /* field[0] = schema_content */
5456 +};
5457 +static const ProtobufCIntRange sr__get_schema_resp__number_ranges[1 + 1] =
5458 +{
5459 + { 1, 0 },
5460 + { 0, 1 }
5461 +};
5462 +const ProtobufCMessageDescriptor sr__get_schema_resp__descriptor =
5463 +{
5464 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
5465 + "sr.GetSchemaResp",
5466 + "GetSchemaResp",
5467 + "Sr__GetSchemaResp",
5468 + "sr",
5469 + sizeof(Sr__GetSchemaResp),
5470 + 1,
5471 + sr__get_schema_resp__field_descriptors,
5472 + sr__get_schema_resp__field_indices_by_name,
5473 + 1, sr__get_schema_resp__number_ranges,
5474 + (ProtobufCMessageInit) sr__get_schema_resp__init,
5475 + NULL,NULL,NULL /* reserved[123] */
5476 +};
5477 +static const ProtobufCFieldDescriptor sr__get_item_req__field_descriptors[1] =
5478 +{
5479 + {
5480 + "xpath",
5481 + 1,
5482 + PROTOBUF_C_LABEL_REQUIRED,
5483 + PROTOBUF_C_TYPE_STRING,
5484 + 0, /* quantifier_offset */
5485 + offsetof(Sr__GetItemReq, xpath),
5486 + NULL,
5487 + NULL,
5488 + 0, /* flags */
5489 + 0,NULL,NULL /* reserved1,reserved2, etc */
5490 + },
5491 +};
5492 +static const unsigned sr__get_item_req__field_indices_by_name[] = {
5493 + 0, /* field[0] = xpath */
5494 +};
5495 +static const ProtobufCIntRange sr__get_item_req__number_ranges[1 + 1] =
5496 +{
5497 + { 1, 0 },
5498 + { 0, 1 }
5499 +};
5500 +const ProtobufCMessageDescriptor sr__get_item_req__descriptor =
5501 +{
5502 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
5503 + "sr.GetItemReq",
5504 + "GetItemReq",
5505 + "Sr__GetItemReq",
5506 + "sr",
5507 + sizeof(Sr__GetItemReq),
5508 + 1,
5509 + sr__get_item_req__field_descriptors,
5510 + sr__get_item_req__field_indices_by_name,
5511 + 1, sr__get_item_req__number_ranges,
5512 + (ProtobufCMessageInit) sr__get_item_req__init,
5513 + NULL,NULL,NULL /* reserved[123] */
5514 +};
5515 +static const ProtobufCFieldDescriptor sr__get_item_resp__field_descriptors[1] =
5516 +{
5517 + {
5518 + "value",
5519 + 1,
5520 + PROTOBUF_C_LABEL_OPTIONAL,
5521 + PROTOBUF_C_TYPE_MESSAGE,
5522 + 0, /* quantifier_offset */
5523 + offsetof(Sr__GetItemResp, value),
5524 + &sr__value__descriptor,
5525 + NULL,
5526 + 0, /* flags */
5527 + 0,NULL,NULL /* reserved1,reserved2, etc */
5528 + },
5529 +};
5530 +static const unsigned sr__get_item_resp__field_indices_by_name[] = {
5531 + 0, /* field[0] = value */
5532 +};
5533 +static const ProtobufCIntRange sr__get_item_resp__number_ranges[1 + 1] =
5534 +{
5535 + { 1, 0 },
5536 + { 0, 1 }
5537 +};
5538 +const ProtobufCMessageDescriptor sr__get_item_resp__descriptor =
5539 +{
5540 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
5541 + "sr.GetItemResp",
5542 + "GetItemResp",
5543 + "Sr__GetItemResp",
5544 + "sr",
5545 + sizeof(Sr__GetItemResp),
5546 + 1,
5547 + sr__get_item_resp__field_descriptors,
5548 + sr__get_item_resp__field_indices_by_name,
5549 + 1, sr__get_item_resp__number_ranges,
5550 + (ProtobufCMessageInit) sr__get_item_resp__init,
5551 + NULL,NULL,NULL /* reserved[123] */
5552 +};
5553 +static const ProtobufCFieldDescriptor sr__get_items_req__field_descriptors[3] =
5554 +{
5555 + {
5556 + "xpath",
5557 + 1,
5558 + PROTOBUF_C_LABEL_REQUIRED,
5559 + PROTOBUF_C_TYPE_STRING,
5560 + 0, /* quantifier_offset */
5561 + offsetof(Sr__GetItemsReq, xpath),
5562 + NULL,
5563 + NULL,
5564 + 0, /* flags */
5565 + 0,NULL,NULL /* reserved1,reserved2, etc */
5566 + },
5567 + {
5568 + "limit",
5569 + 2,
5570 + PROTOBUF_C_LABEL_OPTIONAL,
5571 + PROTOBUF_C_TYPE_UINT32,
5572 + offsetof(Sr__GetItemsReq, has_limit),
5573 + offsetof(Sr__GetItemsReq, limit),
5574 + NULL,
5575 + NULL,
5576 + 0, /* flags */
5577 + 0,NULL,NULL /* reserved1,reserved2, etc */
5578 + },
5579 + {
5580 + "offset",
5581 + 3,
5582 + PROTOBUF_C_LABEL_OPTIONAL,
5583 + PROTOBUF_C_TYPE_UINT32,
5584 + offsetof(Sr__GetItemsReq, has_offset),
5585 + offsetof(Sr__GetItemsReq, offset),
5586 + NULL,
5587 + NULL,
5588 + 0, /* flags */
5589 + 0,NULL,NULL /* reserved1,reserved2, etc */
5590 + },
5591 +};
5592 +static const unsigned sr__get_items_req__field_indices_by_name[] = {
5593 + 1, /* field[1] = limit */
5594 + 2, /* field[2] = offset */
5595 + 0, /* field[0] = xpath */
5596 +};
5597 +static const ProtobufCIntRange sr__get_items_req__number_ranges[1 + 1] =
5598 +{
5599 + { 1, 0 },
5600 + { 0, 3 }
5601 +};
5602 +const ProtobufCMessageDescriptor sr__get_items_req__descriptor =
5603 +{
5604 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
5605 + "sr.GetItemsReq",
5606 + "GetItemsReq",
5607 + "Sr__GetItemsReq",
5608 + "sr",
5609 + sizeof(Sr__GetItemsReq),
5610 + 3,
5611 + sr__get_items_req__field_descriptors,
5612 + sr__get_items_req__field_indices_by_name,
5613 + 1, sr__get_items_req__number_ranges,
5614 + (ProtobufCMessageInit) sr__get_items_req__init,
5615 + NULL,NULL,NULL /* reserved[123] */
5616 +};
5617 +static const ProtobufCFieldDescriptor sr__get_items_resp__field_descriptors[1] =
5618 +{
5619 + {
5620 + "values",
5621 + 1,
5622 + PROTOBUF_C_LABEL_REPEATED,
5623 + PROTOBUF_C_TYPE_MESSAGE,
5624 + offsetof(Sr__GetItemsResp, n_values),
5625 + offsetof(Sr__GetItemsResp, values),
5626 + &sr__value__descriptor,
5627 + NULL,
5628 + 0, /* flags */
5629 + 0,NULL,NULL /* reserved1,reserved2, etc */
5630 + },
5631 +};
5632 +static const unsigned sr__get_items_resp__field_indices_by_name[] = {
5633 + 0, /* field[0] = values */
5634 +};
5635 +static const ProtobufCIntRange sr__get_items_resp__number_ranges[1 + 1] =
5636 +{
5637 + { 1, 0 },
5638 + { 0, 1 }
5639 +};
5640 +const ProtobufCMessageDescriptor sr__get_items_resp__descriptor =
5641 +{
5642 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
5643 + "sr.GetItemsResp",
5644 + "GetItemsResp",
5645 + "Sr__GetItemsResp",
5646 + "sr",
5647 + sizeof(Sr__GetItemsResp),
5648 + 1,
5649 + sr__get_items_resp__field_descriptors,
5650 + sr__get_items_resp__field_indices_by_name,
5651 + 1, sr__get_items_resp__number_ranges,
5652 + (ProtobufCMessageInit) sr__get_items_resp__init,
5653 + NULL,NULL,NULL /* reserved[123] */
5654 +};
5655 +static const ProtobufCFieldDescriptor sr__get_subtree_req__field_descriptors[1] =
5656 +{
5657 + {
5658 + "xpath",
5659 + 1,
5660 + PROTOBUF_C_LABEL_REQUIRED,
5661 + PROTOBUF_C_TYPE_STRING,
5662 + 0, /* quantifier_offset */
5663 + offsetof(Sr__GetSubtreeReq, xpath),
5664 + NULL,
5665 + NULL,
5666 + 0, /* flags */
5667 + 0,NULL,NULL /* reserved1,reserved2, etc */
5668 + },
5669 +};
5670 +static const unsigned sr__get_subtree_req__field_indices_by_name[] = {
5671 + 0, /* field[0] = xpath */
5672 +};
5673 +static const ProtobufCIntRange sr__get_subtree_req__number_ranges[1 + 1] =
5674 +{
5675 + { 1, 0 },
5676 + { 0, 1 }
5677 +};
5678 +const ProtobufCMessageDescriptor sr__get_subtree_req__descriptor =
5679 +{
5680 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
5681 + "sr.GetSubtreeReq",
5682 + "GetSubtreeReq",
5683 + "Sr__GetSubtreeReq",
5684 + "sr",
5685 + sizeof(Sr__GetSubtreeReq),
5686 + 1,
5687 + sr__get_subtree_req__field_descriptors,
5688 + sr__get_subtree_req__field_indices_by_name,
5689 + 1, sr__get_subtree_req__number_ranges,
5690 + (ProtobufCMessageInit) sr__get_subtree_req__init,
5691 + NULL,NULL,NULL /* reserved[123] */
5692 +};
5693 +static const ProtobufCFieldDescriptor sr__get_subtree_resp__field_descriptors[1] =
5694 +{
5695 + {
5696 + "tree",
5697 + 1,
5698 + PROTOBUF_C_LABEL_OPTIONAL,
5699 + PROTOBUF_C_TYPE_MESSAGE,
5700 + 0, /* quantifier_offset */
5701 + offsetof(Sr__GetSubtreeResp, tree),
5702 + &sr__node__descriptor,
5703 + NULL,
5704 + 0, /* flags */
5705 + 0,NULL,NULL /* reserved1,reserved2, etc */
5706 + },
5707 +};
5708 +static const unsigned sr__get_subtree_resp__field_indices_by_name[] = {
5709 + 0, /* field[0] = tree */
5710 +};
5711 +static const ProtobufCIntRange sr__get_subtree_resp__number_ranges[1 + 1] =
5712 +{
5713 + { 1, 0 },
5714 + { 0, 1 }
5715 +};
5716 +const ProtobufCMessageDescriptor sr__get_subtree_resp__descriptor =
5717 +{
5718 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
5719 + "sr.GetSubtreeResp",
5720 + "GetSubtreeResp",
5721 + "Sr__GetSubtreeResp",
5722 + "sr",
5723 + sizeof(Sr__GetSubtreeResp),
5724 + 1,
5725 + sr__get_subtree_resp__field_descriptors,
5726 + sr__get_subtree_resp__field_indices_by_name,
5727 + 1, sr__get_subtree_resp__number_ranges,
5728 + (ProtobufCMessageInit) sr__get_subtree_resp__init,
5729 + NULL,NULL,NULL /* reserved[123] */
5730 +};
5731 +static const ProtobufCFieldDescriptor sr__get_subtrees_req__field_descriptors[1] =
5732 +{
5733 + {
5734 + "xpath",
5735 + 1,
5736 + PROTOBUF_C_LABEL_REQUIRED,
5737 + PROTOBUF_C_TYPE_STRING,
5738 + 0, /* quantifier_offset */
5739 + offsetof(Sr__GetSubtreesReq, xpath),
5740 + NULL,
5741 + NULL,
5742 + 0, /* flags */
5743 + 0,NULL,NULL /* reserved1,reserved2, etc */
5744 + },
5745 +};
5746 +static const unsigned sr__get_subtrees_req__field_indices_by_name[] = {
5747 + 0, /* field[0] = xpath */
5748 +};
5749 +static const ProtobufCIntRange sr__get_subtrees_req__number_ranges[1 + 1] =
5750 +{
5751 + { 1, 0 },
5752 + { 0, 1 }
5753 +};
5754 +const ProtobufCMessageDescriptor sr__get_subtrees_req__descriptor =
5755 +{
5756 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
5757 + "sr.GetSubtreesReq",
5758 + "GetSubtreesReq",
5759 + "Sr__GetSubtreesReq",
5760 + "sr",
5761 + sizeof(Sr__GetSubtreesReq),
5762 + 1,
5763 + sr__get_subtrees_req__field_descriptors,
5764 + sr__get_subtrees_req__field_indices_by_name,
5765 + 1, sr__get_subtrees_req__number_ranges,
5766 + (ProtobufCMessageInit) sr__get_subtrees_req__init,
5767 + NULL,NULL,NULL /* reserved[123] */
5768 +};
5769 +static const ProtobufCFieldDescriptor sr__get_subtrees_resp__field_descriptors[1] =
5770 +{
5771 + {
5772 + "trees",
5773 + 1,
5774 + PROTOBUF_C_LABEL_REPEATED,
5775 + PROTOBUF_C_TYPE_MESSAGE,
5776 + offsetof(Sr__GetSubtreesResp, n_trees),
5777 + offsetof(Sr__GetSubtreesResp, trees),
5778 + &sr__node__descriptor,
5779 + NULL,
5780 + 0, /* flags */
5781 + 0,NULL,NULL /* reserved1,reserved2, etc */
5782 + },
5783 +};
5784 +static const unsigned sr__get_subtrees_resp__field_indices_by_name[] = {
5785 + 0, /* field[0] = trees */
5786 +};
5787 +static const ProtobufCIntRange sr__get_subtrees_resp__number_ranges[1 + 1] =
5788 +{
5789 + { 1, 0 },
5790 + { 0, 1 }
5791 +};
5792 +const ProtobufCMessageDescriptor sr__get_subtrees_resp__descriptor =
5793 +{
5794 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
5795 + "sr.GetSubtreesResp",
5796 + "GetSubtreesResp",
5797 + "Sr__GetSubtreesResp",
5798 + "sr",
5799 + sizeof(Sr__GetSubtreesResp),
5800 + 1,
5801 + sr__get_subtrees_resp__field_descriptors,
5802 + sr__get_subtrees_resp__field_indices_by_name,
5803 + 1, sr__get_subtrees_resp__number_ranges,
5804 + (ProtobufCMessageInit) sr__get_subtrees_resp__init,
5805 + NULL,NULL,NULL /* reserved[123] */
5806 +};
5807 +static const ProtobufCFieldDescriptor sr__get_subtree_chunk_req__field_descriptors[6] =
5808 +{
5809 + {
5810 + "xpath",
5811 + 1,
5812 + PROTOBUF_C_LABEL_REQUIRED,
5813 + PROTOBUF_C_TYPE_STRING,
5814 + 0, /* quantifier_offset */
5815 + offsetof(Sr__GetSubtreeChunkReq, xpath),
5816 + NULL,
5817 + NULL,
5818 + 0, /* flags */
5819 + 0,NULL,NULL /* reserved1,reserved2, etc */
5820 + },
5821 + {
5822 + "single",
5823 + 2,
5824 + PROTOBUF_C_LABEL_REQUIRED,
5825 + PROTOBUF_C_TYPE_BOOL,
5826 + 0, /* quantifier_offset */
5827 + offsetof(Sr__GetSubtreeChunkReq, single),
5828 + NULL,
5829 + NULL,
5830 + 0, /* flags */
5831 + 0,NULL,NULL /* reserved1,reserved2, etc */
5832 + },
5833 + {
5834 + "slice_offset",
5835 + 3,
5836 + PROTOBUF_C_LABEL_REQUIRED,
5837 + PROTOBUF_C_TYPE_UINT32,
5838 + 0, /* quantifier_offset */
5839 + offsetof(Sr__GetSubtreeChunkReq, slice_offset),
5840 + NULL,
5841 + NULL,
5842 + 0, /* flags */
5843 + 0,NULL,NULL /* reserved1,reserved2, etc */
5844 + },
5845 + {
5846 + "slice_width",
5847 + 4,
5848 + PROTOBUF_C_LABEL_REQUIRED,
5849 + PROTOBUF_C_TYPE_UINT32,
5850 + 0, /* quantifier_offset */
5851 + offsetof(Sr__GetSubtreeChunkReq, slice_width),
5852 + NULL,
5853 + NULL,
5854 + 0, /* flags */
5855 + 0,NULL,NULL /* reserved1,reserved2, etc */
5856 + },
5857 + {
5858 + "child_limit",
5859 + 5,
5860 + PROTOBUF_C_LABEL_REQUIRED,
5861 + PROTOBUF_C_TYPE_UINT32,
5862 + 0, /* quantifier_offset */
5863 + offsetof(Sr__GetSubtreeChunkReq, child_limit),
5864 + NULL,
5865 + NULL,
5866 + 0, /* flags */
5867 + 0,NULL,NULL /* reserved1,reserved2, etc */
5868 + },
5869 + {
5870 + "depth_limit",
5871 + 6,
5872 + PROTOBUF_C_LABEL_REQUIRED,
5873 + PROTOBUF_C_TYPE_UINT32,
5874 + 0, /* quantifier_offset */
5875 + offsetof(Sr__GetSubtreeChunkReq, depth_limit),
5876 + NULL,
5877 + NULL,
5878 + 0, /* flags */
5879 + 0,NULL,NULL /* reserved1,reserved2, etc */
5880 + },
5881 +};
5882 +static const unsigned sr__get_subtree_chunk_req__field_indices_by_name[] = {
5883 + 4, /* field[4] = child_limit */
5884 + 5, /* field[5] = depth_limit */
5885 + 1, /* field[1] = single */
5886 + 2, /* field[2] = slice_offset */
5887 + 3, /* field[3] = slice_width */
5888 + 0, /* field[0] = xpath */
5889 +};
5890 +static const ProtobufCIntRange sr__get_subtree_chunk_req__number_ranges[1 + 1] =
5891 +{
5892 + { 1, 0 },
5893 + { 0, 6 }
5894 +};
5895 +const ProtobufCMessageDescriptor sr__get_subtree_chunk_req__descriptor =
5896 +{
5897 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
5898 + "sr.GetSubtreeChunkReq",
5899 + "GetSubtreeChunkReq",
5900 + "Sr__GetSubtreeChunkReq",
5901 + "sr",
5902 + sizeof(Sr__GetSubtreeChunkReq),
5903 + 6,
5904 + sr__get_subtree_chunk_req__field_descriptors,
5905 + sr__get_subtree_chunk_req__field_indices_by_name,
5906 + 1, sr__get_subtree_chunk_req__number_ranges,
5907 + (ProtobufCMessageInit) sr__get_subtree_chunk_req__init,
5908 + NULL,NULL,NULL /* reserved[123] */
5909 +};
5910 +static const ProtobufCFieldDescriptor sr__get_subtree_chunk_resp__field_descriptors[2] =
5911 +{
5912 + {
5913 + "xpath",
5914 + 1,
5915 + PROTOBUF_C_LABEL_REPEATED,
5916 + PROTOBUF_C_TYPE_STRING,
5917 + offsetof(Sr__GetSubtreeChunkResp, n_xpath),
5918 + offsetof(Sr__GetSubtreeChunkResp, xpath),
5919 + NULL,
5920 + NULL,
5921 + 0, /* flags */
5922 + 0,NULL,NULL /* reserved1,reserved2, etc */
5923 + },
5924 + {
5925 + "chunk",
5926 + 2,
5927 + PROTOBUF_C_LABEL_REPEATED,
5928 + PROTOBUF_C_TYPE_MESSAGE,
5929 + offsetof(Sr__GetSubtreeChunkResp, n_chunk),
5930 + offsetof(Sr__GetSubtreeChunkResp, chunk),
5931 + &sr__node__descriptor,
5932 + NULL,
5933 + 0, /* flags */
5934 + 0,NULL,NULL /* reserved1,reserved2, etc */
5935 + },
5936 +};
5937 +static const unsigned sr__get_subtree_chunk_resp__field_indices_by_name[] = {
5938 + 1, /* field[1] = chunk */
5939 + 0, /* field[0] = xpath */
5940 +};
5941 +static const ProtobufCIntRange sr__get_subtree_chunk_resp__number_ranges[1 + 1] =
5942 +{
5943 + { 1, 0 },
5944 + { 0, 2 }
5945 +};
5946 +const ProtobufCMessageDescriptor sr__get_subtree_chunk_resp__descriptor =
5947 +{
5948 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
5949 + "sr.GetSubtreeChunkResp",
5950 + "GetSubtreeChunkResp",
5951 + "Sr__GetSubtreeChunkResp",
5952 + "sr",
5953 + sizeof(Sr__GetSubtreeChunkResp),
5954 + 2,
5955 + sr__get_subtree_chunk_resp__field_descriptors,
5956 + sr__get_subtree_chunk_resp__field_indices_by_name,
5957 + 1, sr__get_subtree_chunk_resp__number_ranges,
5958 + (ProtobufCMessageInit) sr__get_subtree_chunk_resp__init,
5959 + NULL,NULL,NULL /* reserved[123] */
5960 +};
5961 +static const ProtobufCFieldDescriptor sr__set_item_req__field_descriptors[3] =
5962 +{
5963 + {
5964 + "xpath",
5965 + 1,
5966 + PROTOBUF_C_LABEL_REQUIRED,
5967 + PROTOBUF_C_TYPE_STRING,
5968 + 0, /* quantifier_offset */
5969 + offsetof(Sr__SetItemReq, xpath),
5970 + NULL,
5971 + NULL,
5972 + 0, /* flags */
5973 + 0,NULL,NULL /* reserved1,reserved2, etc */
5974 + },
5975 + {
5976 + "value",
5977 + 2,
5978 + PROTOBUF_C_LABEL_OPTIONAL,
5979 + PROTOBUF_C_TYPE_MESSAGE,
5980 + 0, /* quantifier_offset */
5981 + offsetof(Sr__SetItemReq, value),
5982 + &sr__value__descriptor,
5983 + NULL,
5984 + 0, /* flags */
5985 + 0,NULL,NULL /* reserved1,reserved2, etc */
5986 + },
5987 + {
5988 + "options",
5989 + 3,
5990 + PROTOBUF_C_LABEL_REQUIRED,
5991 + PROTOBUF_C_TYPE_UINT32,
5992 + 0, /* quantifier_offset */
5993 + offsetof(Sr__SetItemReq, options),
5994 + NULL,
5995 + NULL,
5996 + 0, /* flags */
5997 + 0,NULL,NULL /* reserved1,reserved2, etc */
5998 + },
5999 +};
6000 +static const unsigned sr__set_item_req__field_indices_by_name[] = {
6001 + 2, /* field[2] = options */
6002 + 1, /* field[1] = value */
6003 + 0, /* field[0] = xpath */
6004 +};
6005 +static const ProtobufCIntRange sr__set_item_req__number_ranges[1 + 1] =
6006 +{
6007 + { 1, 0 },
6008 + { 0, 3 }
6009 +};
6010 +const ProtobufCMessageDescriptor sr__set_item_req__descriptor =
6011 +{
6012 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
6013 + "sr.SetItemReq",
6014 + "SetItemReq",
6015 + "Sr__SetItemReq",
6016 + "sr",
6017 + sizeof(Sr__SetItemReq),
6018 + 3,
6019 + sr__set_item_req__field_descriptors,
6020 + sr__set_item_req__field_indices_by_name,
6021 + 1, sr__set_item_req__number_ranges,
6022 + (ProtobufCMessageInit) sr__set_item_req__init,
6023 + NULL,NULL,NULL /* reserved[123] */
6024 +};
6025 +#define sr__set_item_resp__field_descriptors NULL
6026 +#define sr__set_item_resp__field_indices_by_name NULL
6027 +#define sr__set_item_resp__number_ranges NULL
6028 +const ProtobufCMessageDescriptor sr__set_item_resp__descriptor =
6029 +{
6030 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
6031 + "sr.SetItemResp",
6032 + "SetItemResp",
6033 + "Sr__SetItemResp",
6034 + "sr",
6035 + sizeof(Sr__SetItemResp),
6036 + 0,
6037 + sr__set_item_resp__field_descriptors,
6038 + sr__set_item_resp__field_indices_by_name,
6039 + 0, sr__set_item_resp__number_ranges,
6040 + (ProtobufCMessageInit) sr__set_item_resp__init,
6041 + NULL,NULL,NULL /* reserved[123] */
6042 +};
6043 +static const ProtobufCFieldDescriptor sr__set_item_str_req__field_descriptors[3] =
6044 +{
6045 + {
6046 + "xpath",
6047 + 1,
6048 + PROTOBUF_C_LABEL_REQUIRED,
6049 + PROTOBUF_C_TYPE_STRING,
6050 + 0, /* quantifier_offset */
6051 + offsetof(Sr__SetItemStrReq, xpath),
6052 + NULL,
6053 + NULL,
6054 + 0, /* flags */
6055 + 0,NULL,NULL /* reserved1,reserved2, etc */
6056 + },
6057 + {
6058 + "value",
6059 + 2,
6060 + PROTOBUF_C_LABEL_OPTIONAL,
6061 + PROTOBUF_C_TYPE_STRING,
6062 + 0, /* quantifier_offset */
6063 + offsetof(Sr__SetItemStrReq, value),
6064 + NULL,
6065 + NULL,
6066 + 0, /* flags */
6067 + 0,NULL,NULL /* reserved1,reserved2, etc */
6068 + },
6069 + {
6070 + "options",
6071 + 3,
6072 + PROTOBUF_C_LABEL_REQUIRED,
6073 + PROTOBUF_C_TYPE_UINT32,
6074 + 0, /* quantifier_offset */
6075 + offsetof(Sr__SetItemStrReq, options),
6076 + NULL,
6077 + NULL,
6078 + 0, /* flags */
6079 + 0,NULL,NULL /* reserved1,reserved2, etc */
6080 + },
6081 +};
6082 +static const unsigned sr__set_item_str_req__field_indices_by_name[] = {
6083 + 2, /* field[2] = options */
6084 + 1, /* field[1] = value */
6085 + 0, /* field[0] = xpath */
6086 +};
6087 +static const ProtobufCIntRange sr__set_item_str_req__number_ranges[1 + 1] =
6088 +{
6089 + { 1, 0 },
6090 + { 0, 3 }
6091 +};
6092 +const ProtobufCMessageDescriptor sr__set_item_str_req__descriptor =
6093 +{
6094 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
6095 + "sr.SetItemStrReq",
6096 + "SetItemStrReq",
6097 + "Sr__SetItemStrReq",
6098 + "sr",
6099 + sizeof(Sr__SetItemStrReq),
6100 + 3,
6101 + sr__set_item_str_req__field_descriptors,
6102 + sr__set_item_str_req__field_indices_by_name,
6103 + 1, sr__set_item_str_req__number_ranges,
6104 + (ProtobufCMessageInit) sr__set_item_str_req__init,
6105 + NULL,NULL,NULL /* reserved[123] */
6106 +};
6107 +#define sr__set_item_str_resp__field_descriptors NULL
6108 +#define sr__set_item_str_resp__field_indices_by_name NULL
6109 +#define sr__set_item_str_resp__number_ranges NULL
6110 +const ProtobufCMessageDescriptor sr__set_item_str_resp__descriptor =
6111 +{
6112 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
6113 + "sr.SetItemStrResp",
6114 + "SetItemStrResp",
6115 + "Sr__SetItemStrResp",
6116 + "sr",
6117 + sizeof(Sr__SetItemStrResp),
6118 + 0,
6119 + sr__set_item_str_resp__field_descriptors,
6120 + sr__set_item_str_resp__field_indices_by_name,
6121 + 0, sr__set_item_str_resp__number_ranges,
6122 + (ProtobufCMessageInit) sr__set_item_str_resp__init,
6123 + NULL,NULL,NULL /* reserved[123] */
6124 +};
6125 +static const ProtobufCFieldDescriptor sr__delete_item_req__field_descriptors[2] =
6126 +{
6127 + {
6128 + "xpath",
6129 + 1,
6130 + PROTOBUF_C_LABEL_REQUIRED,
6131 + PROTOBUF_C_TYPE_STRING,
6132 + 0, /* quantifier_offset */
6133 + offsetof(Sr__DeleteItemReq, xpath),
6134 + NULL,
6135 + NULL,
6136 + 0, /* flags */
6137 + 0,NULL,NULL /* reserved1,reserved2, etc */
6138 + },
6139 + {
6140 + "options",
6141 + 3,
6142 + PROTOBUF_C_LABEL_REQUIRED,
6143 + PROTOBUF_C_TYPE_UINT32,
6144 + 0, /* quantifier_offset */
6145 + offsetof(Sr__DeleteItemReq, options),
6146 + NULL,
6147 + NULL,
6148 + 0, /* flags */
6149 + 0,NULL,NULL /* reserved1,reserved2, etc */
6150 + },
6151 +};
6152 +static const unsigned sr__delete_item_req__field_indices_by_name[] = {
6153 + 1, /* field[1] = options */
6154 + 0, /* field[0] = xpath */
6155 +};
6156 +static const ProtobufCIntRange sr__delete_item_req__number_ranges[2 + 1] =
6157 +{
6158 + { 1, 0 },
6159 + { 3, 1 },
6160 + { 0, 2 }
6161 +};
6162 +const ProtobufCMessageDescriptor sr__delete_item_req__descriptor =
6163 +{
6164 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
6165 + "sr.DeleteItemReq",
6166 + "DeleteItemReq",
6167 + "Sr__DeleteItemReq",
6168 + "sr",
6169 + sizeof(Sr__DeleteItemReq),
6170 + 2,
6171 + sr__delete_item_req__field_descriptors,
6172 + sr__delete_item_req__field_indices_by_name,
6173 + 2, sr__delete_item_req__number_ranges,
6174 + (ProtobufCMessageInit) sr__delete_item_req__init,
6175 + NULL,NULL,NULL /* reserved[123] */
6176 +};
6177 +#define sr__delete_item_resp__field_descriptors NULL
6178 +#define sr__delete_item_resp__field_indices_by_name NULL
6179 +#define sr__delete_item_resp__number_ranges NULL
6180 +const ProtobufCMessageDescriptor sr__delete_item_resp__descriptor =
6181 +{
6182 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
6183 + "sr.DeleteItemResp",
6184 + "DeleteItemResp",
6185 + "Sr__DeleteItemResp",
6186 + "sr",
6187 + sizeof(Sr__DeleteItemResp),
6188 + 0,
6189 + sr__delete_item_resp__field_descriptors,
6190 + sr__delete_item_resp__field_indices_by_name,
6191 + 0, sr__delete_item_resp__number_ranges,
6192 + (ProtobufCMessageInit) sr__delete_item_resp__init,
6193 + NULL,NULL,NULL /* reserved[123] */
6194 +};
6195 +static const ProtobufCEnumValue sr__move_item_req__move_position__enum_values_by_number[4] =
6196 +{
6197 + { "BEFORE", "SR__MOVE_ITEM_REQ__MOVE_POSITION__BEFORE", 1 },
6198 + { "AFTER", "SR__MOVE_ITEM_REQ__MOVE_POSITION__AFTER", 2 },
6199 + { "FIRST", "SR__MOVE_ITEM_REQ__MOVE_POSITION__FIRST", 3 },
6200 + { "LAST", "SR__MOVE_ITEM_REQ__MOVE_POSITION__LAST", 4 },
6201 +};
6202 +static const ProtobufCIntRange sr__move_item_req__move_position__value_ranges[] = {
6203 +{1, 0},{0, 4}
6204 +};
6205 +static const ProtobufCEnumValueIndex sr__move_item_req__move_position__enum_values_by_name[4] =
6206 +{
6207 + { "AFTER", 1 },
6208 + { "BEFORE", 0 },
6209 + { "FIRST", 2 },
6210 + { "LAST", 3 },
6211 +};
6212 +const ProtobufCEnumDescriptor sr__move_item_req__move_position__descriptor =
6213 +{
6214 + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
6215 + "sr.MoveItemReq.MovePosition",
6216 + "MovePosition",
6217 + "Sr__MoveItemReq__MovePosition",
6218 + "sr",
6219 + 4,
6220 + sr__move_item_req__move_position__enum_values_by_number,
6221 + 4,
6222 + sr__move_item_req__move_position__enum_values_by_name,
6223 + 1,
6224 + sr__move_item_req__move_position__value_ranges,
6225 + NULL,NULL,NULL,NULL /* reserved[1234] */
6226 +};
6227 +static const ProtobufCFieldDescriptor sr__move_item_req__field_descriptors[3] =
6228 +{
6229 + {
6230 + "xpath",
6231 + 1,
6232 + PROTOBUF_C_LABEL_REQUIRED,
6233 + PROTOBUF_C_TYPE_STRING,
6234 + 0, /* quantifier_offset */
6235 + offsetof(Sr__MoveItemReq, xpath),
6236 + NULL,
6237 + NULL,
6238 + 0, /* flags */
6239 + 0,NULL,NULL /* reserved1,reserved2, etc */
6240 + },
6241 + {
6242 + "position",
6243 + 2,
6244 + PROTOBUF_C_LABEL_REQUIRED,
6245 + PROTOBUF_C_TYPE_ENUM,
6246 + 0, /* quantifier_offset */
6247 + offsetof(Sr__MoveItemReq, position),
6248 + &sr__move_item_req__move_position__descriptor,
6249 + NULL,
6250 + 0, /* flags */
6251 + 0,NULL,NULL /* reserved1,reserved2, etc */
6252 + },
6253 + {
6254 + "relative_item",
6255 + 3,
6256 + PROTOBUF_C_LABEL_OPTIONAL,
6257 + PROTOBUF_C_TYPE_STRING,
6258 + 0, /* quantifier_offset */
6259 + offsetof(Sr__MoveItemReq, relative_item),
6260 + NULL,
6261 + NULL,
6262 + 0, /* flags */
6263 + 0,NULL,NULL /* reserved1,reserved2, etc */
6264 + },
6265 +};
6266 +static const unsigned sr__move_item_req__field_indices_by_name[] = {
6267 + 1, /* field[1] = position */
6268 + 2, /* field[2] = relative_item */
6269 + 0, /* field[0] = xpath */
6270 +};
6271 +static const ProtobufCIntRange sr__move_item_req__number_ranges[1 + 1] =
6272 +{
6273 + { 1, 0 },
6274 + { 0, 3 }
6275 +};
6276 +const ProtobufCMessageDescriptor sr__move_item_req__descriptor =
6277 +{
6278 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
6279 + "sr.MoveItemReq",
6280 + "MoveItemReq",
6281 + "Sr__MoveItemReq",
6282 + "sr",
6283 + sizeof(Sr__MoveItemReq),
6284 + 3,
6285 + sr__move_item_req__field_descriptors,
6286 + sr__move_item_req__field_indices_by_name,
6287 + 1, sr__move_item_req__number_ranges,
6288 + (ProtobufCMessageInit) sr__move_item_req__init,
6289 + NULL,NULL,NULL /* reserved[123] */
6290 +};
6291 +#define sr__move_item_resp__field_descriptors NULL
6292 +#define sr__move_item_resp__field_indices_by_name NULL
6293 +#define sr__move_item_resp__number_ranges NULL
6294 +const ProtobufCMessageDescriptor sr__move_item_resp__descriptor =
6295 +{
6296 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
6297 + "sr.MoveItemResp",
6298 + "MoveItemResp",
6299 + "Sr__MoveItemResp",
6300 + "sr",
6301 + sizeof(Sr__MoveItemResp),
6302 + 0,
6303 + sr__move_item_resp__field_descriptors,
6304 + sr__move_item_resp__field_indices_by_name,
6305 + 0, sr__move_item_resp__number_ranges,
6306 + (ProtobufCMessageInit) sr__move_item_resp__init,
6307 + NULL,NULL,NULL /* reserved[123] */
6308 +};
6309 +#define sr__validate_req__field_descriptors NULL
6310 +#define sr__validate_req__field_indices_by_name NULL
6311 +#define sr__validate_req__number_ranges NULL
6312 +const ProtobufCMessageDescriptor sr__validate_req__descriptor =
6313 +{
6314 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
6315 + "sr.ValidateReq",
6316 + "ValidateReq",
6317 + "Sr__ValidateReq",
6318 + "sr",
6319 + sizeof(Sr__ValidateReq),
6320 + 0,
6321 + sr__validate_req__field_descriptors,
6322 + sr__validate_req__field_indices_by_name,
6323 + 0, sr__validate_req__number_ranges,
6324 + (ProtobufCMessageInit) sr__validate_req__init,
6325 + NULL,NULL,NULL /* reserved[123] */
6326 +};
6327 +static const ProtobufCFieldDescriptor sr__validate_resp__field_descriptors[1] =
6328 +{
6329 + {
6330 + "errors",
6331 + 1,
6332 + PROTOBUF_C_LABEL_REPEATED,
6333 + PROTOBUF_C_TYPE_MESSAGE,
6334 + offsetof(Sr__ValidateResp, n_errors),
6335 + offsetof(Sr__ValidateResp, errors),
6336 + &sr__error__descriptor,
6337 + NULL,
6338 + 0, /* flags */
6339 + 0,NULL,NULL /* reserved1,reserved2, etc */
6340 + },
6341 +};
6342 +static const unsigned sr__validate_resp__field_indices_by_name[] = {
6343 + 0, /* field[0] = errors */
6344 +};
6345 +static const ProtobufCIntRange sr__validate_resp__number_ranges[1 + 1] =
6346 +{
6347 + { 1, 0 },
6348 + { 0, 1 }
6349 +};
6350 +const ProtobufCMessageDescriptor sr__validate_resp__descriptor =
6351 +{
6352 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
6353 + "sr.ValidateResp",
6354 + "ValidateResp",
6355 + "Sr__ValidateResp",
6356 + "sr",
6357 + sizeof(Sr__ValidateResp),
6358 + 1,
6359 + sr__validate_resp__field_descriptors,
6360 + sr__validate_resp__field_indices_by_name,
6361 + 1, sr__validate_resp__number_ranges,
6362 + (ProtobufCMessageInit) sr__validate_resp__init,
6363 + NULL,NULL,NULL /* reserved[123] */
6364 +};
6365 +#define sr__commit_req__field_descriptors NULL
6366 +#define sr__commit_req__field_indices_by_name NULL
6367 +#define sr__commit_req__number_ranges NULL
6368 +const ProtobufCMessageDescriptor sr__commit_req__descriptor =
6369 +{
6370 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
6371 + "sr.CommitReq",
6372 + "CommitReq",
6373 + "Sr__CommitReq",
6374 + "sr",
6375 + sizeof(Sr__CommitReq),
6376 + 0,
6377 + sr__commit_req__field_descriptors,
6378 + sr__commit_req__field_indices_by_name,
6379 + 0, sr__commit_req__number_ranges,
6380 + (ProtobufCMessageInit) sr__commit_req__init,
6381 + NULL,NULL,NULL /* reserved[123] */
6382 +};
6383 +static const ProtobufCFieldDescriptor sr__commit_resp__field_descriptors[1] =
6384 +{
6385 + {
6386 + "errors",
6387 + 1,
6388 + PROTOBUF_C_LABEL_REPEATED,
6389 + PROTOBUF_C_TYPE_MESSAGE,
6390 + offsetof(Sr__CommitResp, n_errors),
6391 + offsetof(Sr__CommitResp, errors),
6392 + &sr__error__descriptor,
6393 + NULL,
6394 + 0, /* flags */
6395 + 0,NULL,NULL /* reserved1,reserved2, etc */
6396 + },
6397 +};
6398 +static const unsigned sr__commit_resp__field_indices_by_name[] = {
6399 + 0, /* field[0] = errors */
6400 +};
6401 +static const ProtobufCIntRange sr__commit_resp__number_ranges[1 + 1] =
6402 +{
6403 + { 1, 0 },
6404 + { 0, 1 }
6405 +};
6406 +const ProtobufCMessageDescriptor sr__commit_resp__descriptor =
6407 +{
6408 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
6409 + "sr.CommitResp",
6410 + "CommitResp",
6411 + "Sr__CommitResp",
6412 + "sr",
6413 + sizeof(Sr__CommitResp),
6414 + 1,
6415 + sr__commit_resp__field_descriptors,
6416 + sr__commit_resp__field_indices_by_name,
6417 + 1, sr__commit_resp__number_ranges,
6418 + (ProtobufCMessageInit) sr__commit_resp__init,
6419 + NULL,NULL,NULL /* reserved[123] */
6420 +};
6421 +#define sr__discard_changes_req__field_descriptors NULL
6422 +#define sr__discard_changes_req__field_indices_by_name NULL
6423 +#define sr__discard_changes_req__number_ranges NULL
6424 +const ProtobufCMessageDescriptor sr__discard_changes_req__descriptor =
6425 +{
6426 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
6427 + "sr.DiscardChangesReq",
6428 + "DiscardChangesReq",
6429 + "Sr__DiscardChangesReq",
6430 + "sr",
6431 + sizeof(Sr__DiscardChangesReq),
6432 + 0,
6433 + sr__discard_changes_req__field_descriptors,
6434 + sr__discard_changes_req__field_indices_by_name,
6435 + 0, sr__discard_changes_req__number_ranges,
6436 + (ProtobufCMessageInit) sr__discard_changes_req__init,
6437 + NULL,NULL,NULL /* reserved[123] */
6438 +};
6439 +#define sr__discard_changes_resp__field_descriptors NULL
6440 +#define sr__discard_changes_resp__field_indices_by_name NULL
6441 +#define sr__discard_changes_resp__number_ranges NULL
6442 +const ProtobufCMessageDescriptor sr__discard_changes_resp__descriptor =
6443 +{
6444 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
6445 + "sr.DiscardChangesResp",
6446 + "DiscardChangesResp",
6447 + "Sr__DiscardChangesResp",
6448 + "sr",
6449 + sizeof(Sr__DiscardChangesResp),
6450 + 0,
6451 + sr__discard_changes_resp__field_descriptors,
6452 + sr__discard_changes_resp__field_indices_by_name,
6453 + 0, sr__discard_changes_resp__number_ranges,
6454 + (ProtobufCMessageInit) sr__discard_changes_resp__init,
6455 + NULL,NULL,NULL /* reserved[123] */
6456 +};
6457 +static const ProtobufCFieldDescriptor sr__copy_config_req__field_descriptors[3] =
6458 +{
6459 + {
6460 + "src_datastore",
6461 + 1,
6462 + PROTOBUF_C_LABEL_REQUIRED,
6463 + PROTOBUF_C_TYPE_ENUM,
6464 + 0, /* quantifier_offset */
6465 + offsetof(Sr__CopyConfigReq, src_datastore),
6466 + &sr__data_store__descriptor,
6467 + NULL,
6468 + 0, /* flags */
6469 + 0,NULL,NULL /* reserved1,reserved2, etc */
6470 + },
6471 + {
6472 + "dst_datastore",
6473 + 2,
6474 + PROTOBUF_C_LABEL_REQUIRED,
6475 + PROTOBUF_C_TYPE_ENUM,
6476 + 0, /* quantifier_offset */
6477 + offsetof(Sr__CopyConfigReq, dst_datastore),
6478 + &sr__data_store__descriptor,
6479 + NULL,
6480 + 0, /* flags */
6481 + 0,NULL,NULL /* reserved1,reserved2, etc */
6482 + },
6483 + {
6484 + "module_name",
6485 + 3,
6486 + PROTOBUF_C_LABEL_OPTIONAL,
6487 + PROTOBUF_C_TYPE_STRING,
6488 + 0, /* quantifier_offset */
6489 + offsetof(Sr__CopyConfigReq, module_name),
6490 + NULL,
6491 + NULL,
6492 + 0, /* flags */
6493 + 0,NULL,NULL /* reserved1,reserved2, etc */
6494 + },
6495 +};
6496 +static const unsigned sr__copy_config_req__field_indices_by_name[] = {
6497 + 1, /* field[1] = dst_datastore */
6498 + 2, /* field[2] = module_name */
6499 + 0, /* field[0] = src_datastore */
6500 +};
6501 +static const ProtobufCIntRange sr__copy_config_req__number_ranges[1 + 1] =
6502 +{
6503 + { 1, 0 },
6504 + { 0, 3 }
6505 +};
6506 +const ProtobufCMessageDescriptor sr__copy_config_req__descriptor =
6507 +{
6508 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
6509 + "sr.CopyConfigReq",
6510 + "CopyConfigReq",
6511 + "Sr__CopyConfigReq",
6512 + "sr",
6513 + sizeof(Sr__CopyConfigReq),
6514 + 3,
6515 + sr__copy_config_req__field_descriptors,
6516 + sr__copy_config_req__field_indices_by_name,
6517 + 1, sr__copy_config_req__number_ranges,
6518 + (ProtobufCMessageInit) sr__copy_config_req__init,
6519 + NULL,NULL,NULL /* reserved[123] */
6520 +};
6521 +#define sr__copy_config_resp__field_descriptors NULL
6522 +#define sr__copy_config_resp__field_indices_by_name NULL
6523 +#define sr__copy_config_resp__number_ranges NULL
6524 +const ProtobufCMessageDescriptor sr__copy_config_resp__descriptor =
6525 +{
6526 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
6527 + "sr.CopyConfigResp",
6528 + "CopyConfigResp",
6529 + "Sr__CopyConfigResp",
6530 + "sr",
6531 + sizeof(Sr__CopyConfigResp),
6532 + 0,
6533 + sr__copy_config_resp__field_descriptors,
6534 + sr__copy_config_resp__field_indices_by_name,
6535 + 0, sr__copy_config_resp__number_ranges,
6536 + (ProtobufCMessageInit) sr__copy_config_resp__init,
6537 + NULL,NULL,NULL /* reserved[123] */
6538 +};
6539 +static const ProtobufCFieldDescriptor sr__lock_req__field_descriptors[1] =
6540 +{
6541 + {
6542 + "module_name",
6543 + 1,
6544 + PROTOBUF_C_LABEL_OPTIONAL,
6545 + PROTOBUF_C_TYPE_STRING,
6546 + 0, /* quantifier_offset */
6547 + offsetof(Sr__LockReq, module_name),
6548 + NULL,
6549 + NULL,
6550 + 0, /* flags */
6551 + 0,NULL,NULL /* reserved1,reserved2, etc */
6552 + },
6553 +};
6554 +static const unsigned sr__lock_req__field_indices_by_name[] = {
6555 + 0, /* field[0] = module_name */
6556 +};
6557 +static const ProtobufCIntRange sr__lock_req__number_ranges[1 + 1] =
6558 +{
6559 + { 1, 0 },
6560 + { 0, 1 }
6561 +};
6562 +const ProtobufCMessageDescriptor sr__lock_req__descriptor =
6563 +{
6564 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
6565 + "sr.LockReq",
6566 + "LockReq",
6567 + "Sr__LockReq",
6568 + "sr",
6569 + sizeof(Sr__LockReq),
6570 + 1,
6571 + sr__lock_req__field_descriptors,
6572 + sr__lock_req__field_indices_by_name,
6573 + 1, sr__lock_req__number_ranges,
6574 + (ProtobufCMessageInit) sr__lock_req__init,
6575 + NULL,NULL,NULL /* reserved[123] */
6576 +};
6577 +#define sr__lock_resp__field_descriptors NULL
6578 +#define sr__lock_resp__field_indices_by_name NULL
6579 +#define sr__lock_resp__number_ranges NULL
6580 +const ProtobufCMessageDescriptor sr__lock_resp__descriptor =
6581 +{
6582 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
6583 + "sr.LockResp",
6584 + "LockResp",
6585 + "Sr__LockResp",
6586 + "sr",
6587 + sizeof(Sr__LockResp),
6588 + 0,
6589 + sr__lock_resp__field_descriptors,
6590 + sr__lock_resp__field_indices_by_name,
6591 + 0, sr__lock_resp__number_ranges,
6592 + (ProtobufCMessageInit) sr__lock_resp__init,
6593 + NULL,NULL,NULL /* reserved[123] */
6594 +};
6595 +static const ProtobufCFieldDescriptor sr__unlock_req__field_descriptors[1] =
6596 +{
6597 + {
6598 + "module_name",
6599 + 1,
6600 + PROTOBUF_C_LABEL_OPTIONAL,
6601 + PROTOBUF_C_TYPE_STRING,
6602 + 0, /* quantifier_offset */
6603 + offsetof(Sr__UnlockReq, module_name),
6604 + NULL,
6605 + NULL,
6606 + 0, /* flags */
6607 + 0,NULL,NULL /* reserved1,reserved2, etc */
6608 + },
6609 +};
6610 +static const unsigned sr__unlock_req__field_indices_by_name[] = {
6611 + 0, /* field[0] = module_name */
6612 +};
6613 +static const ProtobufCIntRange sr__unlock_req__number_ranges[1 + 1] =
6614 +{
6615 + { 1, 0 },
6616 + { 0, 1 }
6617 +};
6618 +const ProtobufCMessageDescriptor sr__unlock_req__descriptor =
6619 +{
6620 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
6621 + "sr.UnlockReq",
6622 + "UnlockReq",
6623 + "Sr__UnlockReq",
6624 + "sr",
6625 + sizeof(Sr__UnlockReq),
6626 + 1,
6627 + sr__unlock_req__field_descriptors,
6628 + sr__unlock_req__field_indices_by_name,
6629 + 1, sr__unlock_req__number_ranges,
6630 + (ProtobufCMessageInit) sr__unlock_req__init,
6631 + NULL,NULL,NULL /* reserved[123] */
6632 +};
6633 +#define sr__unlock_resp__field_descriptors NULL
6634 +#define sr__unlock_resp__field_indices_by_name NULL
6635 +#define sr__unlock_resp__number_ranges NULL
6636 +const ProtobufCMessageDescriptor sr__unlock_resp__descriptor =
6637 +{
6638 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
6639 + "sr.UnlockResp",
6640 + "UnlockResp",
6641 + "Sr__UnlockResp",
6642 + "sr",
6643 + sizeof(Sr__UnlockResp),
6644 + 0,
6645 + sr__unlock_resp__field_descriptors,
6646 + sr__unlock_resp__field_indices_by_name,
6647 + 0, sr__unlock_resp__number_ranges,
6648 + (ProtobufCMessageInit) sr__unlock_resp__init,
6649 + NULL,NULL,NULL /* reserved[123] */
6650 +};
6651 +static const ProtobufCFieldDescriptor sr__subscribe_req__field_descriptors[10] =
6652 +{
6653 + {
6654 + "type",
6655 + 1,
6656 + PROTOBUF_C_LABEL_REQUIRED,
6657 + PROTOBUF_C_TYPE_ENUM,
6658 + 0, /* quantifier_offset */
6659 + offsetof(Sr__SubscribeReq, type),
6660 + &sr__subscription_type__descriptor,
6661 + NULL,
6662 + 0, /* flags */
6663 + 0,NULL,NULL /* reserved1,reserved2, etc */
6664 + },
6665 + {
6666 + "destination",
6667 + 2,
6668 + PROTOBUF_C_LABEL_REQUIRED,
6669 + PROTOBUF_C_TYPE_STRING,
6670 + 0, /* quantifier_offset */
6671 + offsetof(Sr__SubscribeReq, destination),
6672 + NULL,
6673 + NULL,
6674 + 0, /* flags */
6675 + 0,NULL,NULL /* reserved1,reserved2, etc */
6676 + },
6677 + {
6678 + "subscription_id",
6679 + 3,
6680 + PROTOBUF_C_LABEL_REQUIRED,
6681 + PROTOBUF_C_TYPE_UINT32,
6682 + 0, /* quantifier_offset */
6683 + offsetof(Sr__SubscribeReq, subscription_id),
6684 + NULL,
6685 + NULL,
6686 + 0, /* flags */
6687 + 0,NULL,NULL /* reserved1,reserved2, etc */
6688 + },
6689 + {
6690 + "module_name",
6691 + 4,
6692 + PROTOBUF_C_LABEL_OPTIONAL,
6693 + PROTOBUF_C_TYPE_STRING,
6694 + 0, /* quantifier_offset */
6695 + offsetof(Sr__SubscribeReq, module_name),
6696 + NULL,
6697 + NULL,
6698 + 0, /* flags */
6699 + 0,NULL,NULL /* reserved1,reserved2, etc */
6700 + },
6701 + {
6702 + "xpath",
6703 + 5,
6704 + PROTOBUF_C_LABEL_OPTIONAL,
6705 + PROTOBUF_C_TYPE_STRING,
6706 + 0, /* quantifier_offset */
6707 + offsetof(Sr__SubscribeReq, xpath),
6708 + NULL,
6709 + NULL,
6710 + 0, /* flags */
6711 + 0,NULL,NULL /* reserved1,reserved2, etc */
6712 + },
6713 + {
6714 + "notif_event",
6715 + 10,
6716 + PROTOBUF_C_LABEL_OPTIONAL,
6717 + PROTOBUF_C_TYPE_ENUM,
6718 + offsetof(Sr__SubscribeReq, has_notif_event),
6719 + offsetof(Sr__SubscribeReq, notif_event),
6720 + &sr__notification_event__descriptor,
6721 + NULL,
6722 + 0, /* flags */
6723 + 0,NULL,NULL /* reserved1,reserved2, etc */
6724 + },
6725 + {
6726 + "priority",
6727 + 11,
6728 + PROTOBUF_C_LABEL_OPTIONAL,
6729 + PROTOBUF_C_TYPE_UINT32,
6730 + offsetof(Sr__SubscribeReq, has_priority),
6731 + offsetof(Sr__SubscribeReq, priority),
6732 + NULL,
6733 + NULL,
6734 + 0, /* flags */
6735 + 0,NULL,NULL /* reserved1,reserved2, etc */
6736 + },
6737 + {
6738 + "enable_running",
6739 + 12,
6740 + PROTOBUF_C_LABEL_OPTIONAL,
6741 + PROTOBUF_C_TYPE_BOOL,
6742 + offsetof(Sr__SubscribeReq, has_enable_running),
6743 + offsetof(Sr__SubscribeReq, enable_running),
6744 + NULL,
6745 + NULL,
6746 + 0, /* flags */
6747 + 0,NULL,NULL /* reserved1,reserved2, etc */
6748 + },
6749 + {
6750 + "enable_event",
6751 + 13,
6752 + PROTOBUF_C_LABEL_OPTIONAL,
6753 + PROTOBUF_C_TYPE_BOOL,
6754 + offsetof(Sr__SubscribeReq, has_enable_event),
6755 + offsetof(Sr__SubscribeReq, enable_event),
6756 + NULL,
6757 + NULL,
6758 + 0, /* flags */
6759 + 0,NULL,NULL /* reserved1,reserved2, etc */
6760 + },
6761 + {
6762 + "api_variant",
6763 + 20,
6764 + PROTOBUF_C_LABEL_REQUIRED,
6765 + PROTOBUF_C_TYPE_ENUM,
6766 + 0, /* quantifier_offset */
6767 + offsetof(Sr__SubscribeReq, api_variant),
6768 + &sr__api_variant__descriptor,
6769 + NULL,
6770 + 0, /* flags */
6771 + 0,NULL,NULL /* reserved1,reserved2, etc */
6772 + },
6773 +};
6774 +static const unsigned sr__subscribe_req__field_indices_by_name[] = {
6775 + 9, /* field[9] = api_variant */
6776 + 1, /* field[1] = destination */
6777 + 8, /* field[8] = enable_event */
6778 + 7, /* field[7] = enable_running */
6779 + 3, /* field[3] = module_name */
6780 + 5, /* field[5] = notif_event */
6781 + 6, /* field[6] = priority */
6782 + 2, /* field[2] = subscription_id */
6783 + 0, /* field[0] = type */
6784 + 4, /* field[4] = xpath */
6785 +};
6786 +static const ProtobufCIntRange sr__subscribe_req__number_ranges[3 + 1] =
6787 +{
6788 + { 1, 0 },
6789 + { 10, 5 },
6790 + { 20, 9 },
6791 + { 0, 10 }
6792 +};
6793 +const ProtobufCMessageDescriptor sr__subscribe_req__descriptor =
6794 +{
6795 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
6796 + "sr.SubscribeReq",
6797 + "SubscribeReq",
6798 + "Sr__SubscribeReq",
6799 + "sr",
6800 + sizeof(Sr__SubscribeReq),
6801 + 10,
6802 + sr__subscribe_req__field_descriptors,
6803 + sr__subscribe_req__field_indices_by_name,
6804 + 3, sr__subscribe_req__number_ranges,
6805 + (ProtobufCMessageInit) sr__subscribe_req__init,
6806 + NULL,NULL,NULL /* reserved[123] */
6807 +};
6808 +#define sr__subscribe_resp__field_descriptors NULL
6809 +#define sr__subscribe_resp__field_indices_by_name NULL
6810 +#define sr__subscribe_resp__number_ranges NULL
6811 +const ProtobufCMessageDescriptor sr__subscribe_resp__descriptor =
6812 +{
6813 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
6814 + "sr.SubscribeResp",
6815 + "SubscribeResp",
6816 + "Sr__SubscribeResp",
6817 + "sr",
6818 + sizeof(Sr__SubscribeResp),
6819 + 0,
6820 + sr__subscribe_resp__field_descriptors,
6821 + sr__subscribe_resp__field_indices_by_name,
6822 + 0, sr__subscribe_resp__number_ranges,
6823 + (ProtobufCMessageInit) sr__subscribe_resp__init,
6824 + NULL,NULL,NULL /* reserved[123] */
6825 +};
6826 +static const ProtobufCFieldDescriptor sr__unsubscribe_req__field_descriptors[4] =
6827 +{
6828 + {
6829 + "type",
6830 + 1,
6831 + PROTOBUF_C_LABEL_REQUIRED,
6832 + PROTOBUF_C_TYPE_ENUM,
6833 + 0, /* quantifier_offset */
6834 + offsetof(Sr__UnsubscribeReq, type),
6835 + &sr__subscription_type__descriptor,
6836 + NULL,
6837 + 0, /* flags */
6838 + 0,NULL,NULL /* reserved1,reserved2, etc */
6839 + },
6840 + {
6841 + "destination",
6842 + 2,
6843 + PROTOBUF_C_LABEL_REQUIRED,
6844 + PROTOBUF_C_TYPE_STRING,
6845 + 0, /* quantifier_offset */
6846 + offsetof(Sr__UnsubscribeReq, destination),
6847 + NULL,
6848 + NULL,
6849 + 0, /* flags */
6850 + 0,NULL,NULL /* reserved1,reserved2, etc */
6851 + },
6852 + {
6853 + "subscription_id",
6854 + 3,
6855 + PROTOBUF_C_LABEL_REQUIRED,
6856 + PROTOBUF_C_TYPE_UINT32,
6857 + 0, /* quantifier_offset */
6858 + offsetof(Sr__UnsubscribeReq, subscription_id),
6859 + NULL,
6860 + NULL,
6861 + 0, /* flags */
6862 + 0,NULL,NULL /* reserved1,reserved2, etc */
6863 + },
6864 + {
6865 + "module_name",
6866 + 4,
6867 + PROTOBUF_C_LABEL_OPTIONAL,
6868 + PROTOBUF_C_TYPE_STRING,
6869 + 0, /* quantifier_offset */
6870 + offsetof(Sr__UnsubscribeReq, module_name),
6871 + NULL,
6872 + NULL,
6873 + 0, /* flags */
6874 + 0,NULL,NULL /* reserved1,reserved2, etc */
6875 + },
6876 +};
6877 +static const unsigned sr__unsubscribe_req__field_indices_by_name[] = {
6878 + 1, /* field[1] = destination */
6879 + 3, /* field[3] = module_name */
6880 + 2, /* field[2] = subscription_id */
6881 + 0, /* field[0] = type */
6882 +};
6883 +static const ProtobufCIntRange sr__unsubscribe_req__number_ranges[1 + 1] =
6884 +{
6885 + { 1, 0 },
6886 + { 0, 4 }
6887 +};
6888 +const ProtobufCMessageDescriptor sr__unsubscribe_req__descriptor =
6889 +{
6890 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
6891 + "sr.UnsubscribeReq",
6892 + "UnsubscribeReq",
6893 + "Sr__UnsubscribeReq",
6894 + "sr",
6895 + sizeof(Sr__UnsubscribeReq),
6896 + 4,
6897 + sr__unsubscribe_req__field_descriptors,
6898 + sr__unsubscribe_req__field_indices_by_name,
6899 + 1, sr__unsubscribe_req__number_ranges,
6900 + (ProtobufCMessageInit) sr__unsubscribe_req__init,
6901 + NULL,NULL,NULL /* reserved[123] */
6902 +};
6903 +#define sr__unsubscribe_resp__field_descriptors NULL
6904 +#define sr__unsubscribe_resp__field_indices_by_name NULL
6905 +#define sr__unsubscribe_resp__number_ranges NULL
6906 +const ProtobufCMessageDescriptor sr__unsubscribe_resp__descriptor =
6907 +{
6908 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
6909 + "sr.UnsubscribeResp",
6910 + "UnsubscribeResp",
6911 + "Sr__UnsubscribeResp",
6912 + "sr",
6913 + sizeof(Sr__UnsubscribeResp),
6914 + 0,
6915 + sr__unsubscribe_resp__field_descriptors,
6916 + sr__unsubscribe_resp__field_indices_by_name,
6917 + 0, sr__unsubscribe_resp__number_ranges,
6918 + (ProtobufCMessageInit) sr__unsubscribe_resp__init,
6919 + NULL,NULL,NULL /* reserved[123] */
6920 +};
6921 +static const ProtobufCFieldDescriptor sr__check_enabled_running_req__field_descriptors[1] =
6922 +{
6923 + {
6924 + "module_name",
6925 + 1,
6926 + PROTOBUF_C_LABEL_REQUIRED,
6927 + PROTOBUF_C_TYPE_STRING,
6928 + 0, /* quantifier_offset */
6929 + offsetof(Sr__CheckEnabledRunningReq, module_name),
6930 + NULL,
6931 + NULL,
6932 + 0, /* flags */
6933 + 0,NULL,NULL /* reserved1,reserved2, etc */
6934 + },
6935 +};
6936 +static const unsigned sr__check_enabled_running_req__field_indices_by_name[] = {
6937 + 0, /* field[0] = module_name */
6938 +};
6939 +static const ProtobufCIntRange sr__check_enabled_running_req__number_ranges[1 + 1] =
6940 +{
6941 + { 1, 0 },
6942 + { 0, 1 }
6943 +};
6944 +const ProtobufCMessageDescriptor sr__check_enabled_running_req__descriptor =
6945 +{
6946 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
6947 + "sr.CheckEnabledRunningReq",
6948 + "CheckEnabledRunningReq",
6949 + "Sr__CheckEnabledRunningReq",
6950 + "sr",
6951 + sizeof(Sr__CheckEnabledRunningReq),
6952 + 1,
6953 + sr__check_enabled_running_req__field_descriptors,
6954 + sr__check_enabled_running_req__field_indices_by_name,
6955 + 1, sr__check_enabled_running_req__number_ranges,
6956 + (ProtobufCMessageInit) sr__check_enabled_running_req__init,
6957 + NULL,NULL,NULL /* reserved[123] */
6958 +};
6959 +static const ProtobufCFieldDescriptor sr__check_enabled_running_resp__field_descriptors[1] =
6960 +{
6961 + {
6962 + "enabled",
6963 + 1,
6964 + PROTOBUF_C_LABEL_REQUIRED,
6965 + PROTOBUF_C_TYPE_BOOL,
6966 + 0, /* quantifier_offset */
6967 + offsetof(Sr__CheckEnabledRunningResp, enabled),
6968 + NULL,
6969 + NULL,
6970 + 0, /* flags */
6971 + 0,NULL,NULL /* reserved1,reserved2, etc */
6972 + },
6973 +};
6974 +static const unsigned sr__check_enabled_running_resp__field_indices_by_name[] = {
6975 + 0, /* field[0] = enabled */
6976 +};
6977 +static const ProtobufCIntRange sr__check_enabled_running_resp__number_ranges[1 + 1] =
6978 +{
6979 + { 1, 0 },
6980 + { 0, 1 }
6981 +};
6982 +const ProtobufCMessageDescriptor sr__check_enabled_running_resp__descriptor =
6983 +{
6984 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
6985 + "sr.CheckEnabledRunningResp",
6986 + "CheckEnabledRunningResp",
6987 + "Sr__CheckEnabledRunningResp",
6988 + "sr",
6989 + sizeof(Sr__CheckEnabledRunningResp),
6990 + 1,
6991 + sr__check_enabled_running_resp__field_descriptors,
6992 + sr__check_enabled_running_resp__field_indices_by_name,
6993 + 1, sr__check_enabled_running_resp__number_ranges,
6994 + (ProtobufCMessageInit) sr__check_enabled_running_resp__init,
6995 + NULL,NULL,NULL /* reserved[123] */
6996 +};
6997 +static const ProtobufCFieldDescriptor sr__module_install_notification__field_descriptors[3] =
6998 +{
6999 + {
7000 + "module_name",
7001 + 1,
7002 + PROTOBUF_C_LABEL_OPTIONAL,
7003 + PROTOBUF_C_TYPE_STRING,
7004 + 0, /* quantifier_offset */
7005 + offsetof(Sr__ModuleInstallNotification, module_name),
7006 + NULL,
7007 + NULL,
7008 + 0, /* flags */
7009 + 0,NULL,NULL /* reserved1,reserved2, etc */
7010 + },
7011 + {
7012 + "revision",
7013 + 2,
7014 + PROTOBUF_C_LABEL_OPTIONAL,
7015 + PROTOBUF_C_TYPE_STRING,
7016 + 0, /* quantifier_offset */
7017 + offsetof(Sr__ModuleInstallNotification, revision),
7018 + NULL,
7019 + NULL,
7020 + 0, /* flags */
7021 + 0,NULL,NULL /* reserved1,reserved2, etc */
7022 + },
7023 + {
7024 + "state",
7025 + 3,
7026 + PROTOBUF_C_LABEL_REQUIRED,
7027 + PROTOBUF_C_TYPE_ENUM,
7028 + 0, /* quantifier_offset */
7029 + offsetof(Sr__ModuleInstallNotification, state),
7030 + &sr__module_state__descriptor,
7031 + NULL,
7032 + 0, /* flags */
7033 + 0,NULL,NULL /* reserved1,reserved2, etc */
7034 + },
7035 +};
7036 +static const unsigned sr__module_install_notification__field_indices_by_name[] = {
7037 + 0, /* field[0] = module_name */
7038 + 1, /* field[1] = revision */
7039 + 2, /* field[2] = state */
7040 +};
7041 +static const ProtobufCIntRange sr__module_install_notification__number_ranges[1 + 1] =
7042 +{
7043 + { 1, 0 },
7044 + { 0, 3 }
7045 +};
7046 +const ProtobufCMessageDescriptor sr__module_install_notification__descriptor =
7047 +{
7048 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
7049 + "sr.ModuleInstallNotification",
7050 + "ModuleInstallNotification",
7051 + "Sr__ModuleInstallNotification",
7052 + "sr",
7053 + sizeof(Sr__ModuleInstallNotification),
7054 + 3,
7055 + sr__module_install_notification__field_descriptors,
7056 + sr__module_install_notification__field_indices_by_name,
7057 + 1, sr__module_install_notification__number_ranges,
7058 + (ProtobufCMessageInit) sr__module_install_notification__init,
7059 + NULL,NULL,NULL /* reserved[123] */
7060 +};
7061 +static const ProtobufCFieldDescriptor sr__feature_enable_notification__field_descriptors[3] =
7062 +{
7063 + {
7064 + "module_name",
7065 + 1,
7066 + PROTOBUF_C_LABEL_REQUIRED,
7067 + PROTOBUF_C_TYPE_STRING,
7068 + 0, /* quantifier_offset */
7069 + offsetof(Sr__FeatureEnableNotification, module_name),
7070 + NULL,
7071 + NULL,
7072 + 0, /* flags */
7073 + 0,NULL,NULL /* reserved1,reserved2, etc */
7074 + },
7075 + {
7076 + "feature_name",
7077 + 2,
7078 + PROTOBUF_C_LABEL_REQUIRED,
7079 + PROTOBUF_C_TYPE_STRING,
7080 + 0, /* quantifier_offset */
7081 + offsetof(Sr__FeatureEnableNotification, feature_name),
7082 + NULL,
7083 + NULL,
7084 + 0, /* flags */
7085 + 0,NULL,NULL /* reserved1,reserved2, etc */
7086 + },
7087 + {
7088 + "enabled",
7089 + 3,
7090 + PROTOBUF_C_LABEL_REQUIRED,
7091 + PROTOBUF_C_TYPE_BOOL,
7092 + 0, /* quantifier_offset */
7093 + offsetof(Sr__FeatureEnableNotification, enabled),
7094 + NULL,
7095 + NULL,
7096 + 0, /* flags */
7097 + 0,NULL,NULL /* reserved1,reserved2, etc */
7098 + },
7099 +};
7100 +static const unsigned sr__feature_enable_notification__field_indices_by_name[] = {
7101 + 2, /* field[2] = enabled */
7102 + 1, /* field[1] = feature_name */
7103 + 0, /* field[0] = module_name */
7104 +};
7105 +static const ProtobufCIntRange sr__feature_enable_notification__number_ranges[1 + 1] =
7106 +{
7107 + { 1, 0 },
7108 + { 0, 3 }
7109 +};
7110 +const ProtobufCMessageDescriptor sr__feature_enable_notification__descriptor =
7111 +{
7112 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
7113 + "sr.FeatureEnableNotification",
7114 + "FeatureEnableNotification",
7115 + "Sr__FeatureEnableNotification",
7116 + "sr",
7117 + sizeof(Sr__FeatureEnableNotification),
7118 + 3,
7119 + sr__feature_enable_notification__field_descriptors,
7120 + sr__feature_enable_notification__field_indices_by_name,
7121 + 1, sr__feature_enable_notification__number_ranges,
7122 + (ProtobufCMessageInit) sr__feature_enable_notification__init,
7123 + NULL,NULL,NULL /* reserved[123] */
7124 +};
7125 +static const ProtobufCFieldDescriptor sr__module_change_notification__field_descriptors[2] =
7126 +{
7127 + {
7128 + "event",
7129 + 1,
7130 + PROTOBUF_C_LABEL_REQUIRED,
7131 + PROTOBUF_C_TYPE_ENUM,
7132 + 0, /* quantifier_offset */
7133 + offsetof(Sr__ModuleChangeNotification, event),
7134 + &sr__notification_event__descriptor,
7135 + NULL,
7136 + 0, /* flags */
7137 + 0,NULL,NULL /* reserved1,reserved2, etc */
7138 + },
7139 + {
7140 + "module_name",
7141 + 2,
7142 + PROTOBUF_C_LABEL_REQUIRED,
7143 + PROTOBUF_C_TYPE_STRING,
7144 + 0, /* quantifier_offset */
7145 + offsetof(Sr__ModuleChangeNotification, module_name),
7146 + NULL,
7147 + NULL,
7148 + 0, /* flags */
7149 + 0,NULL,NULL /* reserved1,reserved2, etc */
7150 + },
7151 +};
7152 +static const unsigned sr__module_change_notification__field_indices_by_name[] = {
7153 + 0, /* field[0] = event */
7154 + 1, /* field[1] = module_name */
7155 +};
7156 +static const ProtobufCIntRange sr__module_change_notification__number_ranges[1 + 1] =
7157 +{
7158 + { 1, 0 },
7159 + { 0, 2 }
7160 +};
7161 +const ProtobufCMessageDescriptor sr__module_change_notification__descriptor =
7162 +{
7163 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
7164 + "sr.ModuleChangeNotification",
7165 + "ModuleChangeNotification",
7166 + "Sr__ModuleChangeNotification",
7167 + "sr",
7168 + sizeof(Sr__ModuleChangeNotification),
7169 + 2,
7170 + sr__module_change_notification__field_descriptors,
7171 + sr__module_change_notification__field_indices_by_name,
7172 + 1, sr__module_change_notification__number_ranges,
7173 + (ProtobufCMessageInit) sr__module_change_notification__init,
7174 + NULL,NULL,NULL /* reserved[123] */
7175 +};
7176 +static const ProtobufCFieldDescriptor sr__subtree_change_notification__field_descriptors[2] =
7177 +{
7178 + {
7179 + "event",
7180 + 1,
7181 + PROTOBUF_C_LABEL_REQUIRED,
7182 + PROTOBUF_C_TYPE_ENUM,
7183 + 0, /* quantifier_offset */
7184 + offsetof(Sr__SubtreeChangeNotification, event),
7185 + &sr__notification_event__descriptor,
7186 + NULL,
7187 + 0, /* flags */
7188 + 0,NULL,NULL /* reserved1,reserved2, etc */
7189 + },
7190 + {
7191 + "xpath",
7192 + 2,
7193 + PROTOBUF_C_LABEL_REQUIRED,
7194 + PROTOBUF_C_TYPE_STRING,
7195 + 0, /* quantifier_offset */
7196 + offsetof(Sr__SubtreeChangeNotification, xpath),
7197 + NULL,
7198 + NULL,
7199 + 0, /* flags */
7200 + 0,NULL,NULL /* reserved1,reserved2, etc */
7201 + },
7202 +};
7203 +static const unsigned sr__subtree_change_notification__field_indices_by_name[] = {
7204 + 0, /* field[0] = event */
7205 + 1, /* field[1] = xpath */
7206 +};
7207 +static const ProtobufCIntRange sr__subtree_change_notification__number_ranges[1 + 1] =
7208 +{
7209 + { 1, 0 },
7210 + { 0, 2 }
7211 +};
7212 +const ProtobufCMessageDescriptor sr__subtree_change_notification__descriptor =
7213 +{
7214 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
7215 + "sr.SubtreeChangeNotification",
7216 + "SubtreeChangeNotification",
7217 + "Sr__SubtreeChangeNotification",
7218 + "sr",
7219 + sizeof(Sr__SubtreeChangeNotification),
7220 + 2,
7221 + sr__subtree_change_notification__field_descriptors,
7222 + sr__subtree_change_notification__field_indices_by_name,
7223 + 1, sr__subtree_change_notification__number_ranges,
7224 + (ProtobufCMessageInit) sr__subtree_change_notification__init,
7225 + NULL,NULL,NULL /* reserved[123] */
7226 +};
7227 +static const ProtobufCFieldDescriptor sr__change__field_descriptors[3] =
7228 +{
7229 + {
7230 + "changeOperation",
7231 + 1,
7232 + PROTOBUF_C_LABEL_REQUIRED,
7233 + PROTOBUF_C_TYPE_ENUM,
7234 + 0, /* quantifier_offset */
7235 + offsetof(Sr__Change, changeoperation),
7236 + &sr__change_operation__descriptor,
7237 + NULL,
7238 + 0, /* flags */
7239 + 0,NULL,NULL /* reserved1,reserved2, etc */
7240 + },
7241 + {
7242 + "new_value",
7243 + 2,
7244 + PROTOBUF_C_LABEL_OPTIONAL,
7245 + PROTOBUF_C_TYPE_MESSAGE,
7246 + 0, /* quantifier_offset */
7247 + offsetof(Sr__Change, new_value),
7248 + &sr__value__descriptor,
7249 + NULL,
7250 + 0, /* flags */
7251 + 0,NULL,NULL /* reserved1,reserved2, etc */
7252 + },
7253 + {
7254 + "old_value",
7255 + 3,
7256 + PROTOBUF_C_LABEL_OPTIONAL,
7257 + PROTOBUF_C_TYPE_MESSAGE,
7258 + 0, /* quantifier_offset */
7259 + offsetof(Sr__Change, old_value),
7260 + &sr__value__descriptor,
7261 + NULL,
7262 + 0, /* flags */
7263 + 0,NULL,NULL /* reserved1,reserved2, etc */
7264 + },
7265 +};
7266 +static const unsigned sr__change__field_indices_by_name[] = {
7267 + 0, /* field[0] = changeOperation */
7268 + 1, /* field[1] = new_value */
7269 + 2, /* field[2] = old_value */
7270 +};
7271 +static const ProtobufCIntRange sr__change__number_ranges[1 + 1] =
7272 +{
7273 + { 1, 0 },
7274 + { 0, 3 }
7275 +};
7276 +const ProtobufCMessageDescriptor sr__change__descriptor =
7277 +{
7278 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
7279 + "sr.Change",
7280 + "Change",
7281 + "Sr__Change",
7282 + "sr",
7283 + sizeof(Sr__Change),
7284 + 3,
7285 + sr__change__field_descriptors,
7286 + sr__change__field_indices_by_name,
7287 + 1, sr__change__number_ranges,
7288 + (ProtobufCMessageInit) sr__change__init,
7289 + NULL,NULL,NULL /* reserved[123] */
7290 +};
7291 +static const ProtobufCFieldDescriptor sr__get_changes_req__field_descriptors[3] =
7292 +{
7293 + {
7294 + "xpath",
7295 + 1,
7296 + PROTOBUF_C_LABEL_REQUIRED,
7297 + PROTOBUF_C_TYPE_STRING,
7298 + 0, /* quantifier_offset */
7299 + offsetof(Sr__GetChangesReq, xpath),
7300 + NULL,
7301 + NULL,
7302 + 0, /* flags */
7303 + 0,NULL,NULL /* reserved1,reserved2, etc */
7304 + },
7305 + {
7306 + "limit",
7307 + 2,
7308 + PROTOBUF_C_LABEL_REQUIRED,
7309 + PROTOBUF_C_TYPE_UINT32,
7310 + 0, /* quantifier_offset */
7311 + offsetof(Sr__GetChangesReq, limit),
7312 + NULL,
7313 + NULL,
7314 + 0, /* flags */
7315 + 0,NULL,NULL /* reserved1,reserved2, etc */
7316 + },
7317 + {
7318 + "offset",
7319 + 3,
7320 + PROTOBUF_C_LABEL_REQUIRED,
7321 + PROTOBUF_C_TYPE_UINT32,
7322 + 0, /* quantifier_offset */
7323 + offsetof(Sr__GetChangesReq, offset),
7324 + NULL,
7325 + NULL,
7326 + 0, /* flags */
7327 + 0,NULL,NULL /* reserved1,reserved2, etc */
7328 + },
7329 +};
7330 +static const unsigned sr__get_changes_req__field_indices_by_name[] = {
7331 + 1, /* field[1] = limit */
7332 + 2, /* field[2] = offset */
7333 + 0, /* field[0] = xpath */
7334 +};
7335 +static const ProtobufCIntRange sr__get_changes_req__number_ranges[1 + 1] =
7336 +{
7337 + { 1, 0 },
7338 + { 0, 3 }
7339 +};
7340 +const ProtobufCMessageDescriptor sr__get_changes_req__descriptor =
7341 +{
7342 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
7343 + "sr.GetChangesReq",
7344 + "GetChangesReq",
7345 + "Sr__GetChangesReq",
7346 + "sr",
7347 + sizeof(Sr__GetChangesReq),
7348 + 3,
7349 + sr__get_changes_req__field_descriptors,
7350 + sr__get_changes_req__field_indices_by_name,
7351 + 1, sr__get_changes_req__number_ranges,
7352 + (ProtobufCMessageInit) sr__get_changes_req__init,
7353 + NULL,NULL,NULL /* reserved[123] */
7354 +};
7355 +static const ProtobufCFieldDescriptor sr__get_changes_resp__field_descriptors[1] =
7356 +{
7357 + {
7358 + "changes",
7359 + 1,
7360 + PROTOBUF_C_LABEL_REPEATED,
7361 + PROTOBUF_C_TYPE_MESSAGE,
7362 + offsetof(Sr__GetChangesResp, n_changes),
7363 + offsetof(Sr__GetChangesResp, changes),
7364 + &sr__change__descriptor,
7365 + NULL,
7366 + 0, /* flags */
7367 + 0,NULL,NULL /* reserved1,reserved2, etc */
7368 + },
7369 +};
7370 +static const unsigned sr__get_changes_resp__field_indices_by_name[] = {
7371 + 0, /* field[0] = changes */
7372 +};
7373 +static const ProtobufCIntRange sr__get_changes_resp__number_ranges[1 + 1] =
7374 +{
7375 + { 1, 0 },
7376 + { 0, 1 }
7377 +};
7378 +const ProtobufCMessageDescriptor sr__get_changes_resp__descriptor =
7379 +{
7380 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
7381 + "sr.GetChangesResp",
7382 + "GetChangesResp",
7383 + "Sr__GetChangesResp",
7384 + "sr",
7385 + sizeof(Sr__GetChangesResp),
7386 + 1,
7387 + sr__get_changes_resp__field_descriptors,
7388 + sr__get_changes_resp__field_indices_by_name,
7389 + 1, sr__get_changes_resp__number_ranges,
7390 + (ProtobufCMessageInit) sr__get_changes_resp__init,
7391 + NULL,NULL,NULL /* reserved[123] */
7392 +};
7393 +static const ProtobufCFieldDescriptor sr__check_exec_perm_req__field_descriptors[1] =
7394 +{
7395 + {
7396 + "xpath",
7397 + 1,
7398 + PROTOBUF_C_LABEL_REQUIRED,
7399 + PROTOBUF_C_TYPE_STRING,
7400 + 0, /* quantifier_offset */
7401 + offsetof(Sr__CheckExecPermReq, xpath),
7402 + NULL,
7403 + NULL,
7404 + 0, /* flags */
7405 + 0,NULL,NULL /* reserved1,reserved2, etc */
7406 + },
7407 +};
7408 +static const unsigned sr__check_exec_perm_req__field_indices_by_name[] = {
7409 + 0, /* field[0] = xpath */
7410 +};
7411 +static const ProtobufCIntRange sr__check_exec_perm_req__number_ranges[1 + 1] =
7412 +{
7413 + { 1, 0 },
7414 + { 0, 1 }
7415 +};
7416 +const ProtobufCMessageDescriptor sr__check_exec_perm_req__descriptor =
7417 +{
7418 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
7419 + "sr.CheckExecPermReq",
7420 + "CheckExecPermReq",
7421 + "Sr__CheckExecPermReq",
7422 + "sr",
7423 + sizeof(Sr__CheckExecPermReq),
7424 + 1,
7425 + sr__check_exec_perm_req__field_descriptors,
7426 + sr__check_exec_perm_req__field_indices_by_name,
7427 + 1, sr__check_exec_perm_req__number_ranges,
7428 + (ProtobufCMessageInit) sr__check_exec_perm_req__init,
7429 + NULL,NULL,NULL /* reserved[123] */
7430 +};
7431 +static const ProtobufCFieldDescriptor sr__check_exec_perm_resp__field_descriptors[1] =
7432 +{
7433 + {
7434 + "permitted",
7435 + 1,
7436 + PROTOBUF_C_LABEL_REQUIRED,
7437 + PROTOBUF_C_TYPE_BOOL,
7438 + 0, /* quantifier_offset */
7439 + offsetof(Sr__CheckExecPermResp, permitted),
7440 + NULL,
7441 + NULL,
7442 + 0, /* flags */
7443 + 0,NULL,NULL /* reserved1,reserved2, etc */
7444 + },
7445 +};
7446 +static const unsigned sr__check_exec_perm_resp__field_indices_by_name[] = {
7447 + 0, /* field[0] = permitted */
7448 +};
7449 +static const ProtobufCIntRange sr__check_exec_perm_resp__number_ranges[1 + 1] =
7450 +{
7451 + { 1, 0 },
7452 + { 0, 1 }
7453 +};
7454 +const ProtobufCMessageDescriptor sr__check_exec_perm_resp__descriptor =
7455 +{
7456 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
7457 + "sr.CheckExecPermResp",
7458 + "CheckExecPermResp",
7459 + "Sr__CheckExecPermResp",
7460 + "sr",
7461 + sizeof(Sr__CheckExecPermResp),
7462 + 1,
7463 + sr__check_exec_perm_resp__field_descriptors,
7464 + sr__check_exec_perm_resp__field_indices_by_name,
7465 + 1, sr__check_exec_perm_resp__number_ranges,
7466 + (ProtobufCMessageInit) sr__check_exec_perm_resp__init,
7467 + NULL,NULL,NULL /* reserved[123] */
7468 +};
7469 +static const ProtobufCFieldDescriptor sr__rpcreq__field_descriptors[7] =
7470 +{
7471 + {
7472 + "action",
7473 + 1,
7474 + PROTOBUF_C_LABEL_REQUIRED,
7475 + PROTOBUF_C_TYPE_BOOL,
7476 + 0, /* quantifier_offset */
7477 + offsetof(Sr__RPCReq, action),
7478 + NULL,
7479 + NULL,
7480 + 0, /* flags */
7481 + 0,NULL,NULL /* reserved1,reserved2, etc */
7482 + },
7483 + {
7484 + "xpath",
7485 + 2,
7486 + PROTOBUF_C_LABEL_REQUIRED,
7487 + PROTOBUF_C_TYPE_STRING,
7488 + 0, /* quantifier_offset */
7489 + offsetof(Sr__RPCReq, xpath),
7490 + NULL,
7491 + NULL,
7492 + 0, /* flags */
7493 + 0,NULL,NULL /* reserved1,reserved2, etc */
7494 + },
7495 + {
7496 + "orig_api_variant",
7497 + 3,
7498 + PROTOBUF_C_LABEL_REQUIRED,
7499 + PROTOBUF_C_TYPE_ENUM,
7500 + 0, /* quantifier_offset */
7501 + offsetof(Sr__RPCReq, orig_api_variant),
7502 + &sr__api_variant__descriptor,
7503 + NULL,
7504 + 0, /* flags */
7505 + 0,NULL,NULL /* reserved1,reserved2, etc */
7506 + },
7507 + {
7508 + "input",
7509 + 4,
7510 + PROTOBUF_C_LABEL_REPEATED,
7511 + PROTOBUF_C_TYPE_MESSAGE,
7512 + offsetof(Sr__RPCReq, n_input),
7513 + offsetof(Sr__RPCReq, input),
7514 + &sr__value__descriptor,
7515 + NULL,
7516 + 0, /* flags */
7517 + 0,NULL,NULL /* reserved1,reserved2, etc */
7518 + },
7519 + {
7520 + "input_tree",
7521 + 5,
7522 + PROTOBUF_C_LABEL_REPEATED,
7523 + PROTOBUF_C_TYPE_MESSAGE,
7524 + offsetof(Sr__RPCReq, n_input_tree),
7525 + offsetof(Sr__RPCReq, input_tree),
7526 + &sr__node__descriptor,
7527 + NULL,
7528 + 0, /* flags */
7529 + 0,NULL,NULL /* reserved1,reserved2, etc */
7530 + },
7531 + {
7532 + "subscriber_address",
7533 + 10,
7534 + PROTOBUF_C_LABEL_OPTIONAL,
7535 + PROTOBUF_C_TYPE_STRING,
7536 + 0, /* quantifier_offset */
7537 + offsetof(Sr__RPCReq, subscriber_address),
7538 + NULL,
7539 + NULL,
7540 + 0, /* flags */
7541 + 0,NULL,NULL /* reserved1,reserved2, etc */
7542 + },
7543 + {
7544 + "subscription_id",
7545 + 11,
7546 + PROTOBUF_C_LABEL_OPTIONAL,
7547 + PROTOBUF_C_TYPE_UINT32,
7548 + offsetof(Sr__RPCReq, has_subscription_id),
7549 + offsetof(Sr__RPCReq, subscription_id),
7550 + NULL,
7551 + NULL,
7552 + 0, /* flags */
7553 + 0,NULL,NULL /* reserved1,reserved2, etc */
7554 + },
7555 +};
7556 +static const unsigned sr__rpcreq__field_indices_by_name[] = {
7557 + 0, /* field[0] = action */
7558 + 3, /* field[3] = input */
7559 + 4, /* field[4] = input_tree */
7560 + 2, /* field[2] = orig_api_variant */
7561 + 5, /* field[5] = subscriber_address */
7562 + 6, /* field[6] = subscription_id */
7563 + 1, /* field[1] = xpath */
7564 +};
7565 +static const ProtobufCIntRange sr__rpcreq__number_ranges[2 + 1] =
7566 +{
7567 + { 1, 0 },
7568 + { 10, 5 },
7569 + { 0, 7 }
7570 +};
7571 +const ProtobufCMessageDescriptor sr__rpcreq__descriptor =
7572 +{
7573 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
7574 + "sr.RPCReq",
7575 + "RPCReq",
7576 + "Sr__RPCReq",
7577 + "sr",
7578 + sizeof(Sr__RPCReq),
7579 + 7,
7580 + sr__rpcreq__field_descriptors,
7581 + sr__rpcreq__field_indices_by_name,
7582 + 2, sr__rpcreq__number_ranges,
7583 + (ProtobufCMessageInit) sr__rpcreq__init,
7584 + NULL,NULL,NULL /* reserved[123] */
7585 +};
7586 +static const ProtobufCFieldDescriptor sr__rpcresp__field_descriptors[5] =
7587 +{
7588 + {
7589 + "action",
7590 + 1,
7591 + PROTOBUF_C_LABEL_REQUIRED,
7592 + PROTOBUF_C_TYPE_BOOL,
7593 + 0, /* quantifier_offset */
7594 + offsetof(Sr__RPCResp, action),
7595 + NULL,
7596 + NULL,
7597 + 0, /* flags */
7598 + 0,NULL,NULL /* reserved1,reserved2, etc */
7599 + },
7600 + {
7601 + "xpath",
7602 + 2,
7603 + PROTOBUF_C_LABEL_REQUIRED,
7604 + PROTOBUF_C_TYPE_STRING,
7605 + 0, /* quantifier_offset */
7606 + offsetof(Sr__RPCResp, xpath),
7607 + NULL,
7608 + NULL,
7609 + 0, /* flags */
7610 + 0,NULL,NULL /* reserved1,reserved2, etc */
7611 + },
7612 + {
7613 + "orig_api_variant",
7614 + 3,
7615 + PROTOBUF_C_LABEL_REQUIRED,
7616 + PROTOBUF_C_TYPE_ENUM,
7617 + 0, /* quantifier_offset */
7618 + offsetof(Sr__RPCResp, orig_api_variant),
7619 + &sr__api_variant__descriptor,
7620 + NULL,
7621 + 0, /* flags */
7622 + 0,NULL,NULL /* reserved1,reserved2, etc */
7623 + },
7624 + {
7625 + "output",
7626 + 4,
7627 + PROTOBUF_C_LABEL_REPEATED,
7628 + PROTOBUF_C_TYPE_MESSAGE,
7629 + offsetof(Sr__RPCResp, n_output),
7630 + offsetof(Sr__RPCResp, output),
7631 + &sr__value__descriptor,
7632 + NULL,
7633 + 0, /* flags */
7634 + 0,NULL,NULL /* reserved1,reserved2, etc */
7635 + },
7636 + {
7637 + "output_tree",
7638 + 5,
7639 + PROTOBUF_C_LABEL_REPEATED,
7640 + PROTOBUF_C_TYPE_MESSAGE,
7641 + offsetof(Sr__RPCResp, n_output_tree),
7642 + offsetof(Sr__RPCResp, output_tree),
7643 + &sr__node__descriptor,
7644 + NULL,
7645 + 0, /* flags */
7646 + 0,NULL,NULL /* reserved1,reserved2, etc */
7647 + },
7648 +};
7649 +static const unsigned sr__rpcresp__field_indices_by_name[] = {
7650 + 0, /* field[0] = action */
7651 + 2, /* field[2] = orig_api_variant */
7652 + 3, /* field[3] = output */
7653 + 4, /* field[4] = output_tree */
7654 + 1, /* field[1] = xpath */
7655 +};
7656 +static const ProtobufCIntRange sr__rpcresp__number_ranges[1 + 1] =
7657 +{
7658 + { 1, 0 },
7659 + { 0, 5 }
7660 +};
7661 +const ProtobufCMessageDescriptor sr__rpcresp__descriptor =
7662 +{
7663 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
7664 + "sr.RPCResp",
7665 + "RPCResp",
7666 + "Sr__RPCResp",
7667 + "sr",
7668 + sizeof(Sr__RPCResp),
7669 + 5,
7670 + sr__rpcresp__field_descriptors,
7671 + sr__rpcresp__field_indices_by_name,
7672 + 1, sr__rpcresp__number_ranges,
7673 + (ProtobufCMessageInit) sr__rpcresp__init,
7674 + NULL,NULL,NULL /* reserved[123] */
7675 +};
7676 +static const ProtobufCEnumValue sr__event_notif_req__notif_type__enum_values_by_number[4] =
7677 +{
7678 + { "REALTIME", "SR__EVENT_NOTIF_REQ__NOTIF_TYPE__REALTIME", 1 },
7679 + { "REPLAY", "SR__EVENT_NOTIF_REQ__NOTIF_TYPE__REPLAY", 2 },
7680 + { "REPLAY_COMPLETE", "SR__EVENT_NOTIF_REQ__NOTIF_TYPE__REPLAY_COMPLETE", 3 },
7681 + { "REPLAY_STOP", "SR__EVENT_NOTIF_REQ__NOTIF_TYPE__REPLAY_STOP", 4 },
7682 +};
7683 +static const ProtobufCIntRange sr__event_notif_req__notif_type__value_ranges[] = {
7684 +{1, 0},{0, 4}
7685 +};
7686 +static const ProtobufCEnumValueIndex sr__event_notif_req__notif_type__enum_values_by_name[4] =
7687 +{
7688 + { "REALTIME", 0 },
7689 + { "REPLAY", 1 },
7690 + { "REPLAY_COMPLETE", 2 },
7691 + { "REPLAY_STOP", 3 },
7692 +};
7693 +const ProtobufCEnumDescriptor sr__event_notif_req__notif_type__descriptor =
7694 +{
7695 + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
7696 + "sr.EventNotifReq.NotifType",
7697 + "NotifType",
7698 + "Sr__EventNotifReq__NotifType",
7699 + "sr",
7700 + 4,
7701 + sr__event_notif_req__notif_type__enum_values_by_number,
7702 + 4,
7703 + sr__event_notif_req__notif_type__enum_values_by_name,
7704 + 1,
7705 + sr__event_notif_req__notif_type__value_ranges,
7706 + NULL,NULL,NULL,NULL /* reserved[1234] */
7707 +};
7708 +static const ProtobufCEnumValue sr__event_notif_req__notif_flags__enum_values_by_number[2] =
7709 +{
7710 + { "DEFAULT", "SR__EVENT_NOTIF_REQ__NOTIF_FLAGS__DEFAULT", 0 },
7711 + { "EPHEMERAL", "SR__EVENT_NOTIF_REQ__NOTIF_FLAGS__EPHEMERAL", 1 },
7712 +};
7713 +static const ProtobufCIntRange sr__event_notif_req__notif_flags__value_ranges[] = {
7714 +{0, 0},{0, 2}
7715 +};
7716 +static const ProtobufCEnumValueIndex sr__event_notif_req__notif_flags__enum_values_by_name[2] =
7717 +{
7718 + { "DEFAULT", 0 },
7719 + { "EPHEMERAL", 1 },
7720 +};
7721 +const ProtobufCEnumDescriptor sr__event_notif_req__notif_flags__descriptor =
7722 +{
7723 + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
7724 + "sr.EventNotifReq.NotifFlags",
7725 + "NotifFlags",
7726 + "Sr__EventNotifReq__NotifFlags",
7727 + "sr",
7728 + 2,
7729 + sr__event_notif_req__notif_flags__enum_values_by_number,
7730 + 2,
7731 + sr__event_notif_req__notif_flags__enum_values_by_name,
7732 + 1,
7733 + sr__event_notif_req__notif_flags__value_ranges,
7734 + NULL,NULL,NULL,NULL /* reserved[1234] */
7735 +};
7736 +static const ProtobufCFieldDescriptor sr__event_notif_req__field_descriptors[9] =
7737 +{
7738 + {
7739 + "type",
7740 + 1,
7741 + PROTOBUF_C_LABEL_REQUIRED,
7742 + PROTOBUF_C_TYPE_ENUM,
7743 + 0, /* quantifier_offset */
7744 + offsetof(Sr__EventNotifReq, type),
7745 + &sr__event_notif_req__notif_type__descriptor,
7746 + NULL,
7747 + 0, /* flags */
7748 + 0,NULL,NULL /* reserved1,reserved2, etc */
7749 + },
7750 + {
7751 + "options",
7752 + 2,
7753 + PROTOBUF_C_LABEL_REQUIRED,
7754 + PROTOBUF_C_TYPE_UINT32,
7755 + 0, /* quantifier_offset */
7756 + offsetof(Sr__EventNotifReq, options),
7757 + NULL,
7758 + NULL,
7759 + 0, /* flags */
7760 + 0,NULL,NULL /* reserved1,reserved2, etc */
7761 + },
7762 + {
7763 + "xpath",
7764 + 3,
7765 + PROTOBUF_C_LABEL_REQUIRED,
7766 + PROTOBUF_C_TYPE_STRING,
7767 + 0, /* quantifier_offset */
7768 + offsetof(Sr__EventNotifReq, xpath),
7769 + NULL,
7770 + NULL,
7771 + 0, /* flags */
7772 + 0,NULL,NULL /* reserved1,reserved2, etc */
7773 + },
7774 + {
7775 + "values",
7776 + 4,
7777 + PROTOBUF_C_LABEL_REPEATED,
7778 + PROTOBUF_C_TYPE_MESSAGE,
7779 + offsetof(Sr__EventNotifReq, n_values),
7780 + offsetof(Sr__EventNotifReq, values),
7781 + &sr__value__descriptor,
7782 + NULL,
7783 + 0, /* flags */
7784 + 0,NULL,NULL /* reserved1,reserved2, etc */
7785 + },
7786 + {
7787 + "trees",
7788 + 5,
7789 + PROTOBUF_C_LABEL_REPEATED,
7790 + PROTOBUF_C_TYPE_MESSAGE,
7791 + offsetof(Sr__EventNotifReq, n_trees),
7792 + offsetof(Sr__EventNotifReq, trees),
7793 + &sr__node__descriptor,
7794 + NULL,
7795 + 0, /* flags */
7796 + 0,NULL,NULL /* reserved1,reserved2, etc */
7797 + },
7798 + {
7799 + "timestamp",
7800 + 6,
7801 + PROTOBUF_C_LABEL_REQUIRED,
7802 + PROTOBUF_C_TYPE_UINT64,
7803 + 0, /* quantifier_offset */
7804 + offsetof(Sr__EventNotifReq, timestamp),
7805 + NULL,
7806 + NULL,
7807 + 0, /* flags */
7808 + 0,NULL,NULL /* reserved1,reserved2, etc */
7809 + },
7810 + {
7811 + "subscriber_address",
7812 + 10,
7813 + PROTOBUF_C_LABEL_OPTIONAL,
7814 + PROTOBUF_C_TYPE_STRING,
7815 + 0, /* quantifier_offset */
7816 + offsetof(Sr__EventNotifReq, subscriber_address),
7817 + NULL,
7818 + NULL,
7819 + 0, /* flags */
7820 + 0,NULL,NULL /* reserved1,reserved2, etc */
7821 + },
7822 + {
7823 + "subscription_id",
7824 + 11,
7825 + PROTOBUF_C_LABEL_OPTIONAL,
7826 + PROTOBUF_C_TYPE_UINT32,
7827 + offsetof(Sr__EventNotifReq, has_subscription_id),
7828 + offsetof(Sr__EventNotifReq, subscription_id),
7829 + NULL,
7830 + NULL,
7831 + 0, /* flags */
7832 + 0,NULL,NULL /* reserved1,reserved2, etc */
7833 + },
7834 + {
7835 + "do_not_send_reply",
7836 + 20,
7837 + PROTOBUF_C_LABEL_REQUIRED,
7838 + PROTOBUF_C_TYPE_BOOL,
7839 + 0, /* quantifier_offset */
7840 + offsetof(Sr__EventNotifReq, do_not_send_reply),
7841 + NULL,
7842 + NULL,
7843 + 0, /* flags */
7844 + 0,NULL,NULL /* reserved1,reserved2, etc */
7845 + },
7846 +};
7847 +static const unsigned sr__event_notif_req__field_indices_by_name[] = {
7848 + 8, /* field[8] = do_not_send_reply */
7849 + 1, /* field[1] = options */
7850 + 6, /* field[6] = subscriber_address */
7851 + 7, /* field[7] = subscription_id */
7852 + 5, /* field[5] = timestamp */
7853 + 4, /* field[4] = trees */
7854 + 0, /* field[0] = type */
7855 + 3, /* field[3] = values */
7856 + 2, /* field[2] = xpath */
7857 +};
7858 +static const ProtobufCIntRange sr__event_notif_req__number_ranges[3 + 1] =
7859 +{
7860 + { 1, 0 },
7861 + { 10, 6 },
7862 + { 20, 8 },
7863 + { 0, 9 }
7864 +};
7865 +const ProtobufCMessageDescriptor sr__event_notif_req__descriptor =
7866 +{
7867 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
7868 + "sr.EventNotifReq",
7869 + "EventNotifReq",
7870 + "Sr__EventNotifReq",
7871 + "sr",
7872 + sizeof(Sr__EventNotifReq),
7873 + 9,
7874 + sr__event_notif_req__field_descriptors,
7875 + sr__event_notif_req__field_indices_by_name,
7876 + 3, sr__event_notif_req__number_ranges,
7877 + (ProtobufCMessageInit) sr__event_notif_req__init,
7878 + NULL,NULL,NULL /* reserved[123] */
7879 +};
7880 +#define sr__event_notif_resp__field_descriptors NULL
7881 +#define sr__event_notif_resp__field_indices_by_name NULL
7882 +#define sr__event_notif_resp__number_ranges NULL
7883 +const ProtobufCMessageDescriptor sr__event_notif_resp__descriptor =
7884 +{
7885 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
7886 + "sr.EventNotifResp",
7887 + "EventNotifResp",
7888 + "Sr__EventNotifResp",
7889 + "sr",
7890 + sizeof(Sr__EventNotifResp),
7891 + 0,
7892 + sr__event_notif_resp__field_descriptors,
7893 + sr__event_notif_resp__field_indices_by_name,
7894 + 0, sr__event_notif_resp__number_ranges,
7895 + (ProtobufCMessageInit) sr__event_notif_resp__init,
7896 + NULL,NULL,NULL /* reserved[123] */
7897 +};
7898 +static const ProtobufCFieldDescriptor sr__event_notif_replay_req__field_descriptors[6] =
7899 +{
7900 + {
7901 + "xpath",
7902 + 1,
7903 + PROTOBUF_C_LABEL_REQUIRED,
7904 + PROTOBUF_C_TYPE_STRING,
7905 + 0, /* quantifier_offset */
7906 + offsetof(Sr__EventNotifReplayReq, xpath),
7907 + NULL,
7908 + NULL,
7909 + 0, /* flags */
7910 + 0,NULL,NULL /* reserved1,reserved2, etc */
7911 + },
7912 + {
7913 + "start_time",
7914 + 2,
7915 + PROTOBUF_C_LABEL_REQUIRED,
7916 + PROTOBUF_C_TYPE_UINT64,
7917 + 0, /* quantifier_offset */
7918 + offsetof(Sr__EventNotifReplayReq, start_time),
7919 + NULL,
7920 + NULL,
7921 + 0, /* flags */
7922 + 0,NULL,NULL /* reserved1,reserved2, etc */
7923 + },
7924 + {
7925 + "stop_time",
7926 + 3,
7927 + PROTOBUF_C_LABEL_REQUIRED,
7928 + PROTOBUF_C_TYPE_UINT64,
7929 + 0, /* quantifier_offset */
7930 + offsetof(Sr__EventNotifReplayReq, stop_time),
7931 + NULL,
7932 + NULL,
7933 + 0, /* flags */
7934 + 0,NULL,NULL /* reserved1,reserved2, etc */
7935 + },
7936 + {
7937 + "subscriber_address",
7938 + 10,
7939 + PROTOBUF_C_LABEL_REQUIRED,
7940 + PROTOBUF_C_TYPE_STRING,
7941 + 0, /* quantifier_offset */
7942 + offsetof(Sr__EventNotifReplayReq, subscriber_address),
7943 + NULL,
7944 + NULL,
7945 + 0, /* flags */
7946 + 0,NULL,NULL /* reserved1,reserved2, etc */
7947 + },
7948 + {
7949 + "subscription_id",
7950 + 11,
7951 + PROTOBUF_C_LABEL_REQUIRED,
7952 + PROTOBUF_C_TYPE_UINT32,
7953 + 0, /* quantifier_offset */
7954 + offsetof(Sr__EventNotifReplayReq, subscription_id),
7955 + NULL,
7956 + NULL,
7957 + 0, /* flags */
7958 + 0,NULL,NULL /* reserved1,reserved2, etc */
7959 + },
7960 + {
7961 + "api_variant",
7962 + 12,
7963 + PROTOBUF_C_LABEL_REQUIRED,
7964 + PROTOBUF_C_TYPE_ENUM,
7965 + 0, /* quantifier_offset */
7966 + offsetof(Sr__EventNotifReplayReq, api_variant),
7967 + &sr__api_variant__descriptor,
7968 + NULL,
7969 + 0, /* flags */
7970 + 0,NULL,NULL /* reserved1,reserved2, etc */
7971 + },
7972 +};
7973 +static const unsigned sr__event_notif_replay_req__field_indices_by_name[] = {
7974 + 5, /* field[5] = api_variant */
7975 + 1, /* field[1] = start_time */
7976 + 2, /* field[2] = stop_time */
7977 + 3, /* field[3] = subscriber_address */
7978 + 4, /* field[4] = subscription_id */
7979 + 0, /* field[0] = xpath */
7980 +};
7981 +static const ProtobufCIntRange sr__event_notif_replay_req__number_ranges[2 + 1] =
7982 +{
7983 + { 1, 0 },
7984 + { 10, 3 },
7985 + { 0, 6 }
7986 +};
7987 +const ProtobufCMessageDescriptor sr__event_notif_replay_req__descriptor =
7988 +{
7989 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
7990 + "sr.EventNotifReplayReq",
7991 + "EventNotifReplayReq",
7992 + "Sr__EventNotifReplayReq",
7993 + "sr",
7994 + sizeof(Sr__EventNotifReplayReq),
7995 + 6,
7996 + sr__event_notif_replay_req__field_descriptors,
7997 + sr__event_notif_replay_req__field_indices_by_name,
7998 + 2, sr__event_notif_replay_req__number_ranges,
7999 + (ProtobufCMessageInit) sr__event_notif_replay_req__init,
8000 + NULL,NULL,NULL /* reserved[123] */
8001 +};
8002 +#define sr__event_notif_replay_resp__field_descriptors NULL
8003 +#define sr__event_notif_replay_resp__field_indices_by_name NULL
8004 +#define sr__event_notif_replay_resp__number_ranges NULL
8005 +const ProtobufCMessageDescriptor sr__event_notif_replay_resp__descriptor =
8006 +{
8007 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
8008 + "sr.EventNotifReplayResp",
8009 + "EventNotifReplayResp",
8010 + "Sr__EventNotifReplayResp",
8011 + "sr",
8012 + sizeof(Sr__EventNotifReplayResp),
8013 + 0,
8014 + sr__event_notif_replay_resp__field_descriptors,
8015 + sr__event_notif_replay_resp__field_indices_by_name,
8016 + 0, sr__event_notif_replay_resp__number_ranges,
8017 + (ProtobufCMessageInit) sr__event_notif_replay_resp__init,
8018 + NULL,NULL,NULL /* reserved[123] */
8019 +};
8020 +static const ProtobufCFieldDescriptor sr__data_provide_req__field_descriptors[4] =
8021 +{
8022 + {
8023 + "xpath",
8024 + 1,
8025 + PROTOBUF_C_LABEL_REQUIRED,
8026 + PROTOBUF_C_TYPE_STRING,
8027 + 0, /* quantifier_offset */
8028 + offsetof(Sr__DataProvideReq, xpath),
8029 + NULL,
8030 + NULL,
8031 + 0, /* flags */
8032 + 0,NULL,NULL /* reserved1,reserved2, etc */
8033 + },
8034 + {
8035 + "subscriber_address",
8036 + 10,
8037 + PROTOBUF_C_LABEL_REQUIRED,
8038 + PROTOBUF_C_TYPE_STRING,
8039 + 0, /* quantifier_offset */
8040 + offsetof(Sr__DataProvideReq, subscriber_address),
8041 + NULL,
8042 + NULL,
8043 + 0, /* flags */
8044 + 0,NULL,NULL /* reserved1,reserved2, etc */
8045 + },
8046 + {
8047 + "subscription_id",
8048 + 11,
8049 + PROTOBUF_C_LABEL_REQUIRED,
8050 + PROTOBUF_C_TYPE_UINT32,
8051 + 0, /* quantifier_offset */
8052 + offsetof(Sr__DataProvideReq, subscription_id),
8053 + NULL,
8054 + NULL,
8055 + 0, /* flags */
8056 + 0,NULL,NULL /* reserved1,reserved2, etc */
8057 + },
8058 + {
8059 + "request_id",
8060 + 20,
8061 + PROTOBUF_C_LABEL_REQUIRED,
8062 + PROTOBUF_C_TYPE_UINT64,
8063 + 0, /* quantifier_offset */
8064 + offsetof(Sr__DataProvideReq, request_id),
8065 + NULL,
8066 + NULL,
8067 + 0, /* flags */
8068 + 0,NULL,NULL /* reserved1,reserved2, etc */
8069 + },
8070 +};
8071 +static const unsigned sr__data_provide_req__field_indices_by_name[] = {
8072 + 3, /* field[3] = request_id */
8073 + 1, /* field[1] = subscriber_address */
8074 + 2, /* field[2] = subscription_id */
8075 + 0, /* field[0] = xpath */
8076 +};
8077 +static const ProtobufCIntRange sr__data_provide_req__number_ranges[3 + 1] =
8078 +{
8079 + { 1, 0 },
8080 + { 10, 1 },
8081 + { 20, 3 },
8082 + { 0, 4 }
8083 +};
8084 +const ProtobufCMessageDescriptor sr__data_provide_req__descriptor =
8085 +{
8086 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
8087 + "sr.DataProvideReq",
8088 + "DataProvideReq",
8089 + "Sr__DataProvideReq",
8090 + "sr",
8091 + sizeof(Sr__DataProvideReq),
8092 + 4,
8093 + sr__data_provide_req__field_descriptors,
8094 + sr__data_provide_req__field_indices_by_name,
8095 + 3, sr__data_provide_req__number_ranges,
8096 + (ProtobufCMessageInit) sr__data_provide_req__init,
8097 + NULL,NULL,NULL /* reserved[123] */
8098 +};
8099 +static const ProtobufCFieldDescriptor sr__data_provide_resp__field_descriptors[3] =
8100 +{
8101 + {
8102 + "xpath",
8103 + 1,
8104 + PROTOBUF_C_LABEL_REQUIRED,
8105 + PROTOBUF_C_TYPE_STRING,
8106 + 0, /* quantifier_offset */
8107 + offsetof(Sr__DataProvideResp, xpath),
8108 + NULL,
8109 + NULL,
8110 + 0, /* flags */
8111 + 0,NULL,NULL /* reserved1,reserved2, etc */
8112 + },
8113 + {
8114 + "values",
8115 + 2,
8116 + PROTOBUF_C_LABEL_REPEATED,
8117 + PROTOBUF_C_TYPE_MESSAGE,
8118 + offsetof(Sr__DataProvideResp, n_values),
8119 + offsetof(Sr__DataProvideResp, values),
8120 + &sr__value__descriptor,
8121 + NULL,
8122 + 0, /* flags */
8123 + 0,NULL,NULL /* reserved1,reserved2, etc */
8124 + },
8125 + {
8126 + "request_id",
8127 + 10,
8128 + PROTOBUF_C_LABEL_REQUIRED,
8129 + PROTOBUF_C_TYPE_UINT64,
8130 + 0, /* quantifier_offset */
8131 + offsetof(Sr__DataProvideResp, request_id),
8132 + NULL,
8133 + NULL,
8134 + 0, /* flags */
8135 + 0,NULL,NULL /* reserved1,reserved2, etc */
8136 + },
8137 +};
8138 +static const unsigned sr__data_provide_resp__field_indices_by_name[] = {
8139 + 2, /* field[2] = request_id */
8140 + 1, /* field[1] = values */
8141 + 0, /* field[0] = xpath */
8142 +};
8143 +static const ProtobufCIntRange sr__data_provide_resp__number_ranges[2 + 1] =
8144 +{
8145 + { 1, 0 },
8146 + { 10, 2 },
8147 + { 0, 3 }
8148 +};
8149 +const ProtobufCMessageDescriptor sr__data_provide_resp__descriptor =
8150 +{
8151 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
8152 + "sr.DataProvideResp",
8153 + "DataProvideResp",
8154 + "Sr__DataProvideResp",
8155 + "sr",
8156 + sizeof(Sr__DataProvideResp),
8157 + 3,
8158 + sr__data_provide_resp__field_descriptors,
8159 + sr__data_provide_resp__field_indices_by_name,
8160 + 2, sr__data_provide_resp__number_ranges,
8161 + (ProtobufCMessageInit) sr__data_provide_resp__init,
8162 + NULL,NULL,NULL /* reserved[123] */
8163 +};
8164 +static const ProtobufCFieldDescriptor sr__module_install_req__field_descriptors[4] =
8165 +{
8166 + {
8167 + "module_name",
8168 + 1,
8169 + PROTOBUF_C_LABEL_REQUIRED,
8170 + PROTOBUF_C_TYPE_STRING,
8171 + 0, /* quantifier_offset */
8172 + offsetof(Sr__ModuleInstallReq, module_name),
8173 + NULL,
8174 + NULL,
8175 + 0, /* flags */
8176 + 0,NULL,NULL /* reserved1,reserved2, etc */
8177 + },
8178 + {
8179 + "revision",
8180 + 2,
8181 + PROTOBUF_C_LABEL_OPTIONAL,
8182 + PROTOBUF_C_TYPE_STRING,
8183 + 0, /* quantifier_offset */
8184 + offsetof(Sr__ModuleInstallReq, revision),
8185 + NULL,
8186 + NULL,
8187 + 0, /* flags */
8188 + 0,NULL,NULL /* reserved1,reserved2, etc */
8189 + },
8190 + {
8191 + "file_name",
8192 + 3,
8193 + PROTOBUF_C_LABEL_OPTIONAL,
8194 + PROTOBUF_C_TYPE_STRING,
8195 + 0, /* quantifier_offset */
8196 + offsetof(Sr__ModuleInstallReq, file_name),
8197 + NULL,
8198 + NULL,
8199 + 0, /* flags */
8200 + 0,NULL,NULL /* reserved1,reserved2, etc */
8201 + },
8202 + {
8203 + "installed",
8204 + 4,
8205 + PROTOBUF_C_LABEL_REQUIRED,
8206 + PROTOBUF_C_TYPE_BOOL,
8207 + 0, /* quantifier_offset */
8208 + offsetof(Sr__ModuleInstallReq, installed),
8209 + NULL,
8210 + NULL,
8211 + 0, /* flags */
8212 + 0,NULL,NULL /* reserved1,reserved2, etc */
8213 + },
8214 +};
8215 +static const unsigned sr__module_install_req__field_indices_by_name[] = {
8216 + 2, /* field[2] = file_name */
8217 + 3, /* field[3] = installed */
8218 + 0, /* field[0] = module_name */
8219 + 1, /* field[1] = revision */
8220 +};
8221 +static const ProtobufCIntRange sr__module_install_req__number_ranges[1 + 1] =
8222 +{
8223 + { 1, 0 },
8224 + { 0, 4 }
8225 +};
8226 +const ProtobufCMessageDescriptor sr__module_install_req__descriptor =
8227 +{
8228 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
8229 + "sr.ModuleInstallReq",
8230 + "ModuleInstallReq",
8231 + "Sr__ModuleInstallReq",
8232 + "sr",
8233 + sizeof(Sr__ModuleInstallReq),
8234 + 4,
8235 + sr__module_install_req__field_descriptors,
8236 + sr__module_install_req__field_indices_by_name,
8237 + 1, sr__module_install_req__number_ranges,
8238 + (ProtobufCMessageInit) sr__module_install_req__init,
8239 + NULL,NULL,NULL /* reserved[123] */
8240 +};
8241 +#define sr__module_install_resp__field_descriptors NULL
8242 +#define sr__module_install_resp__field_indices_by_name NULL
8243 +#define sr__module_install_resp__number_ranges NULL
8244 +const ProtobufCMessageDescriptor sr__module_install_resp__descriptor =
8245 +{
8246 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
8247 + "sr.ModuleInstallResp",
8248 + "ModuleInstallResp",
8249 + "Sr__ModuleInstallResp",
8250 + "sr",
8251 + sizeof(Sr__ModuleInstallResp),
8252 + 0,
8253 + sr__module_install_resp__field_descriptors,
8254 + sr__module_install_resp__field_indices_by_name,
8255 + 0, sr__module_install_resp__number_ranges,
8256 + (ProtobufCMessageInit) sr__module_install_resp__init,
8257 + NULL,NULL,NULL /* reserved[123] */
8258 +};
8259 +static const ProtobufCFieldDescriptor sr__feature_enable_req__field_descriptors[3] =
8260 +{
8261 + {
8262 + "module_name",
8263 + 1,
8264 + PROTOBUF_C_LABEL_REQUIRED,
8265 + PROTOBUF_C_TYPE_STRING,
8266 + 0, /* quantifier_offset */
8267 + offsetof(Sr__FeatureEnableReq, module_name),
8268 + NULL,
8269 + NULL,
8270 + 0, /* flags */
8271 + 0,NULL,NULL /* reserved1,reserved2, etc */
8272 + },
8273 + {
8274 + "feature_name",
8275 + 2,
8276 + PROTOBUF_C_LABEL_REQUIRED,
8277 + PROTOBUF_C_TYPE_STRING,
8278 + 0, /* quantifier_offset */
8279 + offsetof(Sr__FeatureEnableReq, feature_name),
8280 + NULL,
8281 + NULL,
8282 + 0, /* flags */
8283 + 0,NULL,NULL /* reserved1,reserved2, etc */
8284 + },
8285 + {
8286 + "enabled",
8287 + 3,
8288 + PROTOBUF_C_LABEL_REQUIRED,
8289 + PROTOBUF_C_TYPE_BOOL,
8290 + 0, /* quantifier_offset */
8291 + offsetof(Sr__FeatureEnableReq, enabled),
8292 + NULL,
8293 + NULL,
8294 + 0, /* flags */
8295 + 0,NULL,NULL /* reserved1,reserved2, etc */
8296 + },
8297 +};
8298 +static const unsigned sr__feature_enable_req__field_indices_by_name[] = {
8299 + 2, /* field[2] = enabled */
8300 + 1, /* field[1] = feature_name */
8301 + 0, /* field[0] = module_name */
8302 +};
8303 +static const ProtobufCIntRange sr__feature_enable_req__number_ranges[1 + 1] =
8304 +{
8305 + { 1, 0 },
8306 + { 0, 3 }
8307 +};
8308 +const ProtobufCMessageDescriptor sr__feature_enable_req__descriptor =
8309 +{
8310 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
8311 + "sr.FeatureEnableReq",
8312 + "FeatureEnableReq",
8313 + "Sr__FeatureEnableReq",
8314 + "sr",
8315 + sizeof(Sr__FeatureEnableReq),
8316 + 3,
8317 + sr__feature_enable_req__field_descriptors,
8318 + sr__feature_enable_req__field_indices_by_name,
8319 + 1, sr__feature_enable_req__number_ranges,
8320 + (ProtobufCMessageInit) sr__feature_enable_req__init,
8321 + NULL,NULL,NULL /* reserved[123] */
8322 +};
8323 +#define sr__feature_enable_resp__field_descriptors NULL
8324 +#define sr__feature_enable_resp__field_indices_by_name NULL
8325 +#define sr__feature_enable_resp__number_ranges NULL
8326 +const ProtobufCMessageDescriptor sr__feature_enable_resp__descriptor =
8327 +{
8328 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
8329 + "sr.FeatureEnableResp",
8330 + "FeatureEnableResp",
8331 + "Sr__FeatureEnableResp",
8332 + "sr",
8333 + sizeof(Sr__FeatureEnableResp),
8334 + 0,
8335 + sr__feature_enable_resp__field_descriptors,
8336 + sr__feature_enable_resp__field_indices_by_name,
8337 + 0, sr__feature_enable_resp__number_ranges,
8338 + (ProtobufCMessageInit) sr__feature_enable_resp__init,
8339 + NULL,NULL,NULL /* reserved[123] */
8340 +};
8341 +static const ProtobufCFieldDescriptor sr__unsubscribe_destination_req__field_descriptors[1] =
8342 +{
8343 + {
8344 + "destination",
8345 + 1,
8346 + PROTOBUF_C_LABEL_REQUIRED,
8347 + PROTOBUF_C_TYPE_STRING,
8348 + 0, /* quantifier_offset */
8349 + offsetof(Sr__UnsubscribeDestinationReq, destination),
8350 + NULL,
8351 + NULL,
8352 + 0, /* flags */
8353 + 0,NULL,NULL /* reserved1,reserved2, etc */
8354 + },
8355 +};
8356 +static const unsigned sr__unsubscribe_destination_req__field_indices_by_name[] = {
8357 + 0, /* field[0] = destination */
8358 +};
8359 +static const ProtobufCIntRange sr__unsubscribe_destination_req__number_ranges[1 + 1] =
8360 +{
8361 + { 1, 0 },
8362 + { 0, 1 }
8363 +};
8364 +const ProtobufCMessageDescriptor sr__unsubscribe_destination_req__descriptor =
8365 +{
8366 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
8367 + "sr.UnsubscribeDestinationReq",
8368 + "UnsubscribeDestinationReq",
8369 + "Sr__UnsubscribeDestinationReq",
8370 + "sr",
8371 + sizeof(Sr__UnsubscribeDestinationReq),
8372 + 1,
8373 + sr__unsubscribe_destination_req__field_descriptors,
8374 + sr__unsubscribe_destination_req__field_indices_by_name,
8375 + 1, sr__unsubscribe_destination_req__number_ranges,
8376 + (ProtobufCMessageInit) sr__unsubscribe_destination_req__init,
8377 + NULL,NULL,NULL /* reserved[123] */
8378 +};
8379 +static const ProtobufCFieldDescriptor sr__commit_timeout_req__field_descriptors[2] =
8380 +{
8381 + {
8382 + "commit_id",
8383 + 1,
8384 + PROTOBUF_C_LABEL_REQUIRED,
8385 + PROTOBUF_C_TYPE_UINT32,
8386 + 0, /* quantifier_offset */
8387 + offsetof(Sr__CommitTimeoutReq, commit_id),
8388 + NULL,
8389 + NULL,
8390 + 0, /* flags */
8391 + 0,NULL,NULL /* reserved1,reserved2, etc */
8392 + },
8393 + {
8394 + "expired",
8395 + 2,
8396 + PROTOBUF_C_LABEL_REQUIRED,
8397 + PROTOBUF_C_TYPE_BOOL,
8398 + 0, /* quantifier_offset */
8399 + offsetof(Sr__CommitTimeoutReq, expired),
8400 + NULL,
8401 + NULL,
8402 + 0, /* flags */
8403 + 0,NULL,NULL /* reserved1,reserved2, etc */
8404 + },
8405 +};
8406 +static const unsigned sr__commit_timeout_req__field_indices_by_name[] = {
8407 + 0, /* field[0] = commit_id */
8408 + 1, /* field[1] = expired */
8409 +};
8410 +static const ProtobufCIntRange sr__commit_timeout_req__number_ranges[1 + 1] =
8411 +{
8412 + { 1, 0 },
8413 + { 0, 2 }
8414 +};
8415 +const ProtobufCMessageDescriptor sr__commit_timeout_req__descriptor =
8416 +{
8417 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
8418 + "sr.CommitTimeoutReq",
8419 + "CommitTimeoutReq",
8420 + "Sr__CommitTimeoutReq",
8421 + "sr",
8422 + sizeof(Sr__CommitTimeoutReq),
8423 + 2,
8424 + sr__commit_timeout_req__field_descriptors,
8425 + sr__commit_timeout_req__field_indices_by_name,
8426 + 1, sr__commit_timeout_req__number_ranges,
8427 + (ProtobufCMessageInit) sr__commit_timeout_req__init,
8428 + NULL,NULL,NULL /* reserved[123] */
8429 +};
8430 +static const ProtobufCFieldDescriptor sr__oper_data_timeout_req__field_descriptors[1] =
8431 +{
8432 + {
8433 + "request_id",
8434 + 1,
8435 + PROTOBUF_C_LABEL_REQUIRED,
8436 + PROTOBUF_C_TYPE_UINT64,
8437 + 0, /* quantifier_offset */
8438 + offsetof(Sr__OperDataTimeoutReq, request_id),
8439 + NULL,
8440 + NULL,
8441 + 0, /* flags */
8442 + 0,NULL,NULL /* reserved1,reserved2, etc */
8443 + },
8444 +};
8445 +static const unsigned sr__oper_data_timeout_req__field_indices_by_name[] = {
8446 + 0, /* field[0] = request_id */
8447 +};
8448 +static const ProtobufCIntRange sr__oper_data_timeout_req__number_ranges[1 + 1] =
8449 +{
8450 + { 1, 0 },
8451 + { 0, 1 }
8452 +};
8453 +const ProtobufCMessageDescriptor sr__oper_data_timeout_req__descriptor =
8454 +{
8455 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
8456 + "sr.OperDataTimeoutReq",
8457 + "OperDataTimeoutReq",
8458 + "Sr__OperDataTimeoutReq",
8459 + "sr",
8460 + sizeof(Sr__OperDataTimeoutReq),
8461 + 1,
8462 + sr__oper_data_timeout_req__field_descriptors,
8463 + sr__oper_data_timeout_req__field_indices_by_name,
8464 + 1, sr__oper_data_timeout_req__number_ranges,
8465 + (ProtobufCMessageInit) sr__oper_data_timeout_req__init,
8466 + NULL,NULL,NULL /* reserved[123] */
8467 +};
8468 +static const ProtobufCFieldDescriptor sr__internal_state_data_req__field_descriptors[2] =
8469 +{
8470 + {
8471 + "request_id",
8472 + 1,
8473 + PROTOBUF_C_LABEL_REQUIRED,
8474 + PROTOBUF_C_TYPE_UINT64,
8475 + 0, /* quantifier_offset */
8476 + offsetof(Sr__InternalStateDataReq, request_id),
8477 + NULL,
8478 + NULL,
8479 + 0, /* flags */
8480 + 0,NULL,NULL /* reserved1,reserved2, etc */
8481 + },
8482 + {
8483 + "xpath",
8484 + 2,
8485 + PROTOBUF_C_LABEL_REQUIRED,
8486 + PROTOBUF_C_TYPE_STRING,
8487 + 0, /* quantifier_offset */
8488 + offsetof(Sr__InternalStateDataReq, xpath),
8489 + NULL,
8490 + NULL,
8491 + 0, /* flags */
8492 + 0,NULL,NULL /* reserved1,reserved2, etc */
8493 + },
8494 +};
8495 +static const unsigned sr__internal_state_data_req__field_indices_by_name[] = {
8496 + 0, /* field[0] = request_id */
8497 + 1, /* field[1] = xpath */
8498 +};
8499 +static const ProtobufCIntRange sr__internal_state_data_req__number_ranges[1 + 1] =
8500 +{
8501 + { 1, 0 },
8502 + { 0, 2 }
8503 +};
8504 +const ProtobufCMessageDescriptor sr__internal_state_data_req__descriptor =
8505 +{
8506 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
8507 + "sr.InternalStateDataReq",
8508 + "InternalStateDataReq",
8509 + "Sr__InternalStateDataReq",
8510 + "sr",
8511 + sizeof(Sr__InternalStateDataReq),
8512 + 2,
8513 + sr__internal_state_data_req__field_descriptors,
8514 + sr__internal_state_data_req__field_indices_by_name,
8515 + 1, sr__internal_state_data_req__number_ranges,
8516 + (ProtobufCMessageInit) sr__internal_state_data_req__init,
8517 + NULL,NULL,NULL /* reserved[123] */
8518 +};
8519 +#define sr__notif_store_cleanup_req__field_descriptors NULL
8520 +#define sr__notif_store_cleanup_req__field_indices_by_name NULL
8521 +#define sr__notif_store_cleanup_req__number_ranges NULL
8522 +const ProtobufCMessageDescriptor sr__notif_store_cleanup_req__descriptor =
8523 +{
8524 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
8525 + "sr.NotifStoreCleanupReq",
8526 + "NotifStoreCleanupReq",
8527 + "Sr__NotifStoreCleanupReq",
8528 + "sr",
8529 + sizeof(Sr__NotifStoreCleanupReq),
8530 + 0,
8531 + sr__notif_store_cleanup_req__field_descriptors,
8532 + sr__notif_store_cleanup_req__field_indices_by_name,
8533 + 0, sr__notif_store_cleanup_req__number_ranges,
8534 + (ProtobufCMessageInit) sr__notif_store_cleanup_req__init,
8535 + NULL,NULL,NULL /* reserved[123] */
8536 +};
8537 +static const ProtobufCFieldDescriptor sr__delayed_msg_req__field_descriptors[1] =
8538 +{
8539 + {
8540 + "message",
8541 + 1,
8542 + PROTOBUF_C_LABEL_REQUIRED,
8543 + PROTOBUF_C_TYPE_MESSAGE,
8544 + 0, /* quantifier_offset */
8545 + offsetof(Sr__DelayedMsgReq, message),
8546 + &sr__msg__descriptor,
8547 + NULL,
8548 + 0, /* flags */
8549 + 0,NULL,NULL /* reserved1,reserved2, etc */
8550 + },
8551 +};
8552 +static const unsigned sr__delayed_msg_req__field_indices_by_name[] = {
8553 + 0, /* field[0] = message */
8554 +};
8555 +static const ProtobufCIntRange sr__delayed_msg_req__number_ranges[1 + 1] =
8556 +{
8557 + { 1, 0 },
8558 + { 0, 1 }
8559 +};
8560 +const ProtobufCMessageDescriptor sr__delayed_msg_req__descriptor =
8561 +{
8562 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
8563 + "sr.DelayedMsgReq",
8564 + "DelayedMsgReq",
8565 + "Sr__DelayedMsgReq",
8566 + "sr",
8567 + sizeof(Sr__DelayedMsgReq),
8568 + 1,
8569 + sr__delayed_msg_req__field_descriptors,
8570 + sr__delayed_msg_req__field_indices_by_name,
8571 + 1, sr__delayed_msg_req__number_ranges,
8572 + (ProtobufCMessageInit) sr__delayed_msg_req__init,
8573 + NULL,NULL,NULL /* reserved[123] */
8574 +};
8575 +#define sr__nacm_reload_req__field_descriptors NULL
8576 +#define sr__nacm_reload_req__field_indices_by_name NULL
8577 +#define sr__nacm_reload_req__number_ranges NULL
8578 +const ProtobufCMessageDescriptor sr__nacm_reload_req__descriptor =
8579 +{
8580 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
8581 + "sr.NacmReloadReq",
8582 + "NacmReloadReq",
8583 + "Sr__NacmReloadReq",
8584 + "sr",
8585 + sizeof(Sr__NacmReloadReq),
8586 + 0,
8587 + sr__nacm_reload_req__field_descriptors,
8588 + sr__nacm_reload_req__field_indices_by_name,
8589 + 0, sr__nacm_reload_req__number_ranges,
8590 + (ProtobufCMessageInit) sr__nacm_reload_req__init,
8591 + NULL,NULL,NULL /* reserved[123] */
8592 +};
8593 +static const ProtobufCFieldDescriptor sr__request__field_descriptors[37] =
8594 +{
8595 + {
8596 + "_id",
8597 + 1,
8598 + PROTOBUF_C_LABEL_REQUIRED,
8599 + PROTOBUF_C_TYPE_UINT64,
8600 + 0, /* quantifier_offset */
8601 + offsetof(Sr__Request, _id),
8602 + NULL,
8603 + NULL,
8604 + 0, /* flags */
8605 + 0,NULL,NULL /* reserved1,reserved2, etc */
8606 + },
8607 + {
8608 + "operation",
8609 + 2,
8610 + PROTOBUF_C_LABEL_REQUIRED,
8611 + PROTOBUF_C_TYPE_ENUM,
8612 + 0, /* quantifier_offset */
8613 + offsetof(Sr__Request, operation),
8614 + &sr__operation__descriptor,
8615 + NULL,
8616 + 0, /* flags */
8617 + 0,NULL,NULL /* reserved1,reserved2, etc */
8618 + },
8619 + {
8620 + "session_start_req",
8621 + 10,
8622 + PROTOBUF_C_LABEL_OPTIONAL,
8623 + PROTOBUF_C_TYPE_MESSAGE,
8624 + 0, /* quantifier_offset */
8625 + offsetof(Sr__Request, session_start_req),
8626 + &sr__session_start_req__descriptor,
8627 + NULL,
8628 + 0, /* flags */
8629 + 0,NULL,NULL /* reserved1,reserved2, etc */
8630 + },
8631 + {
8632 + "session_stop_req",
8633 + 11,
8634 + PROTOBUF_C_LABEL_OPTIONAL,
8635 + PROTOBUF_C_TYPE_MESSAGE,
8636 + 0, /* quantifier_offset */
8637 + offsetof(Sr__Request, session_stop_req),
8638 + &sr__session_stop_req__descriptor,
8639 + NULL,
8640 + 0, /* flags */
8641 + 0,NULL,NULL /* reserved1,reserved2, etc */
8642 + },
8643 + {
8644 + "session_refresh_req",
8645 + 12,
8646 + PROTOBUF_C_LABEL_OPTIONAL,
8647 + PROTOBUF_C_TYPE_MESSAGE,
8648 + 0, /* quantifier_offset */
8649 + offsetof(Sr__Request, session_refresh_req),
8650 + &sr__session_refresh_req__descriptor,
8651 + NULL,
8652 + 0, /* flags */
8653 + 0,NULL,NULL /* reserved1,reserved2, etc */
8654 + },
8655 + {
8656 + "session_check_req",
8657 + 13,
8658 + PROTOBUF_C_LABEL_OPTIONAL,
8659 + PROTOBUF_C_TYPE_MESSAGE,
8660 + 0, /* quantifier_offset */
8661 + offsetof(Sr__Request, session_check_req),
8662 + &sr__session_check_req__descriptor,
8663 + NULL,
8664 + 0, /* flags */
8665 + 0,NULL,NULL /* reserved1,reserved2, etc */
8666 + },
8667 + {
8668 + "session_switch_ds_req",
8669 + 14,
8670 + PROTOBUF_C_LABEL_OPTIONAL,
8671 + PROTOBUF_C_TYPE_MESSAGE,
8672 + 0, /* quantifier_offset */
8673 + offsetof(Sr__Request, session_switch_ds_req),
8674 + &sr__session_switch_ds_req__descriptor,
8675 + NULL,
8676 + 0, /* flags */
8677 + 0,NULL,NULL /* reserved1,reserved2, etc */
8678 + },
8679 + {
8680 + "session_set_opts_req",
8681 + 15,
8682 + PROTOBUF_C_LABEL_OPTIONAL,
8683 + PROTOBUF_C_TYPE_MESSAGE,
8684 + 0, /* quantifier_offset */
8685 + offsetof(Sr__Request, session_set_opts_req),
8686 + &sr__session_set_opts_req__descriptor,
8687 + NULL,
8688 + 0, /* flags */
8689 + 0,NULL,NULL /* reserved1,reserved2, etc */
8690 + },
8691 + {
8692 + "version_verify_req",
8693 + 16,
8694 + PROTOBUF_C_LABEL_OPTIONAL,
8695 + PROTOBUF_C_TYPE_MESSAGE,
8696 + 0, /* quantifier_offset */
8697 + offsetof(Sr__Request, version_verify_req),
8698 + &sr__version_verify_req__descriptor,
8699 + NULL,
8700 + 0, /* flags */
8701 + 0,NULL,NULL /* reserved1,reserved2, etc */
8702 + },
8703 + {
8704 + "list_schemas_req",
8705 + 20,
8706 + PROTOBUF_C_LABEL_OPTIONAL,
8707 + PROTOBUF_C_TYPE_MESSAGE,
8708 + 0, /* quantifier_offset */
8709 + offsetof(Sr__Request, list_schemas_req),
8710 + &sr__list_schemas_req__descriptor,
8711 + NULL,
8712 + 0, /* flags */
8713 + 0,NULL,NULL /* reserved1,reserved2, etc */
8714 + },
8715 + {
8716 + "get_schema_req",
8717 + 21,
8718 + PROTOBUF_C_LABEL_OPTIONAL,
8719 + PROTOBUF_C_TYPE_MESSAGE,
8720 + 0, /* quantifier_offset */
8721 + offsetof(Sr__Request, get_schema_req),
8722 + &sr__get_schema_req__descriptor,
8723 + NULL,
8724 + 0, /* flags */
8725 + 0,NULL,NULL /* reserved1,reserved2, etc */
8726 + },
8727 + {
8728 + "module_install_req",
8729 + 22,
8730 + PROTOBUF_C_LABEL_OPTIONAL,
8731 + PROTOBUF_C_TYPE_MESSAGE,
8732 + 0, /* quantifier_offset */
8733 + offsetof(Sr__Request, module_install_req),
8734 + &sr__module_install_req__descriptor,
8735 + NULL,
8736 + 0, /* flags */
8737 + 0,NULL,NULL /* reserved1,reserved2, etc */
8738 + },
8739 + {
8740 + "feature_enable_req",
8741 + 23,
8742 + PROTOBUF_C_LABEL_OPTIONAL,
8743 + PROTOBUF_C_TYPE_MESSAGE,
8744 + 0, /* quantifier_offset */
8745 + offsetof(Sr__Request, feature_enable_req),
8746 + &sr__feature_enable_req__descriptor,
8747 + NULL,
8748 + 0, /* flags */
8749 + 0,NULL,NULL /* reserved1,reserved2, etc */
8750 + },
8751 + {
8752 + "get_item_req",
8753 + 30,
8754 + PROTOBUF_C_LABEL_OPTIONAL,
8755 + PROTOBUF_C_TYPE_MESSAGE,
8756 + 0, /* quantifier_offset */
8757 + offsetof(Sr__Request, get_item_req),
8758 + &sr__get_item_req__descriptor,
8759 + NULL,
8760 + 0, /* flags */
8761 + 0,NULL,NULL /* reserved1,reserved2, etc */
8762 + },
8763 + {
8764 + "get_items_req",
8765 + 31,
8766 + PROTOBUF_C_LABEL_OPTIONAL,
8767 + PROTOBUF_C_TYPE_MESSAGE,
8768 + 0, /* quantifier_offset */
8769 + offsetof(Sr__Request, get_items_req),
8770 + &sr__get_items_req__descriptor,
8771 + NULL,
8772 + 0, /* flags */
8773 + 0,NULL,NULL /* reserved1,reserved2, etc */
8774 + },
8775 + {
8776 + "get_subtree_req",
8777 + 32,
8778 + PROTOBUF_C_LABEL_OPTIONAL,
8779 + PROTOBUF_C_TYPE_MESSAGE,
8780 + 0, /* quantifier_offset */
8781 + offsetof(Sr__Request, get_subtree_req),
8782 + &sr__get_subtree_req__descriptor,
8783 + NULL,
8784 + 0, /* flags */
8785 + 0,NULL,NULL /* reserved1,reserved2, etc */
8786 + },
8787 + {
8788 + "get_subtrees_req",
8789 + 33,
8790 + PROTOBUF_C_LABEL_OPTIONAL,
8791 + PROTOBUF_C_TYPE_MESSAGE,
8792 + 0, /* quantifier_offset */
8793 + offsetof(Sr__Request, get_subtrees_req),
8794 + &sr__get_subtrees_req__descriptor,
8795 + NULL,
8796 + 0, /* flags */
8797 + 0,NULL,NULL /* reserved1,reserved2, etc */
8798 + },
8799 + {
8800 + "get_subtree_chunk_req",
8801 + 34,
8802 + PROTOBUF_C_LABEL_OPTIONAL,
8803 + PROTOBUF_C_TYPE_MESSAGE,
8804 + 0, /* quantifier_offset */
8805 + offsetof(Sr__Request, get_subtree_chunk_req),
8806 + &sr__get_subtree_chunk_req__descriptor,
8807 + NULL,
8808 + 0, /* flags */
8809 + 0,NULL,NULL /* reserved1,reserved2, etc */
8810 + },
8811 + {
8812 + "set_item_req",
8813 + 40,
8814 + PROTOBUF_C_LABEL_OPTIONAL,
8815 + PROTOBUF_C_TYPE_MESSAGE,
8816 + 0, /* quantifier_offset */
8817 + offsetof(Sr__Request, set_item_req),
8818 + &sr__set_item_req__descriptor,
8819 + NULL,
8820 + 0, /* flags */
8821 + 0,NULL,NULL /* reserved1,reserved2, etc */
8822 + },
8823 + {
8824 + "delete_item_req",
8825 + 41,
8826 + PROTOBUF_C_LABEL_OPTIONAL,
8827 + PROTOBUF_C_TYPE_MESSAGE,
8828 + 0, /* quantifier_offset */
8829 + offsetof(Sr__Request, delete_item_req),
8830 + &sr__delete_item_req__descriptor,
8831 + NULL,
8832 + 0, /* flags */
8833 + 0,NULL,NULL /* reserved1,reserved2, etc */
8834 + },
8835 + {
8836 + "move_item_req",
8837 + 42,
8838 + PROTOBUF_C_LABEL_OPTIONAL,
8839 + PROTOBUF_C_TYPE_MESSAGE,
8840 + 0, /* quantifier_offset */
8841 + offsetof(Sr__Request, move_item_req),
8842 + &sr__move_item_req__descriptor,
8843 + NULL,
8844 + 0, /* flags */
8845 + 0,NULL,NULL /* reserved1,reserved2, etc */
8846 + },
8847 + {
8848 + "set_item_str_req",
8849 + 43,
8850 + PROTOBUF_C_LABEL_OPTIONAL,
8851 + PROTOBUF_C_TYPE_MESSAGE,
8852 + 0, /* quantifier_offset */
8853 + offsetof(Sr__Request, set_item_str_req),
8854 + &sr__set_item_str_req__descriptor,
8855 + NULL,
8856 + 0, /* flags */
8857 + 0,NULL,NULL /* reserved1,reserved2, etc */
8858 + },
8859 + {
8860 + "validate_req",
8861 + 50,
8862 + PROTOBUF_C_LABEL_OPTIONAL,
8863 + PROTOBUF_C_TYPE_MESSAGE,
8864 + 0, /* quantifier_offset */
8865 + offsetof(Sr__Request, validate_req),
8866 + &sr__validate_req__descriptor,
8867 + NULL,
8868 + 0, /* flags */
8869 + 0,NULL,NULL /* reserved1,reserved2, etc */
8870 + },
8871 + {
8872 + "commit_req",
8873 + 51,
8874 + PROTOBUF_C_LABEL_OPTIONAL,
8875 + PROTOBUF_C_TYPE_MESSAGE,
8876 + 0, /* quantifier_offset */
8877 + offsetof(Sr__Request, commit_req),
8878 + &sr__commit_req__descriptor,
8879 + NULL,
8880 + 0, /* flags */
8881 + 0,NULL,NULL /* reserved1,reserved2, etc */
8882 + },
8883 + {
8884 + "discard_changes_req",
8885 + 52,
8886 + PROTOBUF_C_LABEL_OPTIONAL,
8887 + PROTOBUF_C_TYPE_MESSAGE,
8888 + 0, /* quantifier_offset */
8889 + offsetof(Sr__Request, discard_changes_req),
8890 + &sr__discard_changes_req__descriptor,
8891 + NULL,
8892 + 0, /* flags */
8893 + 0,NULL,NULL /* reserved1,reserved2, etc */
8894 + },
8895 + {
8896 + "copy_config_req",
8897 + 53,
8898 + PROTOBUF_C_LABEL_OPTIONAL,
8899 + PROTOBUF_C_TYPE_MESSAGE,
8900 + 0, /* quantifier_offset */
8901 + offsetof(Sr__Request, copy_config_req),
8902 + &sr__copy_config_req__descriptor,
8903 + NULL,
8904 + 0, /* flags */
8905 + 0,NULL,NULL /* reserved1,reserved2, etc */
8906 + },
8907 + {
8908 + "lock_req",
8909 + 60,
8910 + PROTOBUF_C_LABEL_OPTIONAL,
8911 + PROTOBUF_C_TYPE_MESSAGE,
8912 + 0, /* quantifier_offset */
8913 + offsetof(Sr__Request, lock_req),
8914 + &sr__lock_req__descriptor,
8915 + NULL,
8916 + 0, /* flags */
8917 + 0,NULL,NULL /* reserved1,reserved2, etc */
8918 + },
8919 + {
8920 + "unlock_req",
8921 + 61,
8922 + PROTOBUF_C_LABEL_OPTIONAL,
8923 + PROTOBUF_C_TYPE_MESSAGE,
8924 + 0, /* quantifier_offset */
8925 + offsetof(Sr__Request, unlock_req),
8926 + &sr__unlock_req__descriptor,
8927 + NULL,
8928 + 0, /* flags */
8929 + 0,NULL,NULL /* reserved1,reserved2, etc */
8930 + },
8931 + {
8932 + "subscribe_req",
8933 + 70,
8934 + PROTOBUF_C_LABEL_OPTIONAL,
8935 + PROTOBUF_C_TYPE_MESSAGE,
8936 + 0, /* quantifier_offset */
8937 + offsetof(Sr__Request, subscribe_req),
8938 + &sr__subscribe_req__descriptor,
8939 + NULL,
8940 + 0, /* flags */
8941 + 0,NULL,NULL /* reserved1,reserved2, etc */
8942 + },
8943 + {
8944 + "unsubscribe_req",
8945 + 71,
8946 + PROTOBUF_C_LABEL_OPTIONAL,
8947 + PROTOBUF_C_TYPE_MESSAGE,
8948 + 0, /* quantifier_offset */
8949 + offsetof(Sr__Request, unsubscribe_req),
8950 + &sr__unsubscribe_req__descriptor,
8951 + NULL,
8952 + 0, /* flags */
8953 + 0,NULL,NULL /* reserved1,reserved2, etc */
8954 + },
8955 + {
8956 + "check_enabled_running_req",
8957 + 72,
8958 + PROTOBUF_C_LABEL_OPTIONAL,
8959 + PROTOBUF_C_TYPE_MESSAGE,
8960 + 0, /* quantifier_offset */
8961 + offsetof(Sr__Request, check_enabled_running_req),
8962 + &sr__check_enabled_running_req__descriptor,
8963 + NULL,
8964 + 0, /* flags */
8965 + 0,NULL,NULL /* reserved1,reserved2, etc */
8966 + },
8967 + {
8968 + "get_changes_req",
8969 + 73,
8970 + PROTOBUF_C_LABEL_OPTIONAL,
8971 + PROTOBUF_C_TYPE_MESSAGE,
8972 + 0, /* quantifier_offset */
8973 + offsetof(Sr__Request, get_changes_req),
8974 + &sr__get_changes_req__descriptor,
8975 + NULL,
8976 + 0, /* flags */
8977 + 0,NULL,NULL /* reserved1,reserved2, etc */
8978 + },
8979 + {
8980 + "data_provide_req",
8981 + 80,
8982 + PROTOBUF_C_LABEL_OPTIONAL,
8983 + PROTOBUF_C_TYPE_MESSAGE,
8984 + 0, /* quantifier_offset */
8985 + offsetof(Sr__Request, data_provide_req),
8986 + &sr__data_provide_req__descriptor,
8987 + NULL,
8988 + 0, /* flags */
8989 + 0,NULL,NULL /* reserved1,reserved2, etc */
8990 + },
8991 + {
8992 + "check_exec_perm_req",
8993 + 81,
8994 + PROTOBUF_C_LABEL_OPTIONAL,
8995 + PROTOBUF_C_TYPE_MESSAGE,
8996 + 0, /* quantifier_offset */
8997 + offsetof(Sr__Request, check_exec_perm_req),
8998 + &sr__check_exec_perm_req__descriptor,
8999 + NULL,
9000 + 0, /* flags */
9001 + 0,NULL,NULL /* reserved1,reserved2, etc */
9002 + },
9003 + {
9004 + "rpc_req",
9005 + 82,
9006 + PROTOBUF_C_LABEL_OPTIONAL,
9007 + PROTOBUF_C_TYPE_MESSAGE,
9008 + 0, /* quantifier_offset */
9009 + offsetof(Sr__Request, rpc_req),
9010 + &sr__rpcreq__descriptor,
9011 + NULL,
9012 + 0, /* flags */
9013 + 0,NULL,NULL /* reserved1,reserved2, etc */
9014 + },
9015 + {
9016 + "event_notif_req",
9017 + 83,
9018 + PROTOBUF_C_LABEL_OPTIONAL,
9019 + PROTOBUF_C_TYPE_MESSAGE,
9020 + 0, /* quantifier_offset */
9021 + offsetof(Sr__Request, event_notif_req),
9022 + &sr__event_notif_req__descriptor,
9023 + NULL,
9024 + 0, /* flags */
9025 + 0,NULL,NULL /* reserved1,reserved2, etc */
9026 + },
9027 + {
9028 + "event_notif_replay_req",
9029 + 84,
9030 + PROTOBUF_C_LABEL_OPTIONAL,
9031 + PROTOBUF_C_TYPE_MESSAGE,
9032 + 0, /* quantifier_offset */
9033 + offsetof(Sr__Request, event_notif_replay_req),
9034 + &sr__event_notif_replay_req__descriptor,
9035 + NULL,
9036 + 0, /* flags */
9037 + 0,NULL,NULL /* reserved1,reserved2, etc */
9038 + },
9039 +};
9040 +static const unsigned sr__request__field_indices_by_name[] = {
9041 + 0, /* field[0] = _id */
9042 + 30, /* field[30] = check_enabled_running_req */
9043 + 33, /* field[33] = check_exec_perm_req */
9044 + 23, /* field[23] = commit_req */
9045 + 25, /* field[25] = copy_config_req */
9046 + 32, /* field[32] = data_provide_req */
9047 + 19, /* field[19] = delete_item_req */
9048 + 24, /* field[24] = discard_changes_req */
9049 + 36, /* field[36] = event_notif_replay_req */
9050 + 35, /* field[35] = event_notif_req */
9051 + 12, /* field[12] = feature_enable_req */
9052 + 31, /* field[31] = get_changes_req */
9053 + 13, /* field[13] = get_item_req */
9054 + 14, /* field[14] = get_items_req */
9055 + 10, /* field[10] = get_schema_req */
9056 + 17, /* field[17] = get_subtree_chunk_req */
9057 + 15, /* field[15] = get_subtree_req */
9058 + 16, /* field[16] = get_subtrees_req */
9059 + 9, /* field[9] = list_schemas_req */
9060 + 26, /* field[26] = lock_req */
9061 + 11, /* field[11] = module_install_req */
9062 + 20, /* field[20] = move_item_req */
9063 + 1, /* field[1] = operation */
9064 + 34, /* field[34] = rpc_req */
9065 + 5, /* field[5] = session_check_req */
9066 + 4, /* field[4] = session_refresh_req */
9067 + 7, /* field[7] = session_set_opts_req */
9068 + 2, /* field[2] = session_start_req */
9069 + 3, /* field[3] = session_stop_req */
9070 + 6, /* field[6] = session_switch_ds_req */
9071 + 18, /* field[18] = set_item_req */
9072 + 21, /* field[21] = set_item_str_req */
9073 + 28, /* field[28] = subscribe_req */
9074 + 27, /* field[27] = unlock_req */
9075 + 29, /* field[29] = unsubscribe_req */
9076 + 22, /* field[22] = validate_req */
9077 + 8, /* field[8] = version_verify_req */
9078 +};
9079 +static const ProtobufCIntRange sr__request__number_ranges[9 + 1] =
9080 +{
9081 + { 1, 0 },
9082 + { 10, 2 },
9083 + { 20, 9 },
9084 + { 30, 13 },
9085 + { 40, 18 },
9086 + { 50, 22 },
9087 + { 60, 26 },
9088 + { 70, 28 },
9089 + { 80, 32 },
9090 + { 0, 37 }
9091 +};
9092 +const ProtobufCMessageDescriptor sr__request__descriptor =
9093 +{
9094 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
9095 + "sr.Request",
9096 + "Request",
9097 + "Sr__Request",
9098 + "sr",
9099 + sizeof(Sr__Request),
9100 + 37,
9101 + sr__request__field_descriptors,
9102 + sr__request__field_indices_by_name,
9103 + 9, sr__request__number_ranges,
9104 + (ProtobufCMessageInit) sr__request__init,
9105 + NULL,NULL,NULL /* reserved[123] */
9106 +};
9107 +static const ProtobufCFieldDescriptor sr__response__field_descriptors[38] =
9108 +{
9109 + {
9110 + "operation",
9111 + 1,
9112 + PROTOBUF_C_LABEL_REQUIRED,
9113 + PROTOBUF_C_TYPE_ENUM,
9114 + 0, /* quantifier_offset */
9115 + offsetof(Sr__Response, operation),
9116 + &sr__operation__descriptor,
9117 + NULL,
9118 + 0, /* flags */
9119 + 0,NULL,NULL /* reserved1,reserved2, etc */
9120 + },
9121 + {
9122 + "result",
9123 + 2,
9124 + PROTOBUF_C_LABEL_REQUIRED,
9125 + PROTOBUF_C_TYPE_UINT32,
9126 + 0, /* quantifier_offset */
9127 + offsetof(Sr__Response, result),
9128 + NULL,
9129 + NULL,
9130 + 0, /* flags */
9131 + 0,NULL,NULL /* reserved1,reserved2, etc */
9132 + },
9133 + {
9134 + "error",
9135 + 3,
9136 + PROTOBUF_C_LABEL_OPTIONAL,
9137 + PROTOBUF_C_TYPE_MESSAGE,
9138 + 0, /* quantifier_offset */
9139 + offsetof(Sr__Response, error),
9140 + &sr__error__descriptor,
9141 + NULL,
9142 + 0, /* flags */
9143 + 0,NULL,NULL /* reserved1,reserved2, etc */
9144 + },
9145 + {
9146 + "session_start_resp",
9147 + 10,
9148 + PROTOBUF_C_LABEL_OPTIONAL,
9149 + PROTOBUF_C_TYPE_MESSAGE,
9150 + 0, /* quantifier_offset */
9151 + offsetof(Sr__Response, session_start_resp),
9152 + &sr__session_start_resp__descriptor,
9153 + NULL,
9154 + 0, /* flags */
9155 + 0,NULL,NULL /* reserved1,reserved2, etc */
9156 + },
9157 + {
9158 + "session_stop_resp",
9159 + 11,
9160 + PROTOBUF_C_LABEL_OPTIONAL,
9161 + PROTOBUF_C_TYPE_MESSAGE,
9162 + 0, /* quantifier_offset */
9163 + offsetof(Sr__Response, session_stop_resp),
9164 + &sr__session_stop_resp__descriptor,
9165 + NULL,
9166 + 0, /* flags */
9167 + 0,NULL,NULL /* reserved1,reserved2, etc */
9168 + },
9169 + {
9170 + "session_refresh_resp",
9171 + 12,
9172 + PROTOBUF_C_LABEL_OPTIONAL,
9173 + PROTOBUF_C_TYPE_MESSAGE,
9174 + 0, /* quantifier_offset */
9175 + offsetof(Sr__Response, session_refresh_resp),
9176 + &sr__session_refresh_resp__descriptor,
9177 + NULL,
9178 + 0, /* flags */
9179 + 0,NULL,NULL /* reserved1,reserved2, etc */
9180 + },
9181 + {
9182 + "session_check_resp",
9183 + 13,
9184 + PROTOBUF_C_LABEL_OPTIONAL,
9185 + PROTOBUF_C_TYPE_MESSAGE,
9186 + 0, /* quantifier_offset */
9187 + offsetof(Sr__Response, session_check_resp),
9188 + &sr__session_check_resp__descriptor,
9189 + NULL,
9190 + 0, /* flags */
9191 + 0,NULL,NULL /* reserved1,reserved2, etc */
9192 + },
9193 + {
9194 + "session_switch_ds_resp",
9195 + 14,
9196 + PROTOBUF_C_LABEL_OPTIONAL,
9197 + PROTOBUF_C_TYPE_MESSAGE,
9198 + 0, /* quantifier_offset */
9199 + offsetof(Sr__Response, session_switch_ds_resp),
9200 + &sr__session_switch_ds_resp__descriptor,
9201 + NULL,
9202 + 0, /* flags */
9203 + 0,NULL,NULL /* reserved1,reserved2, etc */
9204 + },
9205 + {
9206 + "session_set_opts_resp",
9207 + 15,
9208 + PROTOBUF_C_LABEL_OPTIONAL,
9209 + PROTOBUF_C_TYPE_MESSAGE,
9210 + 0, /* quantifier_offset */
9211 + offsetof(Sr__Response, session_set_opts_resp),
9212 + &sr__session_set_opts_resp__descriptor,
9213 + NULL,
9214 + 0, /* flags */
9215 + 0,NULL,NULL /* reserved1,reserved2, etc */
9216 + },
9217 + {
9218 + "version_verify_resp",
9219 + 16,
9220 + PROTOBUF_C_LABEL_OPTIONAL,
9221 + PROTOBUF_C_TYPE_MESSAGE,
9222 + 0, /* quantifier_offset */
9223 + offsetof(Sr__Response, version_verify_resp),
9224 + &sr__version_verify_resp__descriptor,
9225 + NULL,
9226 + 0, /* flags */
9227 + 0,NULL,NULL /* reserved1,reserved2, etc */
9228 + },
9229 + {
9230 + "list_schemas_resp",
9231 + 20,
9232 + PROTOBUF_C_LABEL_OPTIONAL,
9233 + PROTOBUF_C_TYPE_MESSAGE,
9234 + 0, /* quantifier_offset */
9235 + offsetof(Sr__Response, list_schemas_resp),
9236 + &sr__list_schemas_resp__descriptor,
9237 + NULL,
9238 + 0, /* flags */
9239 + 0,NULL,NULL /* reserved1,reserved2, etc */
9240 + },
9241 + {
9242 + "get_schema_resp",
9243 + 21,
9244 + PROTOBUF_C_LABEL_OPTIONAL,
9245 + PROTOBUF_C_TYPE_MESSAGE,
9246 + 0, /* quantifier_offset */
9247 + offsetof(Sr__Response, get_schema_resp),
9248 + &sr__get_schema_resp__descriptor,
9249 + NULL,
9250 + 0, /* flags */
9251 + 0,NULL,NULL /* reserved1,reserved2, etc */
9252 + },
9253 + {
9254 + "module_install_resp",
9255 + 22,
9256 + PROTOBUF_C_LABEL_OPTIONAL,
9257 + PROTOBUF_C_TYPE_MESSAGE,
9258 + 0, /* quantifier_offset */
9259 + offsetof(Sr__Response, module_install_resp),
9260 + &sr__module_install_resp__descriptor,
9261 + NULL,
9262 + 0, /* flags */
9263 + 0,NULL,NULL /* reserved1,reserved2, etc */
9264 + },
9265 + {
9266 + "feature_enable_resp",
9267 + 23,
9268 + PROTOBUF_C_LABEL_OPTIONAL,
9269 + PROTOBUF_C_TYPE_MESSAGE,
9270 + 0, /* quantifier_offset */
9271 + offsetof(Sr__Response, feature_enable_resp),
9272 + &sr__feature_enable_resp__descriptor,
9273 + NULL,
9274 + 0, /* flags */
9275 + 0,NULL,NULL /* reserved1,reserved2, etc */
9276 + },
9277 + {
9278 + "get_item_resp",
9279 + 30,
9280 + PROTOBUF_C_LABEL_OPTIONAL,
9281 + PROTOBUF_C_TYPE_MESSAGE,
9282 + 0, /* quantifier_offset */
9283 + offsetof(Sr__Response, get_item_resp),
9284 + &sr__get_item_resp__descriptor,
9285 + NULL,
9286 + 0, /* flags */
9287 + 0,NULL,NULL /* reserved1,reserved2, etc */
9288 + },
9289 + {
9290 + "get_items_resp",
9291 + 31,
9292 + PROTOBUF_C_LABEL_OPTIONAL,
9293 + PROTOBUF_C_TYPE_MESSAGE,
9294 + 0, /* quantifier_offset */
9295 + offsetof(Sr__Response, get_items_resp),
9296 + &sr__get_items_resp__descriptor,
9297 + NULL,
9298 + 0, /* flags */
9299 + 0,NULL,NULL /* reserved1,reserved2, etc */
9300 + },
9301 + {
9302 + "get_subtree_resp",
9303 + 32,
9304 + PROTOBUF_C_LABEL_OPTIONAL,
9305 + PROTOBUF_C_TYPE_MESSAGE,
9306 + 0, /* quantifier_offset */
9307 + offsetof(Sr__Response, get_subtree_resp),
9308 + &sr__get_subtree_resp__descriptor,
9309 + NULL,
9310 + 0, /* flags */
9311 + 0,NULL,NULL /* reserved1,reserved2, etc */
9312 + },
9313 + {
9314 + "get_subtrees_resp",
9315 + 33,
9316 + PROTOBUF_C_LABEL_OPTIONAL,
9317 + PROTOBUF_C_TYPE_MESSAGE,
9318 + 0, /* quantifier_offset */
9319 + offsetof(Sr__Response, get_subtrees_resp),
9320 + &sr__get_subtrees_resp__descriptor,
9321 + NULL,
9322 + 0, /* flags */
9323 + 0,NULL,NULL /* reserved1,reserved2, etc */
9324 + },
9325 + {
9326 + "get_subtree_chunk_resp",
9327 + 34,
9328 + PROTOBUF_C_LABEL_OPTIONAL,
9329 + PROTOBUF_C_TYPE_MESSAGE,
9330 + 0, /* quantifier_offset */
9331 + offsetof(Sr__Response, get_subtree_chunk_resp),
9332 + &sr__get_subtree_chunk_resp__descriptor,
9333 + NULL,
9334 + 0, /* flags */
9335 + 0,NULL,NULL /* reserved1,reserved2, etc */
9336 + },
9337 + {
9338 + "set_item_resp",
9339 + 40,
9340 + PROTOBUF_C_LABEL_OPTIONAL,
9341 + PROTOBUF_C_TYPE_MESSAGE,
9342 + 0, /* quantifier_offset */
9343 + offsetof(Sr__Response, set_item_resp),
9344 + &sr__set_item_resp__descriptor,
9345 + NULL,
9346 + 0, /* flags */
9347 + 0,NULL,NULL /* reserved1,reserved2, etc */
9348 + },
9349 + {
9350 + "delete_item_resp",
9351 + 41,
9352 + PROTOBUF_C_LABEL_OPTIONAL,
9353 + PROTOBUF_C_TYPE_MESSAGE,
9354 + 0, /* quantifier_offset */
9355 + offsetof(Sr__Response, delete_item_resp),
9356 + &sr__delete_item_resp__descriptor,
9357 + NULL,
9358 + 0, /* flags */
9359 + 0,NULL,NULL /* reserved1,reserved2, etc */
9360 + },
9361 + {
9362 + "move_item_resp",
9363 + 42,
9364 + PROTOBUF_C_LABEL_OPTIONAL,
9365 + PROTOBUF_C_TYPE_MESSAGE,
9366 + 0, /* quantifier_offset */
9367 + offsetof(Sr__Response, move_item_resp),
9368 + &sr__move_item_resp__descriptor,
9369 + NULL,
9370 + 0, /* flags */
9371 + 0,NULL,NULL /* reserved1,reserved2, etc */
9372 + },
9373 + {
9374 + "set_item_str_resp",
9375 + 43,
9376 + PROTOBUF_C_LABEL_OPTIONAL,
9377 + PROTOBUF_C_TYPE_MESSAGE,
9378 + 0, /* quantifier_offset */
9379 + offsetof(Sr__Response, set_item_str_resp),
9380 + &sr__set_item_str_resp__descriptor,
9381 + NULL,
9382 + 0, /* flags */
9383 + 0,NULL,NULL /* reserved1,reserved2, etc */
9384 + },
9385 + {
9386 + "validate_resp",
9387 + 50,
9388 + PROTOBUF_C_LABEL_OPTIONAL,
9389 + PROTOBUF_C_TYPE_MESSAGE,
9390 + 0, /* quantifier_offset */
9391 + offsetof(Sr__Response, validate_resp),
9392 + &sr__validate_resp__descriptor,
9393 + NULL,
9394 + 0, /* flags */
9395 + 0,NULL,NULL /* reserved1,reserved2, etc */
9396 + },
9397 + {
9398 + "commit_resp",
9399 + 51,
9400 + PROTOBUF_C_LABEL_OPTIONAL,
9401 + PROTOBUF_C_TYPE_MESSAGE,
9402 + 0, /* quantifier_offset */
9403 + offsetof(Sr__Response, commit_resp),
9404 + &sr__commit_resp__descriptor,
9405 + NULL,
9406 + 0, /* flags */
9407 + 0,NULL,NULL /* reserved1,reserved2, etc */
9408 + },
9409 + {
9410 + "discard_changes_resp",
9411 + 52,
9412 + PROTOBUF_C_LABEL_OPTIONAL,
9413 + PROTOBUF_C_TYPE_MESSAGE,
9414 + 0, /* quantifier_offset */
9415 + offsetof(Sr__Response, discard_changes_resp),
9416 + &sr__discard_changes_resp__descriptor,
9417 + NULL,
9418 + 0, /* flags */
9419 + 0,NULL,NULL /* reserved1,reserved2, etc */
9420 + },
9421 + {
9422 + "copy_config_resp",
9423 + 53,
9424 + PROTOBUF_C_LABEL_OPTIONAL,
9425 + PROTOBUF_C_TYPE_MESSAGE,
9426 + 0, /* quantifier_offset */
9427 + offsetof(Sr__Response, copy_config_resp),
9428 + &sr__copy_config_resp__descriptor,
9429 + NULL,
9430 + 0, /* flags */
9431 + 0,NULL,NULL /* reserved1,reserved2, etc */
9432 + },
9433 + {
9434 + "lock_resp",
9435 + 60,
9436 + PROTOBUF_C_LABEL_OPTIONAL,
9437 + PROTOBUF_C_TYPE_MESSAGE,
9438 + 0, /* quantifier_offset */
9439 + offsetof(Sr__Response, lock_resp),
9440 + &sr__lock_resp__descriptor,
9441 + NULL,
9442 + 0, /* flags */
9443 + 0,NULL,NULL /* reserved1,reserved2, etc */
9444 + },
9445 + {
9446 + "unlock_resp",
9447 + 61,
9448 + PROTOBUF_C_LABEL_OPTIONAL,
9449 + PROTOBUF_C_TYPE_MESSAGE,
9450 + 0, /* quantifier_offset */
9451 + offsetof(Sr__Response, unlock_resp),
9452 + &sr__unlock_resp__descriptor,
9453 + NULL,
9454 + 0, /* flags */
9455 + 0,NULL,NULL /* reserved1,reserved2, etc */
9456 + },
9457 + {
9458 + "subscribe_resp",
9459 + 70,
9460 + PROTOBUF_C_LABEL_OPTIONAL,
9461 + PROTOBUF_C_TYPE_MESSAGE,
9462 + 0, /* quantifier_offset */
9463 + offsetof(Sr__Response, subscribe_resp),
9464 + &sr__subscribe_resp__descriptor,
9465 + NULL,
9466 + 0, /* flags */
9467 + 0,NULL,NULL /* reserved1,reserved2, etc */
9468 + },
9469 + {
9470 + "unsubscribe_resp",
9471 + 71,
9472 + PROTOBUF_C_LABEL_OPTIONAL,
9473 + PROTOBUF_C_TYPE_MESSAGE,
9474 + 0, /* quantifier_offset */
9475 + offsetof(Sr__Response, unsubscribe_resp),
9476 + &sr__unsubscribe_resp__descriptor,
9477 + NULL,
9478 + 0, /* flags */
9479 + 0,NULL,NULL /* reserved1,reserved2, etc */
9480 + },
9481 + {
9482 + "check_enabled_running_resp",
9483 + 72,
9484 + PROTOBUF_C_LABEL_OPTIONAL,
9485 + PROTOBUF_C_TYPE_MESSAGE,
9486 + 0, /* quantifier_offset */
9487 + offsetof(Sr__Response, check_enabled_running_resp),
9488 + &sr__check_enabled_running_resp__descriptor,
9489 + NULL,
9490 + 0, /* flags */
9491 + 0,NULL,NULL /* reserved1,reserved2, etc */
9492 + },
9493 + {
9494 + "get_changes_resp",
9495 + 73,
9496 + PROTOBUF_C_LABEL_OPTIONAL,
9497 + PROTOBUF_C_TYPE_MESSAGE,
9498 + 0, /* quantifier_offset */
9499 + offsetof(Sr__Response, get_changes_resp),
9500 + &sr__get_changes_resp__descriptor,
9501 + NULL,
9502 + 0, /* flags */
9503 + 0,NULL,NULL /* reserved1,reserved2, etc */
9504 + },
9505 + {
9506 + "data_provide_resp",
9507 + 80,
9508 + PROTOBUF_C_LABEL_OPTIONAL,
9509 + PROTOBUF_C_TYPE_MESSAGE,
9510 + 0, /* quantifier_offset */
9511 + offsetof(Sr__Response, data_provide_resp),
9512 + &sr__data_provide_resp__descriptor,
9513 + NULL,
9514 + 0, /* flags */
9515 + 0,NULL,NULL /* reserved1,reserved2, etc */
9516 + },
9517 + {
9518 + "check_exec_perm_resp",
9519 + 81,
9520 + PROTOBUF_C_LABEL_OPTIONAL,
9521 + PROTOBUF_C_TYPE_MESSAGE,
9522 + 0, /* quantifier_offset */
9523 + offsetof(Sr__Response, check_exec_perm_resp),
9524 + &sr__check_exec_perm_resp__descriptor,
9525 + NULL,
9526 + 0, /* flags */
9527 + 0,NULL,NULL /* reserved1,reserved2, etc */
9528 + },
9529 + {
9530 + "rpc_resp",
9531 + 82,
9532 + PROTOBUF_C_LABEL_OPTIONAL,
9533 + PROTOBUF_C_TYPE_MESSAGE,
9534 + 0, /* quantifier_offset */
9535 + offsetof(Sr__Response, rpc_resp),
9536 + &sr__rpcresp__descriptor,
9537 + NULL,
9538 + 0, /* flags */
9539 + 0,NULL,NULL /* reserved1,reserved2, etc */
9540 + },
9541 + {
9542 + "event_notif_resp",
9543 + 83,
9544 + PROTOBUF_C_LABEL_OPTIONAL,
9545 + PROTOBUF_C_TYPE_MESSAGE,
9546 + 0, /* quantifier_offset */
9547 + offsetof(Sr__Response, event_notif_resp),
9548 + &sr__event_notif_resp__descriptor,
9549 + NULL,
9550 + 0, /* flags */
9551 + 0,NULL,NULL /* reserved1,reserved2, etc */
9552 + },
9553 + {
9554 + "event_notif_replay_resp",
9555 + 84,
9556 + PROTOBUF_C_LABEL_OPTIONAL,
9557 + PROTOBUF_C_TYPE_MESSAGE,
9558 + 0, /* quantifier_offset */
9559 + offsetof(Sr__Response, event_notif_replay_resp),
9560 + &sr__event_notif_replay_resp__descriptor,
9561 + NULL,
9562 + 0, /* flags */
9563 + 0,NULL,NULL /* reserved1,reserved2, etc */
9564 + },
9565 +};
9566 +static const unsigned sr__response__field_indices_by_name[] = {
9567 + 31, /* field[31] = check_enabled_running_resp */
9568 + 34, /* field[34] = check_exec_perm_resp */
9569 + 24, /* field[24] = commit_resp */
9570 + 26, /* field[26] = copy_config_resp */
9571 + 33, /* field[33] = data_provide_resp */
9572 + 20, /* field[20] = delete_item_resp */
9573 + 25, /* field[25] = discard_changes_resp */
9574 + 2, /* field[2] = error */
9575 + 37, /* field[37] = event_notif_replay_resp */
9576 + 36, /* field[36] = event_notif_resp */
9577 + 13, /* field[13] = feature_enable_resp */
9578 + 32, /* field[32] = get_changes_resp */
9579 + 14, /* field[14] = get_item_resp */
9580 + 15, /* field[15] = get_items_resp */
9581 + 11, /* field[11] = get_schema_resp */
9582 + 18, /* field[18] = get_subtree_chunk_resp */
9583 + 16, /* field[16] = get_subtree_resp */
9584 + 17, /* field[17] = get_subtrees_resp */
9585 + 10, /* field[10] = list_schemas_resp */
9586 + 27, /* field[27] = lock_resp */
9587 + 12, /* field[12] = module_install_resp */
9588 + 21, /* field[21] = move_item_resp */
9589 + 0, /* field[0] = operation */
9590 + 1, /* field[1] = result */
9591 + 35, /* field[35] = rpc_resp */
9592 + 6, /* field[6] = session_check_resp */
9593 + 5, /* field[5] = session_refresh_resp */
9594 + 8, /* field[8] = session_set_opts_resp */
9595 + 3, /* field[3] = session_start_resp */
9596 + 4, /* field[4] = session_stop_resp */
9597 + 7, /* field[7] = session_switch_ds_resp */
9598 + 19, /* field[19] = set_item_resp */
9599 + 22, /* field[22] = set_item_str_resp */
9600 + 29, /* field[29] = subscribe_resp */
9601 + 28, /* field[28] = unlock_resp */
9602 + 30, /* field[30] = unsubscribe_resp */
9603 + 23, /* field[23] = validate_resp */
9604 + 9, /* field[9] = version_verify_resp */
9605 +};
9606 +static const ProtobufCIntRange sr__response__number_ranges[9 + 1] =
9607 +{
9608 + { 1, 0 },
9609 + { 10, 3 },
9610 + { 20, 10 },
9611 + { 30, 14 },
9612 + { 40, 19 },
9613 + { 50, 23 },
9614 + { 60, 27 },
9615 + { 70, 29 },
9616 + { 80, 33 },
9617 + { 0, 38 }
9618 +};
9619 +const ProtobufCMessageDescriptor sr__response__descriptor =
9620 +{
9621 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
9622 + "sr.Response",
9623 + "Response",
9624 + "Sr__Response",
9625 + "sr",
9626 + sizeof(Sr__Response),
9627 + 38,
9628 + sr__response__field_descriptors,
9629 + sr__response__field_indices_by_name,
9630 + 9, sr__response__number_ranges,
9631 + (ProtobufCMessageInit) sr__response__init,
9632 + NULL,NULL,NULL /* reserved[123] */
9633 +};
9634 +static const ProtobufCFieldDescriptor sr__notification__field_descriptors[10] =
9635 +{
9636 + {
9637 + "type",
9638 + 1,
9639 + PROTOBUF_C_LABEL_REQUIRED,
9640 + PROTOBUF_C_TYPE_ENUM,
9641 + 0, /* quantifier_offset */
9642 + offsetof(Sr__Notification, type),
9643 + &sr__subscription_type__descriptor,
9644 + NULL,
9645 + 0, /* flags */
9646 + 0,NULL,NULL /* reserved1,reserved2, etc */
9647 + },
9648 + {
9649 + "destination_address",
9650 + 2,
9651 + PROTOBUF_C_LABEL_REQUIRED,
9652 + PROTOBUF_C_TYPE_STRING,
9653 + 0, /* quantifier_offset */
9654 + offsetof(Sr__Notification, destination_address),
9655 + NULL,
9656 + NULL,
9657 + 0, /* flags */
9658 + 0,NULL,NULL /* reserved1,reserved2, etc */
9659 + },
9660 + {
9661 + "source_address",
9662 + 3,
9663 + PROTOBUF_C_LABEL_REQUIRED,
9664 + PROTOBUF_C_TYPE_STRING,
9665 + 0, /* quantifier_offset */
9666 + offsetof(Sr__Notification, source_address),
9667 + NULL,
9668 + NULL,
9669 + 0, /* flags */
9670 + 0,NULL,NULL /* reserved1,reserved2, etc */
9671 + },
9672 + {
9673 + "source_pid",
9674 + 4,
9675 + PROTOBUF_C_LABEL_REQUIRED,
9676 + PROTOBUF_C_TYPE_UINT32,
9677 + 0, /* quantifier_offset */
9678 + offsetof(Sr__Notification, source_pid),
9679 + NULL,
9680 + NULL,
9681 + 0, /* flags */
9682 + 0,NULL,NULL /* reserved1,reserved2, etc */
9683 + },
9684 + {
9685 + "subscription_id",
9686 + 5,
9687 + PROTOBUF_C_LABEL_REQUIRED,
9688 + PROTOBUF_C_TYPE_UINT32,
9689 + 0, /* quantifier_offset */
9690 + offsetof(Sr__Notification, subscription_id),
9691 + NULL,
9692 + NULL,
9693 + 0, /* flags */
9694 + 0,NULL,NULL /* reserved1,reserved2, etc */
9695 + },
9696 + {
9697 + "commit_id",
9698 + 6,
9699 + PROTOBUF_C_LABEL_OPTIONAL,
9700 + PROTOBUF_C_TYPE_UINT32,
9701 + offsetof(Sr__Notification, has_commit_id),
9702 + offsetof(Sr__Notification, commit_id),
9703 + NULL,
9704 + NULL,
9705 + 0, /* flags */
9706 + 0,NULL,NULL /* reserved1,reserved2, etc */
9707 + },
9708 + {
9709 + "module_install_notif",
9710 + 10,
9711 + PROTOBUF_C_LABEL_OPTIONAL,
9712 + PROTOBUF_C_TYPE_MESSAGE,
9713 + 0, /* quantifier_offset */
9714 + offsetof(Sr__Notification, module_install_notif),
9715 + &sr__module_install_notification__descriptor,
9716 + NULL,
9717 + 0, /* flags */
9718 + 0,NULL,NULL /* reserved1,reserved2, etc */
9719 + },
9720 + {
9721 + "feature_enable_notif",
9722 + 11,
9723 + PROTOBUF_C_LABEL_OPTIONAL,
9724 + PROTOBUF_C_TYPE_MESSAGE,
9725 + 0, /* quantifier_offset */
9726 + offsetof(Sr__Notification, feature_enable_notif),
9727 + &sr__feature_enable_notification__descriptor,
9728 + NULL,
9729 + 0, /* flags */
9730 + 0,NULL,NULL /* reserved1,reserved2, etc */
9731 + },
9732 + {
9733 + "module_change_notif",
9734 + 12,
9735 + PROTOBUF_C_LABEL_OPTIONAL,
9736 + PROTOBUF_C_TYPE_MESSAGE,
9737 + 0, /* quantifier_offset */
9738 + offsetof(Sr__Notification, module_change_notif),
9739 + &sr__module_change_notification__descriptor,
9740 + NULL,
9741 + 0, /* flags */
9742 + 0,NULL,NULL /* reserved1,reserved2, etc */
9743 + },
9744 + {
9745 + "subtree_change_notif",
9746 + 13,
9747 + PROTOBUF_C_LABEL_OPTIONAL,
9748 + PROTOBUF_C_TYPE_MESSAGE,
9749 + 0, /* quantifier_offset */
9750 + offsetof(Sr__Notification, subtree_change_notif),
9751 + &sr__subtree_change_notification__descriptor,
9752 + NULL,
9753 + 0, /* flags */
9754 + 0,NULL,NULL /* reserved1,reserved2, etc */
9755 + },
9756 +};
9757 +static const unsigned sr__notification__field_indices_by_name[] = {
9758 + 5, /* field[5] = commit_id */
9759 + 1, /* field[1] = destination_address */
9760 + 7, /* field[7] = feature_enable_notif */
9761 + 8, /* field[8] = module_change_notif */
9762 + 6, /* field[6] = module_install_notif */
9763 + 2, /* field[2] = source_address */
9764 + 3, /* field[3] = source_pid */
9765 + 4, /* field[4] = subscription_id */
9766 + 9, /* field[9] = subtree_change_notif */
9767 + 0, /* field[0] = type */
9768 +};
9769 +static const ProtobufCIntRange sr__notification__number_ranges[2 + 1] =
9770 +{
9771 + { 1, 0 },
9772 + { 10, 6 },
9773 + { 0, 10 }
9774 +};
9775 +const ProtobufCMessageDescriptor sr__notification__descriptor =
9776 +{
9777 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
9778 + "sr.Notification",
9779 + "Notification",
9780 + "Sr__Notification",
9781 + "sr",
9782 + sizeof(Sr__Notification),
9783 + 10,
9784 + sr__notification__field_descriptors,
9785 + sr__notification__field_indices_by_name,
9786 + 2, sr__notification__number_ranges,
9787 + (ProtobufCMessageInit) sr__notification__init,
9788 + NULL,NULL,NULL /* reserved[123] */
9789 +};
9790 +static const ProtobufCFieldDescriptor sr__notification_ack__field_descriptors[4] =
9791 +{
9792 + {
9793 + "notif",
9794 + 1,
9795 + PROTOBUF_C_LABEL_REQUIRED,
9796 + PROTOBUF_C_TYPE_MESSAGE,
9797 + 0, /* quantifier_offset */
9798 + offsetof(Sr__NotificationAck, notif),
9799 + &sr__notification__descriptor,
9800 + NULL,
9801 + 0, /* flags */
9802 + 0,NULL,NULL /* reserved1,reserved2, etc */
9803 + },
9804 + {
9805 + "result",
9806 + 2,
9807 + PROTOBUF_C_LABEL_REQUIRED,
9808 + PROTOBUF_C_TYPE_UINT32,
9809 + 0, /* quantifier_offset */
9810 + offsetof(Sr__NotificationAck, result),
9811 + NULL,
9812 + NULL,
9813 + 0, /* flags */
9814 + 0,NULL,NULL /* reserved1,reserved2, etc */
9815 + },
9816 + {
9817 + "error",
9818 + 3,
9819 + PROTOBUF_C_LABEL_OPTIONAL,
9820 + PROTOBUF_C_TYPE_MESSAGE,
9821 + 0, /* quantifier_offset */
9822 + offsetof(Sr__NotificationAck, error),
9823 + &sr__error__descriptor,
9824 + NULL,
9825 + 0, /* flags */
9826 + 0,NULL,NULL /* reserved1,reserved2, etc */
9827 + },
9828 + {
9829 + "do_not_send_abort",
9830 + 4,
9831 + PROTOBUF_C_LABEL_REQUIRED,
9832 + PROTOBUF_C_TYPE_BOOL,
9833 + 0, /* quantifier_offset */
9834 + offsetof(Sr__NotificationAck, do_not_send_abort),
9835 + NULL,
9836 + NULL,
9837 + 0, /* flags */
9838 + 0,NULL,NULL /* reserved1,reserved2, etc */
9839 + },
9840 +};
9841 +static const unsigned sr__notification_ack__field_indices_by_name[] = {
9842 + 3, /* field[3] = do_not_send_abort */
9843 + 2, /* field[2] = error */
9844 + 0, /* field[0] = notif */
9845 + 1, /* field[1] = result */
9846 +};
9847 +static const ProtobufCIntRange sr__notification_ack__number_ranges[1 + 1] =
9848 +{
9849 + { 1, 0 },
9850 + { 0, 4 }
9851 +};
9852 +const ProtobufCMessageDescriptor sr__notification_ack__descriptor =
9853 +{
9854 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
9855 + "sr.NotificationAck",
9856 + "NotificationAck",
9857 + "Sr__NotificationAck",
9858 + "sr",
9859 + sizeof(Sr__NotificationAck),
9860 + 4,
9861 + sr__notification_ack__field_descriptors,
9862 + sr__notification_ack__field_indices_by_name,
9863 + 1, sr__notification_ack__number_ranges,
9864 + (ProtobufCMessageInit) sr__notification_ack__init,
9865 + NULL,NULL,NULL /* reserved[123] */
9866 +};
9867 +static const ProtobufCFieldDescriptor sr__internal_request__field_descriptors[9] =
9868 +{
9869 + {
9870 + "operation",
9871 + 1,
9872 + PROTOBUF_C_LABEL_REQUIRED,
9873 + PROTOBUF_C_TYPE_ENUM,
9874 + 0, /* quantifier_offset */
9875 + offsetof(Sr__InternalRequest, operation),
9876 + &sr__operation__descriptor,
9877 + NULL,
9878 + 0, /* flags */
9879 + 0,NULL,NULL /* reserved1,reserved2, etc */
9880 + },
9881 + {
9882 + "postpone_timeout",
9883 + 2,
9884 + PROTOBUF_C_LABEL_OPTIONAL,
9885 + PROTOBUF_C_TYPE_UINT32,
9886 + offsetof(Sr__InternalRequest, has_postpone_timeout),
9887 + offsetof(Sr__InternalRequest, postpone_timeout),
9888 + NULL,
9889 + NULL,
9890 + 0, /* flags */
9891 + 0,NULL,NULL /* reserved1,reserved2, etc */
9892 + },
9893 + {
9894 + "unsubscribe_dst_req",
9895 + 10,
9896 + PROTOBUF_C_LABEL_OPTIONAL,
9897 + PROTOBUF_C_TYPE_MESSAGE,
9898 + 0, /* quantifier_offset */
9899 + offsetof(Sr__InternalRequest, unsubscribe_dst_req),
9900 + &sr__unsubscribe_destination_req__descriptor,
9901 + NULL,
9902 + 0, /* flags */
9903 + 0,NULL,NULL /* reserved1,reserved2, etc */
9904 + },
9905 + {
9906 + "commit_timeout_req",
9907 + 11,
9908 + PROTOBUF_C_LABEL_OPTIONAL,
9909 + PROTOBUF_C_TYPE_MESSAGE,
9910 + 0, /* quantifier_offset */
9911 + offsetof(Sr__InternalRequest, commit_timeout_req),
9912 + &sr__commit_timeout_req__descriptor,
9913 + NULL,
9914 + 0, /* flags */
9915 + 0,NULL,NULL /* reserved1,reserved2, etc */
9916 + },
9917 + {
9918 + "oper_data_timeout_req",
9919 + 12,
9920 + PROTOBUF_C_LABEL_OPTIONAL,
9921 + PROTOBUF_C_TYPE_MESSAGE,
9922 + 0, /* quantifier_offset */
9923 + offsetof(Sr__InternalRequest, oper_data_timeout_req),
9924 + &sr__oper_data_timeout_req__descriptor,
9925 + NULL,
9926 + 0, /* flags */
9927 + 0,NULL,NULL /* reserved1,reserved2, etc */
9928 + },
9929 + {
9930 + "internal_state_data_req",
9931 + 13,
9932 + PROTOBUF_C_LABEL_OPTIONAL,
9933 + PROTOBUF_C_TYPE_MESSAGE,
9934 + 0, /* quantifier_offset */
9935 + offsetof(Sr__InternalRequest, internal_state_data_req),
9936 + &sr__internal_state_data_req__descriptor,
9937 + NULL,
9938 + 0, /* flags */
9939 + 0,NULL,NULL /* reserved1,reserved2, etc */
9940 + },
9941 + {
9942 + "notif_store_cleanup_req",
9943 + 14,
9944 + PROTOBUF_C_LABEL_OPTIONAL,
9945 + PROTOBUF_C_TYPE_MESSAGE,
9946 + 0, /* quantifier_offset */
9947 + offsetof(Sr__InternalRequest, notif_store_cleanup_req),
9948 + &sr__notif_store_cleanup_req__descriptor,
9949 + NULL,
9950 + 0, /* flags */
9951 + 0,NULL,NULL /* reserved1,reserved2, etc */
9952 + },
9953 + {
9954 + "delayed_msg_req",
9955 + 15,
9956 + PROTOBUF_C_LABEL_OPTIONAL,
9957 + PROTOBUF_C_TYPE_MESSAGE,
9958 + 0, /* quantifier_offset */
9959 + offsetof(Sr__InternalRequest, delayed_msg_req),
9960 + &sr__delayed_msg_req__descriptor,
9961 + NULL,
9962 + 0, /* flags */
9963 + 0,NULL,NULL /* reserved1,reserved2, etc */
9964 + },
9965 + {
9966 + "nacm_reload_req",
9967 + 16,
9968 + PROTOBUF_C_LABEL_OPTIONAL,
9969 + PROTOBUF_C_TYPE_MESSAGE,
9970 + 0, /* quantifier_offset */
9971 + offsetof(Sr__InternalRequest, nacm_reload_req),
9972 + &sr__nacm_reload_req__descriptor,
9973 + NULL,
9974 + 0, /* flags */
9975 + 0,NULL,NULL /* reserved1,reserved2, etc */
9976 + },
9977 +};
9978 +static const unsigned sr__internal_request__field_indices_by_name[] = {
9979 + 3, /* field[3] = commit_timeout_req */
9980 + 7, /* field[7] = delayed_msg_req */
9981 + 5, /* field[5] = internal_state_data_req */
9982 + 8, /* field[8] = nacm_reload_req */
9983 + 6, /* field[6] = notif_store_cleanup_req */
9984 + 4, /* field[4] = oper_data_timeout_req */
9985 + 0, /* field[0] = operation */
9986 + 1, /* field[1] = postpone_timeout */
9987 + 2, /* field[2] = unsubscribe_dst_req */
9988 +};
9989 +static const ProtobufCIntRange sr__internal_request__number_ranges[2 + 1] =
9990 +{
9991 + { 1, 0 },
9992 + { 10, 2 },
9993 + { 0, 9 }
9994 +};
9995 +const ProtobufCMessageDescriptor sr__internal_request__descriptor =
9996 +{
9997 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
9998 + "sr.InternalRequest",
9999 + "InternalRequest",
10000 + "Sr__InternalRequest",
10001 + "sr",
10002 + sizeof(Sr__InternalRequest),
10003 + 9,
10004 + sr__internal_request__field_descriptors,
10005 + sr__internal_request__field_indices_by_name,
10006 + 2, sr__internal_request__number_ranges,
10007 + (ProtobufCMessageInit) sr__internal_request__init,
10008 + NULL,NULL,NULL /* reserved[123] */
10009 +};
10010 +static const ProtobufCEnumValue sr__msg__msg_type__enum_values_by_number[5] =
10011 +{
10012 + { "REQUEST", "SR__MSG__MSG_TYPE__REQUEST", 1 },
10013 + { "RESPONSE", "SR__MSG__MSG_TYPE__RESPONSE", 2 },
10014 + { "NOTIFICATION", "SR__MSG__MSG_TYPE__NOTIFICATION", 3 },
10015 + { "NOTIFICATION_ACK", "SR__MSG__MSG_TYPE__NOTIFICATION_ACK", 4 },
10016 + { "INTERNAL_REQUEST", "SR__MSG__MSG_TYPE__INTERNAL_REQUEST", 5 },
10017 +};
10018 +static const ProtobufCIntRange sr__msg__msg_type__value_ranges[] = {
10019 +{1, 0},{0, 5}
10020 +};
10021 +static const ProtobufCEnumValueIndex sr__msg__msg_type__enum_values_by_name[5] =
10022 +{
10023 + { "INTERNAL_REQUEST", 4 },
10024 + { "NOTIFICATION", 2 },
10025 + { "NOTIFICATION_ACK", 3 },
10026 + { "REQUEST", 0 },
10027 + { "RESPONSE", 1 },
10028 +};
10029 +const ProtobufCEnumDescriptor sr__msg__msg_type__descriptor =
10030 +{
10031 + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
10032 + "sr.Msg.MsgType",
10033 + "MsgType",
10034 + "Sr__Msg__MsgType",
10035 + "sr",
10036 + 5,
10037 + sr__msg__msg_type__enum_values_by_number,
10038 + 5,
10039 + sr__msg__msg_type__enum_values_by_name,
10040 + 1,
10041 + sr__msg__msg_type__value_ranges,
10042 + NULL,NULL,NULL,NULL /* reserved[1234] */
10043 +};
10044 +static const ProtobufCFieldDescriptor sr__msg__field_descriptors[8] =
10045 +{
10046 + {
10047 + "type",
10048 + 1,
10049 + PROTOBUF_C_LABEL_REQUIRED,
10050 + PROTOBUF_C_TYPE_ENUM,
10051 + 0, /* quantifier_offset */
10052 + offsetof(Sr__Msg, type),
10053 + &sr__msg__msg_type__descriptor,
10054 + NULL,
10055 + 0, /* flags */
10056 + 0,NULL,NULL /* reserved1,reserved2, etc */
10057 + },
10058 + {
10059 + "session_id",
10060 + 2,
10061 + PROTOBUF_C_LABEL_REQUIRED,
10062 + PROTOBUF_C_TYPE_UINT32,
10063 + 0, /* quantifier_offset */
10064 + offsetof(Sr__Msg, session_id),
10065 + NULL,
10066 + NULL,
10067 + 0, /* flags */
10068 + 0,NULL,NULL /* reserved1,reserved2, etc */
10069 + },
10070 + {
10071 + "request",
10072 + 3,
10073 + PROTOBUF_C_LABEL_OPTIONAL,
10074 + PROTOBUF_C_TYPE_MESSAGE,
10075 + 0, /* quantifier_offset */
10076 + offsetof(Sr__Msg, request),
10077 + &sr__request__descriptor,
10078 + NULL,
10079 + 0, /* flags */
10080 + 0,NULL,NULL /* reserved1,reserved2, etc */
10081 + },
10082 + {
10083 + "response",
10084 + 4,
10085 + PROTOBUF_C_LABEL_OPTIONAL,
10086 + PROTOBUF_C_TYPE_MESSAGE,
10087 + 0, /* quantifier_offset */
10088 + offsetof(Sr__Msg, response),
10089 + &sr__response__descriptor,
10090 + NULL,
10091 + 0, /* flags */
10092 + 0,NULL,NULL /* reserved1,reserved2, etc */
10093 + },
10094 + {
10095 + "notification",
10096 + 5,
10097 + PROTOBUF_C_LABEL_OPTIONAL,
10098 + PROTOBUF_C_TYPE_MESSAGE,
10099 + 0, /* quantifier_offset */
10100 + offsetof(Sr__Msg, notification),
10101 + &sr__notification__descriptor,
10102 + NULL,
10103 + 0, /* flags */
10104 + 0,NULL,NULL /* reserved1,reserved2, etc */
10105 + },
10106 + {
10107 + "notification_ack",
10108 + 6,
10109 + PROTOBUF_C_LABEL_OPTIONAL,
10110 + PROTOBUF_C_TYPE_MESSAGE,
10111 + 0, /* quantifier_offset */
10112 + offsetof(Sr__Msg, notification_ack),
10113 + &sr__notification_ack__descriptor,
10114 + NULL,
10115 + 0, /* flags */
10116 + 0,NULL,NULL /* reserved1,reserved2, etc */
10117 + },
10118 + {
10119 + "internal_request",
10120 + 7,
10121 + PROTOBUF_C_LABEL_OPTIONAL,
10122 + PROTOBUF_C_TYPE_MESSAGE,
10123 + 0, /* quantifier_offset */
10124 + offsetof(Sr__Msg, internal_request),
10125 + &sr__internal_request__descriptor,
10126 + NULL,
10127 + 0, /* flags */
10128 + 0,NULL,NULL /* reserved1,reserved2, etc */
10129 + },
10130 + {
10131 + "_sysrepo_mem_ctx",
10132 + 20,
10133 + PROTOBUF_C_LABEL_REQUIRED,
10134 + PROTOBUF_C_TYPE_UINT64,
10135 + 0, /* quantifier_offset */
10136 + offsetof(Sr__Msg, _sysrepo_mem_ctx),
10137 + NULL,
10138 + NULL,
10139 + 0, /* flags */
10140 + 0,NULL,NULL /* reserved1,reserved2, etc */
10141 + },
10142 +};
10143 +static const unsigned sr__msg__field_indices_by_name[] = {
10144 + 7, /* field[7] = _sysrepo_mem_ctx */
10145 + 6, /* field[6] = internal_request */
10146 + 4, /* field[4] = notification */
10147 + 5, /* field[5] = notification_ack */
10148 + 2, /* field[2] = request */
10149 + 3, /* field[3] = response */
10150 + 1, /* field[1] = session_id */
10151 + 0, /* field[0] = type */
10152 +};
10153 +static const ProtobufCIntRange sr__msg__number_ranges[2 + 1] =
10154 +{
10155 + { 1, 0 },
10156 + { 20, 7 },
10157 + { 0, 8 }
10158 +};
10159 +const ProtobufCMessageDescriptor sr__msg__descriptor =
10160 +{
10161 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
10162 + "sr.Msg",
10163 + "Msg",
10164 + "Sr__Msg",
10165 + "sr",
10166 + sizeof(Sr__Msg),
10167 + 8,
10168 + sr__msg__field_descriptors,
10169 + sr__msg__field_indices_by_name,
10170 + 2, sr__msg__number_ranges,
10171 + (ProtobufCMessageInit) sr__msg__init,
10172 + NULL,NULL,NULL /* reserved[123] */
10173 +};
10174 +static const ProtobufCEnumValue sr__api_variant__enum_values_by_number[2] =
10175 +{
10176 + { "VALUES", "SR__API_VARIANT__VALUES", 1 },
10177 + { "TREES", "SR__API_VARIANT__TREES", 2 },
10178 +};
10179 +static const ProtobufCIntRange sr__api_variant__value_ranges[] = {
10180 +{1, 0},{0, 2}
10181 +};
10182 +static const ProtobufCEnumValueIndex sr__api_variant__enum_values_by_name[2] =
10183 +{
10184 + { "TREES", 1 },
10185 + { "VALUES", 0 },
10186 +};
10187 +const ProtobufCEnumDescriptor sr__api_variant__descriptor =
10188 +{
10189 + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
10190 + "sr.ApiVariant",
10191 + "ApiVariant",
10192 + "Sr__ApiVariant",
10193 + "sr",
10194 + 2,
10195 + sr__api_variant__enum_values_by_number,
10196 + 2,
10197 + sr__api_variant__enum_values_by_name,
10198 + 1,
10199 + sr__api_variant__value_ranges,
10200 + NULL,NULL,NULL,NULL /* reserved[1234] */
10201 +};
10202 +static const ProtobufCEnumValue sr__data_store__enum_values_by_number[3] =
10203 +{
10204 + { "STARTUP", "SR__DATA_STORE__STARTUP", 1 },
10205 + { "RUNNING", "SR__DATA_STORE__RUNNING", 2 },
10206 + { "CANDIDATE", "SR__DATA_STORE__CANDIDATE", 3 },
10207 +};
10208 +static const ProtobufCIntRange sr__data_store__value_ranges[] = {
10209 +{1, 0},{0, 3}
10210 +};
10211 +static const ProtobufCEnumValueIndex sr__data_store__enum_values_by_name[3] =
10212 +{
10213 + { "CANDIDATE", 2 },
10214 + { "RUNNING", 1 },
10215 + { "STARTUP", 0 },
10216 +};
10217 +const ProtobufCEnumDescriptor sr__data_store__descriptor =
10218 +{
10219 + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
10220 + "sr.DataStore",
10221 + "DataStore",
10222 + "Sr__DataStore",
10223 + "sr",
10224 + 3,
10225 + sr__data_store__enum_values_by_number,
10226 + 3,
10227 + sr__data_store__enum_values_by_name,
10228 + 1,
10229 + sr__data_store__value_ranges,
10230 + NULL,NULL,NULL,NULL /* reserved[1234] */
10231 +};
10232 +static const ProtobufCEnumValue sr__session_flags__enum_values_by_number[4] =
10233 +{
10234 + { "SESS_DEFAULT", "SR__SESSION_FLAGS__SESS_DEFAULT", 0 },
10235 + { "SESS_CONFIG_ONLY", "SR__SESSION_FLAGS__SESS_CONFIG_ONLY", 1 },
10236 + { "SESS_ENABLE_NACM", "SR__SESSION_FLAGS__SESS_ENABLE_NACM", 2 },
10237 + { "SESS_NOTIFICATION", "SR__SESSION_FLAGS__SESS_NOTIFICATION", 1024 },
10238 +};
10239 +static const ProtobufCIntRange sr__session_flags__value_ranges[] = {
10240 +{0, 0},{1024, 3},{0, 4}
10241 +};
10242 +static const ProtobufCEnumValueIndex sr__session_flags__enum_values_by_name[4] =
10243 +{
10244 + { "SESS_CONFIG_ONLY", 1 },
10245 + { "SESS_DEFAULT", 0 },
10246 + { "SESS_ENABLE_NACM", 2 },
10247 + { "SESS_NOTIFICATION", 3 },
10248 +};
10249 +const ProtobufCEnumDescriptor sr__session_flags__descriptor =
10250 +{
10251 + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
10252 + "sr.SessionFlags",
10253 + "SessionFlags",
10254 + "Sr__SessionFlags",
10255 + "sr",
10256 + 4,
10257 + sr__session_flags__enum_values_by_number,
10258 + 4,
10259 + sr__session_flags__enum_values_by_name,
10260 + 2,
10261 + sr__session_flags__value_ranges,
10262 + NULL,NULL,NULL,NULL /* reserved[1234] */
10263 +};
10264 +static const ProtobufCEnumValue sr__edit_flags__enum_values_by_number[3] =
10265 +{
10266 + { "EDIT_DEFAULT", "SR__EDIT_FLAGS__EDIT_DEFAULT", 0 },
10267 + { "EDIT_NON_RECURSIVE", "SR__EDIT_FLAGS__EDIT_NON_RECURSIVE", 1 },
10268 + { "EDIT_STRICT", "SR__EDIT_FLAGS__EDIT_STRICT", 2 },
10269 +};
10270 +static const ProtobufCIntRange sr__edit_flags__value_ranges[] = {
10271 +{0, 0},{0, 3}
10272 +};
10273 +static const ProtobufCEnumValueIndex sr__edit_flags__enum_values_by_name[3] =
10274 +{
10275 + { "EDIT_DEFAULT", 0 },
10276 + { "EDIT_NON_RECURSIVE", 1 },
10277 + { "EDIT_STRICT", 2 },
10278 +};
10279 +const ProtobufCEnumDescriptor sr__edit_flags__descriptor =
10280 +{
10281 + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
10282 + "sr.EditFlags",
10283 + "EditFlags",
10284 + "Sr__EditFlags",
10285 + "sr",
10286 + 3,
10287 + sr__edit_flags__enum_values_by_number,
10288 + 3,
10289 + sr__edit_flags__enum_values_by_name,
10290 + 1,
10291 + sr__edit_flags__value_ranges,
10292 + NULL,NULL,NULL,NULL /* reserved[1234] */
10293 +};
10294 +static const ProtobufCEnumValue sr__subscription_type__enum_values_by_number[10] =
10295 +{
10296 + { "MODULE_INSTALL_SUBS", "SR__SUBSCRIPTION_TYPE__MODULE_INSTALL_SUBS", 1 },
10297 + { "FEATURE_ENABLE_SUBS", "SR__SUBSCRIPTION_TYPE__FEATURE_ENABLE_SUBS", 2 },
10298 + { "MODULE_CHANGE_SUBS", "SR__SUBSCRIPTION_TYPE__MODULE_CHANGE_SUBS", 10 },
10299 + { "SUBTREE_CHANGE_SUBS", "SR__SUBSCRIPTION_TYPE__SUBTREE_CHANGE_SUBS", 11 },
10300 + { "DP_GET_ITEMS_SUBS", "SR__SUBSCRIPTION_TYPE__DP_GET_ITEMS_SUBS", 20 },
10301 + { "RPC_SUBS", "SR__SUBSCRIPTION_TYPE__RPC_SUBS", 30 },
10302 + { "ACTION_SUBS", "SR__SUBSCRIPTION_TYPE__ACTION_SUBS", 31 },
10303 + { "EVENT_NOTIF_SUBS", "SR__SUBSCRIPTION_TYPE__EVENT_NOTIF_SUBS", 40 },
10304 + { "HELLO_SUBS", "SR__SUBSCRIPTION_TYPE__HELLO_SUBS", 50 },
10305 + { "COMMIT_END_SUBS", "SR__SUBSCRIPTION_TYPE__COMMIT_END_SUBS", 51 },
10306 +};
10307 +static const ProtobufCIntRange sr__subscription_type__value_ranges[] = {
10308 +{1, 0},{10, 2},{20, 4},{30, 5},{40, 7},{50, 8},{0, 10}
10309 +};
10310 +static const ProtobufCEnumValueIndex sr__subscription_type__enum_values_by_name[10] =
10311 +{
10312 + { "ACTION_SUBS", 6 },
10313 + { "COMMIT_END_SUBS", 9 },
10314 + { "DP_GET_ITEMS_SUBS", 4 },
10315 + { "EVENT_NOTIF_SUBS", 7 },
10316 + { "FEATURE_ENABLE_SUBS", 1 },
10317 + { "HELLO_SUBS", 8 },
10318 + { "MODULE_CHANGE_SUBS", 2 },
10319 + { "MODULE_INSTALL_SUBS", 0 },
10320 + { "RPC_SUBS", 5 },
10321 + { "SUBTREE_CHANGE_SUBS", 3 },
10322 +};
10323 +const ProtobufCEnumDescriptor sr__subscription_type__descriptor =
10324 +{
10325 + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
10326 + "sr.SubscriptionType",
10327 + "SubscriptionType",
10328 + "Sr__SubscriptionType",
10329 + "sr",
10330 + 10,
10331 + sr__subscription_type__enum_values_by_number,
10332 + 10,
10333 + sr__subscription_type__enum_values_by_name,
10334 + 6,
10335 + sr__subscription_type__value_ranges,
10336 + NULL,NULL,NULL,NULL /* reserved[1234] */
10337 +};
10338 +static const ProtobufCEnumValue sr__notification_event__enum_values_by_number[4] =
10339 +{
10340 + { "VERIFY_EV", "SR__NOTIFICATION_EVENT__VERIFY_EV", 1 },
10341 + { "APPLY_EV", "SR__NOTIFICATION_EVENT__APPLY_EV", 2 },
10342 + { "ABORT_EV", "SR__NOTIFICATION_EVENT__ABORT_EV", 3 },
10343 + { "ENABLED_EV", "SR__NOTIFICATION_EVENT__ENABLED_EV", 4 },
10344 +};
10345 +static const ProtobufCIntRange sr__notification_event__value_ranges[] = {
10346 +{1, 0},{0, 4}
10347 +};
10348 +static const ProtobufCEnumValueIndex sr__notification_event__enum_values_by_name[4] =
10349 +{
10350 + { "ABORT_EV", 2 },
10351 + { "APPLY_EV", 1 },
10352 + { "ENABLED_EV", 3 },
10353 + { "VERIFY_EV", 0 },
10354 +};
10355 +const ProtobufCEnumDescriptor sr__notification_event__descriptor =
10356 +{
10357 + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
10358 + "sr.NotificationEvent",
10359 + "NotificationEvent",
10360 + "Sr__NotificationEvent",
10361 + "sr",
10362 + 4,
10363 + sr__notification_event__enum_values_by_number,
10364 + 4,
10365 + sr__notification_event__enum_values_by_name,
10366 + 1,
10367 + sr__notification_event__value_ranges,
10368 + NULL,NULL,NULL,NULL /* reserved[1234] */
10369 +};
10370 +static const ProtobufCEnumValue sr__module_state__enum_values_by_number[3] =
10371 +{
10372 + { "UNINSTALLED", "SR__MODULE_STATE__UNINSTALLED", 1 },
10373 + { "IMPORTED", "SR__MODULE_STATE__IMPORTED", 2 },
10374 + { "IMPLEMENTED", "SR__MODULE_STATE__IMPLEMENTED", 3 },
10375 +};
10376 +static const ProtobufCIntRange sr__module_state__value_ranges[] = {
10377 +{1, 0},{0, 3}
10378 +};
10379 +static const ProtobufCEnumValueIndex sr__module_state__enum_values_by_name[3] =
10380 +{
10381 + { "IMPLEMENTED", 2 },
10382 + { "IMPORTED", 1 },
10383 + { "UNINSTALLED", 0 },
10384 +};
10385 +const ProtobufCEnumDescriptor sr__module_state__descriptor =
10386 +{
10387 + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
10388 + "sr.ModuleState",
10389 + "ModuleState",
10390 + "Sr__ModuleState",
10391 + "sr",
10392 + 3,
10393 + sr__module_state__enum_values_by_number,
10394 + 3,
10395 + sr__module_state__enum_values_by_name,
10396 + 1,
10397 + sr__module_state__value_ranges,
10398 + NULL,NULL,NULL,NULL /* reserved[1234] */
10399 +};
10400 +static const ProtobufCEnumValue sr__change_operation__enum_values_by_number[4] =
10401 +{
10402 + { "CREATED", "SR__CHANGE_OPERATION__CREATED", 1 },
10403 + { "MODIFIED", "SR__CHANGE_OPERATION__MODIFIED", 2 },
10404 + { "DELETED", "SR__CHANGE_OPERATION__DELETED", 3 },
10405 + { "MOVED", "SR__CHANGE_OPERATION__MOVED", 4 },
10406 +};
10407 +static const ProtobufCIntRange sr__change_operation__value_ranges[] = {
10408 +{1, 0},{0, 4}
10409 +};
10410 +static const ProtobufCEnumValueIndex sr__change_operation__enum_values_by_name[4] =
10411 +{
10412 + { "CREATED", 0 },
10413 + { "DELETED", 2 },
10414 + { "MODIFIED", 1 },
10415 + { "MOVED", 3 },
10416 +};
10417 +const ProtobufCEnumDescriptor sr__change_operation__descriptor =
10418 +{
10419 + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
10420 + "sr.ChangeOperation",
10421 + "ChangeOperation",
10422 + "Sr__ChangeOperation",
10423 + "sr",
10424 + 4,
10425 + sr__change_operation__enum_values_by_number,
10426 + 4,
10427 + sr__change_operation__enum_values_by_name,
10428 + 1,
10429 + sr__change_operation__value_ranges,
10430 + NULL,NULL,NULL,NULL /* reserved[1234] */
10431 +};
10432 +static const ProtobufCEnumValue sr__operation__enum_values_by_number[43] =
10433 +{
10434 + { "SESSION_START", "SR__OPERATION__SESSION_START", 10 },
10435 + { "SESSION_STOP", "SR__OPERATION__SESSION_STOP", 11 },
10436 + { "SESSION_REFRESH", "SR__OPERATION__SESSION_REFRESH", 12 },
10437 + { "SESSION_CHECK", "SR__OPERATION__SESSION_CHECK", 13 },
10438 + { "SESSION_SWITCH_DS", "SR__OPERATION__SESSION_SWITCH_DS", 14 },
10439 + { "SESSION_SET_OPTS", "SR__OPERATION__SESSION_SET_OPTS", 15 },
10440 + { "VERSION_VERIFY", "SR__OPERATION__VERSION_VERIFY", 16 },
10441 + { "LIST_SCHEMAS", "SR__OPERATION__LIST_SCHEMAS", 20 },
10442 + { "GET_SCHEMA", "SR__OPERATION__GET_SCHEMA", 21 },
10443 + { "MODULE_INSTALL", "SR__OPERATION__MODULE_INSTALL", 22 },
10444 + { "FEATURE_ENABLE", "SR__OPERATION__FEATURE_ENABLE", 23 },
10445 + { "GET_ITEM", "SR__OPERATION__GET_ITEM", 30 },
10446 + { "GET_ITEMS", "SR__OPERATION__GET_ITEMS", 31 },
10447 + { "GET_SUBTREE", "SR__OPERATION__GET_SUBTREE", 32 },
10448 + { "GET_SUBTREES", "SR__OPERATION__GET_SUBTREES", 33 },
10449 + { "GET_SUBTREE_CHUNK", "SR__OPERATION__GET_SUBTREE_CHUNK", 34 },
10450 + { "SET_ITEM", "SR__OPERATION__SET_ITEM", 40 },
10451 + { "DELETE_ITEM", "SR__OPERATION__DELETE_ITEM", 41 },
10452 + { "MOVE_ITEM", "SR__OPERATION__MOVE_ITEM", 42 },
10453 + { "SET_ITEM_STR", "SR__OPERATION__SET_ITEM_STR", 43 },
10454 + { "VALIDATE", "SR__OPERATION__VALIDATE", 50 },
10455 + { "COMMIT", "SR__OPERATION__COMMIT", 51 },
10456 + { "DISCARD_CHANGES", "SR__OPERATION__DISCARD_CHANGES", 52 },
10457 + { "COPY_CONFIG", "SR__OPERATION__COPY_CONFIG", 53 },
10458 + { "LOCK", "SR__OPERATION__LOCK", 60 },
10459 + { "UNLOCK", "SR__OPERATION__UNLOCK", 61 },
10460 + { "SUBSCRIBE", "SR__OPERATION__SUBSCRIBE", 70 },
10461 + { "UNSUBSCRIBE", "SR__OPERATION__UNSUBSCRIBE", 71 },
10462 + { "CHECK_ENABLED_RUNNING", "SR__OPERATION__CHECK_ENABLED_RUNNING", 72 },
10463 + { "GET_CHANGES", "SR__OPERATION__GET_CHANGES", 73 },
10464 + { "DATA_PROVIDE", "SR__OPERATION__DATA_PROVIDE", 80 },
10465 + { "CHECK_EXEC_PERMISSION", "SR__OPERATION__CHECK_EXEC_PERMISSION", 81 },
10466 + { "RPC", "SR__OPERATION__RPC", 82 },
10467 + { "ACTION", "SR__OPERATION__ACTION", 83 },
10468 + { "EVENT_NOTIF", "SR__OPERATION__EVENT_NOTIF", 84 },
10469 + { "EVENT_NOTIF_REPLAY", "SR__OPERATION__EVENT_NOTIF_REPLAY", 85 },
10470 + { "UNSUBSCRIBE_DESTINATION", "SR__OPERATION__UNSUBSCRIBE_DESTINATION", 101 },
10471 + { "COMMIT_TIMEOUT", "SR__OPERATION__COMMIT_TIMEOUT", 102 },
10472 + { "OPER_DATA_TIMEOUT", "SR__OPERATION__OPER_DATA_TIMEOUT", 103 },
10473 + { "INTERNAL_STATE_DATA", "SR__OPERATION__INTERNAL_STATE_DATA", 104 },
10474 + { "NOTIF_STORE_CLEANUP", "SR__OPERATION__NOTIF_STORE_CLEANUP", 105 },
10475 + { "DELAYED_MSG", "SR__OPERATION__DELAYED_MSG", 106 },
10476 + { "NACM_RELOAD", "SR__OPERATION__NACM_RELOAD", 107 },
10477 +};
10478 +static const ProtobufCIntRange sr__operation__value_ranges[] = {
10479 +{10, 0},{20, 7},{30, 11},{40, 16},{50, 20},{60, 24},{70, 26},{80, 30},{101, 36},{0, 43}
10480 +};
10481 +static const ProtobufCEnumValueIndex sr__operation__enum_values_by_name[43] =
10482 +{
10483 + { "ACTION", 33 },
10484 + { "CHECK_ENABLED_RUNNING", 28 },
10485 + { "CHECK_EXEC_PERMISSION", 31 },
10486 + { "COMMIT", 21 },
10487 + { "COMMIT_TIMEOUT", 37 },
10488 + { "COPY_CONFIG", 23 },
10489 + { "DATA_PROVIDE", 30 },
10490 + { "DELAYED_MSG", 41 },
10491 + { "DELETE_ITEM", 17 },
10492 + { "DISCARD_CHANGES", 22 },
10493 + { "EVENT_NOTIF", 34 },
10494 + { "EVENT_NOTIF_REPLAY", 35 },
10495 + { "FEATURE_ENABLE", 10 },
10496 + { "GET_CHANGES", 29 },
10497 + { "GET_ITEM", 11 },
10498 + { "GET_ITEMS", 12 },
10499 + { "GET_SCHEMA", 8 },
10500 + { "GET_SUBTREE", 13 },
10501 + { "GET_SUBTREES", 14 },
10502 + { "GET_SUBTREE_CHUNK", 15 },
10503 + { "INTERNAL_STATE_DATA", 39 },
10504 + { "LIST_SCHEMAS", 7 },
10505 + { "LOCK", 24 },
10506 + { "MODULE_INSTALL", 9 },
10507 + { "MOVE_ITEM", 18 },
10508 + { "NACM_RELOAD", 42 },
10509 + { "NOTIF_STORE_CLEANUP", 40 },
10510 + { "OPER_DATA_TIMEOUT", 38 },
10511 + { "RPC", 32 },
10512 + { "SESSION_CHECK", 3 },
10513 + { "SESSION_REFRESH", 2 },
10514 + { "SESSION_SET_OPTS", 5 },
10515 + { "SESSION_START", 0 },
10516 + { "SESSION_STOP", 1 },
10517 + { "SESSION_SWITCH_DS", 4 },
10518 + { "SET_ITEM", 16 },
10519 + { "SET_ITEM_STR", 19 },
10520 + { "SUBSCRIBE", 26 },
10521 + { "UNLOCK", 25 },
10522 + { "UNSUBSCRIBE", 27 },
10523 + { "UNSUBSCRIBE_DESTINATION", 36 },
10524 + { "VALIDATE", 20 },
10525 + { "VERSION_VERIFY", 6 },
10526 +};
10527 +const ProtobufCEnumDescriptor sr__operation__descriptor =
10528 +{
10529 + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
10530 + "sr.Operation",
10531 + "Operation",
10532 + "Sr__Operation",
10533 + "sr",
10534 + 43,
10535 + sr__operation__enum_values_by_number,
10536 + 43,
10537 + sr__operation__enum_values_by_name,
10538 + 9,
10539 + sr__operation__value_ranges,
10540 + NULL,NULL,NULL,NULL /* reserved[1234] */
10541 +};
10542 Index: sysrepo-e4a5705a4c5293ba121048c71899b98243d99edf/src/common/sysrepo.pb-c.h
10543 ===================================================================
10544 --- /dev/null
10545 +++ sysrepo-e4a5705a4c5293ba121048c71899b98243d99edf/src/common/sysrepo.pb-c.h
10546 @@ -0,0 +1,4236 @@
10547 +/* Generated by the protocol buffer compiler. DO NOT EDIT! */
10548 +/* Generated from: sysrepo.proto */
10549 +
10550 +#ifndef PROTOBUF_C_sysrepo_2eproto__INCLUDED
10551 +#define PROTOBUF_C_sysrepo_2eproto__INCLUDED
10552 +
10553 +#include <protobuf-c/protobuf-c.h>
10554 +
10555 +PROTOBUF_C__BEGIN_DECLS
10556 +
10557 +#if PROTOBUF_C_VERSION_NUMBER < 1000000
10558 +# error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers.
10559 +#elif 1001001 < PROTOBUF_C_MIN_COMPILER_VERSION
10560 +# 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.
10561 +#endif
10562 +
10563 +
10564 +typedef struct _Sr__Value Sr__Value;
10565 +typedef struct _Sr__Node Sr__Node;
10566 +typedef struct _Sr__Error Sr__Error;
10567 +typedef struct _Sr__SessionStartReq Sr__SessionStartReq;
10568 +typedef struct _Sr__SessionStartResp Sr__SessionStartResp;
10569 +typedef struct _Sr__SessionStopReq Sr__SessionStopReq;
10570 +typedef struct _Sr__SessionStopResp Sr__SessionStopResp;
10571 +typedef struct _Sr__SessionRefreshReq Sr__SessionRefreshReq;
10572 +typedef struct _Sr__SessionRefreshResp Sr__SessionRefreshResp;
10573 +typedef struct _Sr__SessionCheckReq Sr__SessionCheckReq;
10574 +typedef struct _Sr__SessionCheckResp Sr__SessionCheckResp;
10575 +typedef struct _Sr__SessionSwitchDsReq Sr__SessionSwitchDsReq;
10576 +typedef struct _Sr__SessionSwitchDsResp Sr__SessionSwitchDsResp;
10577 +typedef struct _Sr__SessionSetOptsReq Sr__SessionSetOptsReq;
10578 +typedef struct _Sr__SessionSetOptsResp Sr__SessionSetOptsResp;
10579 +typedef struct _Sr__VersionVerifyReq Sr__VersionVerifyReq;
10580 +typedef struct _Sr__VersionVerifyResp Sr__VersionVerifyResp;
10581 +typedef struct _Sr__SchemaRevision Sr__SchemaRevision;
10582 +typedef struct _Sr__SchemaSubmodule Sr__SchemaSubmodule;
10583 +typedef struct _Sr__Schema Sr__Schema;
10584 +typedef struct _Sr__ListSchemasReq Sr__ListSchemasReq;
10585 +typedef struct _Sr__ListSchemasResp Sr__ListSchemasResp;
10586 +typedef struct _Sr__GetSchemaReq Sr__GetSchemaReq;
10587 +typedef struct _Sr__GetSchemaResp Sr__GetSchemaResp;
10588 +typedef struct _Sr__GetItemReq Sr__GetItemReq;
10589 +typedef struct _Sr__GetItemResp Sr__GetItemResp;
10590 +typedef struct _Sr__GetItemsReq Sr__GetItemsReq;
10591 +typedef struct _Sr__GetItemsResp Sr__GetItemsResp;
10592 +typedef struct _Sr__GetSubtreeReq Sr__GetSubtreeReq;
10593 +typedef struct _Sr__GetSubtreeResp Sr__GetSubtreeResp;
10594 +typedef struct _Sr__GetSubtreesReq Sr__GetSubtreesReq;
10595 +typedef struct _Sr__GetSubtreesResp Sr__GetSubtreesResp;
10596 +typedef struct _Sr__GetSubtreeChunkReq Sr__GetSubtreeChunkReq;
10597 +typedef struct _Sr__GetSubtreeChunkResp Sr__GetSubtreeChunkResp;
10598 +typedef struct _Sr__SetItemReq Sr__SetItemReq;
10599 +typedef struct _Sr__SetItemResp Sr__SetItemResp;
10600 +typedef struct _Sr__SetItemStrReq Sr__SetItemStrReq;
10601 +typedef struct _Sr__SetItemStrResp Sr__SetItemStrResp;
10602 +typedef struct _Sr__DeleteItemReq Sr__DeleteItemReq;
10603 +typedef struct _Sr__DeleteItemResp Sr__DeleteItemResp;
10604 +typedef struct _Sr__MoveItemReq Sr__MoveItemReq;
10605 +typedef struct _Sr__MoveItemResp Sr__MoveItemResp;
10606 +typedef struct _Sr__ValidateReq Sr__ValidateReq;
10607 +typedef struct _Sr__ValidateResp Sr__ValidateResp;
10608 +typedef struct _Sr__CommitReq Sr__CommitReq;
10609 +typedef struct _Sr__CommitResp Sr__CommitResp;
10610 +typedef struct _Sr__DiscardChangesReq Sr__DiscardChangesReq;
10611 +typedef struct _Sr__DiscardChangesResp Sr__DiscardChangesResp;
10612 +typedef struct _Sr__CopyConfigReq Sr__CopyConfigReq;
10613 +typedef struct _Sr__CopyConfigResp Sr__CopyConfigResp;
10614 +typedef struct _Sr__LockReq Sr__LockReq;
10615 +typedef struct _Sr__LockResp Sr__LockResp;
10616 +typedef struct _Sr__UnlockReq Sr__UnlockReq;
10617 +typedef struct _Sr__UnlockResp Sr__UnlockResp;
10618 +typedef struct _Sr__SubscribeReq Sr__SubscribeReq;
10619 +typedef struct _Sr__SubscribeResp Sr__SubscribeResp;
10620 +typedef struct _Sr__UnsubscribeReq Sr__UnsubscribeReq;
10621 +typedef struct _Sr__UnsubscribeResp Sr__UnsubscribeResp;
10622 +typedef struct _Sr__CheckEnabledRunningReq Sr__CheckEnabledRunningReq;
10623 +typedef struct _Sr__CheckEnabledRunningResp Sr__CheckEnabledRunningResp;
10624 +typedef struct _Sr__ModuleInstallNotification Sr__ModuleInstallNotification;
10625 +typedef struct _Sr__FeatureEnableNotification Sr__FeatureEnableNotification;
10626 +typedef struct _Sr__ModuleChangeNotification Sr__ModuleChangeNotification;
10627 +typedef struct _Sr__SubtreeChangeNotification Sr__SubtreeChangeNotification;
10628 +typedef struct _Sr__Change Sr__Change;
10629 +typedef struct _Sr__GetChangesReq Sr__GetChangesReq;
10630 +typedef struct _Sr__GetChangesResp Sr__GetChangesResp;
10631 +typedef struct _Sr__CheckExecPermReq Sr__CheckExecPermReq;
10632 +typedef struct _Sr__CheckExecPermResp Sr__CheckExecPermResp;
10633 +typedef struct _Sr__RPCReq Sr__RPCReq;
10634 +typedef struct _Sr__RPCResp Sr__RPCResp;
10635 +typedef struct _Sr__EventNotifReq Sr__EventNotifReq;
10636 +typedef struct _Sr__EventNotifResp Sr__EventNotifResp;
10637 +typedef struct _Sr__EventNotifReplayReq Sr__EventNotifReplayReq;
10638 +typedef struct _Sr__EventNotifReplayResp Sr__EventNotifReplayResp;
10639 +typedef struct _Sr__DataProvideReq Sr__DataProvideReq;
10640 +typedef struct _Sr__DataProvideResp Sr__DataProvideResp;
10641 +typedef struct _Sr__ModuleInstallReq Sr__ModuleInstallReq;
10642 +typedef struct _Sr__ModuleInstallResp Sr__ModuleInstallResp;
10643 +typedef struct _Sr__FeatureEnableReq Sr__FeatureEnableReq;
10644 +typedef struct _Sr__FeatureEnableResp Sr__FeatureEnableResp;
10645 +typedef struct _Sr__UnsubscribeDestinationReq Sr__UnsubscribeDestinationReq;
10646 +typedef struct _Sr__CommitTimeoutReq Sr__CommitTimeoutReq;
10647 +typedef struct _Sr__OperDataTimeoutReq Sr__OperDataTimeoutReq;
10648 +typedef struct _Sr__InternalStateDataReq Sr__InternalStateDataReq;
10649 +typedef struct _Sr__NotifStoreCleanupReq Sr__NotifStoreCleanupReq;
10650 +typedef struct _Sr__DelayedMsgReq Sr__DelayedMsgReq;
10651 +typedef struct _Sr__NacmReloadReq Sr__NacmReloadReq;
10652 +typedef struct _Sr__Request Sr__Request;
10653 +typedef struct _Sr__Response Sr__Response;
10654 +typedef struct _Sr__Notification Sr__Notification;
10655 +typedef struct _Sr__NotificationAck Sr__NotificationAck;
10656 +typedef struct _Sr__InternalRequest Sr__InternalRequest;
10657 +typedef struct _Sr__Msg Sr__Msg;
10658 +
10659 +
10660 +/* --- enums --- */
10661 +
10662 +typedef enum _Sr__Value__Types {
10663 + SR__VALUE__TYPES__LIST = 1,
10664 + SR__VALUE__TYPES__CONTAINER = 2,
10665 + SR__VALUE__TYPES__CONTAINER_PRESENCE = 3,
10666 + SR__VALUE__TYPES__LEAF_EMPTY = 4,
10667 + SR__VALUE__TYPES__BINARY = 10,
10668 + SR__VALUE__TYPES__BITS = 11,
10669 + SR__VALUE__TYPES__BOOL = 12,
10670 + SR__VALUE__TYPES__DECIMAL64 = 13,
10671 + SR__VALUE__TYPES__ENUM = 14,
10672 + SR__VALUE__TYPES__IDENTITYREF = 15,
10673 + SR__VALUE__TYPES__INSTANCEID = 16,
10674 + SR__VALUE__TYPES__INT8 = 17,
10675 + SR__VALUE__TYPES__INT16 = 18,
10676 + SR__VALUE__TYPES__INT32 = 19,
10677 + SR__VALUE__TYPES__INT64 = 20,
10678 + SR__VALUE__TYPES__STRING = 21,
10679 + SR__VALUE__TYPES__UINT8 = 22,
10680 + SR__VALUE__TYPES__UINT16 = 23,
10681 + SR__VALUE__TYPES__UINT32 = 24,
10682 + SR__VALUE__TYPES__UINT64 = 25,
10683 + SR__VALUE__TYPES__ANYXML = 26,
10684 + SR__VALUE__TYPES__ANYDATA = 27
10685 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SR__VALUE__TYPES)
10686 +} Sr__Value__Types;
10687 +typedef enum _Sr__MoveItemReq__MovePosition {
10688 + SR__MOVE_ITEM_REQ__MOVE_POSITION__BEFORE = 1,
10689 + SR__MOVE_ITEM_REQ__MOVE_POSITION__AFTER = 2,
10690 + SR__MOVE_ITEM_REQ__MOVE_POSITION__FIRST = 3,
10691 + SR__MOVE_ITEM_REQ__MOVE_POSITION__LAST = 4
10692 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SR__MOVE_ITEM_REQ__MOVE_POSITION)
10693 +} Sr__MoveItemReq__MovePosition;
10694 +/*
10695 + **
10696 + * @brief Type of the event notification.
10697 + */
10698 +typedef enum _Sr__EventNotifReq__NotifType {
10699 + SR__EVENT_NOTIF_REQ__NOTIF_TYPE__REALTIME = 1,
10700 + SR__EVENT_NOTIF_REQ__NOTIF_TYPE__REPLAY = 2,
10701 + SR__EVENT_NOTIF_REQ__NOTIF_TYPE__REPLAY_COMPLETE = 3,
10702 + SR__EVENT_NOTIF_REQ__NOTIF_TYPE__REPLAY_STOP = 4
10703 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SR__EVENT_NOTIF_REQ__NOTIF_TYPE)
10704 +} Sr__EventNotifReq__NotifType;
10705 +/*
10706 + **
10707 + * @brief Flags used to override default session handling.
10708 + */
10709 +typedef enum _Sr__EventNotifReq__NotifFlags {
10710 + /*
10711 + **< Notification will be handled normally.
10712 + */
10713 + SR__EVENT_NOTIF_REQ__NOTIF_FLAGS__DEFAULT = 0,
10714 + /*
10715 + **< Notification will not be stored in the notification store.
10716 + */
10717 + SR__EVENT_NOTIF_REQ__NOTIF_FLAGS__EPHEMERAL = 1
10718 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SR__EVENT_NOTIF_REQ__NOTIF_FLAGS)
10719 +} Sr__EventNotifReq__NotifFlags;
10720 +/*
10721 + **
10722 + * @brief Type of the message.
10723 + */
10724 +typedef enum _Sr__Msg__MsgType {
10725 + /*
10726 + **< The message is a request.
10727 + */
10728 + SR__MSG__MSG_TYPE__REQUEST = 1,
10729 + /*
10730 + **< The message is a response to the request.
10731 + */
10732 + SR__MSG__MSG_TYPE__RESPONSE = 2,
10733 + /*
10734 + **< The message is a notification.
10735 + */
10736 + SR__MSG__MSG_TYPE__NOTIFICATION = 3,
10737 + /*
10738 + **< The message is a notification acknowledgment.
10739 + */
10740 + SR__MSG__MSG_TYPE__NOTIFICATION_ACK = 4,
10741 + /*
10742 + **< The message is an internal request, should not be used from the public API.
10743 + */
10744 + SR__MSG__MSG_TYPE__INTERNAL_REQUEST = 5
10745 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SR__MSG__MSG_TYPE)
10746 +} Sr__Msg__MsgType;
10747 +/*
10748 + **
10749 + * @brief Variant of the API. Currently only values (sr_val_t) vs. trees (sr_node_t).
10750 + */
10751 +typedef enum _Sr__ApiVariant {
10752 + SR__API_VARIANT__VALUES = 1,
10753 + SR__API_VARIANT__TREES = 2
10754 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SR__API_VARIANT)
10755 +} Sr__ApiVariant;
10756 +/*
10757 + **
10758 + * @brief Datastore on which the configuration session will operate.
10759 + */
10760 +typedef enum _Sr__DataStore {
10761 + SR__DATA_STORE__STARTUP = 1,
10762 + SR__DATA_STORE__RUNNING = 2,
10763 + SR__DATA_STORE__CANDIDATE = 3
10764 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SR__DATA_STORE)
10765 +} Sr__DataStore;
10766 +/*
10767 + **
10768 + * @brief Flags used to override default session handling.
10769 + */
10770 +typedef enum _Sr__SessionFlags {
10771 + /*
10772 + **< Default (normal) session behavior.
10773 + */
10774 + SR__SESSION_FLAGS__SESS_DEFAULT = 0,
10775 + /*
10776 + **< Session will process only configuration data (e.g. sysrepo won't
10777 + *return any state data by ::sr_get_items / ::sr_get_items_iter calls).
10778 + */
10779 + SR__SESSION_FLAGS__SESS_CONFIG_ONLY = 1,
10780 + /*
10781 + **< Enable NETCONF access control for this session.
10782 + */
10783 + SR__SESSION_FLAGS__SESS_ENABLE_NACM = 2,
10784 + /*
10785 + **< Notification session (internal type of session).
10786 + */
10787 + SR__SESSION_FLAGS__SESS_NOTIFICATION = 1024
10788 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SR__SESSION_FLAGS)
10789 +} Sr__SessionFlags;
10790 +/*
10791 + **
10792 + * @brief Flags used to override default behavior of data manipulation calls.
10793 + */
10794 +typedef enum _Sr__EditFlags {
10795 + /*
10796 + **< Default behavior - recursive and non-strict.
10797 + */
10798 + SR__EDIT_FLAGS__EDIT_DEFAULT = 0,
10799 + /*
10800 + **< Non-recursive behavior:
10801 + *by ::SetItemReq, all preceding nodes (parents) of the identified element must exist,
10802 + *by ::DeleteItemReq xpath must not identify an non-empty list or non-empty container.
10803 + */
10804 + SR__EDIT_FLAGS__EDIT_NON_RECURSIVE = 1,
10805 + /*
10806 + **< Strict behavior:
10807 + *by ::SetItemReq the identified element must not exist (similar to netconf create operation),
10808 + *by ::DeleteItemReq the identified element must exist (similar to netconf delete operation).
10809 + */
10810 + SR__EDIT_FLAGS__EDIT_STRICT = 2
10811 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SR__EDIT_FLAGS)
10812 +} Sr__EditFlags;
10813 +typedef enum _Sr__SubscriptionType {
10814 + SR__SUBSCRIPTION_TYPE__MODULE_INSTALL_SUBS = 1,
10815 + SR__SUBSCRIPTION_TYPE__FEATURE_ENABLE_SUBS = 2,
10816 + SR__SUBSCRIPTION_TYPE__MODULE_CHANGE_SUBS = 10,
10817 + SR__SUBSCRIPTION_TYPE__SUBTREE_CHANGE_SUBS = 11,
10818 + SR__SUBSCRIPTION_TYPE__DP_GET_ITEMS_SUBS = 20,
10819 + SR__SUBSCRIPTION_TYPE__RPC_SUBS = 30,
10820 + SR__SUBSCRIPTION_TYPE__ACTION_SUBS = 31,
10821 + SR__SUBSCRIPTION_TYPE__EVENT_NOTIF_SUBS = 40,
10822 + /*
10823 + **< Used only internally to test for inactive notification subscriptions.
10824 + */
10825 + SR__SUBSCRIPTION_TYPE__HELLO_SUBS = 50,
10826 + /*
10827 + **< Used only internally to notify about the end of the commit process.
10828 + */
10829 + SR__SUBSCRIPTION_TYPE__COMMIT_END_SUBS = 51
10830 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SR__SUBSCRIPTION_TYPE)
10831 +} Sr__SubscriptionType;
10832 +typedef enum _Sr__NotificationEvent {
10833 + SR__NOTIFICATION_EVENT__VERIFY_EV = 1,
10834 + SR__NOTIFICATION_EVENT__APPLY_EV = 2,
10835 + SR__NOTIFICATION_EVENT__ABORT_EV = 3,
10836 + SR__NOTIFICATION_EVENT__ENABLED_EV = 4
10837 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SR__NOTIFICATION_EVENT)
10838 +} Sr__NotificationEvent;
10839 +typedef enum _Sr__ModuleState {
10840 + SR__MODULE_STATE__UNINSTALLED = 1,
10841 + SR__MODULE_STATE__IMPORTED = 2,
10842 + SR__MODULE_STATE__IMPLEMENTED = 3
10843 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SR__MODULE_STATE)
10844 +} Sr__ModuleState;
10845 +typedef enum _Sr__ChangeOperation {
10846 + SR__CHANGE_OPERATION__CREATED = 1,
10847 + SR__CHANGE_OPERATION__MODIFIED = 2,
10848 + SR__CHANGE_OPERATION__DELETED = 3,
10849 + SR__CHANGE_OPERATION__MOVED = 4
10850 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SR__CHANGE_OPERATION)
10851 +} Sr__ChangeOperation;
10852 +/*
10853 + **
10854 + * @brief Requested operation.
10855 + */
10856 +typedef enum _Sr__Operation {
10857 + SR__OPERATION__SESSION_START = 10,
10858 + SR__OPERATION__SESSION_STOP = 11,
10859 + SR__OPERATION__SESSION_REFRESH = 12,
10860 + SR__OPERATION__SESSION_CHECK = 13,
10861 + SR__OPERATION__SESSION_SWITCH_DS = 14,
10862 + SR__OPERATION__SESSION_SET_OPTS = 15,
10863 + SR__OPERATION__VERSION_VERIFY = 16,
10864 + SR__OPERATION__LIST_SCHEMAS = 20,
10865 + SR__OPERATION__GET_SCHEMA = 21,
10866 + SR__OPERATION__MODULE_INSTALL = 22,
10867 + SR__OPERATION__FEATURE_ENABLE = 23,
10868 + SR__OPERATION__GET_ITEM = 30,
10869 + SR__OPERATION__GET_ITEMS = 31,
10870 + SR__OPERATION__GET_SUBTREE = 32,
10871 + SR__OPERATION__GET_SUBTREES = 33,
10872 + SR__OPERATION__GET_SUBTREE_CHUNK = 34,
10873 + SR__OPERATION__SET_ITEM = 40,
10874 + SR__OPERATION__DELETE_ITEM = 41,
10875 + SR__OPERATION__MOVE_ITEM = 42,
10876 + SR__OPERATION__SET_ITEM_STR = 43,
10877 + SR__OPERATION__VALIDATE = 50,
10878 + SR__OPERATION__COMMIT = 51,
10879 + SR__OPERATION__DISCARD_CHANGES = 52,
10880 + SR__OPERATION__COPY_CONFIG = 53,
10881 + SR__OPERATION__LOCK = 60,
10882 + SR__OPERATION__UNLOCK = 61,
10883 + SR__OPERATION__SUBSCRIBE = 70,
10884 + SR__OPERATION__UNSUBSCRIBE = 71,
10885 + SR__OPERATION__CHECK_ENABLED_RUNNING = 72,
10886 + SR__OPERATION__GET_CHANGES = 73,
10887 + SR__OPERATION__DATA_PROVIDE = 80,
10888 + SR__OPERATION__CHECK_EXEC_PERMISSION = 81,
10889 + SR__OPERATION__RPC = 82,
10890 + SR__OPERATION__ACTION = 83,
10891 + SR__OPERATION__EVENT_NOTIF = 84,
10892 + SR__OPERATION__EVENT_NOTIF_REPLAY = 85,
10893 + SR__OPERATION__UNSUBSCRIBE_DESTINATION = 101,
10894 + SR__OPERATION__COMMIT_TIMEOUT = 102,
10895 + SR__OPERATION__OPER_DATA_TIMEOUT = 103,
10896 + SR__OPERATION__INTERNAL_STATE_DATA = 104,
10897 + SR__OPERATION__NOTIF_STORE_CLEANUP = 105,
10898 + SR__OPERATION__DELAYED_MSG = 106,
10899 + SR__OPERATION__NACM_RELOAD = 107
10900 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SR__OPERATION)
10901 +} Sr__Operation;
10902 +
10903 +/* --- messages --- */
10904 +
10905 +/*
10906 + **
10907 + * @brief Value of an item stored (or to be stored) in the datastore.
10908 + * Can be mapped to sr_val_t data structure from sysrepo library API.
10909 + */
10910 +struct _Sr__Value
10911 +{
10912 + ProtobufCMessage base;
10913 + char *xpath;
10914 + Sr__Value__Types type;
10915 + protobuf_c_boolean dflt;
10916 + char *binary_val;
10917 + char *bits_val;
10918 + protobuf_c_boolean has_bool_val;
10919 + protobuf_c_boolean bool_val;
10920 + protobuf_c_boolean has_decimal64_val;
10921 + double decimal64_val;
10922 + char *enum_val;
10923 + char *identityref_val;
10924 + char *instanceid_val;
10925 + protobuf_c_boolean has_int8_val;
10926 + int32_t int8_val;
10927 + protobuf_c_boolean has_int16_val;
10928 + int32_t int16_val;
10929 + protobuf_c_boolean has_int32_val;
10930 + int32_t int32_val;
10931 + protobuf_c_boolean has_int64_val;
10932 + int64_t int64_val;
10933 + char *string_val;
10934 + protobuf_c_boolean has_uint8_val;
10935 + uint32_t uint8_val;
10936 + protobuf_c_boolean has_uint16_val;
10937 + uint32_t uint16_val;
10938 + protobuf_c_boolean has_uint32_val;
10939 + uint32_t uint32_val;
10940 + protobuf_c_boolean has_uint64_val;
10941 + uint64_t uint64_val;
10942 + char *anyxml_val;
10943 + char *anydata_val;
10944 +};
10945 +#define SR__VALUE__INIT \
10946 + { PROTOBUF_C_MESSAGE_INIT (&sr__value__descriptor) \
10947 + , 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 }
10948 +
10949 +
10950 +/*
10951 + **
10952 + * @brief Item stored (or to be stored) in the datastore represented as a tree node
10953 + * reflecting module schema. Can be mapped to sr_node_t data structure from sysrepo library API.
10954 + */
10955 +struct _Sr__Node
10956 +{
10957 + ProtobufCMessage base;
10958 + /*
10959 + **< Value of the node; member *xpath* is used to store node's name.
10960 + */
10961 + Sr__Value *value;
10962 + /*
10963 + **< Name of the module that defines scheme of this node.
10964 + */
10965 + char *module_name;
10966 + /*
10967 + **< Direct descendands of this node.
10968 + */
10969 + size_t n_children;
10970 + Sr__Node **children;
10971 +};
10972 +#define SR__NODE__INIT \
10973 + { PROTOBUF_C_MESSAGE_INIT (&sr__node__descriptor) \
10974 + , NULL, NULL, 0,NULL }
10975 +
10976 +
10977 +/*
10978 + **
10979 + * @brief Error message retuned from the Sysrepo Engine.
10980 + */
10981 +struct _Sr__Error
10982 +{
10983 + ProtobufCMessage base;
10984 + char *message;
10985 + char *xpath;
10986 +};
10987 +#define SR__ERROR__INIT \
10988 + { PROTOBUF_C_MESSAGE_INIT (&sr__error__descriptor) \
10989 + , NULL, NULL }
10990 +
10991 +
10992 +/*
10993 + **
10994 + * @brief Request for starting a session. Sent by sr_session_start API call.
10995 + */
10996 +struct _Sr__SessionStartReq
10997 +{
10998 + ProtobufCMessage base;
10999 + Sr__DataStore datastore;
11000 + char *user_name;
11001 + /*
11002 + **< Bitwise OR of SessionFlags.
11003 + */
11004 + uint32_t options;
11005 + /*
11006 + **< Applicable if SESS_NOTIFICATION was specified.
11007 + */
11008 + protobuf_c_boolean has_commit_id;
11009 + uint32_t commit_id;
11010 +};
11011 +#define SR__SESSION_START_REQ__INIT \
11012 + { PROTOBUF_C_MESSAGE_INIT (&sr__session_start_req__descriptor) \
11013 + , 0, NULL, 0, 0,0 }
11014 +
11015 +
11016 +/*
11017 + **
11018 + * @brief Response to session_start request.
11019 + */
11020 +struct _Sr__SessionStartResp
11021 +{
11022 + ProtobufCMessage base;
11023 + uint32_t session_id;
11024 +};
11025 +#define SR__SESSION_START_RESP__INIT \
11026 + { PROTOBUF_C_MESSAGE_INIT (&sr__session_start_resp__descriptor) \
11027 + , 0 }
11028 +
11029 +
11030 +/*
11031 + **
11032 + * @brief Request for stopping the session. Sent by sr_session_stop API call.
11033 + */
11034 +struct _Sr__SessionStopReq
11035 +{
11036 + ProtobufCMessage base;
11037 + uint32_t session_id;
11038 +};
11039 +#define SR__SESSION_STOP_REQ__INIT \
11040 + { PROTOBUF_C_MESSAGE_INIT (&sr__session_stop_req__descriptor) \
11041 + , 0 }
11042 +
11043 +
11044 +/*
11045 + **
11046 + * @brief Response to session_stop request.
11047 + */
11048 +struct _Sr__SessionStopResp
11049 +{
11050 + ProtobufCMessage base;
11051 + uint32_t session_id;
11052 +};
11053 +#define SR__SESSION_STOP_RESP__INIT \
11054 + { PROTOBUF_C_MESSAGE_INIT (&sr__session_stop_resp__descriptor) \
11055 + , 0 }
11056 +
11057 +
11058 +/*
11059 + **
11060 + * @brief Refreshes configuration data cached within the session.
11061 + * Sent by sr_session_refresh API call.
11062 + */
11063 +struct _Sr__SessionRefreshReq
11064 +{
11065 + ProtobufCMessage base;
11066 +};
11067 +#define SR__SESSION_REFRESH_REQ__INIT \
11068 + { PROTOBUF_C_MESSAGE_INIT (&sr__session_refresh_req__descriptor) \
11069 + }
11070 +
11071 +
11072 +/*
11073 + **
11074 + * @brief Response to sr_session_refresh request.
11075 + */
11076 +struct _Sr__SessionRefreshResp
11077 +{
11078 + ProtobufCMessage base;
11079 + size_t n_errors;
11080 + Sr__Error **errors;
11081 +};
11082 +#define SR__SESSION_REFRESH_RESP__INIT \
11083 + { PROTOBUF_C_MESSAGE_INIT (&sr__session_refresh_resp__descriptor) \
11084 + , 0,NULL }
11085 +
11086 +
11087 +/*
11088 + **
11089 + * @brief Checks aliveness and validity of the session & connection tied to it.
11090 + * Sent by sr_session_check API call.
11091 + */
11092 +struct _Sr__SessionCheckReq
11093 +{
11094 + ProtobufCMessage base;
11095 +};
11096 +#define SR__SESSION_CHECK_REQ__INIT \
11097 + { PROTOBUF_C_MESSAGE_INIT (&sr__session_check_req__descriptor) \
11098 + }
11099 +
11100 +
11101 +/*
11102 + **
11103 + * @brief Response to sr_session_check request.
11104 + */
11105 +struct _Sr__SessionCheckResp
11106 +{
11107 + ProtobufCMessage base;
11108 + size_t n_errors;
11109 + Sr__Error **errors;
11110 +};
11111 +#define SR__SESSION_CHECK_RESP__INIT \
11112 + { PROTOBUF_C_MESSAGE_INIT (&sr__session_check_resp__descriptor) \
11113 + , 0,NULL }
11114 +
11115 +
11116 +/*
11117 + **
11118 + * @brief Changes the datastore to which the session is tied to.
11119 + */
11120 +struct _Sr__SessionSwitchDsReq
11121 +{
11122 + ProtobufCMessage base;
11123 + Sr__DataStore datastore;
11124 +};
11125 +#define SR__SESSION_SWITCH_DS_REQ__INIT \
11126 + { PROTOBUF_C_MESSAGE_INIT (&sr__session_switch_ds_req__descriptor) \
11127 + , 0 }
11128 +
11129 +
11130 +/*
11131 + **
11132 + * @brief Response to sr_session_switch_ds request.
11133 + */
11134 +struct _Sr__SessionSwitchDsResp
11135 +{
11136 + ProtobufCMessage base;
11137 +};
11138 +#define SR__SESSION_SWITCH_DS_RESP__INIT \
11139 + { PROTOBUF_C_MESSAGE_INIT (&sr__session_switch_ds_resp__descriptor) \
11140 + }
11141 +
11142 +
11143 +/*
11144 + **
11145 + * @brief Request for modification of session options.
11146 + */
11147 +struct _Sr__SessionSetOptsReq
11148 +{
11149 + ProtobufCMessage base;
11150 + uint32_t options;
11151 +};
11152 +#define SR__SESSION_SET_OPTS_REQ__INIT \
11153 + { PROTOBUF_C_MESSAGE_INIT (&sr__session_set_opts_req__descriptor) \
11154 + , 0 }
11155 +
11156 +
11157 +/*
11158 + **
11159 + * @brief Response to sr_session_set_options.
11160 + */
11161 +struct _Sr__SessionSetOptsResp
11162 +{
11163 + ProtobufCMessage base;
11164 +};
11165 +#define SR__SESSION_SET_OPTS_RESP__INIT \
11166 + { PROTOBUF_C_MESSAGE_INIT (&sr__session_set_opts_resp__descriptor) \
11167 + }
11168 +
11169 +
11170 +/*
11171 + **
11172 + * @brief Request to verify version compatibility.
11173 + */
11174 +struct _Sr__VersionVerifyReq
11175 +{
11176 + ProtobufCMessage base;
11177 + char *soname;
11178 +};
11179 +#define SR__VERSION_VERIFY_REQ__INIT \
11180 + { PROTOBUF_C_MESSAGE_INIT (&sr__version_verify_req__descriptor) \
11181 + , NULL }
11182 +
11183 +
11184 +/*
11185 + **
11186 + * @brief Response to version verification.
11187 + */
11188 +struct _Sr__VersionVerifyResp
11189 +{
11190 + ProtobufCMessage base;
11191 + /*
11192 + **< server-side SONAME version in case of versions incompatibility.
11193 + */
11194 + char *soname;
11195 +};
11196 +#define SR__VERSION_VERIFY_RESP__INIT \
11197 + { PROTOBUF_C_MESSAGE_INIT (&sr__version_verify_resp__descriptor) \
11198 + , NULL }
11199 +
11200 +
11201 +/*
11202 + **
11203 + * @brief Schema revision details.
11204 + */
11205 +struct _Sr__SchemaRevision
11206 +{
11207 + ProtobufCMessage base;
11208 + /*
11209 + **< Latest revision date of the module.
11210 + */
11211 + char *revision;
11212 + /*
11213 + **< Absolute path to file where the schema is stored (YANG format).
11214 + */
11215 + char *file_path_yang;
11216 + /*
11217 + **< Absolute path to file where the schema is stored (.yin format).
11218 + */
11219 + char *file_path_yin;
11220 +};
11221 +#define SR__SCHEMA_REVISION__INIT \
11222 + { PROTOBUF_C_MESSAGE_INIT (&sr__schema_revision__descriptor) \
11223 + , NULL, NULL, NULL }
11224 +
11225 +
11226 +/*
11227 + **
11228 + * @brief Schema submodule information.
11229 + */
11230 +struct _Sr__SchemaSubmodule
11231 +{
11232 + ProtobufCMessage base;
11233 + /*
11234 + **< Submodule name
11235 + */
11236 + char *submodule_name;
11237 + /*
11238 + **< Revision of the submodule
11239 + */
11240 + Sr__SchemaRevision *revision;
11241 +};
11242 +#define SR__SCHEMA_SUBMODULE__INIT \
11243 + { PROTOBUF_C_MESSAGE_INIT (&sr__schema_submodule__descriptor) \
11244 + , NULL, NULL }
11245 +
11246 +
11247 +/*
11248 + **
11249 + * @brief Information about a schema installed in sysrepo datastore.
11250 + */
11251 +struct _Sr__Schema
11252 +{
11253 + ProtobufCMessage base;
11254 + /*
11255 + **< Name of the module.
11256 + */
11257 + char *module_name;
11258 + /*
11259 + **< Namespace of the module.
11260 + */
11261 + char *ns;
11262 + /*
11263 + **< Prefix of he module.
11264 + */
11265 + char *prefix;
11266 + /*
11267 + **< TRUE only for explicitly installed modules (those are always implemented).
11268 + */
11269 + protobuf_c_boolean installed;
11270 + /*
11271 + **< TRUE for implemented modules (do not have to be installed if they have augments,
11272 + *deviations or are targets for leafrefs of other implemented modules).
11273 + */
11274 + protobuf_c_boolean implemented;
11275 + /*
11276 + **< Revision of the module
11277 + */
11278 + Sr__SchemaRevision *revision;
11279 + /*
11280 + **< Submodules
11281 + */
11282 + size_t n_submodules;
11283 + Sr__SchemaSubmodule **submodules;
11284 + /*
11285 + **< Features enabled for the module
11286 + */
11287 + size_t n_enabled_features;
11288 + char **enabled_features;
11289 +};
11290 +#define SR__SCHEMA__INIT \
11291 + { PROTOBUF_C_MESSAGE_INIT (&sr__schema__descriptor) \
11292 + , NULL, NULL, NULL, 0, 0, NULL, 0,NULL, 0,NULL }
11293 +
11294 +
11295 +/*
11296 + **
11297 + * @brief Retrieves an array of schemas installed in the sysrepo datastore.
11298 + * Sent by sr_list_schemas API call.
11299 + */
11300 +struct _Sr__ListSchemasReq
11301 +{
11302 + ProtobufCMessage base;
11303 +};
11304 +#define SR__LIST_SCHEMAS_REQ__INIT \
11305 + { PROTOBUF_C_MESSAGE_INIT (&sr__list_schemas_req__descriptor) \
11306 + }
11307 +
11308 +
11309 +/*
11310 + **
11311 + * @brief Response to sr_list_schemas request.
11312 + */
11313 +struct _Sr__ListSchemasResp
11314 +{
11315 + ProtobufCMessage base;
11316 + size_t n_schemas;
11317 + Sr__Schema **schemas;
11318 +};
11319 +#define SR__LIST_SCHEMAS_RESP__INIT \
11320 + { PROTOBUF_C_MESSAGE_INIT (&sr__list_schemas_resp__descriptor) \
11321 + , 0,NULL }
11322 +
11323 +
11324 +/*
11325 + **
11326 + * @brief Retrieves the content of specified schema file.
11327 + * Sent by sr_get_schema API call.
11328 + */
11329 +struct _Sr__GetSchemaReq
11330 +{
11331 + ProtobufCMessage base;
11332 + char *module_name;
11333 + char *revision;
11334 + char *submodule_name;
11335 + char *submodule_revision;
11336 + protobuf_c_boolean yang_format;
11337 +};
11338 +#define SR__GET_SCHEMA_REQ__INIT \
11339 + { PROTOBUF_C_MESSAGE_INIT (&sr__get_schema_req__descriptor) \
11340 + , NULL, NULL, NULL, NULL, 0 }
11341 +
11342 +
11343 +/*
11344 + **
11345 + * @brief Response to sr_get_schema request.
11346 + */
11347 +struct _Sr__GetSchemaResp
11348 +{
11349 + ProtobufCMessage base;
11350 + char *schema_content;
11351 +};
11352 +#define SR__GET_SCHEMA_RESP__INIT \
11353 + { PROTOBUF_C_MESSAGE_INIT (&sr__get_schema_resp__descriptor) \
11354 + , NULL }
11355 +
11356 +
11357 +/*
11358 + **
11359 + * @brief Retrieves a single data element stored under provided path.
11360 + * Sent by sr_get_item API call.
11361 + */
11362 +struct _Sr__GetItemReq
11363 +{
11364 + ProtobufCMessage base;
11365 + char *xpath;
11366 +};
11367 +#define SR__GET_ITEM_REQ__INIT \
11368 + { PROTOBUF_C_MESSAGE_INIT (&sr__get_item_req__descriptor) \
11369 + , NULL }
11370 +
11371 +
11372 +/*
11373 + **
11374 + * @brief Response to get_item request.
11375 + */
11376 +struct _Sr__GetItemResp
11377 +{
11378 + ProtobufCMessage base;
11379 + Sr__Value *value;
11380 +};
11381 +#define SR__GET_ITEM_RESP__INIT \
11382 + { PROTOBUF_C_MESSAGE_INIT (&sr__get_item_resp__descriptor) \
11383 + , NULL }
11384 +
11385 +
11386 +/*
11387 + **
11388 + * @brief Retrieves an array of data elements stored under provided path.
11389 + * Sent by sr_get_items and sr_get_items_iter API calls.
11390 + */
11391 +struct _Sr__GetItemsReq
11392 +{
11393 + ProtobufCMessage base;
11394 + char *xpath;
11395 + /*
11396 + * The options below are applicable only for sr_get_items_iter
11397 + * (not set by sr_get_items).
11398 + */
11399 + protobuf_c_boolean has_limit;
11400 + uint32_t limit;
11401 + protobuf_c_boolean has_offset;
11402 + uint32_t offset;
11403 +};
11404 +#define SR__GET_ITEMS_REQ__INIT \
11405 + { PROTOBUF_C_MESSAGE_INIT (&sr__get_items_req__descriptor) \
11406 + , NULL, 0,0, 0,0 }
11407 +
11408 +
11409 +/*
11410 + **
11411 + * @brief Response to get_items / sr_get_items_iter request.
11412 + */
11413 +struct _Sr__GetItemsResp
11414 +{
11415 + ProtobufCMessage base;
11416 + size_t n_values;
11417 + Sr__Value **values;
11418 +};
11419 +#define SR__GET_ITEMS_RESP__INIT \
11420 + { PROTOBUF_C_MESSAGE_INIT (&sr__get_items_resp__descriptor) \
11421 + , 0,NULL }
11422 +
11423 +
11424 +/*
11425 + **
11426 + * @brief Retrieves a single subtree whose root is stored under provided path.
11427 + * Sent by sr_get_subtree API call.
11428 + */
11429 +struct _Sr__GetSubtreeReq
11430 +{
11431 + ProtobufCMessage base;
11432 + char *xpath;
11433 +};
11434 +#define SR__GET_SUBTREE_REQ__INIT \
11435 + { PROTOBUF_C_MESSAGE_INIT (&sr__get_subtree_req__descriptor) \
11436 + , NULL }
11437 +
11438 +
11439 +/*
11440 + **
11441 + * @brief Response to sr_get_subtree request.
11442 + */
11443 +struct _Sr__GetSubtreeResp
11444 +{
11445 + ProtobufCMessage base;
11446 + Sr__Node *tree;
11447 +};
11448 +#define SR__GET_SUBTREE_RESP__INIT \
11449 + { PROTOBUF_C_MESSAGE_INIT (&sr__get_subtree_resp__descriptor) \
11450 + , NULL }
11451 +
11452 +
11453 +/*
11454 + **
11455 + * @brief Retrieves an array of subtrees whose root nodes match provided path.
11456 + * Sent by sr_get_subtrees API call.
11457 + */
11458 +struct _Sr__GetSubtreesReq
11459 +{
11460 + ProtobufCMessage base;
11461 + char *xpath;
11462 +};
11463 +#define SR__GET_SUBTREES_REQ__INIT \
11464 + { PROTOBUF_C_MESSAGE_INIT (&sr__get_subtrees_req__descriptor) \
11465 + , NULL }
11466 +
11467 +
11468 +/*
11469 + **
11470 + * @brief Response to sr_get_subtrees request.
11471 + */
11472 +struct _Sr__GetSubtreesResp
11473 +{
11474 + ProtobufCMessage base;
11475 + size_t n_trees;
11476 + Sr__Node **trees;
11477 +};
11478 +#define SR__GET_SUBTREES_RESP__INIT \
11479 + { PROTOBUF_C_MESSAGE_INIT (&sr__get_subtrees_resp__descriptor) \
11480 + , 0,NULL }
11481 +
11482 +
11483 +/*
11484 + **
11485 + * @brief Retrieves a chunk of a single or multiple subtrees.
11486 + * A subtree chunk is also a tree, where the root node is the node referenced by XPath,
11487 + * the next level consists of its children skipping the first "slice_offset" nodes and including
11488 + * at most "slice_limit" nodes, while the remaining (depth_limit-2) levels always start with
11489 + * the first child (slice_offset is ignored) and include at most "child_limit" nodes.
11490 + * The chunk consists of at most "depth_limit" levels.
11491 + * @note Order of child nodes depends on the libyang implementation.
11492 + */
11493 +struct _Sr__GetSubtreeChunkReq
11494 +{
11495 + ProtobufCMessage base;
11496 + char *xpath;
11497 + protobuf_c_boolean single;
11498 + uint32_t slice_offset;
11499 + uint32_t slice_width;
11500 + uint32_t child_limit;
11501 + uint32_t depth_limit;
11502 +};
11503 +#define SR__GET_SUBTREE_CHUNK_REQ__INIT \
11504 + { PROTOBUF_C_MESSAGE_INIT (&sr__get_subtree_chunk_req__descriptor) \
11505 + , NULL, 0, 0, 0, 0, 0 }
11506 +
11507 +
11508 +/*
11509 + **
11510 + * @brief Response to sr_get_subtree_chunk request.
11511 + */
11512 +struct _Sr__GetSubtreeChunkResp
11513 +{
11514 + ProtobufCMessage base;
11515 + /*
11516 + **< JSON node-id of the root node for each subtree chunk
11517 + */
11518 + size_t n_xpath;
11519 + char **xpath;
11520 + /*
11521 + **< first chunk may carry mutliple trees
11522 + */
11523 + size_t n_chunk;
11524 + Sr__Node **chunk;
11525 +};
11526 +#define SR__GET_SUBTREE_CHUNK_RESP__INIT \
11527 + { PROTOBUF_C_MESSAGE_INIT (&sr__get_subtree_chunk_resp__descriptor) \
11528 + , 0,NULL, 0,NULL }
11529 +
11530 +
11531 +/*
11532 + **
11533 + * @brief Sets the value of the leaf, leaf-list or presence container.
11534 + * Sent by sr_set_item API call.
11535 + */
11536 +struct _Sr__SetItemReq
11537 +{
11538 + ProtobufCMessage base;
11539 + char *xpath;
11540 + Sr__Value *value;
11541 + /*
11542 + **< Bitwise OR of EditFlags
11543 + */
11544 + uint32_t options;
11545 +};
11546 +#define SR__SET_ITEM_REQ__INIT \
11547 + { PROTOBUF_C_MESSAGE_INIT (&sr__set_item_req__descriptor) \
11548 + , NULL, NULL, 0 }
11549 +
11550 +
11551 +/*
11552 + **
11553 + * @brief Response to sr_set_item request.
11554 + */
11555 +struct _Sr__SetItemResp
11556 +{
11557 + ProtobufCMessage base;
11558 +};
11559 +#define SR__SET_ITEM_RESP__INIT \
11560 + { PROTOBUF_C_MESSAGE_INIT (&sr__set_item_resp__descriptor) \
11561 + }
11562 +
11563 +
11564 +/*
11565 + **
11566 + * @brief Sets the value of the leaf, leaf-list or presence container.
11567 + * The value is transferred as string.
11568 + * Sent by sr_set_item_str API call.
11569 + */
11570 +struct _Sr__SetItemStrReq
11571 +{
11572 + ProtobufCMessage base;
11573 + char *xpath;
11574 + char *value;
11575 + /*
11576 + **< Bitwise OR of EditFlags
11577 + */
11578 + uint32_t options;
11579 +};
11580 +#define SR__SET_ITEM_STR_REQ__INIT \
11581 + { PROTOBUF_C_MESSAGE_INIT (&sr__set_item_str_req__descriptor) \
11582 + , NULL, NULL, 0 }
11583 +
11584 +
11585 +/*
11586 + **
11587 + * @brief Response to sr_set_item_str request.
11588 + */
11589 +struct _Sr__SetItemStrResp
11590 +{
11591 + ProtobufCMessage base;
11592 +};
11593 +#define SR__SET_ITEM_STR_RESP__INIT \
11594 + { PROTOBUF_C_MESSAGE_INIT (&sr__set_item_str_resp__descriptor) \
11595 + }
11596 +
11597 +
11598 +/*
11599 + **
11600 + * @brief Deletes the nodes under the specified xpath.
11601 + * Sent by sr_delete_item API call.
11602 + */
11603 +struct _Sr__DeleteItemReq
11604 +{
11605 + ProtobufCMessage base;
11606 + char *xpath;
11607 + /*
11608 + **< Bitwise OR of EditFlags
11609 + */
11610 + uint32_t options;
11611 +};
11612 +#define SR__DELETE_ITEM_REQ__INIT \
11613 + { PROTOBUF_C_MESSAGE_INIT (&sr__delete_item_req__descriptor) \
11614 + , NULL, 0 }
11615 +
11616 +
11617 +/*
11618 + **
11619 + * @brief Response to sr_delete_item request.
11620 + */
11621 +struct _Sr__DeleteItemResp
11622 +{
11623 + ProtobufCMessage base;
11624 +};
11625 +#define SR__DELETE_ITEM_RESP__INIT \
11626 + { PROTOBUF_C_MESSAGE_INIT (&sr__delete_item_resp__descriptor) \
11627 + }
11628 +
11629 +
11630 +/*
11631 + **
11632 + * @brief Move the instance of an ordered list in specified direction.
11633 + * Sent by sr_move_item API call.
11634 + */
11635 +struct _Sr__MoveItemReq
11636 +{
11637 + ProtobufCMessage base;
11638 + char *xpath;
11639 + Sr__MoveItemReq__MovePosition position;
11640 + char *relative_item;
11641 +};
11642 +#define SR__MOVE_ITEM_REQ__INIT \
11643 + { PROTOBUF_C_MESSAGE_INIT (&sr__move_item_req__descriptor) \
11644 + , NULL, 0, NULL }
11645 +
11646 +
11647 +/*
11648 + **
11649 + * @brief Response to sr_move_item request.
11650 + */
11651 +struct _Sr__MoveItemResp
11652 +{
11653 + ProtobufCMessage base;
11654 +};
11655 +#define SR__MOVE_ITEM_RESP__INIT \
11656 + { PROTOBUF_C_MESSAGE_INIT (&sr__move_item_resp__descriptor) \
11657 + }
11658 +
11659 +
11660 +/*
11661 + **
11662 + * @brief Perform the validation of changes made in current session, but do not
11663 + * commit nor discard them. Sent by sr_validate API call.
11664 + */
11665 +struct _Sr__ValidateReq
11666 +{
11667 + ProtobufCMessage base;
11668 +};
11669 +#define SR__VALIDATE_REQ__INIT \
11670 + { PROTOBUF_C_MESSAGE_INIT (&sr__validate_req__descriptor) \
11671 + }
11672 +
11673 +
11674 +/*
11675 + **
11676 + * @brief Response to sr_validate request.
11677 + */
11678 +struct _Sr__ValidateResp
11679 +{
11680 + ProtobufCMessage base;
11681 + size_t n_errors;
11682 + Sr__Error **errors;
11683 +};
11684 +#define SR__VALIDATE_RESP__INIT \
11685 + { PROTOBUF_C_MESSAGE_INIT (&sr__validate_resp__descriptor) \
11686 + , 0,NULL }
11687 +
11688 +
11689 +/*
11690 + **
11691 + * @brief Apply changes made in current session.
11692 + * Sent by sr_commit API call.
11693 + */
11694 +struct _Sr__CommitReq
11695 +{
11696 + ProtobufCMessage base;
11697 +};
11698 +#define SR__COMMIT_REQ__INIT \
11699 + { PROTOBUF_C_MESSAGE_INIT (&sr__commit_req__descriptor) \
11700 + }
11701 +
11702 +
11703 +/*
11704 + **
11705 + * @brief Response to sr_commit request.
11706 + */
11707 +struct _Sr__CommitResp
11708 +{
11709 + ProtobufCMessage base;
11710 + size_t n_errors;
11711 + Sr__Error **errors;
11712 +};
11713 +#define SR__COMMIT_RESP__INIT \
11714 + { PROTOBUF_C_MESSAGE_INIT (&sr__commit_resp__descriptor) \
11715 + , 0,NULL }
11716 +
11717 +
11718 +/*
11719 + **
11720 + * @brief Discard non-committed changes made in current session.
11721 + * Sent by sr_discard_changes API call.
11722 + */
11723 +struct _Sr__DiscardChangesReq
11724 +{
11725 + ProtobufCMessage base;
11726 +};
11727 +#define SR__DISCARD_CHANGES_REQ__INIT \
11728 + { PROTOBUF_C_MESSAGE_INIT (&sr__discard_changes_req__descriptor) \
11729 + }
11730 +
11731 +
11732 +/*
11733 + **
11734 + * @brief Response to sr_discard_changes request.
11735 + */
11736 +struct _Sr__DiscardChangesResp
11737 +{
11738 + ProtobufCMessage base;
11739 +};
11740 +#define SR__DISCARD_CHANGES_RESP__INIT \
11741 + { PROTOBUF_C_MESSAGE_INIT (&sr__discard_changes_resp__descriptor) \
11742 + }
11743 +
11744 +
11745 +/*
11746 + **
11747 + * @brief Replaces an entire configuration datastore with the contents of
11748 + * another complete configuration datastore. Sent by sr_copy_config request.
11749 + */
11750 +struct _Sr__CopyConfigReq
11751 +{
11752 + ProtobufCMessage base;
11753 + Sr__DataStore src_datastore;
11754 + Sr__DataStore dst_datastore;
11755 + /*
11756 + **< If not specified, the operation is performed on all
11757 + *modules that are currently active in the source datastore
11758 + */
11759 + char *module_name;
11760 +};
11761 +#define SR__COPY_CONFIG_REQ__INIT \
11762 + { PROTOBUF_C_MESSAGE_INIT (&sr__copy_config_req__descriptor) \
11763 + , 0, 0, NULL }
11764 +
11765 +
11766 +/*
11767 + **
11768 + * @brief Response to sr_copy_config request.
11769 + */
11770 +struct _Sr__CopyConfigResp
11771 +{
11772 + ProtobufCMessage base;
11773 +};
11774 +#define SR__COPY_CONFIG_RESP__INIT \
11775 + { PROTOBUF_C_MESSAGE_INIT (&sr__copy_config_resp__descriptor) \
11776 + }
11777 +
11778 +
11779 +/*
11780 + **
11781 + * @brief Locks specified data model or the datastore which the session is tied to.
11782 + * Sent by sr_lock_datastore and sr_lock_model API calls.
11783 + */
11784 +struct _Sr__LockReq
11785 +{
11786 + ProtobufCMessage base;
11787 + /*
11788 + **< If module name is not set, LockReq locks whole datastore.
11789 + */
11790 + char *module_name;
11791 +};
11792 +#define SR__LOCK_REQ__INIT \
11793 + { PROTOBUF_C_MESSAGE_INIT (&sr__lock_req__descriptor) \
11794 + , NULL }
11795 +
11796 +
11797 +/*
11798 + **
11799 + * @brief Response to sr_lock_datastore or sr_lock_model request.
11800 + */
11801 +struct _Sr__LockResp
11802 +{
11803 + ProtobufCMessage base;
11804 +};
11805 +#define SR__LOCK_RESP__INIT \
11806 + { PROTOBUF_C_MESSAGE_INIT (&sr__lock_resp__descriptor) \
11807 + }
11808 +
11809 +
11810 +/*
11811 + **
11812 + * @brief Unlocks specified data model or the datastore which the session is tied to.
11813 + * Sent by sr_unlock_datastore and sr_unlock_model API calls.
11814 + */
11815 +struct _Sr__UnlockReq
11816 +{
11817 + ProtobufCMessage base;
11818 + /*
11819 + **< If module name is not set, UnlockReq unlocks whole datastore.
11820 + */
11821 + char *module_name;
11822 +};
11823 +#define SR__UNLOCK_REQ__INIT \
11824 + { PROTOBUF_C_MESSAGE_INIT (&sr__unlock_req__descriptor) \
11825 + , NULL }
11826 +
11827 +
11828 +/*
11829 + **
11830 + * @brief Response to sr_lock_datastore or sr_lock_model request.
11831 + */
11832 +struct _Sr__UnlockResp
11833 +{
11834 + ProtobufCMessage base;
11835 +};
11836 +#define SR__UNLOCK_RESP__INIT \
11837 + { PROTOBUF_C_MESSAGE_INIT (&sr__unlock_resp__descriptor) \
11838 + }
11839 +
11840 +
11841 +struct _Sr__SubscribeReq
11842 +{
11843 + ProtobufCMessage base;
11844 + Sr__SubscriptionType type;
11845 + char *destination;
11846 + uint32_t subscription_id;
11847 + char *module_name;
11848 + char *xpath;
11849 + protobuf_c_boolean has_notif_event;
11850 + Sr__NotificationEvent notif_event;
11851 + protobuf_c_boolean has_priority;
11852 + uint32_t priority;
11853 + protobuf_c_boolean has_enable_running;
11854 + protobuf_c_boolean enable_running;
11855 + protobuf_c_boolean has_enable_event;
11856 + protobuf_c_boolean enable_event;
11857 + Sr__ApiVariant api_variant;
11858 +};
11859 +#define SR__SUBSCRIBE_REQ__INIT \
11860 + { PROTOBUF_C_MESSAGE_INIT (&sr__subscribe_req__descriptor) \
11861 + , 0, NULL, 0, NULL, NULL, 0,0, 0,0, 0,0, 0,0, 0 }
11862 +
11863 +
11864 +struct _Sr__SubscribeResp
11865 +{
11866 + ProtobufCMessage base;
11867 +};
11868 +#define SR__SUBSCRIBE_RESP__INIT \
11869 + { PROTOBUF_C_MESSAGE_INIT (&sr__subscribe_resp__descriptor) \
11870 + }
11871 +
11872 +
11873 +struct _Sr__UnsubscribeReq
11874 +{
11875 + ProtobufCMessage base;
11876 + Sr__SubscriptionType type;
11877 + char *destination;
11878 + uint32_t subscription_id;
11879 + char *module_name;
11880 +};
11881 +#define SR__UNSUBSCRIBE_REQ__INIT \
11882 + { PROTOBUF_C_MESSAGE_INIT (&sr__unsubscribe_req__descriptor) \
11883 + , 0, NULL, 0, NULL }
11884 +
11885 +
11886 +struct _Sr__UnsubscribeResp
11887 +{
11888 + ProtobufCMessage base;
11889 +};
11890 +#define SR__UNSUBSCRIBE_RESP__INIT \
11891 + { PROTOBUF_C_MESSAGE_INIT (&sr__unsubscribe_resp__descriptor) \
11892 + }
11893 +
11894 +
11895 +/*
11896 + **
11897 + * @brief Checks whether the module has any enabled subtree.
11898 + * Sent by sr_check_enabled_running.
11899 + */
11900 +struct _Sr__CheckEnabledRunningReq
11901 +{
11902 + ProtobufCMessage base;
11903 + char *module_name;
11904 +};
11905 +#define SR__CHECK_ENABLED_RUNNING_REQ__INIT \
11906 + { PROTOBUF_C_MESSAGE_INIT (&sr__check_enabled_running_req__descriptor) \
11907 + , NULL }
11908 +
11909 +
11910 +struct _Sr__CheckEnabledRunningResp
11911 +{
11912 + ProtobufCMessage base;
11913 + protobuf_c_boolean enabled;
11914 +};
11915 +#define SR__CHECK_ENABLED_RUNNING_RESP__INIT \
11916 + { PROTOBUF_C_MESSAGE_INIT (&sr__check_enabled_running_resp__descriptor) \
11917 + , 0 }
11918 +
11919 +
11920 +struct _Sr__ModuleInstallNotification
11921 +{
11922 + ProtobufCMessage base;
11923 + char *module_name;
11924 + char *revision;
11925 + Sr__ModuleState state;
11926 +};
11927 +#define SR__MODULE_INSTALL_NOTIFICATION__INIT \
11928 + { PROTOBUF_C_MESSAGE_INIT (&sr__module_install_notification__descriptor) \
11929 + , NULL, NULL, 0 }
11930 +
11931 +
11932 +struct _Sr__FeatureEnableNotification
11933 +{
11934 + ProtobufCMessage base;
11935 + char *module_name;
11936 + char *feature_name;
11937 + protobuf_c_boolean enabled;
11938 +};
11939 +#define SR__FEATURE_ENABLE_NOTIFICATION__INIT \
11940 + { PROTOBUF_C_MESSAGE_INIT (&sr__feature_enable_notification__descriptor) \
11941 + , NULL, NULL, 0 }
11942 +
11943 +
11944 +struct _Sr__ModuleChangeNotification
11945 +{
11946 + ProtobufCMessage base;
11947 + Sr__NotificationEvent event;
11948 + char *module_name;
11949 +};
11950 +#define SR__MODULE_CHANGE_NOTIFICATION__INIT \
11951 + { PROTOBUF_C_MESSAGE_INIT (&sr__module_change_notification__descriptor) \
11952 + , 0, NULL }
11953 +
11954 +
11955 +struct _Sr__SubtreeChangeNotification
11956 +{
11957 + ProtobufCMessage base;
11958 + Sr__NotificationEvent event;
11959 + char *xpath;
11960 +};
11961 +#define SR__SUBTREE_CHANGE_NOTIFICATION__INIT \
11962 + { PROTOBUF_C_MESSAGE_INIT (&sr__subtree_change_notification__descriptor) \
11963 + , 0, NULL }
11964 +
11965 +
11966 +struct _Sr__Change
11967 +{
11968 + ProtobufCMessage base;
11969 + Sr__ChangeOperation changeoperation;
11970 + Sr__Value *new_value;
11971 + Sr__Value *old_value;
11972 +};
11973 +#define SR__CHANGE__INIT \
11974 + { PROTOBUF_C_MESSAGE_INIT (&sr__change__descriptor) \
11975 + , 0, NULL, NULL }
11976 +
11977 +
11978 +/*
11979 + **
11980 + * @brief Retrieves an array of changes made under provided path.
11981 + * Sent by sr_get_changes_iter or sr_get_change_next API calls.
11982 + */
11983 +struct _Sr__GetChangesReq
11984 +{
11985 + ProtobufCMessage base;
11986 + char *xpath;
11987 + uint32_t limit;
11988 + uint32_t offset;
11989 +};
11990 +#define SR__GET_CHANGES_REQ__INIT \
11991 + { PROTOBUF_C_MESSAGE_INIT (&sr__get_changes_req__descriptor) \
11992 + , NULL, 0, 0 }
11993 +
11994 +
11995 +/*
11996 + **
11997 + * @brief Response to get_changes request.
11998 + */
11999 +struct _Sr__GetChangesResp
12000 +{
12001 + ProtobufCMessage base;
12002 + size_t n_changes;
12003 + Sr__Change **changes;
12004 +};
12005 +#define SR__GET_CHANGES_RESP__INIT \
12006 + { PROTOBUF_C_MESSAGE_INIT (&sr__get_changes_resp__descriptor) \
12007 + , 0,NULL }
12008 +
12009 +
12010 +/*
12011 + **
12012 + * @brief Sends a request to check if the owner of this session is authorized to invoke
12013 + * the protocol operation referenced by the xpath.
12014 + * Sent by sr_check_exec_permission.
12015 + */
12016 +struct _Sr__CheckExecPermReq
12017 +{
12018 + ProtobufCMessage base;
12019 + char *xpath;
12020 +};
12021 +#define SR__CHECK_EXEC_PERM_REQ__INIT \
12022 + { PROTOBUF_C_MESSAGE_INIT (&sr__check_exec_perm_req__descriptor) \
12023 + , NULL }
12024 +
12025 +
12026 +/*
12027 + **
12028 + * @brief Response to sr_check_exec_permission request.
12029 + */
12030 +struct _Sr__CheckExecPermResp
12031 +{
12032 + ProtobufCMessage base;
12033 + protobuf_c_boolean permitted;
12034 +};
12035 +#define SR__CHECK_EXEC_PERM_RESP__INIT \
12036 + { PROTOBUF_C_MESSAGE_INIT (&sr__check_exec_perm_resp__descriptor) \
12037 + , 0 }
12038 +
12039 +
12040 +/*
12041 + **
12042 + * @brief Sends a RPC / action request into the datastore, will be delivered to the RPC subscriber.
12043 + * Sent by sr_rpc_send / sr_rpc_send_tree and sr_action_send / sr_action_send_tree API calls.
12044 + */
12045 +struct _Sr__RPCReq
12046 +{
12047 + ProtobufCMessage base;
12048 + protobuf_c_boolean action;
12049 + char *xpath;
12050 + /*
12051 + **< which API variant was used to send RPC req.
12052 + */
12053 + Sr__ApiVariant orig_api_variant;
12054 + size_t n_input;
12055 + Sr__Value **input;
12056 + size_t n_input_tree;
12057 + Sr__Node **input_tree;
12058 + char *subscriber_address;
12059 + protobuf_c_boolean has_subscription_id;
12060 + uint32_t subscription_id;
12061 +};
12062 +#define SR__RPCREQ__INIT \
12063 + { PROTOBUF_C_MESSAGE_INIT (&sr__rpcreq__descriptor) \
12064 + , 0, NULL, 0, 0,NULL, 0,NULL, NULL, 0,0 }
12065 +
12066 +
12067 +/*
12068 + **
12069 + * @brief Response to sr_rpc_send / sr_rpc_send_tree or sr_action_send / sr_action_send_tree request.
12070 + */
12071 +struct _Sr__RPCResp
12072 +{
12073 + ProtobufCMessage base;
12074 + protobuf_c_boolean action;
12075 + char *xpath;
12076 + /*
12077 + **< which API variant was used to send RPC req.
12078 + */
12079 + Sr__ApiVariant orig_api_variant;
12080 + size_t n_output;
12081 + Sr__Value **output;
12082 + size_t n_output_tree;
12083 + Sr__Node **output_tree;
12084 +};
12085 +#define SR__RPCRESP__INIT \
12086 + { PROTOBUF_C_MESSAGE_INIT (&sr__rpcresp__descriptor) \
12087 + , 0, NULL, 0, 0,NULL, 0,NULL }
12088 +
12089 +
12090 +/*
12091 + **
12092 + * @brief Sends an event notification into the datastore, will be delivered to all notification subscribers.
12093 + * Sent by sr_event_notif_send API call.
12094 + */
12095 +struct _Sr__EventNotifReq
12096 +{
12097 + ProtobufCMessage base;
12098 + Sr__EventNotifReq__NotifType type;
12099 + /*
12100 + **< Bitwise OR of NotifFlags.
12101 + */
12102 + uint32_t options;
12103 + char *xpath;
12104 + size_t n_values;
12105 + Sr__Value **values;
12106 + size_t n_trees;
12107 + Sr__Node **trees;
12108 + uint64_t timestamp;
12109 + char *subscriber_address;
12110 + protobuf_c_boolean has_subscription_id;
12111 + uint32_t subscription_id;
12112 + protobuf_c_boolean do_not_send_reply;
12113 +};
12114 +#define SR__EVENT_NOTIF_REQ__INIT \
12115 + { PROTOBUF_C_MESSAGE_INIT (&sr__event_notif_req__descriptor) \
12116 + , 0, 0, NULL, 0,NULL, 0,NULL, 0, NULL, 0,0, 0 }
12117 +
12118 +
12119 +/*
12120 + **
12121 + * @brief Response to sr_event_notif_send request.
12122 + */
12123 +struct _Sr__EventNotifResp
12124 +{
12125 + ProtobufCMessage base;
12126 +};
12127 +#define SR__EVENT_NOTIF_RESP__INIT \
12128 + { PROTOBUF_C_MESSAGE_INIT (&sr__event_notif_resp__descriptor) \
12129 + }
12130 +
12131 +
12132 +/*
12133 + **
12134 + * @brief Sends a request to replay event notifications stored in the datastore.
12135 + * Sent by sr_event_notif_replay API call.
12136 + */
12137 +struct _Sr__EventNotifReplayReq
12138 +{
12139 + ProtobufCMessage base;
12140 + char *xpath;
12141 + uint64_t start_time;
12142 + uint64_t stop_time;
12143 + char *subscriber_address;
12144 + uint32_t subscription_id;
12145 + Sr__ApiVariant api_variant;
12146 +};
12147 +#define SR__EVENT_NOTIF_REPLAY_REQ__INIT \
12148 + { PROTOBUF_C_MESSAGE_INIT (&sr__event_notif_replay_req__descriptor) \
12149 + , NULL, 0, 0, NULL, 0, 0 }
12150 +
12151 +
12152 +/*
12153 + **
12154 + * @brief Response to sr_event_notif_replay request.
12155 + */
12156 +struct _Sr__EventNotifReplayResp
12157 +{
12158 + ProtobufCMessage base;
12159 +};
12160 +#define SR__EVENT_NOTIF_REPLAY_RESP__INIT \
12161 + { PROTOBUF_C_MESSAGE_INIT (&sr__event_notif_replay_resp__descriptor) \
12162 + }
12163 +
12164 +
12165 +/*
12166 + **
12167 + * @brief Requests operational data under given path form an operational data
12168 + * provider.
12169 + */
12170 +struct _Sr__DataProvideReq
12171 +{
12172 + ProtobufCMessage base;
12173 + char *xpath;
12174 + char *subscriber_address;
12175 + uint32_t subscription_id;
12176 + uint64_t request_id;
12177 +};
12178 +#define SR__DATA_PROVIDE_REQ__INIT \
12179 + { PROTOBUF_C_MESSAGE_INIT (&sr__data_provide_req__descriptor) \
12180 + , NULL, NULL, 0, 0 }
12181 +
12182 +
12183 +/*
12184 + **
12185 + * @brief Response to a request of operational data under given path form an
12186 + * operational data provider.
12187 + */
12188 +struct _Sr__DataProvideResp
12189 +{
12190 + ProtobufCMessage base;
12191 + char *xpath;
12192 + size_t n_values;
12193 + Sr__Value **values;
12194 + uint64_t request_id;
12195 +};
12196 +#define SR__DATA_PROVIDE_RESP__INIT \
12197 + { PROTOBUF_C_MESSAGE_INIT (&sr__data_provide_resp__descriptor) \
12198 + , NULL, 0,NULL, 0 }
12199 +
12200 +
12201 +/*
12202 + **
12203 + * @brief Requests installation / uinstallation of specified YANG model.
12204 + * Sent by sr_module_install internal API calls.
12205 + */
12206 +struct _Sr__ModuleInstallReq
12207 +{
12208 + ProtobufCMessage base;
12209 + char *module_name;
12210 + char *revision;
12211 + char *file_name;
12212 + protobuf_c_boolean installed;
12213 +};
12214 +#define SR__MODULE_INSTALL_REQ__INIT \
12215 + { PROTOBUF_C_MESSAGE_INIT (&sr__module_install_req__descriptor) \
12216 + , NULL, NULL, NULL, 0 }
12217 +
12218 +
12219 +/*
12220 + **
12221 + * @brief Response to sr_module_install request.
12222 + */
12223 +struct _Sr__ModuleInstallResp
12224 +{
12225 + ProtobufCMessage base;
12226 +};
12227 +#define SR__MODULE_INSTALL_RESP__INIT \
12228 + { PROTOBUF_C_MESSAGE_INIT (&sr__module_install_resp__descriptor) \
12229 + }
12230 +
12231 +
12232 +/*
12233 + **
12234 + * @brief Requests enabling / disabling of specified YANG feature within the
12235 + * YANG model. Sent by sr_feature_enable internal API calls.
12236 + */
12237 +struct _Sr__FeatureEnableReq
12238 +{
12239 + ProtobufCMessage base;
12240 + char *module_name;
12241 + char *feature_name;
12242 + protobuf_c_boolean enabled;
12243 +};
12244 +#define SR__FEATURE_ENABLE_REQ__INIT \
12245 + { PROTOBUF_C_MESSAGE_INIT (&sr__feature_enable_req__descriptor) \
12246 + , NULL, NULL, 0 }
12247 +
12248 +
12249 +/*
12250 + **
12251 + * @brief Response to sr_feature_enable request.
12252 + */
12253 +struct _Sr__FeatureEnableResp
12254 +{
12255 + ProtobufCMessage base;
12256 +};
12257 +#define SR__FEATURE_ENABLE_RESP__INIT \
12258 + { PROTOBUF_C_MESSAGE_INIT (&sr__feature_enable_resp__descriptor) \
12259 + }
12260 +
12261 +
12262 +/*
12263 + **
12264 + * @brief Internal request to unsubscribe all subscriptions of a subscriber on given destination address.
12265 + */
12266 +struct _Sr__UnsubscribeDestinationReq
12267 +{
12268 + ProtobufCMessage base;
12269 + char *destination;
12270 +};
12271 +#define SR__UNSUBSCRIBE_DESTINATION_REQ__INIT \
12272 + { PROTOBUF_C_MESSAGE_INIT (&sr__unsubscribe_destination_req__descriptor) \
12273 + , NULL }
12274 +
12275 +
12276 +/*
12277 + **
12278 + * @brief Internal request to timeout a commit, if it hasn't been terminated yet.
12279 + */
12280 +struct _Sr__CommitTimeoutReq
12281 +{
12282 + ProtobufCMessage base;
12283 + uint32_t commit_id;
12284 + protobuf_c_boolean expired;
12285 +};
12286 +#define SR__COMMIT_TIMEOUT_REQ__INIT \
12287 + { PROTOBUF_C_MESSAGE_INIT (&sr__commit_timeout_req__descriptor) \
12288 + , 0, 0 }
12289 +
12290 +
12291 +/*
12292 + **
12293 + * @brief Internal request to timeout a request for operational data, if it hasn't been terminated yet.
12294 + */
12295 +struct _Sr__OperDataTimeoutReq
12296 +{
12297 + ProtobufCMessage base;
12298 + uint64_t request_id;
12299 +};
12300 +#define SR__OPER_DATA_TIMEOUT_REQ__INIT \
12301 + { PROTOBUF_C_MESSAGE_INIT (&sr__oper_data_timeout_req__descriptor) \
12302 + , 0 }
12303 +
12304 +
12305 +/*
12306 + **
12307 + * @brief Internal request for internal state data (state data provided by Sysrepo Engine itself).
12308 + */
12309 +struct _Sr__InternalStateDataReq
12310 +{
12311 + ProtobufCMessage base;
12312 + uint64_t request_id;
12313 + char *xpath;
12314 +};
12315 +#define SR__INTERNAL_STATE_DATA_REQ__INIT \
12316 + { PROTOBUF_C_MESSAGE_INIT (&sr__internal_state_data_req__descriptor) \
12317 + , 0, NULL }
12318 +
12319 +
12320 +/*
12321 + **
12322 + * @brief Internal request to cleanup aged notifications in the Notification Store.
12323 + */
12324 +struct _Sr__NotifStoreCleanupReq
12325 +{
12326 + ProtobufCMessage base;
12327 +};
12328 +#define SR__NOTIF_STORE_CLEANUP_REQ__INIT \
12329 + { PROTOBUF_C_MESSAGE_INIT (&sr__notif_store_cleanup_req__descriptor) \
12330 + }
12331 +
12332 +
12333 +/*
12334 + **
12335 + * @brief Message to be delivered to the client after some timeout.
12336 + */
12337 +struct _Sr__DelayedMsgReq
12338 +{
12339 + ProtobufCMessage base;
12340 + Sr__Msg *message;
12341 +};
12342 +#define SR__DELAYED_MSG_REQ__INIT \
12343 + { PROTOBUF_C_MESSAGE_INIT (&sr__delayed_msg_req__descriptor) \
12344 + , NULL }
12345 +
12346 +
12347 +/*
12348 + **
12349 + * @brief Internal request to reload NACM configuration from the running datastore.
12350 + */
12351 +struct _Sr__NacmReloadReq
12352 +{
12353 + ProtobufCMessage base;
12354 +};
12355 +#define SR__NACM_RELOAD_REQ__INIT \
12356 + { PROTOBUF_C_MESSAGE_INIT (&sr__nacm_reload_req__descriptor) \
12357 + }
12358 +
12359 +
12360 +/*
12361 + **
12362 + * @brief Request for an operation.
12363 + */
12364 +struct _Sr__Request
12365 +{
12366 + ProtobufCMessage base;
12367 + /*
12368 + * Request ID used internally by sysrepo
12369 + */
12370 + uint64_t _id;
12371 + Sr__Operation operation;
12372 + Sr__SessionStartReq *session_start_req;
12373 + Sr__SessionStopReq *session_stop_req;
12374 + Sr__SessionRefreshReq *session_refresh_req;
12375 + Sr__SessionCheckReq *session_check_req;
12376 + Sr__SessionSwitchDsReq *session_switch_ds_req;
12377 + Sr__SessionSetOptsReq *session_set_opts_req;
12378 + Sr__VersionVerifyReq *version_verify_req;
12379 + Sr__ListSchemasReq *list_schemas_req;
12380 + Sr__GetSchemaReq *get_schema_req;
12381 + Sr__ModuleInstallReq *module_install_req;
12382 + Sr__FeatureEnableReq *feature_enable_req;
12383 + Sr__GetItemReq *get_item_req;
12384 + Sr__GetItemsReq *get_items_req;
12385 + Sr__GetSubtreeReq *get_subtree_req;
12386 + Sr__GetSubtreesReq *get_subtrees_req;
12387 + Sr__GetSubtreeChunkReq *get_subtree_chunk_req;
12388 + Sr__SetItemReq *set_item_req;
12389 + Sr__DeleteItemReq *delete_item_req;
12390 + Sr__MoveItemReq *move_item_req;
12391 + Sr__SetItemStrReq *set_item_str_req;
12392 + Sr__ValidateReq *validate_req;
12393 + Sr__CommitReq *commit_req;
12394 + Sr__DiscardChangesReq *discard_changes_req;
12395 + Sr__CopyConfigReq *copy_config_req;
12396 + Sr__LockReq *lock_req;
12397 + Sr__UnlockReq *unlock_req;
12398 + Sr__SubscribeReq *subscribe_req;
12399 + Sr__UnsubscribeReq *unsubscribe_req;
12400 + Sr__CheckEnabledRunningReq *check_enabled_running_req;
12401 + Sr__GetChangesReq *get_changes_req;
12402 + Sr__DataProvideReq *data_provide_req;
12403 + Sr__CheckExecPermReq *check_exec_perm_req;
12404 + Sr__RPCReq *rpc_req;
12405 + Sr__EventNotifReq *event_notif_req;
12406 + Sr__EventNotifReplayReq *event_notif_replay_req;
12407 +};
12408 +#define SR__REQUEST__INIT \
12409 + { PROTOBUF_C_MESSAGE_INIT (&sr__request__descriptor) \
12410 + , 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 }
12411 +
12412 +
12413 +/*
12414 + **
12415 + * @brief Response to the received request.
12416 + */
12417 +struct _Sr__Response
12418 +{
12419 + ProtobufCMessage base;
12420 + Sr__Operation operation;
12421 + /*
12422 + **< Result of the operation. 0 on success, non-zero values map to sr_error_t enum in sysrepo.h.
12423 + */
12424 + uint32_t result;
12425 + /*
12426 + **< Additional error information.
12427 + */
12428 + Sr__Error *error;
12429 + Sr__SessionStartResp *session_start_resp;
12430 + Sr__SessionStopResp *session_stop_resp;
12431 + Sr__SessionRefreshResp *session_refresh_resp;
12432 + Sr__SessionCheckResp *session_check_resp;
12433 + Sr__SessionSwitchDsResp *session_switch_ds_resp;
12434 + Sr__SessionSetOptsResp *session_set_opts_resp;
12435 + Sr__VersionVerifyResp *version_verify_resp;
12436 + Sr__ListSchemasResp *list_schemas_resp;
12437 + Sr__GetSchemaResp *get_schema_resp;
12438 + Sr__ModuleInstallResp *module_install_resp;
12439 + Sr__FeatureEnableResp *feature_enable_resp;
12440 + Sr__GetItemResp *get_item_resp;
12441 + Sr__GetItemsResp *get_items_resp;
12442 + Sr__GetSubtreeResp *get_subtree_resp;
12443 + Sr__GetSubtreesResp *get_subtrees_resp;
12444 + Sr__GetSubtreeChunkResp *get_subtree_chunk_resp;
12445 + Sr__SetItemResp *set_item_resp;
12446 + Sr__DeleteItemResp *delete_item_resp;
12447 + Sr__MoveItemResp *move_item_resp;
12448 + Sr__SetItemStrResp *set_item_str_resp;
12449 + Sr__ValidateResp *validate_resp;
12450 + Sr__CommitResp *commit_resp;
12451 + Sr__DiscardChangesResp *discard_changes_resp;
12452 + Sr__CopyConfigResp *copy_config_resp;
12453 + Sr__LockResp *lock_resp;
12454 + Sr__UnlockResp *unlock_resp;
12455 + Sr__SubscribeResp *subscribe_resp;
12456 + Sr__UnsubscribeResp *unsubscribe_resp;
12457 + Sr__CheckEnabledRunningResp *check_enabled_running_resp;
12458 + Sr__GetChangesResp *get_changes_resp;
12459 + Sr__DataProvideResp *data_provide_resp;
12460 + Sr__CheckExecPermResp *check_exec_perm_resp;
12461 + Sr__RPCResp *rpc_resp;
12462 + Sr__EventNotifResp *event_notif_resp;
12463 + Sr__EventNotifReplayResp *event_notif_replay_resp;
12464 +};
12465 +#define SR__RESPONSE__INIT \
12466 + { PROTOBUF_C_MESSAGE_INIT (&sr__response__descriptor) \
12467 + , 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 }
12468 +
12469 +
12470 +/*
12471 + **
12472 + * @brief Notification about an event that occurred in the datastore.
12473 + */
12474 +struct _Sr__Notification
12475 +{
12476 + ProtobufCMessage base;
12477 + Sr__SubscriptionType type;
12478 + char *destination_address;
12479 + char *source_address;
12480 + uint32_t source_pid;
12481 + uint32_t subscription_id;
12482 + protobuf_c_boolean has_commit_id;
12483 + uint32_t commit_id;
12484 + Sr__ModuleInstallNotification *module_install_notif;
12485 + Sr__FeatureEnableNotification *feature_enable_notif;
12486 + Sr__ModuleChangeNotification *module_change_notif;
12487 + Sr__SubtreeChangeNotification *subtree_change_notif;
12488 +};
12489 +#define SR__NOTIFICATION__INIT \
12490 + { PROTOBUF_C_MESSAGE_INIT (&sr__notification__descriptor) \
12491 + , 0, NULL, NULL, 0, 0, 0,0, NULL, NULL, NULL, NULL }
12492 +
12493 +
12494 +/*
12495 + **
12496 + * @brief Notification Acknowledgment.
12497 + */
12498 +struct _Sr__NotificationAck
12499 +{
12500 + ProtobufCMessage base;
12501 + /*
12502 + **< Original notification.
12503 + */
12504 + Sr__Notification *notif;
12505 + /*
12506 + **< Result of the notification (success / error code).
12507 + */
12508 + uint32_t result;
12509 + /*
12510 + **< Additional error information.
12511 + */
12512 + Sr__Error *error;
12513 + /*
12514 + **< If the result is error and this flag is set to true abort notification
12515 + * will not be delivered to this subscriber
12516 + * (Subscriber doesn't want notification about changes that he refused).
12517 + */
12518 + protobuf_c_boolean do_not_send_abort;
12519 +};
12520 +#define SR__NOTIFICATION_ACK__INIT \
12521 + { PROTOBUF_C_MESSAGE_INIT (&sr__notification_ack__descriptor) \
12522 + , NULL, 0, NULL, 0 }
12523 +
12524 +
12525 +/*
12526 + **
12527 + * @brief Internal request sent by sysrepo. Should not be used from the public API.
12528 + */
12529 +struct _Sr__InternalRequest
12530 +{
12531 + ProtobufCMessage base;
12532 + Sr__Operation operation;
12533 + protobuf_c_boolean has_postpone_timeout;
12534 + uint32_t postpone_timeout;
12535 + Sr__UnsubscribeDestinationReq *unsubscribe_dst_req;
12536 + Sr__CommitTimeoutReq *commit_timeout_req;
12537 + Sr__OperDataTimeoutReq *oper_data_timeout_req;
12538 + Sr__InternalStateDataReq *internal_state_data_req;
12539 + Sr__NotifStoreCleanupReq *notif_store_cleanup_req;
12540 + Sr__DelayedMsgReq *delayed_msg_req;
12541 + Sr__NacmReloadReq *nacm_reload_req;
12542 +};
12543 +#define SR__INTERNAL_REQUEST__INIT \
12544 + { PROTOBUF_C_MESSAGE_INIT (&sr__internal_request__descriptor) \
12545 + , 0, 0,0, NULL, NULL, NULL, NULL, NULL, NULL, NULL }
12546 +
12547 +
12548 +/*
12549 + **
12550 + * @brief Umbrella sysrepo message used for communication between sysrepo
12551 + * engine and client library.
12552 + */
12553 +struct _Sr__Msg
12554 +{
12555 + ProtobufCMessage base;
12556 + /*
12557 + **< Indicates type of the message.
12558 + */
12559 + Sr__Msg__MsgType type;
12560 + /*
12561 + **< Session identifier. Can be 0 (value is ignored) for session_start and version_verify requests.
12562 + */
12563 + uint32_t session_id;
12564 + /*
12565 + **< Filled in in case of type == REQUEST.
12566 + */
12567 + Sr__Request *request;
12568 + /*
12569 + **< Filled in in case of type == RESPONSE.
12570 + */
12571 + Sr__Response *response;
12572 + /*
12573 + **< Filled in in case of type == NOTIFICATION.
12574 + */
12575 + Sr__Notification *notification;
12576 + /*
12577 + **< Filled in in case of type == NOTIFICATION_ACK
12578 + */
12579 + Sr__NotificationAck *notification_ack;
12580 + /*
12581 + **< Filled in in case of type == INTERNAL.
12582 + */
12583 + Sr__InternalRequest *internal_request;
12584 + /*
12585 + **< Not part of the protocol. Used internally by Sysrepo to store a pointer to memory context.
12586 + */
12587 + uint64_t _sysrepo_mem_ctx;
12588 +};
12589 +#define SR__MSG__INIT \
12590 + { PROTOBUF_C_MESSAGE_INIT (&sr__msg__descriptor) \
12591 + , 0, 0, NULL, NULL, NULL, NULL, NULL, 0 }
12592 +
12593 +
12594 +/* Sr__Value methods */
12595 +void sr__value__init
12596 + (Sr__Value *message);
12597 +size_t sr__value__get_packed_size
12598 + (const Sr__Value *message);
12599 +size_t sr__value__pack
12600 + (const Sr__Value *message,
12601 + uint8_t *out);
12602 +size_t sr__value__pack_to_buffer
12603 + (const Sr__Value *message,
12604 + ProtobufCBuffer *buffer);
12605 +Sr__Value *
12606 + sr__value__unpack
12607 + (ProtobufCAllocator *allocator,
12608 + size_t len,
12609 + const uint8_t *data);
12610 +void sr__value__free_unpacked
12611 + (Sr__Value *message,
12612 + ProtobufCAllocator *allocator);
12613 +/* Sr__Node methods */
12614 +void sr__node__init
12615 + (Sr__Node *message);
12616 +size_t sr__node__get_packed_size
12617 + (const Sr__Node *message);
12618 +size_t sr__node__pack
12619 + (const Sr__Node *message,
12620 + uint8_t *out);
12621 +size_t sr__node__pack_to_buffer
12622 + (const Sr__Node *message,
12623 + ProtobufCBuffer *buffer);
12624 +Sr__Node *
12625 + sr__node__unpack
12626 + (ProtobufCAllocator *allocator,
12627 + size_t len,
12628 + const uint8_t *data);
12629 +void sr__node__free_unpacked
12630 + (Sr__Node *message,
12631 + ProtobufCAllocator *allocator);
12632 +/* Sr__Error methods */
12633 +void sr__error__init
12634 + (Sr__Error *message);
12635 +size_t sr__error__get_packed_size
12636 + (const Sr__Error *message);
12637 +size_t sr__error__pack
12638 + (const Sr__Error *message,
12639 + uint8_t *out);
12640 +size_t sr__error__pack_to_buffer
12641 + (const Sr__Error *message,
12642 + ProtobufCBuffer *buffer);
12643 +Sr__Error *
12644 + sr__error__unpack
12645 + (ProtobufCAllocator *allocator,
12646 + size_t len,
12647 + const uint8_t *data);
12648 +void sr__error__free_unpacked
12649 + (Sr__Error *message,
12650 + ProtobufCAllocator *allocator);
12651 +/* Sr__SessionStartReq methods */
12652 +void sr__session_start_req__init
12653 + (Sr__SessionStartReq *message);
12654 +size_t sr__session_start_req__get_packed_size
12655 + (const Sr__SessionStartReq *message);
12656 +size_t sr__session_start_req__pack
12657 + (const Sr__SessionStartReq *message,
12658 + uint8_t *out);
12659 +size_t sr__session_start_req__pack_to_buffer
12660 + (const Sr__SessionStartReq *message,
12661 + ProtobufCBuffer *buffer);
12662 +Sr__SessionStartReq *
12663 + sr__session_start_req__unpack
12664 + (ProtobufCAllocator *allocator,
12665 + size_t len,
12666 + const uint8_t *data);
12667 +void sr__session_start_req__free_unpacked
12668 + (Sr__SessionStartReq *message,
12669 + ProtobufCAllocator *allocator);
12670 +/* Sr__SessionStartResp methods */
12671 +void sr__session_start_resp__init
12672 + (Sr__SessionStartResp *message);
12673 +size_t sr__session_start_resp__get_packed_size
12674 + (const Sr__SessionStartResp *message);
12675 +size_t sr__session_start_resp__pack
12676 + (const Sr__SessionStartResp *message,
12677 + uint8_t *out);
12678 +size_t sr__session_start_resp__pack_to_buffer
12679 + (const Sr__SessionStartResp *message,
12680 + ProtobufCBuffer *buffer);
12681 +Sr__SessionStartResp *
12682 + sr__session_start_resp__unpack
12683 + (ProtobufCAllocator *allocator,
12684 + size_t len,
12685 + const uint8_t *data);
12686 +void sr__session_start_resp__free_unpacked
12687 + (Sr__SessionStartResp *message,
12688 + ProtobufCAllocator *allocator);
12689 +/* Sr__SessionStopReq methods */
12690 +void sr__session_stop_req__init
12691 + (Sr__SessionStopReq *message);
12692 +size_t sr__session_stop_req__get_packed_size
12693 + (const Sr__SessionStopReq *message);
12694 +size_t sr__session_stop_req__pack
12695 + (const Sr__SessionStopReq *message,
12696 + uint8_t *out);
12697 +size_t sr__session_stop_req__pack_to_buffer
12698 + (const Sr__SessionStopReq *message,
12699 + ProtobufCBuffer *buffer);
12700 +Sr__SessionStopReq *
12701 + sr__session_stop_req__unpack
12702 + (ProtobufCAllocator *allocator,
12703 + size_t len,
12704 + const uint8_t *data);
12705 +void sr__session_stop_req__free_unpacked
12706 + (Sr__SessionStopReq *message,
12707 + ProtobufCAllocator *allocator);
12708 +/* Sr__SessionStopResp methods */
12709 +void sr__session_stop_resp__init
12710 + (Sr__SessionStopResp *message);
12711 +size_t sr__session_stop_resp__get_packed_size
12712 + (const Sr__SessionStopResp *message);
12713 +size_t sr__session_stop_resp__pack
12714 + (const Sr__SessionStopResp *message,
12715 + uint8_t *out);
12716 +size_t sr__session_stop_resp__pack_to_buffer
12717 + (const Sr__SessionStopResp *message,
12718 + ProtobufCBuffer *buffer);
12719 +Sr__SessionStopResp *
12720 + sr__session_stop_resp__unpack
12721 + (ProtobufCAllocator *allocator,
12722 + size_t len,
12723 + const uint8_t *data);
12724 +void sr__session_stop_resp__free_unpacked
12725 + (Sr__SessionStopResp *message,
12726 + ProtobufCAllocator *allocator);
12727 +/* Sr__SessionRefreshReq methods */
12728 +void sr__session_refresh_req__init
12729 + (Sr__SessionRefreshReq *message);
12730 +size_t sr__session_refresh_req__get_packed_size
12731 + (const Sr__SessionRefreshReq *message);
12732 +size_t sr__session_refresh_req__pack
12733 + (const Sr__SessionRefreshReq *message,
12734 + uint8_t *out);
12735 +size_t sr__session_refresh_req__pack_to_buffer
12736 + (const Sr__SessionRefreshReq *message,
12737 + ProtobufCBuffer *buffer);
12738 +Sr__SessionRefreshReq *
12739 + sr__session_refresh_req__unpack
12740 + (ProtobufCAllocator *allocator,
12741 + size_t len,
12742 + const uint8_t *data);
12743 +void sr__session_refresh_req__free_unpacked
12744 + (Sr__SessionRefreshReq *message,
12745 + ProtobufCAllocator *allocator);
12746 +/* Sr__SessionRefreshResp methods */
12747 +void sr__session_refresh_resp__init
12748 + (Sr__SessionRefreshResp *message);
12749 +size_t sr__session_refresh_resp__get_packed_size
12750 + (const Sr__SessionRefreshResp *message);
12751 +size_t sr__session_refresh_resp__pack
12752 + (const Sr__SessionRefreshResp *message,
12753 + uint8_t *out);
12754 +size_t sr__session_refresh_resp__pack_to_buffer
12755 + (const Sr__SessionRefreshResp *message,
12756 + ProtobufCBuffer *buffer);
12757 +Sr__SessionRefreshResp *
12758 + sr__session_refresh_resp__unpack
12759 + (ProtobufCAllocator *allocator,
12760 + size_t len,
12761 + const uint8_t *data);
12762 +void sr__session_refresh_resp__free_unpacked
12763 + (Sr__SessionRefreshResp *message,
12764 + ProtobufCAllocator *allocator);
12765 +/* Sr__SessionCheckReq methods */
12766 +void sr__session_check_req__init
12767 + (Sr__SessionCheckReq *message);
12768 +size_t sr__session_check_req__get_packed_size
12769 + (const Sr__SessionCheckReq *message);
12770 +size_t sr__session_check_req__pack
12771 + (const Sr__SessionCheckReq *message,
12772 + uint8_t *out);
12773 +size_t sr__session_check_req__pack_to_buffer
12774 + (const Sr__SessionCheckReq *message,
12775 + ProtobufCBuffer *buffer);
12776 +Sr__SessionCheckReq *
12777 + sr__session_check_req__unpack
12778 + (ProtobufCAllocator *allocator,
12779 + size_t len,
12780 + const uint8_t *data);
12781 +void sr__session_check_req__free_unpacked
12782 + (Sr__SessionCheckReq *message,
12783 + ProtobufCAllocator *allocator);
12784 +/* Sr__SessionCheckResp methods */
12785 +void sr__session_check_resp__init
12786 + (Sr__SessionCheckResp *message);
12787 +size_t sr__session_check_resp__get_packed_size
12788 + (const Sr__SessionCheckResp *message);
12789 +size_t sr__session_check_resp__pack
12790 + (const Sr__SessionCheckResp *message,
12791 + uint8_t *out);
12792 +size_t sr__session_check_resp__pack_to_buffer
12793 + (const Sr__SessionCheckResp *message,
12794 + ProtobufCBuffer *buffer);
12795 +Sr__SessionCheckResp *
12796 + sr__session_check_resp__unpack
12797 + (ProtobufCAllocator *allocator,
12798 + size_t len,
12799 + const uint8_t *data);
12800 +void sr__session_check_resp__free_unpacked
12801 + (Sr__SessionCheckResp *message,
12802 + ProtobufCAllocator *allocator);
12803 +/* Sr__SessionSwitchDsReq methods */
12804 +void sr__session_switch_ds_req__init
12805 + (Sr__SessionSwitchDsReq *message);
12806 +size_t sr__session_switch_ds_req__get_packed_size
12807 + (const Sr__SessionSwitchDsReq *message);
12808 +size_t sr__session_switch_ds_req__pack
12809 + (const Sr__SessionSwitchDsReq *message,
12810 + uint8_t *out);
12811 +size_t sr__session_switch_ds_req__pack_to_buffer
12812 + (const Sr__SessionSwitchDsReq *message,
12813 + ProtobufCBuffer *buffer);
12814 +Sr__SessionSwitchDsReq *
12815 + sr__session_switch_ds_req__unpack
12816 + (ProtobufCAllocator *allocator,
12817 + size_t len,
12818 + const uint8_t *data);
12819 +void sr__session_switch_ds_req__free_unpacked
12820 + (Sr__SessionSwitchDsReq *message,
12821 + ProtobufCAllocator *allocator);
12822 +/* Sr__SessionSwitchDsResp methods */
12823 +void sr__session_switch_ds_resp__init
12824 + (Sr__SessionSwitchDsResp *message);
12825 +size_t sr__session_switch_ds_resp__get_packed_size
12826 + (const Sr__SessionSwitchDsResp *message);
12827 +size_t sr__session_switch_ds_resp__pack
12828 + (const Sr__SessionSwitchDsResp *message,
12829 + uint8_t *out);
12830 +size_t sr__session_switch_ds_resp__pack_to_buffer
12831 + (const Sr__SessionSwitchDsResp *message,
12832 + ProtobufCBuffer *buffer);
12833 +Sr__SessionSwitchDsResp *
12834 + sr__session_switch_ds_resp__unpack
12835 + (ProtobufCAllocator *allocator,
12836 + size_t len,
12837 + const uint8_t *data);
12838 +void sr__session_switch_ds_resp__free_unpacked
12839 + (Sr__SessionSwitchDsResp *message,
12840 + ProtobufCAllocator *allocator);
12841 +/* Sr__SessionSetOptsReq methods */
12842 +void sr__session_set_opts_req__init
12843 + (Sr__SessionSetOptsReq *message);
12844 +size_t sr__session_set_opts_req__get_packed_size
12845 + (const Sr__SessionSetOptsReq *message);
12846 +size_t sr__session_set_opts_req__pack
12847 + (const Sr__SessionSetOptsReq *message,
12848 + uint8_t *out);
12849 +size_t sr__session_set_opts_req__pack_to_buffer
12850 + (const Sr__SessionSetOptsReq *message,
12851 + ProtobufCBuffer *buffer);
12852 +Sr__SessionSetOptsReq *
12853 + sr__session_set_opts_req__unpack
12854 + (ProtobufCAllocator *allocator,
12855 + size_t len,
12856 + const uint8_t *data);
12857 +void sr__session_set_opts_req__free_unpacked
12858 + (Sr__SessionSetOptsReq *message,
12859 + ProtobufCAllocator *allocator);
12860 +/* Sr__SessionSetOptsResp methods */
12861 +void sr__session_set_opts_resp__init
12862 + (Sr__SessionSetOptsResp *message);
12863 +size_t sr__session_set_opts_resp__get_packed_size
12864 + (const Sr__SessionSetOptsResp *message);
12865 +size_t sr__session_set_opts_resp__pack
12866 + (const Sr__SessionSetOptsResp *message,
12867 + uint8_t *out);
12868 +size_t sr__session_set_opts_resp__pack_to_buffer
12869 + (const Sr__SessionSetOptsResp *message,
12870 + ProtobufCBuffer *buffer);
12871 +Sr__SessionSetOptsResp *
12872 + sr__session_set_opts_resp__unpack
12873 + (ProtobufCAllocator *allocator,
12874 + size_t len,
12875 + const uint8_t *data);
12876 +void sr__session_set_opts_resp__free_unpacked
12877 + (Sr__SessionSetOptsResp *message,
12878 + ProtobufCAllocator *allocator);
12879 +/* Sr__VersionVerifyReq methods */
12880 +void sr__version_verify_req__init
12881 + (Sr__VersionVerifyReq *message);
12882 +size_t sr__version_verify_req__get_packed_size
12883 + (const Sr__VersionVerifyReq *message);
12884 +size_t sr__version_verify_req__pack
12885 + (const Sr__VersionVerifyReq *message,
12886 + uint8_t *out);
12887 +size_t sr__version_verify_req__pack_to_buffer
12888 + (const Sr__VersionVerifyReq *message,
12889 + ProtobufCBuffer *buffer);
12890 +Sr__VersionVerifyReq *
12891 + sr__version_verify_req__unpack
12892 + (ProtobufCAllocator *allocator,
12893 + size_t len,
12894 + const uint8_t *data);
12895 +void sr__version_verify_req__free_unpacked
12896 + (Sr__VersionVerifyReq *message,
12897 + ProtobufCAllocator *allocator);
12898 +/* Sr__VersionVerifyResp methods */
12899 +void sr__version_verify_resp__init
12900 + (Sr__VersionVerifyResp *message);
12901 +size_t sr__version_verify_resp__get_packed_size
12902 + (const Sr__VersionVerifyResp *message);
12903 +size_t sr__version_verify_resp__pack
12904 + (const Sr__VersionVerifyResp *message,
12905 + uint8_t *out);
12906 +size_t sr__version_verify_resp__pack_to_buffer
12907 + (const Sr__VersionVerifyResp *message,
12908 + ProtobufCBuffer *buffer);
12909 +Sr__VersionVerifyResp *
12910 + sr__version_verify_resp__unpack
12911 + (ProtobufCAllocator *allocator,
12912 + size_t len,
12913 + const uint8_t *data);
12914 +void sr__version_verify_resp__free_unpacked
12915 + (Sr__VersionVerifyResp *message,
12916 + ProtobufCAllocator *allocator);
12917 +/* Sr__SchemaRevision methods */
12918 +void sr__schema_revision__init
12919 + (Sr__SchemaRevision *message);
12920 +size_t sr__schema_revision__get_packed_size
12921 + (const Sr__SchemaRevision *message);
12922 +size_t sr__schema_revision__pack
12923 + (const Sr__SchemaRevision *message,
12924 + uint8_t *out);
12925 +size_t sr__schema_revision__pack_to_buffer
12926 + (const Sr__SchemaRevision *message,
12927 + ProtobufCBuffer *buffer);
12928 +Sr__SchemaRevision *
12929 + sr__schema_revision__unpack
12930 + (ProtobufCAllocator *allocator,
12931 + size_t len,
12932 + const uint8_t *data);
12933 +void sr__schema_revision__free_unpacked
12934 + (Sr__SchemaRevision *message,
12935 + ProtobufCAllocator *allocator);
12936 +/* Sr__SchemaSubmodule methods */
12937 +void sr__schema_submodule__init
12938 + (Sr__SchemaSubmodule *message);
12939 +size_t sr__schema_submodule__get_packed_size
12940 + (const Sr__SchemaSubmodule *message);
12941 +size_t sr__schema_submodule__pack
12942 + (const Sr__SchemaSubmodule *message,
12943 + uint8_t *out);
12944 +size_t sr__schema_submodule__pack_to_buffer
12945 + (const Sr__SchemaSubmodule *message,
12946 + ProtobufCBuffer *buffer);
12947 +Sr__SchemaSubmodule *
12948 + sr__schema_submodule__unpack
12949 + (ProtobufCAllocator *allocator,
12950 + size_t len,
12951 + const uint8_t *data);
12952 +void sr__schema_submodule__free_unpacked
12953 + (Sr__SchemaSubmodule *message,
12954 + ProtobufCAllocator *allocator);
12955 +/* Sr__Schema methods */
12956 +void sr__schema__init
12957 + (Sr__Schema *message);
12958 +size_t sr__schema__get_packed_size
12959 + (const Sr__Schema *message);
12960 +size_t sr__schema__pack
12961 + (const Sr__Schema *message,
12962 + uint8_t *out);
12963 +size_t sr__schema__pack_to_buffer
12964 + (const Sr__Schema *message,
12965 + ProtobufCBuffer *buffer);
12966 +Sr__Schema *
12967 + sr__schema__unpack
12968 + (ProtobufCAllocator *allocator,
12969 + size_t len,
12970 + const uint8_t *data);
12971 +void sr__schema__free_unpacked
12972 + (Sr__Schema *message,
12973 + ProtobufCAllocator *allocator);
12974 +/* Sr__ListSchemasReq methods */
12975 +void sr__list_schemas_req__init
12976 + (Sr__ListSchemasReq *message);
12977 +size_t sr__list_schemas_req__get_packed_size
12978 + (const Sr__ListSchemasReq *message);
12979 +size_t sr__list_schemas_req__pack
12980 + (const Sr__ListSchemasReq *message,
12981 + uint8_t *out);
12982 +size_t sr__list_schemas_req__pack_to_buffer
12983 + (const Sr__ListSchemasReq *message,
12984 + ProtobufCBuffer *buffer);
12985 +Sr__ListSchemasReq *
12986 + sr__list_schemas_req__unpack
12987 + (ProtobufCAllocator *allocator,
12988 + size_t len,
12989 + const uint8_t *data);
12990 +void sr__list_schemas_req__free_unpacked
12991 + (Sr__ListSchemasReq *message,
12992 + ProtobufCAllocator *allocator);
12993 +/* Sr__ListSchemasResp methods */
12994 +void sr__list_schemas_resp__init
12995 + (Sr__ListSchemasResp *message);
12996 +size_t sr__list_schemas_resp__get_packed_size
12997 + (const Sr__ListSchemasResp *message);
12998 +size_t sr__list_schemas_resp__pack
12999 + (const Sr__ListSchemasResp *message,
13000 + uint8_t *out);
13001 +size_t sr__list_schemas_resp__pack_to_buffer
13002 + (const Sr__ListSchemasResp *message,
13003 + ProtobufCBuffer *buffer);
13004 +Sr__ListSchemasResp *
13005 + sr__list_schemas_resp__unpack
13006 + (ProtobufCAllocator *allocator,
13007 + size_t len,
13008 + const uint8_t *data);
13009 +void sr__list_schemas_resp__free_unpacked
13010 + (Sr__ListSchemasResp *message,
13011 + ProtobufCAllocator *allocator);
13012 +/* Sr__GetSchemaReq methods */
13013 +void sr__get_schema_req__init
13014 + (Sr__GetSchemaReq *message);
13015 +size_t sr__get_schema_req__get_packed_size
13016 + (const Sr__GetSchemaReq *message);
13017 +size_t sr__get_schema_req__pack
13018 + (const Sr__GetSchemaReq *message,
13019 + uint8_t *out);
13020 +size_t sr__get_schema_req__pack_to_buffer
13021 + (const Sr__GetSchemaReq *message,
13022 + ProtobufCBuffer *buffer);
13023 +Sr__GetSchemaReq *
13024 + sr__get_schema_req__unpack
13025 + (ProtobufCAllocator *allocator,
13026 + size_t len,
13027 + const uint8_t *data);
13028 +void sr__get_schema_req__free_unpacked
13029 + (Sr__GetSchemaReq *message,
13030 + ProtobufCAllocator *allocator);
13031 +/* Sr__GetSchemaResp methods */
13032 +void sr__get_schema_resp__init
13033 + (Sr__GetSchemaResp *message);
13034 +size_t sr__get_schema_resp__get_packed_size
13035 + (const Sr__GetSchemaResp *message);
13036 +size_t sr__get_schema_resp__pack
13037 + (const Sr__GetSchemaResp *message,
13038 + uint8_t *out);
13039 +size_t sr__get_schema_resp__pack_to_buffer
13040 + (const Sr__GetSchemaResp *message,
13041 + ProtobufCBuffer *buffer);
13042 +Sr__GetSchemaResp *
13043 + sr__get_schema_resp__unpack
13044 + (ProtobufCAllocator *allocator,
13045 + size_t len,
13046 + const uint8_t *data);
13047 +void sr__get_schema_resp__free_unpacked
13048 + (Sr__GetSchemaResp *message,
13049 + ProtobufCAllocator *allocator);
13050 +/* Sr__GetItemReq methods */
13051 +void sr__get_item_req__init
13052 + (Sr__GetItemReq *message);
13053 +size_t sr__get_item_req__get_packed_size
13054 + (const Sr__GetItemReq *message);
13055 +size_t sr__get_item_req__pack
13056 + (const Sr__GetItemReq *message,
13057 + uint8_t *out);
13058 +size_t sr__get_item_req__pack_to_buffer
13059 + (const Sr__GetItemReq *message,
13060 + ProtobufCBuffer *buffer);
13061 +Sr__GetItemReq *
13062 + sr__get_item_req__unpack
13063 + (ProtobufCAllocator *allocator,
13064 + size_t len,
13065 + const uint8_t *data);
13066 +void sr__get_item_req__free_unpacked
13067 + (Sr__GetItemReq *message,
13068 + ProtobufCAllocator *allocator);
13069 +/* Sr__GetItemResp methods */
13070 +void sr__get_item_resp__init
13071 + (Sr__GetItemResp *message);
13072 +size_t sr__get_item_resp__get_packed_size
13073 + (const Sr__GetItemResp *message);
13074 +size_t sr__get_item_resp__pack
13075 + (const Sr__GetItemResp *message,
13076 + uint8_t *out);
13077 +size_t sr__get_item_resp__pack_to_buffer
13078 + (const Sr__GetItemResp *message,
13079 + ProtobufCBuffer *buffer);
13080 +Sr__GetItemResp *
13081 + sr__get_item_resp__unpack
13082 + (ProtobufCAllocator *allocator,
13083 + size_t len,
13084 + const uint8_t *data);
13085 +void sr__get_item_resp__free_unpacked
13086 + (Sr__GetItemResp *message,
13087 + ProtobufCAllocator *allocator);
13088 +/* Sr__GetItemsReq methods */
13089 +void sr__get_items_req__init
13090 + (Sr__GetItemsReq *message);
13091 +size_t sr__get_items_req__get_packed_size
13092 + (const Sr__GetItemsReq *message);
13093 +size_t sr__get_items_req__pack
13094 + (const Sr__GetItemsReq *message,
13095 + uint8_t *out);
13096 +size_t sr__get_items_req__pack_to_buffer
13097 + (const Sr__GetItemsReq *message,
13098 + ProtobufCBuffer *buffer);
13099 +Sr__GetItemsReq *
13100 + sr__get_items_req__unpack
13101 + (ProtobufCAllocator *allocator,
13102 + size_t len,
13103 + const uint8_t *data);
13104 +void sr__get_items_req__free_unpacked
13105 + (Sr__GetItemsReq *message,
13106 + ProtobufCAllocator *allocator);
13107 +/* Sr__GetItemsResp methods */
13108 +void sr__get_items_resp__init
13109 + (Sr__GetItemsResp *message);
13110 +size_t sr__get_items_resp__get_packed_size
13111 + (const Sr__GetItemsResp *message);
13112 +size_t sr__get_items_resp__pack
13113 + (const Sr__GetItemsResp *message,
13114 + uint8_t *out);
13115 +size_t sr__get_items_resp__pack_to_buffer
13116 + (const Sr__GetItemsResp *message,
13117 + ProtobufCBuffer *buffer);
13118 +Sr__GetItemsResp *
13119 + sr__get_items_resp__unpack
13120 + (ProtobufCAllocator *allocator,
13121 + size_t len,
13122 + const uint8_t *data);
13123 +void sr__get_items_resp__free_unpacked
13124 + (Sr__GetItemsResp *message,
13125 + ProtobufCAllocator *allocator);
13126 +/* Sr__GetSubtreeReq methods */
13127 +void sr__get_subtree_req__init
13128 + (Sr__GetSubtreeReq *message);
13129 +size_t sr__get_subtree_req__get_packed_size
13130 + (const Sr__GetSubtreeReq *message);
13131 +size_t sr__get_subtree_req__pack
13132 + (const Sr__GetSubtreeReq *message,
13133 + uint8_t *out);
13134 +size_t sr__get_subtree_req__pack_to_buffer
13135 + (const Sr__GetSubtreeReq *message,
13136 + ProtobufCBuffer *buffer);
13137 +Sr__GetSubtreeReq *
13138 + sr__get_subtree_req__unpack
13139 + (ProtobufCAllocator *allocator,
13140 + size_t len,
13141 + const uint8_t *data);
13142 +void sr__get_subtree_req__free_unpacked
13143 + (Sr__GetSubtreeReq *message,
13144 + ProtobufCAllocator *allocator);
13145 +/* Sr__GetSubtreeResp methods */
13146 +void sr__get_subtree_resp__init
13147 + (Sr__GetSubtreeResp *message);
13148 +size_t sr__get_subtree_resp__get_packed_size
13149 + (const Sr__GetSubtreeResp *message);
13150 +size_t sr__get_subtree_resp__pack
13151 + (const Sr__GetSubtreeResp *message,
13152 + uint8_t *out);
13153 +size_t sr__get_subtree_resp__pack_to_buffer
13154 + (const Sr__GetSubtreeResp *message,
13155 + ProtobufCBuffer *buffer);
13156 +Sr__GetSubtreeResp *
13157 + sr__get_subtree_resp__unpack
13158 + (ProtobufCAllocator *allocator,
13159 + size_t len,
13160 + const uint8_t *data);
13161 +void sr__get_subtree_resp__free_unpacked
13162 + (Sr__GetSubtreeResp *message,
13163 + ProtobufCAllocator *allocator);
13164 +/* Sr__GetSubtreesReq methods */
13165 +void sr__get_subtrees_req__init
13166 + (Sr__GetSubtreesReq *message);
13167 +size_t sr__get_subtrees_req__get_packed_size
13168 + (const Sr__GetSubtreesReq *message);
13169 +size_t sr__get_subtrees_req__pack
13170 + (const Sr__GetSubtreesReq *message,
13171 + uint8_t *out);
13172 +size_t sr__get_subtrees_req__pack_to_buffer
13173 + (const Sr__GetSubtreesReq *message,
13174 + ProtobufCBuffer *buffer);
13175 +Sr__GetSubtreesReq *
13176 + sr__get_subtrees_req__unpack
13177 + (ProtobufCAllocator *allocator,
13178 + size_t len,
13179 + const uint8_t *data);
13180 +void sr__get_subtrees_req__free_unpacked
13181 + (Sr__GetSubtreesReq *message,
13182 + ProtobufCAllocator *allocator);
13183 +/* Sr__GetSubtreesResp methods */
13184 +void sr__get_subtrees_resp__init
13185 + (Sr__GetSubtreesResp *message);
13186 +size_t sr__get_subtrees_resp__get_packed_size
13187 + (const Sr__GetSubtreesResp *message);
13188 +size_t sr__get_subtrees_resp__pack
13189 + (const Sr__GetSubtreesResp *message,
13190 + uint8_t *out);
13191 +size_t sr__get_subtrees_resp__pack_to_buffer
13192 + (const Sr__GetSubtreesResp *message,
13193 + ProtobufCBuffer *buffer);
13194 +Sr__GetSubtreesResp *
13195 + sr__get_subtrees_resp__unpack
13196 + (ProtobufCAllocator *allocator,
13197 + size_t len,
13198 + const uint8_t *data);
13199 +void sr__get_subtrees_resp__free_unpacked
13200 + (Sr__GetSubtreesResp *message,
13201 + ProtobufCAllocator *allocator);
13202 +/* Sr__GetSubtreeChunkReq methods */
13203 +void sr__get_subtree_chunk_req__init
13204 + (Sr__GetSubtreeChunkReq *message);
13205 +size_t sr__get_subtree_chunk_req__get_packed_size
13206 + (const Sr__GetSubtreeChunkReq *message);
13207 +size_t sr__get_subtree_chunk_req__pack
13208 + (const Sr__GetSubtreeChunkReq *message,
13209 + uint8_t *out);
13210 +size_t sr__get_subtree_chunk_req__pack_to_buffer
13211 + (const Sr__GetSubtreeChunkReq *message,
13212 + ProtobufCBuffer *buffer);
13213 +Sr__GetSubtreeChunkReq *
13214 + sr__get_subtree_chunk_req__unpack
13215 + (ProtobufCAllocator *allocator,
13216 + size_t len,
13217 + const uint8_t *data);
13218 +void sr__get_subtree_chunk_req__free_unpacked
13219 + (Sr__GetSubtreeChunkReq *message,
13220 + ProtobufCAllocator *allocator);
13221 +/* Sr__GetSubtreeChunkResp methods */
13222 +void sr__get_subtree_chunk_resp__init
13223 + (Sr__GetSubtreeChunkResp *message);
13224 +size_t sr__get_subtree_chunk_resp__get_packed_size
13225 + (const Sr__GetSubtreeChunkResp *message);
13226 +size_t sr__get_subtree_chunk_resp__pack
13227 + (const Sr__GetSubtreeChunkResp *message,
13228 + uint8_t *out);
13229 +size_t sr__get_subtree_chunk_resp__pack_to_buffer
13230 + (const Sr__GetSubtreeChunkResp *message,
13231 + ProtobufCBuffer *buffer);
13232 +Sr__GetSubtreeChunkResp *
13233 + sr__get_subtree_chunk_resp__unpack
13234 + (ProtobufCAllocator *allocator,
13235 + size_t len,
13236 + const uint8_t *data);
13237 +void sr__get_subtree_chunk_resp__free_unpacked
13238 + (Sr__GetSubtreeChunkResp *message,
13239 + ProtobufCAllocator *allocator);
13240 +/* Sr__SetItemReq methods */
13241 +void sr__set_item_req__init
13242 + (Sr__SetItemReq *message);
13243 +size_t sr__set_item_req__get_packed_size
13244 + (const Sr__SetItemReq *message);
13245 +size_t sr__set_item_req__pack
13246 + (const Sr__SetItemReq *message,
13247 + uint8_t *out);
13248 +size_t sr__set_item_req__pack_to_buffer
13249 + (const Sr__SetItemReq *message,
13250 + ProtobufCBuffer *buffer);
13251 +Sr__SetItemReq *
13252 + sr__set_item_req__unpack
13253 + (ProtobufCAllocator *allocator,
13254 + size_t len,
13255 + const uint8_t *data);
13256 +void sr__set_item_req__free_unpacked
13257 + (Sr__SetItemReq *message,
13258 + ProtobufCAllocator *allocator);
13259 +/* Sr__SetItemResp methods */
13260 +void sr__set_item_resp__init
13261 + (Sr__SetItemResp *message);
13262 +size_t sr__set_item_resp__get_packed_size
13263 + (const Sr__SetItemResp *message);
13264 +size_t sr__set_item_resp__pack
13265 + (const Sr__SetItemResp *message,
13266 + uint8_t *out);
13267 +size_t sr__set_item_resp__pack_to_buffer
13268 + (const Sr__SetItemResp *message,
13269 + ProtobufCBuffer *buffer);
13270 +Sr__SetItemResp *
13271 + sr__set_item_resp__unpack
13272 + (ProtobufCAllocator *allocator,
13273 + size_t len,
13274 + const uint8_t *data);
13275 +void sr__set_item_resp__free_unpacked
13276 + (Sr__SetItemResp *message,
13277 + ProtobufCAllocator *allocator);
13278 +/* Sr__SetItemStrReq methods */
13279 +void sr__set_item_str_req__init
13280 + (Sr__SetItemStrReq *message);
13281 +size_t sr__set_item_str_req__get_packed_size
13282 + (const Sr__SetItemStrReq *message);
13283 +size_t sr__set_item_str_req__pack
13284 + (const Sr__SetItemStrReq *message,
13285 + uint8_t *out);
13286 +size_t sr__set_item_str_req__pack_to_buffer
13287 + (const Sr__SetItemStrReq *message,
13288 + ProtobufCBuffer *buffer);
13289 +Sr__SetItemStrReq *
13290 + sr__set_item_str_req__unpack
13291 + (ProtobufCAllocator *allocator,
13292 + size_t len,
13293 + const uint8_t *data);
13294 +void sr__set_item_str_req__free_unpacked
13295 + (Sr__SetItemStrReq *message,
13296 + ProtobufCAllocator *allocator);
13297 +/* Sr__SetItemStrResp methods */
13298 +void sr__set_item_str_resp__init
13299 + (Sr__SetItemStrResp *message);
13300 +size_t sr__set_item_str_resp__get_packed_size
13301 + (const Sr__SetItemStrResp *message);
13302 +size_t sr__set_item_str_resp__pack
13303 + (const Sr__SetItemStrResp *message,
13304 + uint8_t *out);
13305 +size_t sr__set_item_str_resp__pack_to_buffer
13306 + (const Sr__SetItemStrResp *message,
13307 + ProtobufCBuffer *buffer);
13308 +Sr__SetItemStrResp *
13309 + sr__set_item_str_resp__unpack
13310 + (ProtobufCAllocator *allocator,
13311 + size_t len,
13312 + const uint8_t *data);
13313 +void sr__set_item_str_resp__free_unpacked
13314 + (Sr__SetItemStrResp *message,
13315 + ProtobufCAllocator *allocator);
13316 +/* Sr__DeleteItemReq methods */
13317 +void sr__delete_item_req__init
13318 + (Sr__DeleteItemReq *message);
13319 +size_t sr__delete_item_req__get_packed_size
13320 + (const Sr__DeleteItemReq *message);
13321 +size_t sr__delete_item_req__pack
13322 + (const Sr__DeleteItemReq *message,
13323 + uint8_t *out);
13324 +size_t sr__delete_item_req__pack_to_buffer
13325 + (const Sr__DeleteItemReq *message,
13326 + ProtobufCBuffer *buffer);
13327 +Sr__DeleteItemReq *
13328 + sr__delete_item_req__unpack
13329 + (ProtobufCAllocator *allocator,
13330 + size_t len,
13331 + const uint8_t *data);
13332 +void sr__delete_item_req__free_unpacked
13333 + (Sr__DeleteItemReq *message,
13334 + ProtobufCAllocator *allocator);
13335 +/* Sr__DeleteItemResp methods */
13336 +void sr__delete_item_resp__init
13337 + (Sr__DeleteItemResp *message);
13338 +size_t sr__delete_item_resp__get_packed_size
13339 + (const Sr__DeleteItemResp *message);
13340 +size_t sr__delete_item_resp__pack
13341 + (const Sr__DeleteItemResp *message,
13342 + uint8_t *out);
13343 +size_t sr__delete_item_resp__pack_to_buffer
13344 + (const Sr__DeleteItemResp *message,
13345 + ProtobufCBuffer *buffer);
13346 +Sr__DeleteItemResp *
13347 + sr__delete_item_resp__unpack
13348 + (ProtobufCAllocator *allocator,
13349 + size_t len,
13350 + const uint8_t *data);
13351 +void sr__delete_item_resp__free_unpacked
13352 + (Sr__DeleteItemResp *message,
13353 + ProtobufCAllocator *allocator);
13354 +/* Sr__MoveItemReq methods */
13355 +void sr__move_item_req__init
13356 + (Sr__MoveItemReq *message);
13357 +size_t sr__move_item_req__get_packed_size
13358 + (const Sr__MoveItemReq *message);
13359 +size_t sr__move_item_req__pack
13360 + (const Sr__MoveItemReq *message,
13361 + uint8_t *out);
13362 +size_t sr__move_item_req__pack_to_buffer
13363 + (const Sr__MoveItemReq *message,
13364 + ProtobufCBuffer *buffer);
13365 +Sr__MoveItemReq *
13366 + sr__move_item_req__unpack
13367 + (ProtobufCAllocator *allocator,
13368 + size_t len,
13369 + const uint8_t *data);
13370 +void sr__move_item_req__free_unpacked
13371 + (Sr__MoveItemReq *message,
13372 + ProtobufCAllocator *allocator);
13373 +/* Sr__MoveItemResp methods */
13374 +void sr__move_item_resp__init
13375 + (Sr__MoveItemResp *message);
13376 +size_t sr__move_item_resp__get_packed_size
13377 + (const Sr__MoveItemResp *message);
13378 +size_t sr__move_item_resp__pack
13379 + (const Sr__MoveItemResp *message,
13380 + uint8_t *out);
13381 +size_t sr__move_item_resp__pack_to_buffer
13382 + (const Sr__MoveItemResp *message,
13383 + ProtobufCBuffer *buffer);
13384 +Sr__MoveItemResp *
13385 + sr__move_item_resp__unpack
13386 + (ProtobufCAllocator *allocator,
13387 + size_t len,
13388 + const uint8_t *data);
13389 +void sr__move_item_resp__free_unpacked
13390 + (Sr__MoveItemResp *message,
13391 + ProtobufCAllocator *allocator);
13392 +/* Sr__ValidateReq methods */
13393 +void sr__validate_req__init
13394 + (Sr__ValidateReq *message);
13395 +size_t sr__validate_req__get_packed_size
13396 + (const Sr__ValidateReq *message);
13397 +size_t sr__validate_req__pack
13398 + (const Sr__ValidateReq *message,
13399 + uint8_t *out);
13400 +size_t sr__validate_req__pack_to_buffer
13401 + (const Sr__ValidateReq *message,
13402 + ProtobufCBuffer *buffer);
13403 +Sr__ValidateReq *
13404 + sr__validate_req__unpack
13405 + (ProtobufCAllocator *allocator,
13406 + size_t len,
13407 + const uint8_t *data);
13408 +void sr__validate_req__free_unpacked
13409 + (Sr__ValidateReq *message,
13410 + ProtobufCAllocator *allocator);
13411 +/* Sr__ValidateResp methods */
13412 +void sr__validate_resp__init
13413 + (Sr__ValidateResp *message);
13414 +size_t sr__validate_resp__get_packed_size
13415 + (const Sr__ValidateResp *message);
13416 +size_t sr__validate_resp__pack
13417 + (const Sr__ValidateResp *message,
13418 + uint8_t *out);
13419 +size_t sr__validate_resp__pack_to_buffer
13420 + (const Sr__ValidateResp *message,
13421 + ProtobufCBuffer *buffer);
13422 +Sr__ValidateResp *
13423 + sr__validate_resp__unpack
13424 + (ProtobufCAllocator *allocator,
13425 + size_t len,
13426 + const uint8_t *data);
13427 +void sr__validate_resp__free_unpacked
13428 + (Sr__ValidateResp *message,
13429 + ProtobufCAllocator *allocator);
13430 +/* Sr__CommitReq methods */
13431 +void sr__commit_req__init
13432 + (Sr__CommitReq *message);
13433 +size_t sr__commit_req__get_packed_size
13434 + (const Sr__CommitReq *message);
13435 +size_t sr__commit_req__pack
13436 + (const Sr__CommitReq *message,
13437 + uint8_t *out);
13438 +size_t sr__commit_req__pack_to_buffer
13439 + (const Sr__CommitReq *message,
13440 + ProtobufCBuffer *buffer);
13441 +Sr__CommitReq *
13442 + sr__commit_req__unpack
13443 + (ProtobufCAllocator *allocator,
13444 + size_t len,
13445 + const uint8_t *data);
13446 +void sr__commit_req__free_unpacked
13447 + (Sr__CommitReq *message,
13448 + ProtobufCAllocator *allocator);
13449 +/* Sr__CommitResp methods */
13450 +void sr__commit_resp__init
13451 + (Sr__CommitResp *message);
13452 +size_t sr__commit_resp__get_packed_size
13453 + (const Sr__CommitResp *message);
13454 +size_t sr__commit_resp__pack
13455 + (const Sr__CommitResp *message,
13456 + uint8_t *out);
13457 +size_t sr__commit_resp__pack_to_buffer
13458 + (const Sr__CommitResp *message,
13459 + ProtobufCBuffer *buffer);
13460 +Sr__CommitResp *
13461 + sr__commit_resp__unpack
13462 + (ProtobufCAllocator *allocator,
13463 + size_t len,
13464 + const uint8_t *data);
13465 +void sr__commit_resp__free_unpacked
13466 + (Sr__CommitResp *message,
13467 + ProtobufCAllocator *allocator);
13468 +/* Sr__DiscardChangesReq methods */
13469 +void sr__discard_changes_req__init
13470 + (Sr__DiscardChangesReq *message);
13471 +size_t sr__discard_changes_req__get_packed_size
13472 + (const Sr__DiscardChangesReq *message);
13473 +size_t sr__discard_changes_req__pack
13474 + (const Sr__DiscardChangesReq *message,
13475 + uint8_t *out);
13476 +size_t sr__discard_changes_req__pack_to_buffer
13477 + (const Sr__DiscardChangesReq *message,
13478 + ProtobufCBuffer *buffer);
13479 +Sr__DiscardChangesReq *
13480 + sr__discard_changes_req__unpack
13481 + (ProtobufCAllocator *allocator,
13482 + size_t len,
13483 + const uint8_t *data);
13484 +void sr__discard_changes_req__free_unpacked
13485 + (Sr__DiscardChangesReq *message,
13486 + ProtobufCAllocator *allocator);
13487 +/* Sr__DiscardChangesResp methods */
13488 +void sr__discard_changes_resp__init
13489 + (Sr__DiscardChangesResp *message);
13490 +size_t sr__discard_changes_resp__get_packed_size
13491 + (const Sr__DiscardChangesResp *message);
13492 +size_t sr__discard_changes_resp__pack
13493 + (const Sr__DiscardChangesResp *message,
13494 + uint8_t *out);
13495 +size_t sr__discard_changes_resp__pack_to_buffer
13496 + (const Sr__DiscardChangesResp *message,
13497 + ProtobufCBuffer *buffer);
13498 +Sr__DiscardChangesResp *
13499 + sr__discard_changes_resp__unpack
13500 + (ProtobufCAllocator *allocator,
13501 + size_t len,
13502 + const uint8_t *data);
13503 +void sr__discard_changes_resp__free_unpacked
13504 + (Sr__DiscardChangesResp *message,
13505 + ProtobufCAllocator *allocator);
13506 +/* Sr__CopyConfigReq methods */
13507 +void sr__copy_config_req__init
13508 + (Sr__CopyConfigReq *message);
13509 +size_t sr__copy_config_req__get_packed_size
13510 + (const Sr__CopyConfigReq *message);
13511 +size_t sr__copy_config_req__pack
13512 + (const Sr__CopyConfigReq *message,
13513 + uint8_t *out);
13514 +size_t sr__copy_config_req__pack_to_buffer
13515 + (const Sr__CopyConfigReq *message,
13516 + ProtobufCBuffer *buffer);
13517 +Sr__CopyConfigReq *
13518 + sr__copy_config_req__unpack
13519 + (ProtobufCAllocator *allocator,
13520 + size_t len,
13521 + const uint8_t *data);
13522 +void sr__copy_config_req__free_unpacked
13523 + (Sr__CopyConfigReq *message,
13524 + ProtobufCAllocator *allocator);
13525 +/* Sr__CopyConfigResp methods */
13526 +void sr__copy_config_resp__init
13527 + (Sr__CopyConfigResp *message);
13528 +size_t sr__copy_config_resp__get_packed_size
13529 + (const Sr__CopyConfigResp *message);
13530 +size_t sr__copy_config_resp__pack
13531 + (const Sr__CopyConfigResp *message,
13532 + uint8_t *out);
13533 +size_t sr__copy_config_resp__pack_to_buffer
13534 + (const Sr__CopyConfigResp *message,
13535 + ProtobufCBuffer *buffer);
13536 +Sr__CopyConfigResp *
13537 + sr__copy_config_resp__unpack
13538 + (ProtobufCAllocator *allocator,
13539 + size_t len,
13540 + const uint8_t *data);
13541 +void sr__copy_config_resp__free_unpacked
13542 + (Sr__CopyConfigResp *message,
13543 + ProtobufCAllocator *allocator);
13544 +/* Sr__LockReq methods */
13545 +void sr__lock_req__init
13546 + (Sr__LockReq *message);
13547 +size_t sr__lock_req__get_packed_size
13548 + (const Sr__LockReq *message);
13549 +size_t sr__lock_req__pack
13550 + (const Sr__LockReq *message,
13551 + uint8_t *out);
13552 +size_t sr__lock_req__pack_to_buffer
13553 + (const Sr__LockReq *message,
13554 + ProtobufCBuffer *buffer);
13555 +Sr__LockReq *
13556 + sr__lock_req__unpack
13557 + (ProtobufCAllocator *allocator,
13558 + size_t len,
13559 + const uint8_t *data);
13560 +void sr__lock_req__free_unpacked
13561 + (Sr__LockReq *message,
13562 + ProtobufCAllocator *allocator);
13563 +/* Sr__LockResp methods */
13564 +void sr__lock_resp__init
13565 + (Sr__LockResp *message);
13566 +size_t sr__lock_resp__get_packed_size
13567 + (const Sr__LockResp *message);
13568 +size_t sr__lock_resp__pack
13569 + (const Sr__LockResp *message,
13570 + uint8_t *out);
13571 +size_t sr__lock_resp__pack_to_buffer
13572 + (const Sr__LockResp *message,
13573 + ProtobufCBuffer *buffer);
13574 +Sr__LockResp *
13575 + sr__lock_resp__unpack
13576 + (ProtobufCAllocator *allocator,
13577 + size_t len,
13578 + const uint8_t *data);
13579 +void sr__lock_resp__free_unpacked
13580 + (Sr__LockResp *message,
13581 + ProtobufCAllocator *allocator);
13582 +/* Sr__UnlockReq methods */
13583 +void sr__unlock_req__init
13584 + (Sr__UnlockReq *message);
13585 +size_t sr__unlock_req__get_packed_size
13586 + (const Sr__UnlockReq *message);
13587 +size_t sr__unlock_req__pack
13588 + (const Sr__UnlockReq *message,
13589 + uint8_t *out);
13590 +size_t sr__unlock_req__pack_to_buffer
13591 + (const Sr__UnlockReq *message,
13592 + ProtobufCBuffer *buffer);
13593 +Sr__UnlockReq *
13594 + sr__unlock_req__unpack
13595 + (ProtobufCAllocator *allocator,
13596 + size_t len,
13597 + const uint8_t *data);
13598 +void sr__unlock_req__free_unpacked
13599 + (Sr__UnlockReq *message,
13600 + ProtobufCAllocator *allocator);
13601 +/* Sr__UnlockResp methods */
13602 +void sr__unlock_resp__init
13603 + (Sr__UnlockResp *message);
13604 +size_t sr__unlock_resp__get_packed_size
13605 + (const Sr__UnlockResp *message);
13606 +size_t sr__unlock_resp__pack
13607 + (const Sr__UnlockResp *message,
13608 + uint8_t *out);
13609 +size_t sr__unlock_resp__pack_to_buffer
13610 + (const Sr__UnlockResp *message,
13611 + ProtobufCBuffer *buffer);
13612 +Sr__UnlockResp *
13613 + sr__unlock_resp__unpack
13614 + (ProtobufCAllocator *allocator,
13615 + size_t len,
13616 + const uint8_t *data);
13617 +void sr__unlock_resp__free_unpacked
13618 + (Sr__UnlockResp *message,
13619 + ProtobufCAllocator *allocator);
13620 +/* Sr__SubscribeReq methods */
13621 +void sr__subscribe_req__init
13622 + (Sr__SubscribeReq *message);
13623 +size_t sr__subscribe_req__get_packed_size
13624 + (const Sr__SubscribeReq *message);
13625 +size_t sr__subscribe_req__pack
13626 + (const Sr__SubscribeReq *message,
13627 + uint8_t *out);
13628 +size_t sr__subscribe_req__pack_to_buffer
13629 + (const Sr__SubscribeReq *message,
13630 + ProtobufCBuffer *buffer);
13631 +Sr__SubscribeReq *
13632 + sr__subscribe_req__unpack
13633 + (ProtobufCAllocator *allocator,
13634 + size_t len,
13635 + const uint8_t *data);
13636 +void sr__subscribe_req__free_unpacked
13637 + (Sr__SubscribeReq *message,
13638 + ProtobufCAllocator *allocator);
13639 +/* Sr__SubscribeResp methods */
13640 +void sr__subscribe_resp__init
13641 + (Sr__SubscribeResp *message);
13642 +size_t sr__subscribe_resp__get_packed_size
13643 + (const Sr__SubscribeResp *message);
13644 +size_t sr__subscribe_resp__pack
13645 + (const Sr__SubscribeResp *message,
13646 + uint8_t *out);
13647 +size_t sr__subscribe_resp__pack_to_buffer
13648 + (const Sr__SubscribeResp *message,
13649 + ProtobufCBuffer *buffer);
13650 +Sr__SubscribeResp *
13651 + sr__subscribe_resp__unpack
13652 + (ProtobufCAllocator *allocator,
13653 + size_t len,
13654 + const uint8_t *data);
13655 +void sr__subscribe_resp__free_unpacked
13656 + (Sr__SubscribeResp *message,
13657 + ProtobufCAllocator *allocator);
13658 +/* Sr__UnsubscribeReq methods */
13659 +void sr__unsubscribe_req__init
13660 + (Sr__UnsubscribeReq *message);
13661 +size_t sr__unsubscribe_req__get_packed_size
13662 + (const Sr__UnsubscribeReq *message);
13663 +size_t sr__unsubscribe_req__pack
13664 + (const Sr__UnsubscribeReq *message,
13665 + uint8_t *out);
13666 +size_t sr__unsubscribe_req__pack_to_buffer
13667 + (const Sr__UnsubscribeReq *message,
13668 + ProtobufCBuffer *buffer);
13669 +Sr__UnsubscribeReq *
13670 + sr__unsubscribe_req__unpack
13671 + (ProtobufCAllocator *allocator,
13672 + size_t len,
13673 + const uint8_t *data);
13674 +void sr__unsubscribe_req__free_unpacked
13675 + (Sr__UnsubscribeReq *message,
13676 + ProtobufCAllocator *allocator);
13677 +/* Sr__UnsubscribeResp methods */
13678 +void sr__unsubscribe_resp__init
13679 + (Sr__UnsubscribeResp *message);
13680 +size_t sr__unsubscribe_resp__get_packed_size
13681 + (const Sr__UnsubscribeResp *message);
13682 +size_t sr__unsubscribe_resp__pack
13683 + (const Sr__UnsubscribeResp *message,
13684 + uint8_t *out);
13685 +size_t sr__unsubscribe_resp__pack_to_buffer
13686 + (const Sr__UnsubscribeResp *message,
13687 + ProtobufCBuffer *buffer);
13688 +Sr__UnsubscribeResp *
13689 + sr__unsubscribe_resp__unpack
13690 + (ProtobufCAllocator *allocator,
13691 + size_t len,
13692 + const uint8_t *data);
13693 +void sr__unsubscribe_resp__free_unpacked
13694 + (Sr__UnsubscribeResp *message,
13695 + ProtobufCAllocator *allocator);
13696 +/* Sr__CheckEnabledRunningReq methods */
13697 +void sr__check_enabled_running_req__init
13698 + (Sr__CheckEnabledRunningReq *message);
13699 +size_t sr__check_enabled_running_req__get_packed_size
13700 + (const Sr__CheckEnabledRunningReq *message);
13701 +size_t sr__check_enabled_running_req__pack
13702 + (const Sr__CheckEnabledRunningReq *message,
13703 + uint8_t *out);
13704 +size_t sr__check_enabled_running_req__pack_to_buffer
13705 + (const Sr__CheckEnabledRunningReq *message,
13706 + ProtobufCBuffer *buffer);
13707 +Sr__CheckEnabledRunningReq *
13708 + sr__check_enabled_running_req__unpack
13709 + (ProtobufCAllocator *allocator,
13710 + size_t len,
13711 + const uint8_t *data);
13712 +void sr__check_enabled_running_req__free_unpacked
13713 + (Sr__CheckEnabledRunningReq *message,
13714 + ProtobufCAllocator *allocator);
13715 +/* Sr__CheckEnabledRunningResp methods */
13716 +void sr__check_enabled_running_resp__init
13717 + (Sr__CheckEnabledRunningResp *message);
13718 +size_t sr__check_enabled_running_resp__get_packed_size
13719 + (const Sr__CheckEnabledRunningResp *message);
13720 +size_t sr__check_enabled_running_resp__pack
13721 + (const Sr__CheckEnabledRunningResp *message,
13722 + uint8_t *out);
13723 +size_t sr__check_enabled_running_resp__pack_to_buffer
13724 + (const Sr__CheckEnabledRunningResp *message,
13725 + ProtobufCBuffer *buffer);
13726 +Sr__CheckEnabledRunningResp *
13727 + sr__check_enabled_running_resp__unpack
13728 + (ProtobufCAllocator *allocator,
13729 + size_t len,
13730 + const uint8_t *data);
13731 +void sr__check_enabled_running_resp__free_unpacked
13732 + (Sr__CheckEnabledRunningResp *message,
13733 + ProtobufCAllocator *allocator);
13734 +/* Sr__ModuleInstallNotification methods */
13735 +void sr__module_install_notification__init
13736 + (Sr__ModuleInstallNotification *message);
13737 +size_t sr__module_install_notification__get_packed_size
13738 + (const Sr__ModuleInstallNotification *message);
13739 +size_t sr__module_install_notification__pack
13740 + (const Sr__ModuleInstallNotification *message,
13741 + uint8_t *out);
13742 +size_t sr__module_install_notification__pack_to_buffer
13743 + (const Sr__ModuleInstallNotification *message,
13744 + ProtobufCBuffer *buffer);
13745 +Sr__ModuleInstallNotification *
13746 + sr__module_install_notification__unpack
13747 + (ProtobufCAllocator *allocator,
13748 + size_t len,
13749 + const uint8_t *data);
13750 +void sr__module_install_notification__free_unpacked
13751 + (Sr__ModuleInstallNotification *message,
13752 + ProtobufCAllocator *allocator);
13753 +/* Sr__FeatureEnableNotification methods */
13754 +void sr__feature_enable_notification__init
13755 + (Sr__FeatureEnableNotification *message);
13756 +size_t sr__feature_enable_notification__get_packed_size
13757 + (const Sr__FeatureEnableNotification *message);
13758 +size_t sr__feature_enable_notification__pack
13759 + (const Sr__FeatureEnableNotification *message,
13760 + uint8_t *out);
13761 +size_t sr__feature_enable_notification__pack_to_buffer
13762 + (const Sr__FeatureEnableNotification *message,
13763 + ProtobufCBuffer *buffer);
13764 +Sr__FeatureEnableNotification *
13765 + sr__feature_enable_notification__unpack
13766 + (ProtobufCAllocator *allocator,
13767 + size_t len,
13768 + const uint8_t *data);
13769 +void sr__feature_enable_notification__free_unpacked
13770 + (Sr__FeatureEnableNotification *message,
13771 + ProtobufCAllocator *allocator);
13772 +/* Sr__ModuleChangeNotification methods */
13773 +void sr__module_change_notification__init
13774 + (Sr__ModuleChangeNotification *message);
13775 +size_t sr__module_change_notification__get_packed_size
13776 + (const Sr__ModuleChangeNotification *message);
13777 +size_t sr__module_change_notification__pack
13778 + (const Sr__ModuleChangeNotification *message,
13779 + uint8_t *out);
13780 +size_t sr__module_change_notification__pack_to_buffer
13781 + (const Sr__ModuleChangeNotification *message,
13782 + ProtobufCBuffer *buffer);
13783 +Sr__ModuleChangeNotification *
13784 + sr__module_change_notification__unpack
13785 + (ProtobufCAllocator *allocator,
13786 + size_t len,
13787 + const uint8_t *data);
13788 +void sr__module_change_notification__free_unpacked
13789 + (Sr__ModuleChangeNotification *message,
13790 + ProtobufCAllocator *allocator);
13791 +/* Sr__SubtreeChangeNotification methods */
13792 +void sr__subtree_change_notification__init
13793 + (Sr__SubtreeChangeNotification *message);
13794 +size_t sr__subtree_change_notification__get_packed_size
13795 + (const Sr__SubtreeChangeNotification *message);
13796 +size_t sr__subtree_change_notification__pack
13797 + (const Sr__SubtreeChangeNotification *message,
13798 + uint8_t *out);
13799 +size_t sr__subtree_change_notification__pack_to_buffer
13800 + (const Sr__SubtreeChangeNotification *message,
13801 + ProtobufCBuffer *buffer);
13802 +Sr__SubtreeChangeNotification *
13803 + sr__subtree_change_notification__unpack
13804 + (ProtobufCAllocator *allocator,
13805 + size_t len,
13806 + const uint8_t *data);
13807 +void sr__subtree_change_notification__free_unpacked
13808 + (Sr__SubtreeChangeNotification *message,
13809 + ProtobufCAllocator *allocator);
13810 +/* Sr__Change methods */
13811 +void sr__change__init
13812 + (Sr__Change *message);
13813 +size_t sr__change__get_packed_size
13814 + (const Sr__Change *message);
13815 +size_t sr__change__pack
13816 + (const Sr__Change *message,
13817 + uint8_t *out);
13818 +size_t sr__change__pack_to_buffer
13819 + (const Sr__Change *message,
13820 + ProtobufCBuffer *buffer);
13821 +Sr__Change *
13822 + sr__change__unpack
13823 + (ProtobufCAllocator *allocator,
13824 + size_t len,
13825 + const uint8_t *data);
13826 +void sr__change__free_unpacked
13827 + (Sr__Change *message,
13828 + ProtobufCAllocator *allocator);
13829 +/* Sr__GetChangesReq methods */
13830 +void sr__get_changes_req__init
13831 + (Sr__GetChangesReq *message);
13832 +size_t sr__get_changes_req__get_packed_size
13833 + (const Sr__GetChangesReq *message);
13834 +size_t sr__get_changes_req__pack
13835 + (const Sr__GetChangesReq *message,
13836 + uint8_t *out);
13837 +size_t sr__get_changes_req__pack_to_buffer
13838 + (const Sr__GetChangesReq *message,
13839 + ProtobufCBuffer *buffer);
13840 +Sr__GetChangesReq *
13841 + sr__get_changes_req__unpack
13842 + (ProtobufCAllocator *allocator,
13843 + size_t len,
13844 + const uint8_t *data);
13845 +void sr__get_changes_req__free_unpacked
13846 + (Sr__GetChangesReq *message,
13847 + ProtobufCAllocator *allocator);
13848 +/* Sr__GetChangesResp methods */
13849 +void sr__get_changes_resp__init
13850 + (Sr__GetChangesResp *message);
13851 +size_t sr__get_changes_resp__get_packed_size
13852 + (const Sr__GetChangesResp *message);
13853 +size_t sr__get_changes_resp__pack
13854 + (const Sr__GetChangesResp *message,
13855 + uint8_t *out);
13856 +size_t sr__get_changes_resp__pack_to_buffer
13857 + (const Sr__GetChangesResp *message,
13858 + ProtobufCBuffer *buffer);
13859 +Sr__GetChangesResp *
13860 + sr__get_changes_resp__unpack
13861 + (ProtobufCAllocator *allocator,
13862 + size_t len,
13863 + const uint8_t *data);
13864 +void sr__get_changes_resp__free_unpacked
13865 + (Sr__GetChangesResp *message,
13866 + ProtobufCAllocator *allocator);
13867 +/* Sr__CheckExecPermReq methods */
13868 +void sr__check_exec_perm_req__init
13869 + (Sr__CheckExecPermReq *message);
13870 +size_t sr__check_exec_perm_req__get_packed_size
13871 + (const Sr__CheckExecPermReq *message);
13872 +size_t sr__check_exec_perm_req__pack
13873 + (const Sr__CheckExecPermReq *message,
13874 + uint8_t *out);
13875 +size_t sr__check_exec_perm_req__pack_to_buffer
13876 + (const Sr__CheckExecPermReq *message,
13877 + ProtobufCBuffer *buffer);
13878 +Sr__CheckExecPermReq *
13879 + sr__check_exec_perm_req__unpack
13880 + (ProtobufCAllocator *allocator,
13881 + size_t len,
13882 + const uint8_t *data);
13883 +void sr__check_exec_perm_req__free_unpacked
13884 + (Sr__CheckExecPermReq *message,
13885 + ProtobufCAllocator *allocator);
13886 +/* Sr__CheckExecPermResp methods */
13887 +void sr__check_exec_perm_resp__init
13888 + (Sr__CheckExecPermResp *message);
13889 +size_t sr__check_exec_perm_resp__get_packed_size
13890 + (const Sr__CheckExecPermResp *message);
13891 +size_t sr__check_exec_perm_resp__pack
13892 + (const Sr__CheckExecPermResp *message,
13893 + uint8_t *out);
13894 +size_t sr__check_exec_perm_resp__pack_to_buffer
13895 + (const Sr__CheckExecPermResp *message,
13896 + ProtobufCBuffer *buffer);
13897 +Sr__CheckExecPermResp *
13898 + sr__check_exec_perm_resp__unpack
13899 + (ProtobufCAllocator *allocator,
13900 + size_t len,
13901 + const uint8_t *data);
13902 +void sr__check_exec_perm_resp__free_unpacked
13903 + (Sr__CheckExecPermResp *message,
13904 + ProtobufCAllocator *allocator);
13905 +/* Sr__RPCReq methods */
13906 +void sr__rpcreq__init
13907 + (Sr__RPCReq *message);
13908 +size_t sr__rpcreq__get_packed_size
13909 + (const Sr__RPCReq *message);
13910 +size_t sr__rpcreq__pack
13911 + (const Sr__RPCReq *message,
13912 + uint8_t *out);
13913 +size_t sr__rpcreq__pack_to_buffer
13914 + (const Sr__RPCReq *message,
13915 + ProtobufCBuffer *buffer);
13916 +Sr__RPCReq *
13917 + sr__rpcreq__unpack
13918 + (ProtobufCAllocator *allocator,
13919 + size_t len,
13920 + const uint8_t *data);
13921 +void sr__rpcreq__free_unpacked
13922 + (Sr__RPCReq *message,
13923 + ProtobufCAllocator *allocator);
13924 +/* Sr__RPCResp methods */
13925 +void sr__rpcresp__init
13926 + (Sr__RPCResp *message);
13927 +size_t sr__rpcresp__get_packed_size
13928 + (const Sr__RPCResp *message);
13929 +size_t sr__rpcresp__pack
13930 + (const Sr__RPCResp *message,
13931 + uint8_t *out);
13932 +size_t sr__rpcresp__pack_to_buffer
13933 + (const Sr__RPCResp *message,
13934 + ProtobufCBuffer *buffer);
13935 +Sr__RPCResp *
13936 + sr__rpcresp__unpack
13937 + (ProtobufCAllocator *allocator,
13938 + size_t len,
13939 + const uint8_t *data);
13940 +void sr__rpcresp__free_unpacked
13941 + (Sr__RPCResp *message,
13942 + ProtobufCAllocator *allocator);
13943 +/* Sr__EventNotifReq methods */
13944 +void sr__event_notif_req__init
13945 + (Sr__EventNotifReq *message);
13946 +size_t sr__event_notif_req__get_packed_size
13947 + (const Sr__EventNotifReq *message);
13948 +size_t sr__event_notif_req__pack
13949 + (const Sr__EventNotifReq *message,
13950 + uint8_t *out);
13951 +size_t sr__event_notif_req__pack_to_buffer
13952 + (const Sr__EventNotifReq *message,
13953 + ProtobufCBuffer *buffer);
13954 +Sr__EventNotifReq *
13955 + sr__event_notif_req__unpack
13956 + (ProtobufCAllocator *allocator,
13957 + size_t len,
13958 + const uint8_t *data);
13959 +void sr__event_notif_req__free_unpacked
13960 + (Sr__EventNotifReq *message,
13961 + ProtobufCAllocator *allocator);
13962 +/* Sr__EventNotifResp methods */
13963 +void sr__event_notif_resp__init
13964 + (Sr__EventNotifResp *message);
13965 +size_t sr__event_notif_resp__get_packed_size
13966 + (const Sr__EventNotifResp *message);
13967 +size_t sr__event_notif_resp__pack
13968 + (const Sr__EventNotifResp *message,
13969 + uint8_t *out);
13970 +size_t sr__event_notif_resp__pack_to_buffer
13971 + (const Sr__EventNotifResp *message,
13972 + ProtobufCBuffer *buffer);
13973 +Sr__EventNotifResp *
13974 + sr__event_notif_resp__unpack
13975 + (ProtobufCAllocator *allocator,
13976 + size_t len,
13977 + const uint8_t *data);
13978 +void sr__event_notif_resp__free_unpacked
13979 + (Sr__EventNotifResp *message,
13980 + ProtobufCAllocator *allocator);
13981 +/* Sr__EventNotifReplayReq methods */
13982 +void sr__event_notif_replay_req__init
13983 + (Sr__EventNotifReplayReq *message);
13984 +size_t sr__event_notif_replay_req__get_packed_size
13985 + (const Sr__EventNotifReplayReq *message);
13986 +size_t sr__event_notif_replay_req__pack
13987 + (const Sr__EventNotifReplayReq *message,
13988 + uint8_t *out);
13989 +size_t sr__event_notif_replay_req__pack_to_buffer
13990 + (const Sr__EventNotifReplayReq *message,
13991 + ProtobufCBuffer *buffer);
13992 +Sr__EventNotifReplayReq *
13993 + sr__event_notif_replay_req__unpack
13994 + (ProtobufCAllocator *allocator,
13995 + size_t len,
13996 + const uint8_t *data);
13997 +void sr__event_notif_replay_req__free_unpacked
13998 + (Sr__EventNotifReplayReq *message,
13999 + ProtobufCAllocator *allocator);
14000 +/* Sr__EventNotifReplayResp methods */
14001 +void sr__event_notif_replay_resp__init
14002 + (Sr__EventNotifReplayResp *message);
14003 +size_t sr__event_notif_replay_resp__get_packed_size
14004 + (const Sr__EventNotifReplayResp *message);
14005 +size_t sr__event_notif_replay_resp__pack
14006 + (const Sr__EventNotifReplayResp *message,
14007 + uint8_t *out);
14008 +size_t sr__event_notif_replay_resp__pack_to_buffer
14009 + (const Sr__EventNotifReplayResp *message,
14010 + ProtobufCBuffer *buffer);
14011 +Sr__EventNotifReplayResp *
14012 + sr__event_notif_replay_resp__unpack
14013 + (ProtobufCAllocator *allocator,
14014 + size_t len,
14015 + const uint8_t *data);
14016 +void sr__event_notif_replay_resp__free_unpacked
14017 + (Sr__EventNotifReplayResp *message,
14018 + ProtobufCAllocator *allocator);
14019 +/* Sr__DataProvideReq methods */
14020 +void sr__data_provide_req__init
14021 + (Sr__DataProvideReq *message);
14022 +size_t sr__data_provide_req__get_packed_size
14023 + (const Sr__DataProvideReq *message);
14024 +size_t sr__data_provide_req__pack
14025 + (const Sr__DataProvideReq *message,
14026 + uint8_t *out);
14027 +size_t sr__data_provide_req__pack_to_buffer
14028 + (const Sr__DataProvideReq *message,
14029 + ProtobufCBuffer *buffer);
14030 +Sr__DataProvideReq *
14031 + sr__data_provide_req__unpack
14032 + (ProtobufCAllocator *allocator,
14033 + size_t len,
14034 + const uint8_t *data);
14035 +void sr__data_provide_req__free_unpacked
14036 + (Sr__DataProvideReq *message,
14037 + ProtobufCAllocator *allocator);
14038 +/* Sr__DataProvideResp methods */
14039 +void sr__data_provide_resp__init
14040 + (Sr__DataProvideResp *message);
14041 +size_t sr__data_provide_resp__get_packed_size
14042 + (const Sr__DataProvideResp *message);
14043 +size_t sr__data_provide_resp__pack
14044 + (const Sr__DataProvideResp *message,
14045 + uint8_t *out);
14046 +size_t sr__data_provide_resp__pack_to_buffer
14047 + (const Sr__DataProvideResp *message,
14048 + ProtobufCBuffer *buffer);
14049 +Sr__DataProvideResp *
14050 + sr__data_provide_resp__unpack
14051 + (ProtobufCAllocator *allocator,
14052 + size_t len,
14053 + const uint8_t *data);
14054 +void sr__data_provide_resp__free_unpacked
14055 + (Sr__DataProvideResp *message,
14056 + ProtobufCAllocator *allocator);
14057 +/* Sr__ModuleInstallReq methods */
14058 +void sr__module_install_req__init
14059 + (Sr__ModuleInstallReq *message);
14060 +size_t sr__module_install_req__get_packed_size
14061 + (const Sr__ModuleInstallReq *message);
14062 +size_t sr__module_install_req__pack
14063 + (const Sr__ModuleInstallReq *message,
14064 + uint8_t *out);
14065 +size_t sr__module_install_req__pack_to_buffer
14066 + (const Sr__ModuleInstallReq *message,
14067 + ProtobufCBuffer *buffer);
14068 +Sr__ModuleInstallReq *
14069 + sr__module_install_req__unpack
14070 + (ProtobufCAllocator *allocator,
14071 + size_t len,
14072 + const uint8_t *data);
14073 +void sr__module_install_req__free_unpacked
14074 + (Sr__ModuleInstallReq *message,
14075 + ProtobufCAllocator *allocator);
14076 +/* Sr__ModuleInstallResp methods */
14077 +void sr__module_install_resp__init
14078 + (Sr__ModuleInstallResp *message);
14079 +size_t sr__module_install_resp__get_packed_size
14080 + (const Sr__ModuleInstallResp *message);
14081 +size_t sr__module_install_resp__pack
14082 + (const Sr__ModuleInstallResp *message,
14083 + uint8_t *out);
14084 +size_t sr__module_install_resp__pack_to_buffer
14085 + (const Sr__ModuleInstallResp *message,
14086 + ProtobufCBuffer *buffer);
14087 +Sr__ModuleInstallResp *
14088 + sr__module_install_resp__unpack
14089 + (ProtobufCAllocator *allocator,
14090 + size_t len,
14091 + const uint8_t *data);
14092 +void sr__module_install_resp__free_unpacked
14093 + (Sr__ModuleInstallResp *message,
14094 + ProtobufCAllocator *allocator);
14095 +/* Sr__FeatureEnableReq methods */
14096 +void sr__feature_enable_req__init
14097 + (Sr__FeatureEnableReq *message);
14098 +size_t sr__feature_enable_req__get_packed_size
14099 + (const Sr__FeatureEnableReq *message);
14100 +size_t sr__feature_enable_req__pack
14101 + (const Sr__FeatureEnableReq *message,
14102 + uint8_t *out);
14103 +size_t sr__feature_enable_req__pack_to_buffer
14104 + (const Sr__FeatureEnableReq *message,
14105 + ProtobufCBuffer *buffer);
14106 +Sr__FeatureEnableReq *
14107 + sr__feature_enable_req__unpack
14108 + (ProtobufCAllocator *allocator,
14109 + size_t len,
14110 + const uint8_t *data);
14111 +void sr__feature_enable_req__free_unpacked
14112 + (Sr__FeatureEnableReq *message,
14113 + ProtobufCAllocator *allocator);
14114 +/* Sr__FeatureEnableResp methods */
14115 +void sr__feature_enable_resp__init
14116 + (Sr__FeatureEnableResp *message);
14117 +size_t sr__feature_enable_resp__get_packed_size
14118 + (const Sr__FeatureEnableResp *message);
14119 +size_t sr__feature_enable_resp__pack
14120 + (const Sr__FeatureEnableResp *message,
14121 + uint8_t *out);
14122 +size_t sr__feature_enable_resp__pack_to_buffer
14123 + (const Sr__FeatureEnableResp *message,
14124 + ProtobufCBuffer *buffer);
14125 +Sr__FeatureEnableResp *
14126 + sr__feature_enable_resp__unpack
14127 + (ProtobufCAllocator *allocator,
14128 + size_t len,
14129 + const uint8_t *data);
14130 +void sr__feature_enable_resp__free_unpacked
14131 + (Sr__FeatureEnableResp *message,
14132 + ProtobufCAllocator *allocator);
14133 +/* Sr__UnsubscribeDestinationReq methods */
14134 +void sr__unsubscribe_destination_req__init
14135 + (Sr__UnsubscribeDestinationReq *message);
14136 +size_t sr__unsubscribe_destination_req__get_packed_size
14137 + (const Sr__UnsubscribeDestinationReq *message);
14138 +size_t sr__unsubscribe_destination_req__pack
14139 + (const Sr__UnsubscribeDestinationReq *message,
14140 + uint8_t *out);
14141 +size_t sr__unsubscribe_destination_req__pack_to_buffer
14142 + (const Sr__UnsubscribeDestinationReq *message,
14143 + ProtobufCBuffer *buffer);
14144 +Sr__UnsubscribeDestinationReq *
14145 + sr__unsubscribe_destination_req__unpack
14146 + (ProtobufCAllocator *allocator,
14147 + size_t len,
14148 + const uint8_t *data);
14149 +void sr__unsubscribe_destination_req__free_unpacked
14150 + (Sr__UnsubscribeDestinationReq *message,
14151 + ProtobufCAllocator *allocator);
14152 +/* Sr__CommitTimeoutReq methods */
14153 +void sr__commit_timeout_req__init
14154 + (Sr__CommitTimeoutReq *message);
14155 +size_t sr__commit_timeout_req__get_packed_size
14156 + (const Sr__CommitTimeoutReq *message);
14157 +size_t sr__commit_timeout_req__pack
14158 + (const Sr__CommitTimeoutReq *message,
14159 + uint8_t *out);
14160 +size_t sr__commit_timeout_req__pack_to_buffer
14161 + (const Sr__CommitTimeoutReq *message,
14162 + ProtobufCBuffer *buffer);
14163 +Sr__CommitTimeoutReq *
14164 + sr__commit_timeout_req__unpack
14165 + (ProtobufCAllocator *allocator,
14166 + size_t len,
14167 + const uint8_t *data);
14168 +void sr__commit_timeout_req__free_unpacked
14169 + (Sr__CommitTimeoutReq *message,
14170 + ProtobufCAllocator *allocator);
14171 +/* Sr__OperDataTimeoutReq methods */
14172 +void sr__oper_data_timeout_req__init
14173 + (Sr__OperDataTimeoutReq *message);
14174 +size_t sr__oper_data_timeout_req__get_packed_size
14175 + (const Sr__OperDataTimeoutReq *message);
14176 +size_t sr__oper_data_timeout_req__pack
14177 + (const Sr__OperDataTimeoutReq *message,
14178 + uint8_t *out);
14179 +size_t sr__oper_data_timeout_req__pack_to_buffer
14180 + (const Sr__OperDataTimeoutReq *message,
14181 + ProtobufCBuffer *buffer);
14182 +Sr__OperDataTimeoutReq *
14183 + sr__oper_data_timeout_req__unpack
14184 + (ProtobufCAllocator *allocator,
14185 + size_t len,
14186 + const uint8_t *data);
14187 +void sr__oper_data_timeout_req__free_unpacked
14188 + (Sr__OperDataTimeoutReq *message,
14189 + ProtobufCAllocator *allocator);
14190 +/* Sr__InternalStateDataReq methods */
14191 +void sr__internal_state_data_req__init
14192 + (Sr__InternalStateDataReq *message);
14193 +size_t sr__internal_state_data_req__get_packed_size
14194 + (const Sr__InternalStateDataReq *message);
14195 +size_t sr__internal_state_data_req__pack
14196 + (const Sr__InternalStateDataReq *message,
14197 + uint8_t *out);
14198 +size_t sr__internal_state_data_req__pack_to_buffer
14199 + (const Sr__InternalStateDataReq *message,
14200 + ProtobufCBuffer *buffer);
14201 +Sr__InternalStateDataReq *
14202 + sr__internal_state_data_req__unpack
14203 + (ProtobufCAllocator *allocator,
14204 + size_t len,
14205 + const uint8_t *data);
14206 +void sr__internal_state_data_req__free_unpacked
14207 + (Sr__InternalStateDataReq *message,
14208 + ProtobufCAllocator *allocator);
14209 +/* Sr__NotifStoreCleanupReq methods */
14210 +void sr__notif_store_cleanup_req__init
14211 + (Sr__NotifStoreCleanupReq *message);
14212 +size_t sr__notif_store_cleanup_req__get_packed_size
14213 + (const Sr__NotifStoreCleanupReq *message);
14214 +size_t sr__notif_store_cleanup_req__pack
14215 + (const Sr__NotifStoreCleanupReq *message,
14216 + uint8_t *out);
14217 +size_t sr__notif_store_cleanup_req__pack_to_buffer
14218 + (const Sr__NotifStoreCleanupReq *message,
14219 + ProtobufCBuffer *buffer);
14220 +Sr__NotifStoreCleanupReq *
14221 + sr__notif_store_cleanup_req__unpack
14222 + (ProtobufCAllocator *allocator,
14223 + size_t len,
14224 + const uint8_t *data);
14225 +void sr__notif_store_cleanup_req__free_unpacked
14226 + (Sr__NotifStoreCleanupReq *message,
14227 + ProtobufCAllocator *allocator);
14228 +/* Sr__DelayedMsgReq methods */
14229 +void sr__delayed_msg_req__init
14230 + (Sr__DelayedMsgReq *message);
14231 +size_t sr__delayed_msg_req__get_packed_size
14232 + (const Sr__DelayedMsgReq *message);
14233 +size_t sr__delayed_msg_req__pack
14234 + (const Sr__DelayedMsgReq *message,
14235 + uint8_t *out);
14236 +size_t sr__delayed_msg_req__pack_to_buffer
14237 + (const Sr__DelayedMsgReq *message,
14238 + ProtobufCBuffer *buffer);
14239 +Sr__DelayedMsgReq *
14240 + sr__delayed_msg_req__unpack
14241 + (ProtobufCAllocator *allocator,
14242 + size_t len,
14243 + const uint8_t *data);
14244 +void sr__delayed_msg_req__free_unpacked
14245 + (Sr__DelayedMsgReq *message,
14246 + ProtobufCAllocator *allocator);
14247 +/* Sr__NacmReloadReq methods */
14248 +void sr__nacm_reload_req__init
14249 + (Sr__NacmReloadReq *message);
14250 +size_t sr__nacm_reload_req__get_packed_size
14251 + (const Sr__NacmReloadReq *message);
14252 +size_t sr__nacm_reload_req__pack
14253 + (const Sr__NacmReloadReq *message,
14254 + uint8_t *out);
14255 +size_t sr__nacm_reload_req__pack_to_buffer
14256 + (const Sr__NacmReloadReq *message,
14257 + ProtobufCBuffer *buffer);
14258 +Sr__NacmReloadReq *
14259 + sr__nacm_reload_req__unpack
14260 + (ProtobufCAllocator *allocator,
14261 + size_t len,
14262 + const uint8_t *data);
14263 +void sr__nacm_reload_req__free_unpacked
14264 + (Sr__NacmReloadReq *message,
14265 + ProtobufCAllocator *allocator);
14266 +/* Sr__Request methods */
14267 +void sr__request__init
14268 + (Sr__Request *message);
14269 +size_t sr__request__get_packed_size
14270 + (const Sr__Request *message);
14271 +size_t sr__request__pack
14272 + (const Sr__Request *message,
14273 + uint8_t *out);
14274 +size_t sr__request__pack_to_buffer
14275 + (const Sr__Request *message,
14276 + ProtobufCBuffer *buffer);
14277 +Sr__Request *
14278 + sr__request__unpack
14279 + (ProtobufCAllocator *allocator,
14280 + size_t len,
14281 + const uint8_t *data);
14282 +void sr__request__free_unpacked
14283 + (Sr__Request *message,
14284 + ProtobufCAllocator *allocator);
14285 +/* Sr__Response methods */
14286 +void sr__response__init
14287 + (Sr__Response *message);
14288 +size_t sr__response__get_packed_size
14289 + (const Sr__Response *message);
14290 +size_t sr__response__pack
14291 + (const Sr__Response *message,
14292 + uint8_t *out);
14293 +size_t sr__response__pack_to_buffer
14294 + (const Sr__Response *message,
14295 + ProtobufCBuffer *buffer);
14296 +Sr__Response *
14297 + sr__response__unpack
14298 + (ProtobufCAllocator *allocator,
14299 + size_t len,
14300 + const uint8_t *data);
14301 +void sr__response__free_unpacked
14302 + (Sr__Response *message,
14303 + ProtobufCAllocator *allocator);
14304 +/* Sr__Notification methods */
14305 +void sr__notification__init
14306 + (Sr__Notification *message);
14307 +size_t sr__notification__get_packed_size
14308 + (const Sr__Notification *message);
14309 +size_t sr__notification__pack
14310 + (const Sr__Notification *message,
14311 + uint8_t *out);
14312 +size_t sr__notification__pack_to_buffer
14313 + (const Sr__Notification *message,
14314 + ProtobufCBuffer *buffer);
14315 +Sr__Notification *
14316 + sr__notification__unpack
14317 + (ProtobufCAllocator *allocator,
14318 + size_t len,
14319 + const uint8_t *data);
14320 +void sr__notification__free_unpacked
14321 + (Sr__Notification *message,
14322 + ProtobufCAllocator *allocator);
14323 +/* Sr__NotificationAck methods */
14324 +void sr__notification_ack__init
14325 + (Sr__NotificationAck *message);
14326 +size_t sr__notification_ack__get_packed_size
14327 + (const Sr__NotificationAck *message);
14328 +size_t sr__notification_ack__pack
14329 + (const Sr__NotificationAck *message,
14330 + uint8_t *out);
14331 +size_t sr__notification_ack__pack_to_buffer
14332 + (const Sr__NotificationAck *message,
14333 + ProtobufCBuffer *buffer);
14334 +Sr__NotificationAck *
14335 + sr__notification_ack__unpack
14336 + (ProtobufCAllocator *allocator,
14337 + size_t len,
14338 + const uint8_t *data);
14339 +void sr__notification_ack__free_unpacked
14340 + (Sr__NotificationAck *message,
14341 + ProtobufCAllocator *allocator);
14342 +/* Sr__InternalRequest methods */
14343 +void sr__internal_request__init
14344 + (Sr__InternalRequest *message);
14345 +size_t sr__internal_request__get_packed_size
14346 + (const Sr__InternalRequest *message);
14347 +size_t sr__internal_request__pack
14348 + (const Sr__InternalRequest *message,
14349 + uint8_t *out);
14350 +size_t sr__internal_request__pack_to_buffer
14351 + (const Sr__InternalRequest *message,
14352 + ProtobufCBuffer *buffer);
14353 +Sr__InternalRequest *
14354 + sr__internal_request__unpack
14355 + (ProtobufCAllocator *allocator,
14356 + size_t len,
14357 + const uint8_t *data);
14358 +void sr__internal_request__free_unpacked
14359 + (Sr__InternalRequest *message,
14360 + ProtobufCAllocator *allocator);
14361 +/* Sr__Msg methods */
14362 +void sr__msg__init
14363 + (Sr__Msg *message);
14364 +size_t sr__msg__get_packed_size
14365 + (const Sr__Msg *message);
14366 +size_t sr__msg__pack
14367 + (const Sr__Msg *message,
14368 + uint8_t *out);
14369 +size_t sr__msg__pack_to_buffer
14370 + (const Sr__Msg *message,
14371 + ProtobufCBuffer *buffer);
14372 +Sr__Msg *
14373 + sr__msg__unpack
14374 + (ProtobufCAllocator *allocator,
14375 + size_t len,
14376 + const uint8_t *data);
14377 +void sr__msg__free_unpacked
14378 + (Sr__Msg *message,
14379 + ProtobufCAllocator *allocator);
14380 +/* --- per-message closures --- */
14381 +
14382 +typedef void (*Sr__Value_Closure)
14383 + (const Sr__Value *message,
14384 + void *closure_data);
14385 +typedef void (*Sr__Node_Closure)
14386 + (const Sr__Node *message,
14387 + void *closure_data);
14388 +typedef void (*Sr__Error_Closure)
14389 + (const Sr__Error *message,
14390 + void *closure_data);
14391 +typedef void (*Sr__SessionStartReq_Closure)
14392 + (const Sr__SessionStartReq *message,
14393 + void *closure_data);
14394 +typedef void (*Sr__SessionStartResp_Closure)
14395 + (const Sr__SessionStartResp *message,
14396 + void *closure_data);
14397 +typedef void (*Sr__SessionStopReq_Closure)
14398 + (const Sr__SessionStopReq *message,
14399 + void *closure_data);
14400 +typedef void (*Sr__SessionStopResp_Closure)
14401 + (const Sr__SessionStopResp *message,
14402 + void *closure_data);
14403 +typedef void (*Sr__SessionRefreshReq_Closure)
14404 + (const Sr__SessionRefreshReq *message,
14405 + void *closure_data);
14406 +typedef void (*Sr__SessionRefreshResp_Closure)
14407 + (const Sr__SessionRefreshResp *message,
14408 + void *closure_data);
14409 +typedef void (*Sr__SessionCheckReq_Closure)
14410 + (const Sr__SessionCheckReq *message,
14411 + void *closure_data);
14412 +typedef void (*Sr__SessionCheckResp_Closure)
14413 + (const Sr__SessionCheckResp *message,
14414 + void *closure_data);
14415 +typedef void (*Sr__SessionSwitchDsReq_Closure)
14416 + (const Sr__SessionSwitchDsReq *message,
14417 + void *closure_data);
14418 +typedef void (*Sr__SessionSwitchDsResp_Closure)
14419 + (const Sr__SessionSwitchDsResp *message,
14420 + void *closure_data);
14421 +typedef void (*Sr__SessionSetOptsReq_Closure)
14422 + (const Sr__SessionSetOptsReq *message,
14423 + void *closure_data);
14424 +typedef void (*Sr__SessionSetOptsResp_Closure)
14425 + (const Sr__SessionSetOptsResp *message,
14426 + void *closure_data);
14427 +typedef void (*Sr__VersionVerifyReq_Closure)
14428 + (const Sr__VersionVerifyReq *message,
14429 + void *closure_data);
14430 +typedef void (*Sr__VersionVerifyResp_Closure)
14431 + (const Sr__VersionVerifyResp *message,
14432 + void *closure_data);
14433 +typedef void (*Sr__SchemaRevision_Closure)
14434 + (const Sr__SchemaRevision *message,
14435 + void *closure_data);
14436 +typedef void (*Sr__SchemaSubmodule_Closure)
14437 + (const Sr__SchemaSubmodule *message,
14438 + void *closure_data);
14439 +typedef void (*Sr__Schema_Closure)
14440 + (const Sr__Schema *message,
14441 + void *closure_data);
14442 +typedef void (*Sr__ListSchemasReq_Closure)
14443 + (const Sr__ListSchemasReq *message,
14444 + void *closure_data);
14445 +typedef void (*Sr__ListSchemasResp_Closure)
14446 + (const Sr__ListSchemasResp *message,
14447 + void *closure_data);
14448 +typedef void (*Sr__GetSchemaReq_Closure)
14449 + (const Sr__GetSchemaReq *message,
14450 + void *closure_data);
14451 +typedef void (*Sr__GetSchemaResp_Closure)
14452 + (const Sr__GetSchemaResp *message,
14453 + void *closure_data);
14454 +typedef void (*Sr__GetItemReq_Closure)
14455 + (const Sr__GetItemReq *message,
14456 + void *closure_data);
14457 +typedef void (*Sr__GetItemResp_Closure)
14458 + (const Sr__GetItemResp *message,
14459 + void *closure_data);
14460 +typedef void (*Sr__GetItemsReq_Closure)
14461 + (const Sr__GetItemsReq *message,
14462 + void *closure_data);
14463 +typedef void (*Sr__GetItemsResp_Closure)
14464 + (const Sr__GetItemsResp *message,
14465 + void *closure_data);
14466 +typedef void (*Sr__GetSubtreeReq_Closure)
14467 + (const Sr__GetSubtreeReq *message,
14468 + void *closure_data);
14469 +typedef void (*Sr__GetSubtreeResp_Closure)
14470 + (const Sr__GetSubtreeResp *message,
14471 + void *closure_data);
14472 +typedef void (*Sr__GetSubtreesReq_Closure)
14473 + (const Sr__GetSubtreesReq *message,
14474 + void *closure_data);
14475 +typedef void (*Sr__GetSubtreesResp_Closure)
14476 + (const Sr__GetSubtreesResp *message,
14477 + void *closure_data);
14478 +typedef void (*Sr__GetSubtreeChunkReq_Closure)
14479 + (const Sr__GetSubtreeChunkReq *message,
14480 + void *closure_data);
14481 +typedef void (*Sr__GetSubtreeChunkResp_Closure)
14482 + (const Sr__GetSubtreeChunkResp *message,
14483 + void *closure_data);
14484 +typedef void (*Sr__SetItemReq_Closure)
14485 + (const Sr__SetItemReq *message,
14486 + void *closure_data);
14487 +typedef void (*Sr__SetItemResp_Closure)
14488 + (const Sr__SetItemResp *message,
14489 + void *closure_data);
14490 +typedef void (*Sr__SetItemStrReq_Closure)
14491 + (const Sr__SetItemStrReq *message,
14492 + void *closure_data);
14493 +typedef void (*Sr__SetItemStrResp_Closure)
14494 + (const Sr__SetItemStrResp *message,
14495 + void *closure_data);
14496 +typedef void (*Sr__DeleteItemReq_Closure)
14497 + (const Sr__DeleteItemReq *message,
14498 + void *closure_data);
14499 +typedef void (*Sr__DeleteItemResp_Closure)
14500 + (const Sr__DeleteItemResp *message,
14501 + void *closure_data);
14502 +typedef void (*Sr__MoveItemReq_Closure)
14503 + (const Sr__MoveItemReq *message,
14504 + void *closure_data);
14505 +typedef void (*Sr__MoveItemResp_Closure)
14506 + (const Sr__MoveItemResp *message,
14507 + void *closure_data);
14508 +typedef void (*Sr__ValidateReq_Closure)
14509 + (const Sr__ValidateReq *message,
14510 + void *closure_data);
14511 +typedef void (*Sr__ValidateResp_Closure)
14512 + (const Sr__ValidateResp *message,
14513 + void *closure_data);
14514 +typedef void (*Sr__CommitReq_Closure)
14515 + (const Sr__CommitReq *message,
14516 + void *closure_data);
14517 +typedef void (*Sr__CommitResp_Closure)
14518 + (const Sr__CommitResp *message,
14519 + void *closure_data);
14520 +typedef void (*Sr__DiscardChangesReq_Closure)
14521 + (const Sr__DiscardChangesReq *message,
14522 + void *closure_data);
14523 +typedef void (*Sr__DiscardChangesResp_Closure)
14524 + (const Sr__DiscardChangesResp *message,
14525 + void *closure_data);
14526 +typedef void (*Sr__CopyConfigReq_Closure)
14527 + (const Sr__CopyConfigReq *message,
14528 + void *closure_data);
14529 +typedef void (*Sr__CopyConfigResp_Closure)
14530 + (const Sr__CopyConfigResp *message,
14531 + void *closure_data);
14532 +typedef void (*Sr__LockReq_Closure)
14533 + (const Sr__LockReq *message,
14534 + void *closure_data);
14535 +typedef void (*Sr__LockResp_Closure)
14536 + (const Sr__LockResp *message,
14537 + void *closure_data);
14538 +typedef void (*Sr__UnlockReq_Closure)
14539 + (const Sr__UnlockReq *message,
14540 + void *closure_data);
14541 +typedef void (*Sr__UnlockResp_Closure)
14542 + (const Sr__UnlockResp *message,
14543 + void *closure_data);
14544 +typedef void (*Sr__SubscribeReq_Closure)
14545 + (const Sr__SubscribeReq *message,
14546 + void *closure_data);
14547 +typedef void (*Sr__SubscribeResp_Closure)
14548 + (const Sr__SubscribeResp *message,
14549 + void *closure_data);
14550 +typedef void (*Sr__UnsubscribeReq_Closure)
14551 + (const Sr__UnsubscribeReq *message,
14552 + void *closure_data);
14553 +typedef void (*Sr__UnsubscribeResp_Closure)
14554 + (const Sr__UnsubscribeResp *message,
14555 + void *closure_data);
14556 +typedef void (*Sr__CheckEnabledRunningReq_Closure)
14557 + (const Sr__CheckEnabledRunningReq *message,
14558 + void *closure_data);
14559 +typedef void (*Sr__CheckEnabledRunningResp_Closure)
14560 + (const Sr__CheckEnabledRunningResp *message,
14561 + void *closure_data);
14562 +typedef void (*Sr__ModuleInstallNotification_Closure)
14563 + (const Sr__ModuleInstallNotification *message,
14564 + void *closure_data);
14565 +typedef void (*Sr__FeatureEnableNotification_Closure)
14566 + (const Sr__FeatureEnableNotification *message,
14567 + void *closure_data);
14568 +typedef void (*Sr__ModuleChangeNotification_Closure)
14569 + (const Sr__ModuleChangeNotification *message,
14570 + void *closure_data);
14571 +typedef void (*Sr__SubtreeChangeNotification_Closure)
14572 + (const Sr__SubtreeChangeNotification *message,
14573 + void *closure_data);
14574 +typedef void (*Sr__Change_Closure)
14575 + (const Sr__Change *message,
14576 + void *closure_data);
14577 +typedef void (*Sr__GetChangesReq_Closure)
14578 + (const Sr__GetChangesReq *message,
14579 + void *closure_data);
14580 +typedef void (*Sr__GetChangesResp_Closure)
14581 + (const Sr__GetChangesResp *message,
14582 + void *closure_data);
14583 +typedef void (*Sr__CheckExecPermReq_Closure)
14584 + (const Sr__CheckExecPermReq *message,
14585 + void *closure_data);
14586 +typedef void (*Sr__CheckExecPermResp_Closure)
14587 + (const Sr__CheckExecPermResp *message,
14588 + void *closure_data);
14589 +typedef void (*Sr__RPCReq_Closure)
14590 + (const Sr__RPCReq *message,
14591 + void *closure_data);
14592 +typedef void (*Sr__RPCResp_Closure)
14593 + (const Sr__RPCResp *message,
14594 + void *closure_data);
14595 +typedef void (*Sr__EventNotifReq_Closure)
14596 + (const Sr__EventNotifReq *message,
14597 + void *closure_data);
14598 +typedef void (*Sr__EventNotifResp_Closure)
14599 + (const Sr__EventNotifResp *message,
14600 + void *closure_data);
14601 +typedef void (*Sr__EventNotifReplayReq_Closure)
14602 + (const Sr__EventNotifReplayReq *message,
14603 + void *closure_data);
14604 +typedef void (*Sr__EventNotifReplayResp_Closure)
14605 + (const Sr__EventNotifReplayResp *message,
14606 + void *closure_data);
14607 +typedef void (*Sr__DataProvideReq_Closure)
14608 + (const Sr__DataProvideReq *message,
14609 + void *closure_data);
14610 +typedef void (*Sr__DataProvideResp_Closure)
14611 + (const Sr__DataProvideResp *message,
14612 + void *closure_data);
14613 +typedef void (*Sr__ModuleInstallReq_Closure)
14614 + (const Sr__ModuleInstallReq *message,
14615 + void *closure_data);
14616 +typedef void (*Sr__ModuleInstallResp_Closure)
14617 + (const Sr__ModuleInstallResp *message,
14618 + void *closure_data);
14619 +typedef void (*Sr__FeatureEnableReq_Closure)
14620 + (const Sr__FeatureEnableReq *message,
14621 + void *closure_data);
14622 +typedef void (*Sr__FeatureEnableResp_Closure)
14623 + (const Sr__FeatureEnableResp *message,
14624 + void *closure_data);
14625 +typedef void (*Sr__UnsubscribeDestinationReq_Closure)
14626 + (const Sr__UnsubscribeDestinationReq *message,
14627 + void *closure_data);
14628 +typedef void (*Sr__CommitTimeoutReq_Closure)
14629 + (const Sr__CommitTimeoutReq *message,
14630 + void *closure_data);
14631 +typedef void (*Sr__OperDataTimeoutReq_Closure)
14632 + (const Sr__OperDataTimeoutReq *message,
14633 + void *closure_data);
14634 +typedef void (*Sr__InternalStateDataReq_Closure)
14635 + (const Sr__InternalStateDataReq *message,
14636 + void *closure_data);
14637 +typedef void (*Sr__NotifStoreCleanupReq_Closure)
14638 + (const Sr__NotifStoreCleanupReq *message,
14639 + void *closure_data);
14640 +typedef void (*Sr__DelayedMsgReq_Closure)
14641 + (const Sr__DelayedMsgReq *message,
14642 + void *closure_data);
14643 +typedef void (*Sr__NacmReloadReq_Closure)
14644 + (const Sr__NacmReloadReq *message,
14645 + void *closure_data);
14646 +typedef void (*Sr__Request_Closure)
14647 + (const Sr__Request *message,
14648 + void *closure_data);
14649 +typedef void (*Sr__Response_Closure)
14650 + (const Sr__Response *message,
14651 + void *closure_data);
14652 +typedef void (*Sr__Notification_Closure)
14653 + (const Sr__Notification *message,
14654 + void *closure_data);
14655 +typedef void (*Sr__NotificationAck_Closure)
14656 + (const Sr__NotificationAck *message,
14657 + void *closure_data);
14658 +typedef void (*Sr__InternalRequest_Closure)
14659 + (const Sr__InternalRequest *message,
14660 + void *closure_data);
14661 +typedef void (*Sr__Msg_Closure)
14662 + (const Sr__Msg *message,
14663 + void *closure_data);
14664 +
14665 +/* --- services --- */
14666 +
14667 +
14668 +/* --- descriptors --- */
14669 +
14670 +extern const ProtobufCEnumDescriptor sr__api_variant__descriptor;
14671 +extern const ProtobufCEnumDescriptor sr__data_store__descriptor;
14672 +extern const ProtobufCEnumDescriptor sr__session_flags__descriptor;
14673 +extern const ProtobufCEnumDescriptor sr__edit_flags__descriptor;
14674 +extern const ProtobufCEnumDescriptor sr__subscription_type__descriptor;
14675 +extern const ProtobufCEnumDescriptor sr__notification_event__descriptor;
14676 +extern const ProtobufCEnumDescriptor sr__module_state__descriptor;
14677 +extern const ProtobufCEnumDescriptor sr__change_operation__descriptor;
14678 +extern const ProtobufCEnumDescriptor sr__operation__descriptor;
14679 +extern const ProtobufCMessageDescriptor sr__value__descriptor;
14680 +extern const ProtobufCEnumDescriptor sr__value__types__descriptor;
14681 +extern const ProtobufCMessageDescriptor sr__node__descriptor;
14682 +extern const ProtobufCMessageDescriptor sr__error__descriptor;
14683 +extern const ProtobufCMessageDescriptor sr__session_start_req__descriptor;
14684 +extern const ProtobufCMessageDescriptor sr__session_start_resp__descriptor;
14685 +extern const ProtobufCMessageDescriptor sr__session_stop_req__descriptor;
14686 +extern const ProtobufCMessageDescriptor sr__session_stop_resp__descriptor;
14687 +extern const ProtobufCMessageDescriptor sr__session_refresh_req__descriptor;
14688 +extern const ProtobufCMessageDescriptor sr__session_refresh_resp__descriptor;
14689 +extern const ProtobufCMessageDescriptor sr__session_check_req__descriptor;
14690 +extern const ProtobufCMessageDescriptor sr__session_check_resp__descriptor;
14691 +extern const ProtobufCMessageDescriptor sr__session_switch_ds_req__descriptor;
14692 +extern const ProtobufCMessageDescriptor sr__session_switch_ds_resp__descriptor;
14693 +extern const ProtobufCMessageDescriptor sr__session_set_opts_req__descriptor;
14694 +extern const ProtobufCMessageDescriptor sr__session_set_opts_resp__descriptor;
14695 +extern const ProtobufCMessageDescriptor sr__version_verify_req__descriptor;
14696 +extern const ProtobufCMessageDescriptor sr__version_verify_resp__descriptor;
14697 +extern const ProtobufCMessageDescriptor sr__schema_revision__descriptor;
14698 +extern const ProtobufCMessageDescriptor sr__schema_submodule__descriptor;
14699 +extern const ProtobufCMessageDescriptor sr__schema__descriptor;
14700 +extern const ProtobufCMessageDescriptor sr__list_schemas_req__descriptor;
14701 +extern const ProtobufCMessageDescriptor sr__list_schemas_resp__descriptor;
14702 +extern const ProtobufCMessageDescriptor sr__get_schema_req__descriptor;
14703 +extern const ProtobufCMessageDescriptor sr__get_schema_resp__descriptor;
14704 +extern const ProtobufCMessageDescriptor sr__get_item_req__descriptor;
14705 +extern const ProtobufCMessageDescriptor sr__get_item_resp__descriptor;
14706 +extern const ProtobufCMessageDescriptor sr__get_items_req__descriptor;
14707 +extern const ProtobufCMessageDescriptor sr__get_items_resp__descriptor;
14708 +extern const ProtobufCMessageDescriptor sr__get_subtree_req__descriptor;
14709 +extern const ProtobufCMessageDescriptor sr__get_subtree_resp__descriptor;
14710 +extern const ProtobufCMessageDescriptor sr__get_subtrees_req__descriptor;
14711 +extern const ProtobufCMessageDescriptor sr__get_subtrees_resp__descriptor;
14712 +extern const ProtobufCMessageDescriptor sr__get_subtree_chunk_req__descriptor;
14713 +extern const ProtobufCMessageDescriptor sr__get_subtree_chunk_resp__descriptor;
14714 +extern const ProtobufCMessageDescriptor sr__set_item_req__descriptor;
14715 +extern const ProtobufCMessageDescriptor sr__set_item_resp__descriptor;
14716 +extern const ProtobufCMessageDescriptor sr__set_item_str_req__descriptor;
14717 +extern const ProtobufCMessageDescriptor sr__set_item_str_resp__descriptor;
14718 +extern const ProtobufCMessageDescriptor sr__delete_item_req__descriptor;
14719 +extern const ProtobufCMessageDescriptor sr__delete_item_resp__descriptor;
14720 +extern const ProtobufCMessageDescriptor sr__move_item_req__descriptor;
14721 +extern const ProtobufCEnumDescriptor sr__move_item_req__move_position__descriptor;
14722 +extern const ProtobufCMessageDescriptor sr__move_item_resp__descriptor;
14723 +extern const ProtobufCMessageDescriptor sr__validate_req__descriptor;
14724 +extern const ProtobufCMessageDescriptor sr__validate_resp__descriptor;
14725 +extern const ProtobufCMessageDescriptor sr__commit_req__descriptor;
14726 +extern const ProtobufCMessageDescriptor sr__commit_resp__descriptor;
14727 +extern const ProtobufCMessageDescriptor sr__discard_changes_req__descriptor;
14728 +extern const ProtobufCMessageDescriptor sr__discard_changes_resp__descriptor;
14729 +extern const ProtobufCMessageDescriptor sr__copy_config_req__descriptor;
14730 +extern const ProtobufCMessageDescriptor sr__copy_config_resp__descriptor;
14731 +extern const ProtobufCMessageDescriptor sr__lock_req__descriptor;
14732 +extern const ProtobufCMessageDescriptor sr__lock_resp__descriptor;
14733 +extern const ProtobufCMessageDescriptor sr__unlock_req__descriptor;
14734 +extern const ProtobufCMessageDescriptor sr__unlock_resp__descriptor;
14735 +extern const ProtobufCMessageDescriptor sr__subscribe_req__descriptor;
14736 +extern const ProtobufCMessageDescriptor sr__subscribe_resp__descriptor;
14737 +extern const ProtobufCMessageDescriptor sr__unsubscribe_req__descriptor;
14738 +extern const ProtobufCMessageDescriptor sr__unsubscribe_resp__descriptor;
14739 +extern const ProtobufCMessageDescriptor sr__check_enabled_running_req__descriptor;
14740 +extern const ProtobufCMessageDescriptor sr__check_enabled_running_resp__descriptor;
14741 +extern const ProtobufCMessageDescriptor sr__module_install_notification__descriptor;
14742 +extern const ProtobufCMessageDescriptor sr__feature_enable_notification__descriptor;
14743 +extern const ProtobufCMessageDescriptor sr__module_change_notification__descriptor;
14744 +extern const ProtobufCMessageDescriptor sr__subtree_change_notification__descriptor;
14745 +extern const ProtobufCMessageDescriptor sr__change__descriptor;
14746 +extern const ProtobufCMessageDescriptor sr__get_changes_req__descriptor;
14747 +extern const ProtobufCMessageDescriptor sr__get_changes_resp__descriptor;
14748 +extern const ProtobufCMessageDescriptor sr__check_exec_perm_req__descriptor;
14749 +extern const ProtobufCMessageDescriptor sr__check_exec_perm_resp__descriptor;
14750 +extern const ProtobufCMessageDescriptor sr__rpcreq__descriptor;
14751 +extern const ProtobufCMessageDescriptor sr__rpcresp__descriptor;
14752 +extern const ProtobufCMessageDescriptor sr__event_notif_req__descriptor;
14753 +extern const ProtobufCEnumDescriptor sr__event_notif_req__notif_type__descriptor;
14754 +extern const ProtobufCEnumDescriptor sr__event_notif_req__notif_flags__descriptor;
14755 +extern const ProtobufCMessageDescriptor sr__event_notif_resp__descriptor;
14756 +extern const ProtobufCMessageDescriptor sr__event_notif_replay_req__descriptor;
14757 +extern const ProtobufCMessageDescriptor sr__event_notif_replay_resp__descriptor;
14758 +extern const ProtobufCMessageDescriptor sr__data_provide_req__descriptor;
14759 +extern const ProtobufCMessageDescriptor sr__data_provide_resp__descriptor;
14760 +extern const ProtobufCMessageDescriptor sr__module_install_req__descriptor;
14761 +extern const ProtobufCMessageDescriptor sr__module_install_resp__descriptor;
14762 +extern const ProtobufCMessageDescriptor sr__feature_enable_req__descriptor;
14763 +extern const ProtobufCMessageDescriptor sr__feature_enable_resp__descriptor;
14764 +extern const ProtobufCMessageDescriptor sr__unsubscribe_destination_req__descriptor;
14765 +extern const ProtobufCMessageDescriptor sr__commit_timeout_req__descriptor;
14766 +extern const ProtobufCMessageDescriptor sr__oper_data_timeout_req__descriptor;
14767 +extern const ProtobufCMessageDescriptor sr__internal_state_data_req__descriptor;
14768 +extern const ProtobufCMessageDescriptor sr__notif_store_cleanup_req__descriptor;
14769 +extern const ProtobufCMessageDescriptor sr__delayed_msg_req__descriptor;
14770 +extern const ProtobufCMessageDescriptor sr__nacm_reload_req__descriptor;
14771 +extern const ProtobufCMessageDescriptor sr__request__descriptor;
14772 +extern const ProtobufCMessageDescriptor sr__response__descriptor;
14773 +extern const ProtobufCMessageDescriptor sr__notification__descriptor;
14774 +extern const ProtobufCMessageDescriptor sr__notification_ack__descriptor;
14775 +extern const ProtobufCMessageDescriptor sr__internal_request__descriptor;
14776 +extern const ProtobufCMessageDescriptor sr__msg__descriptor;
14777 +extern const ProtobufCEnumDescriptor sr__msg__msg_type__descriptor;
14778 +
14779 +PROTOBUF_C__END_DECLS
14780 +
14781 +
14782 +#endif /* PROTOBUF_C_sysrepo_2eproto__INCLUDED */
Mirror of packages feed