projects / feed / packages.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Merge pull request #4853 from StevenHessing/noddos
[feed/packages.git] / net / sysrepo / patches / 001-protobuf-remove-protoc-command-from-cmake-file
1 Index: sysrepo-7aa2f18d234267403147df92c0005c871f0aa840/src/CMakeLists.txt
2 ===================================================================
3 --- sysrepo-7aa2f18d234267403147df92c0005c871f0aa840.orig/src/CMakeLists.txt
4 +++ sysrepo-7aa2f18d234267403147df92c0005c871f0aa840/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-7aa2f18d234267403147df92c0005c871f0aa840/src/common/sysrepo.pb-c.c
21 ===================================================================
22 --- /dev/null
23 +++ sysrepo-7aa2f18d234267403147df92c0005c871f0aa840/src/common/sysrepo.pb-c.c
24 @@ -0,0 +1,10537 @@
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 +static const ProtobufCFieldDescriptor sr__copy_config_resp__field_descriptors[1] =
6522 +{
6523 + {
6524 + "errors",
6525 + 1,
6526 + PROTOBUF_C_LABEL_REPEATED,
6527 + PROTOBUF_C_TYPE_MESSAGE,
6528 + offsetof(Sr__CopyConfigResp, n_errors),
6529 + offsetof(Sr__CopyConfigResp, errors),
6530 + &sr__error__descriptor,
6531 + NULL,
6532 + 0, /* flags */
6533 + 0,NULL,NULL /* reserved1,reserved2, etc */
6534 + },
6535 +};
6536 +static const unsigned sr__copy_config_resp__field_indices_by_name[] = {
6537 + 0, /* field[0] = errors */
6538 +};
6539 +static const ProtobufCIntRange sr__copy_config_resp__number_ranges[1 + 1] =
6540 +{
6541 + { 1, 0 },
6542 + { 0, 1 }
6543 +};
6544 +const ProtobufCMessageDescriptor sr__copy_config_resp__descriptor =
6545 +{
6546 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
6547 + "sr.CopyConfigResp",
6548 + "CopyConfigResp",
6549 + "Sr__CopyConfigResp",
6550 + "sr",
6551 + sizeof(Sr__CopyConfigResp),
6552 + 1,
6553 + sr__copy_config_resp__field_descriptors,
6554 + sr__copy_config_resp__field_indices_by_name,
6555 + 1, sr__copy_config_resp__number_ranges,
6556 + (ProtobufCMessageInit) sr__copy_config_resp__init,
6557 + NULL,NULL,NULL /* reserved[123] */
6558 +};
6559 +static const ProtobufCFieldDescriptor sr__lock_req__field_descriptors[1] =
6560 +{
6561 + {
6562 + "module_name",
6563 + 1,
6564 + PROTOBUF_C_LABEL_OPTIONAL,
6565 + PROTOBUF_C_TYPE_STRING,
6566 + 0, /* quantifier_offset */
6567 + offsetof(Sr__LockReq, module_name),
6568 + NULL,
6569 + NULL,
6570 + 0, /* flags */
6571 + 0,NULL,NULL /* reserved1,reserved2, etc */
6572 + },
6573 +};
6574 +static const unsigned sr__lock_req__field_indices_by_name[] = {
6575 + 0, /* field[0] = module_name */
6576 +};
6577 +static const ProtobufCIntRange sr__lock_req__number_ranges[1 + 1] =
6578 +{
6579 + { 1, 0 },
6580 + { 0, 1 }
6581 +};
6582 +const ProtobufCMessageDescriptor sr__lock_req__descriptor =
6583 +{
6584 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
6585 + "sr.LockReq",
6586 + "LockReq",
6587 + "Sr__LockReq",
6588 + "sr",
6589 + sizeof(Sr__LockReq),
6590 + 1,
6591 + sr__lock_req__field_descriptors,
6592 + sr__lock_req__field_indices_by_name,
6593 + 1, sr__lock_req__number_ranges,
6594 + (ProtobufCMessageInit) sr__lock_req__init,
6595 + NULL,NULL,NULL /* reserved[123] */
6596 +};
6597 +#define sr__lock_resp__field_descriptors NULL
6598 +#define sr__lock_resp__field_indices_by_name NULL
6599 +#define sr__lock_resp__number_ranges NULL
6600 +const ProtobufCMessageDescriptor sr__lock_resp__descriptor =
6601 +{
6602 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
6603 + "sr.LockResp",
6604 + "LockResp",
6605 + "Sr__LockResp",
6606 + "sr",
6607 + sizeof(Sr__LockResp),
6608 + 0,
6609 + sr__lock_resp__field_descriptors,
6610 + sr__lock_resp__field_indices_by_name,
6611 + 0, sr__lock_resp__number_ranges,
6612 + (ProtobufCMessageInit) sr__lock_resp__init,
6613 + NULL,NULL,NULL /* reserved[123] */
6614 +};
6615 +static const ProtobufCFieldDescriptor sr__unlock_req__field_descriptors[1] =
6616 +{
6617 + {
6618 + "module_name",
6619 + 1,
6620 + PROTOBUF_C_LABEL_OPTIONAL,
6621 + PROTOBUF_C_TYPE_STRING,
6622 + 0, /* quantifier_offset */
6623 + offsetof(Sr__UnlockReq, module_name),
6624 + NULL,
6625 + NULL,
6626 + 0, /* flags */
6627 + 0,NULL,NULL /* reserved1,reserved2, etc */
6628 + },
6629 +};
6630 +static const unsigned sr__unlock_req__field_indices_by_name[] = {
6631 + 0, /* field[0] = module_name */
6632 +};
6633 +static const ProtobufCIntRange sr__unlock_req__number_ranges[1 + 1] =
6634 +{
6635 + { 1, 0 },
6636 + { 0, 1 }
6637 +};
6638 +const ProtobufCMessageDescriptor sr__unlock_req__descriptor =
6639 +{
6640 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
6641 + "sr.UnlockReq",
6642 + "UnlockReq",
6643 + "Sr__UnlockReq",
6644 + "sr",
6645 + sizeof(Sr__UnlockReq),
6646 + 1,
6647 + sr__unlock_req__field_descriptors,
6648 + sr__unlock_req__field_indices_by_name,
6649 + 1, sr__unlock_req__number_ranges,
6650 + (ProtobufCMessageInit) sr__unlock_req__init,
6651 + NULL,NULL,NULL /* reserved[123] */
6652 +};
6653 +#define sr__unlock_resp__field_descriptors NULL
6654 +#define sr__unlock_resp__field_indices_by_name NULL
6655 +#define sr__unlock_resp__number_ranges NULL
6656 +const ProtobufCMessageDescriptor sr__unlock_resp__descriptor =
6657 +{
6658 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
6659 + "sr.UnlockResp",
6660 + "UnlockResp",
6661 + "Sr__UnlockResp",
6662 + "sr",
6663 + sizeof(Sr__UnlockResp),
6664 + 0,
6665 + sr__unlock_resp__field_descriptors,
6666 + sr__unlock_resp__field_indices_by_name,
6667 + 0, sr__unlock_resp__number_ranges,
6668 + (ProtobufCMessageInit) sr__unlock_resp__init,
6669 + NULL,NULL,NULL /* reserved[123] */
6670 +};
6671 +static const ProtobufCFieldDescriptor sr__subscribe_req__field_descriptors[10] =
6672 +{
6673 + {
6674 + "type",
6675 + 1,
6676 + PROTOBUF_C_LABEL_REQUIRED,
6677 + PROTOBUF_C_TYPE_ENUM,
6678 + 0, /* quantifier_offset */
6679 + offsetof(Sr__SubscribeReq, type),
6680 + &sr__subscription_type__descriptor,
6681 + NULL,
6682 + 0, /* flags */
6683 + 0,NULL,NULL /* reserved1,reserved2, etc */
6684 + },
6685 + {
6686 + "destination",
6687 + 2,
6688 + PROTOBUF_C_LABEL_REQUIRED,
6689 + PROTOBUF_C_TYPE_STRING,
6690 + 0, /* quantifier_offset */
6691 + offsetof(Sr__SubscribeReq, destination),
6692 + NULL,
6693 + NULL,
6694 + 0, /* flags */
6695 + 0,NULL,NULL /* reserved1,reserved2, etc */
6696 + },
6697 + {
6698 + "subscription_id",
6699 + 3,
6700 + PROTOBUF_C_LABEL_REQUIRED,
6701 + PROTOBUF_C_TYPE_UINT32,
6702 + 0, /* quantifier_offset */
6703 + offsetof(Sr__SubscribeReq, subscription_id),
6704 + NULL,
6705 + NULL,
6706 + 0, /* flags */
6707 + 0,NULL,NULL /* reserved1,reserved2, etc */
6708 + },
6709 + {
6710 + "module_name",
6711 + 4,
6712 + PROTOBUF_C_LABEL_OPTIONAL,
6713 + PROTOBUF_C_TYPE_STRING,
6714 + 0, /* quantifier_offset */
6715 + offsetof(Sr__SubscribeReq, module_name),
6716 + NULL,
6717 + NULL,
6718 + 0, /* flags */
6719 + 0,NULL,NULL /* reserved1,reserved2, etc */
6720 + },
6721 + {
6722 + "xpath",
6723 + 5,
6724 + PROTOBUF_C_LABEL_OPTIONAL,
6725 + PROTOBUF_C_TYPE_STRING,
6726 + 0, /* quantifier_offset */
6727 + offsetof(Sr__SubscribeReq, xpath),
6728 + NULL,
6729 + NULL,
6730 + 0, /* flags */
6731 + 0,NULL,NULL /* reserved1,reserved2, etc */
6732 + },
6733 + {
6734 + "notif_event",
6735 + 10,
6736 + PROTOBUF_C_LABEL_OPTIONAL,
6737 + PROTOBUF_C_TYPE_ENUM,
6738 + offsetof(Sr__SubscribeReq, has_notif_event),
6739 + offsetof(Sr__SubscribeReq, notif_event),
6740 + &sr__notification_event__descriptor,
6741 + NULL,
6742 + 0, /* flags */
6743 + 0,NULL,NULL /* reserved1,reserved2, etc */
6744 + },
6745 + {
6746 + "priority",
6747 + 11,
6748 + PROTOBUF_C_LABEL_OPTIONAL,
6749 + PROTOBUF_C_TYPE_UINT32,
6750 + offsetof(Sr__SubscribeReq, has_priority),
6751 + offsetof(Sr__SubscribeReq, priority),
6752 + NULL,
6753 + NULL,
6754 + 0, /* flags */
6755 + 0,NULL,NULL /* reserved1,reserved2, etc */
6756 + },
6757 + {
6758 + "enable_running",
6759 + 12,
6760 + PROTOBUF_C_LABEL_OPTIONAL,
6761 + PROTOBUF_C_TYPE_BOOL,
6762 + offsetof(Sr__SubscribeReq, has_enable_running),
6763 + offsetof(Sr__SubscribeReq, enable_running),
6764 + NULL,
6765 + NULL,
6766 + 0, /* flags */
6767 + 0,NULL,NULL /* reserved1,reserved2, etc */
6768 + },
6769 + {
6770 + "enable_event",
6771 + 13,
6772 + PROTOBUF_C_LABEL_OPTIONAL,
6773 + PROTOBUF_C_TYPE_BOOL,
6774 + offsetof(Sr__SubscribeReq, has_enable_event),
6775 + offsetof(Sr__SubscribeReq, enable_event),
6776 + NULL,
6777 + NULL,
6778 + 0, /* flags */
6779 + 0,NULL,NULL /* reserved1,reserved2, etc */
6780 + },
6781 + {
6782 + "api_variant",
6783 + 20,
6784 + PROTOBUF_C_LABEL_REQUIRED,
6785 + PROTOBUF_C_TYPE_ENUM,
6786 + 0, /* quantifier_offset */
6787 + offsetof(Sr__SubscribeReq, api_variant),
6788 + &sr__api_variant__descriptor,
6789 + NULL,
6790 + 0, /* flags */
6791 + 0,NULL,NULL /* reserved1,reserved2, etc */
6792 + },
6793 +};
6794 +static const unsigned sr__subscribe_req__field_indices_by_name[] = {
6795 + 9, /* field[9] = api_variant */
6796 + 1, /* field[1] = destination */
6797 + 8, /* field[8] = enable_event */
6798 + 7, /* field[7] = enable_running */
6799 + 3, /* field[3] = module_name */
6800 + 5, /* field[5] = notif_event */
6801 + 6, /* field[6] = priority */
6802 + 2, /* field[2] = subscription_id */
6803 + 0, /* field[0] = type */
6804 + 4, /* field[4] = xpath */
6805 +};
6806 +static const ProtobufCIntRange sr__subscribe_req__number_ranges[3 + 1] =
6807 +{
6808 + { 1, 0 },
6809 + { 10, 5 },
6810 + { 20, 9 },
6811 + { 0, 10 }
6812 +};
6813 +const ProtobufCMessageDescriptor sr__subscribe_req__descriptor =
6814 +{
6815 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
6816 + "sr.SubscribeReq",
6817 + "SubscribeReq",
6818 + "Sr__SubscribeReq",
6819 + "sr",
6820 + sizeof(Sr__SubscribeReq),
6821 + 10,
6822 + sr__subscribe_req__field_descriptors,
6823 + sr__subscribe_req__field_indices_by_name,
6824 + 3, sr__subscribe_req__number_ranges,
6825 + (ProtobufCMessageInit) sr__subscribe_req__init,
6826 + NULL,NULL,NULL /* reserved[123] */
6827 +};
6828 +#define sr__subscribe_resp__field_descriptors NULL
6829 +#define sr__subscribe_resp__field_indices_by_name NULL
6830 +#define sr__subscribe_resp__number_ranges NULL
6831 +const ProtobufCMessageDescriptor sr__subscribe_resp__descriptor =
6832 +{
6833 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
6834 + "sr.SubscribeResp",
6835 + "SubscribeResp",
6836 + "Sr__SubscribeResp",
6837 + "sr",
6838 + sizeof(Sr__SubscribeResp),
6839 + 0,
6840 + sr__subscribe_resp__field_descriptors,
6841 + sr__subscribe_resp__field_indices_by_name,
6842 + 0, sr__subscribe_resp__number_ranges,
6843 + (ProtobufCMessageInit) sr__subscribe_resp__init,
6844 + NULL,NULL,NULL /* reserved[123] */
6845 +};
6846 +static const ProtobufCFieldDescriptor sr__unsubscribe_req__field_descriptors[4] =
6847 +{
6848 + {
6849 + "type",
6850 + 1,
6851 + PROTOBUF_C_LABEL_REQUIRED,
6852 + PROTOBUF_C_TYPE_ENUM,
6853 + 0, /* quantifier_offset */
6854 + offsetof(Sr__UnsubscribeReq, type),
6855 + &sr__subscription_type__descriptor,
6856 + NULL,
6857 + 0, /* flags */
6858 + 0,NULL,NULL /* reserved1,reserved2, etc */
6859 + },
6860 + {
6861 + "destination",
6862 + 2,
6863 + PROTOBUF_C_LABEL_REQUIRED,
6864 + PROTOBUF_C_TYPE_STRING,
6865 + 0, /* quantifier_offset */
6866 + offsetof(Sr__UnsubscribeReq, destination),
6867 + NULL,
6868 + NULL,
6869 + 0, /* flags */
6870 + 0,NULL,NULL /* reserved1,reserved2, etc */
6871 + },
6872 + {
6873 + "subscription_id",
6874 + 3,
6875 + PROTOBUF_C_LABEL_REQUIRED,
6876 + PROTOBUF_C_TYPE_UINT32,
6877 + 0, /* quantifier_offset */
6878 + offsetof(Sr__UnsubscribeReq, subscription_id),
6879 + NULL,
6880 + NULL,
6881 + 0, /* flags */
6882 + 0,NULL,NULL /* reserved1,reserved2, etc */
6883 + },
6884 + {
6885 + "module_name",
6886 + 4,
6887 + PROTOBUF_C_LABEL_OPTIONAL,
6888 + PROTOBUF_C_TYPE_STRING,
6889 + 0, /* quantifier_offset */
6890 + offsetof(Sr__UnsubscribeReq, module_name),
6891 + NULL,
6892 + NULL,
6893 + 0, /* flags */
6894 + 0,NULL,NULL /* reserved1,reserved2, etc */
6895 + },
6896 +};
6897 +static const unsigned sr__unsubscribe_req__field_indices_by_name[] = {
6898 + 1, /* field[1] = destination */
6899 + 3, /* field[3] = module_name */
6900 + 2, /* field[2] = subscription_id */
6901 + 0, /* field[0] = type */
6902 +};
6903 +static const ProtobufCIntRange sr__unsubscribe_req__number_ranges[1 + 1] =
6904 +{
6905 + { 1, 0 },
6906 + { 0, 4 }
6907 +};
6908 +const ProtobufCMessageDescriptor sr__unsubscribe_req__descriptor =
6909 +{
6910 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
6911 + "sr.UnsubscribeReq",
6912 + "UnsubscribeReq",
6913 + "Sr__UnsubscribeReq",
6914 + "sr",
6915 + sizeof(Sr__UnsubscribeReq),
6916 + 4,
6917 + sr__unsubscribe_req__field_descriptors,
6918 + sr__unsubscribe_req__field_indices_by_name,
6919 + 1, sr__unsubscribe_req__number_ranges,
6920 + (ProtobufCMessageInit) sr__unsubscribe_req__init,
6921 + NULL,NULL,NULL /* reserved[123] */
6922 +};
6923 +#define sr__unsubscribe_resp__field_descriptors NULL
6924 +#define sr__unsubscribe_resp__field_indices_by_name NULL
6925 +#define sr__unsubscribe_resp__number_ranges NULL
6926 +const ProtobufCMessageDescriptor sr__unsubscribe_resp__descriptor =
6927 +{
6928 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
6929 + "sr.UnsubscribeResp",
6930 + "UnsubscribeResp",
6931 + "Sr__UnsubscribeResp",
6932 + "sr",
6933 + sizeof(Sr__UnsubscribeResp),
6934 + 0,
6935 + sr__unsubscribe_resp__field_descriptors,
6936 + sr__unsubscribe_resp__field_indices_by_name,
6937 + 0, sr__unsubscribe_resp__number_ranges,
6938 + (ProtobufCMessageInit) sr__unsubscribe_resp__init,
6939 + NULL,NULL,NULL /* reserved[123] */
6940 +};
6941 +static const ProtobufCFieldDescriptor sr__check_enabled_running_req__field_descriptors[1] =
6942 +{
6943 + {
6944 + "module_name",
6945 + 1,
6946 + PROTOBUF_C_LABEL_REQUIRED,
6947 + PROTOBUF_C_TYPE_STRING,
6948 + 0, /* quantifier_offset */
6949 + offsetof(Sr__CheckEnabledRunningReq, module_name),
6950 + NULL,
6951 + NULL,
6952 + 0, /* flags */
6953 + 0,NULL,NULL /* reserved1,reserved2, etc */
6954 + },
6955 +};
6956 +static const unsigned sr__check_enabled_running_req__field_indices_by_name[] = {
6957 + 0, /* field[0] = module_name */
6958 +};
6959 +static const ProtobufCIntRange sr__check_enabled_running_req__number_ranges[1 + 1] =
6960 +{
6961 + { 1, 0 },
6962 + { 0, 1 }
6963 +};
6964 +const ProtobufCMessageDescriptor sr__check_enabled_running_req__descriptor =
6965 +{
6966 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
6967 + "sr.CheckEnabledRunningReq",
6968 + "CheckEnabledRunningReq",
6969 + "Sr__CheckEnabledRunningReq",
6970 + "sr",
6971 + sizeof(Sr__CheckEnabledRunningReq),
6972 + 1,
6973 + sr__check_enabled_running_req__field_descriptors,
6974 + sr__check_enabled_running_req__field_indices_by_name,
6975 + 1, sr__check_enabled_running_req__number_ranges,
6976 + (ProtobufCMessageInit) sr__check_enabled_running_req__init,
6977 + NULL,NULL,NULL /* reserved[123] */
6978 +};
6979 +static const ProtobufCFieldDescriptor sr__check_enabled_running_resp__field_descriptors[1] =
6980 +{
6981 + {
6982 + "enabled",
6983 + 1,
6984 + PROTOBUF_C_LABEL_REQUIRED,
6985 + PROTOBUF_C_TYPE_BOOL,
6986 + 0, /* quantifier_offset */
6987 + offsetof(Sr__CheckEnabledRunningResp, enabled),
6988 + NULL,
6989 + NULL,
6990 + 0, /* flags */
6991 + 0,NULL,NULL /* reserved1,reserved2, etc */
6992 + },
6993 +};
6994 +static const unsigned sr__check_enabled_running_resp__field_indices_by_name[] = {
6995 + 0, /* field[0] = enabled */
6996 +};
6997 +static const ProtobufCIntRange sr__check_enabled_running_resp__number_ranges[1 + 1] =
6998 +{
6999 + { 1, 0 },
7000 + { 0, 1 }
7001 +};
7002 +const ProtobufCMessageDescriptor sr__check_enabled_running_resp__descriptor =
7003 +{
7004 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
7005 + "sr.CheckEnabledRunningResp",
7006 + "CheckEnabledRunningResp",
7007 + "Sr__CheckEnabledRunningResp",
7008 + "sr",
7009 + sizeof(Sr__CheckEnabledRunningResp),
7010 + 1,
7011 + sr__check_enabled_running_resp__field_descriptors,
7012 + sr__check_enabled_running_resp__field_indices_by_name,
7013 + 1, sr__check_enabled_running_resp__number_ranges,
7014 + (ProtobufCMessageInit) sr__check_enabled_running_resp__init,
7015 + NULL,NULL,NULL /* reserved[123] */
7016 +};
7017 +static const ProtobufCFieldDescriptor sr__module_install_notification__field_descriptors[3] =
7018 +{
7019 + {
7020 + "module_name",
7021 + 1,
7022 + PROTOBUF_C_LABEL_OPTIONAL,
7023 + PROTOBUF_C_TYPE_STRING,
7024 + 0, /* quantifier_offset */
7025 + offsetof(Sr__ModuleInstallNotification, module_name),
7026 + NULL,
7027 + NULL,
7028 + 0, /* flags */
7029 + 0,NULL,NULL /* reserved1,reserved2, etc */
7030 + },
7031 + {
7032 + "revision",
7033 + 2,
7034 + PROTOBUF_C_LABEL_OPTIONAL,
7035 + PROTOBUF_C_TYPE_STRING,
7036 + 0, /* quantifier_offset */
7037 + offsetof(Sr__ModuleInstallNotification, revision),
7038 + NULL,
7039 + NULL,
7040 + 0, /* flags */
7041 + 0,NULL,NULL /* reserved1,reserved2, etc */
7042 + },
7043 + {
7044 + "state",
7045 + 3,
7046 + PROTOBUF_C_LABEL_REQUIRED,
7047 + PROTOBUF_C_TYPE_ENUM,
7048 + 0, /* quantifier_offset */
7049 + offsetof(Sr__ModuleInstallNotification, state),
7050 + &sr__module_state__descriptor,
7051 + NULL,
7052 + 0, /* flags */
7053 + 0,NULL,NULL /* reserved1,reserved2, etc */
7054 + },
7055 +};
7056 +static const unsigned sr__module_install_notification__field_indices_by_name[] = {
7057 + 0, /* field[0] = module_name */
7058 + 1, /* field[1] = revision */
7059 + 2, /* field[2] = state */
7060 +};
7061 +static const ProtobufCIntRange sr__module_install_notification__number_ranges[1 + 1] =
7062 +{
7063 + { 1, 0 },
7064 + { 0, 3 }
7065 +};
7066 +const ProtobufCMessageDescriptor sr__module_install_notification__descriptor =
7067 +{
7068 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
7069 + "sr.ModuleInstallNotification",
7070 + "ModuleInstallNotification",
7071 + "Sr__ModuleInstallNotification",
7072 + "sr",
7073 + sizeof(Sr__ModuleInstallNotification),
7074 + 3,
7075 + sr__module_install_notification__field_descriptors,
7076 + sr__module_install_notification__field_indices_by_name,
7077 + 1, sr__module_install_notification__number_ranges,
7078 + (ProtobufCMessageInit) sr__module_install_notification__init,
7079 + NULL,NULL,NULL /* reserved[123] */
7080 +};
7081 +static const ProtobufCFieldDescriptor sr__feature_enable_notification__field_descriptors[3] =
7082 +{
7083 + {
7084 + "module_name",
7085 + 1,
7086 + PROTOBUF_C_LABEL_REQUIRED,
7087 + PROTOBUF_C_TYPE_STRING,
7088 + 0, /* quantifier_offset */
7089 + offsetof(Sr__FeatureEnableNotification, module_name),
7090 + NULL,
7091 + NULL,
7092 + 0, /* flags */
7093 + 0,NULL,NULL /* reserved1,reserved2, etc */
7094 + },
7095 + {
7096 + "feature_name",
7097 + 2,
7098 + PROTOBUF_C_LABEL_REQUIRED,
7099 + PROTOBUF_C_TYPE_STRING,
7100 + 0, /* quantifier_offset */
7101 + offsetof(Sr__FeatureEnableNotification, feature_name),
7102 + NULL,
7103 + NULL,
7104 + 0, /* flags */
7105 + 0,NULL,NULL /* reserved1,reserved2, etc */
7106 + },
7107 + {
7108 + "enabled",
7109 + 3,
7110 + PROTOBUF_C_LABEL_REQUIRED,
7111 + PROTOBUF_C_TYPE_BOOL,
7112 + 0, /* quantifier_offset */
7113 + offsetof(Sr__FeatureEnableNotification, enabled),
7114 + NULL,
7115 + NULL,
7116 + 0, /* flags */
7117 + 0,NULL,NULL /* reserved1,reserved2, etc */
7118 + },
7119 +};
7120 +static const unsigned sr__feature_enable_notification__field_indices_by_name[] = {
7121 + 2, /* field[2] = enabled */
7122 + 1, /* field[1] = feature_name */
7123 + 0, /* field[0] = module_name */
7124 +};
7125 +static const ProtobufCIntRange sr__feature_enable_notification__number_ranges[1 + 1] =
7126 +{
7127 + { 1, 0 },
7128 + { 0, 3 }
7129 +};
7130 +const ProtobufCMessageDescriptor sr__feature_enable_notification__descriptor =
7131 +{
7132 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
7133 + "sr.FeatureEnableNotification",
7134 + "FeatureEnableNotification",
7135 + "Sr__FeatureEnableNotification",
7136 + "sr",
7137 + sizeof(Sr__FeatureEnableNotification),
7138 + 3,
7139 + sr__feature_enable_notification__field_descriptors,
7140 + sr__feature_enable_notification__field_indices_by_name,
7141 + 1, sr__feature_enable_notification__number_ranges,
7142 + (ProtobufCMessageInit) sr__feature_enable_notification__init,
7143 + NULL,NULL,NULL /* reserved[123] */
7144 +};
7145 +static const ProtobufCFieldDescriptor sr__module_change_notification__field_descriptors[2] =
7146 +{
7147 + {
7148 + "event",
7149 + 1,
7150 + PROTOBUF_C_LABEL_REQUIRED,
7151 + PROTOBUF_C_TYPE_ENUM,
7152 + 0, /* quantifier_offset */
7153 + offsetof(Sr__ModuleChangeNotification, event),
7154 + &sr__notification_event__descriptor,
7155 + NULL,
7156 + 0, /* flags */
7157 + 0,NULL,NULL /* reserved1,reserved2, etc */
7158 + },
7159 + {
7160 + "module_name",
7161 + 2,
7162 + PROTOBUF_C_LABEL_REQUIRED,
7163 + PROTOBUF_C_TYPE_STRING,
7164 + 0, /* quantifier_offset */
7165 + offsetof(Sr__ModuleChangeNotification, module_name),
7166 + NULL,
7167 + NULL,
7168 + 0, /* flags */
7169 + 0,NULL,NULL /* reserved1,reserved2, etc */
7170 + },
7171 +};
7172 +static const unsigned sr__module_change_notification__field_indices_by_name[] = {
7173 + 0, /* field[0] = event */
7174 + 1, /* field[1] = module_name */
7175 +};
7176 +static const ProtobufCIntRange sr__module_change_notification__number_ranges[1 + 1] =
7177 +{
7178 + { 1, 0 },
7179 + { 0, 2 }
7180 +};
7181 +const ProtobufCMessageDescriptor sr__module_change_notification__descriptor =
7182 +{
7183 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
7184 + "sr.ModuleChangeNotification",
7185 + "ModuleChangeNotification",
7186 + "Sr__ModuleChangeNotification",
7187 + "sr",
7188 + sizeof(Sr__ModuleChangeNotification),
7189 + 2,
7190 + sr__module_change_notification__field_descriptors,
7191 + sr__module_change_notification__field_indices_by_name,
7192 + 1, sr__module_change_notification__number_ranges,
7193 + (ProtobufCMessageInit) sr__module_change_notification__init,
7194 + NULL,NULL,NULL /* reserved[123] */
7195 +};
7196 +static const ProtobufCFieldDescriptor sr__subtree_change_notification__field_descriptors[2] =
7197 +{
7198 + {
7199 + "event",
7200 + 1,
7201 + PROTOBUF_C_LABEL_REQUIRED,
7202 + PROTOBUF_C_TYPE_ENUM,
7203 + 0, /* quantifier_offset */
7204 + offsetof(Sr__SubtreeChangeNotification, event),
7205 + &sr__notification_event__descriptor,
7206 + NULL,
7207 + 0, /* flags */
7208 + 0,NULL,NULL /* reserved1,reserved2, etc */
7209 + },
7210 + {
7211 + "xpath",
7212 + 2,
7213 + PROTOBUF_C_LABEL_REQUIRED,
7214 + PROTOBUF_C_TYPE_STRING,
7215 + 0, /* quantifier_offset */
7216 + offsetof(Sr__SubtreeChangeNotification, xpath),
7217 + NULL,
7218 + NULL,
7219 + 0, /* flags */
7220 + 0,NULL,NULL /* reserved1,reserved2, etc */
7221 + },
7222 +};
7223 +static const unsigned sr__subtree_change_notification__field_indices_by_name[] = {
7224 + 0, /* field[0] = event */
7225 + 1, /* field[1] = xpath */
7226 +};
7227 +static const ProtobufCIntRange sr__subtree_change_notification__number_ranges[1 + 1] =
7228 +{
7229 + { 1, 0 },
7230 + { 0, 2 }
7231 +};
7232 +const ProtobufCMessageDescriptor sr__subtree_change_notification__descriptor =
7233 +{
7234 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
7235 + "sr.SubtreeChangeNotification",
7236 + "SubtreeChangeNotification",
7237 + "Sr__SubtreeChangeNotification",
7238 + "sr",
7239 + sizeof(Sr__SubtreeChangeNotification),
7240 + 2,
7241 + sr__subtree_change_notification__field_descriptors,
7242 + sr__subtree_change_notification__field_indices_by_name,
7243 + 1, sr__subtree_change_notification__number_ranges,
7244 + (ProtobufCMessageInit) sr__subtree_change_notification__init,
7245 + NULL,NULL,NULL /* reserved[123] */
7246 +};
7247 +static const ProtobufCFieldDescriptor sr__change__field_descriptors[3] =
7248 +{
7249 + {
7250 + "changeOperation",
7251 + 1,
7252 + PROTOBUF_C_LABEL_REQUIRED,
7253 + PROTOBUF_C_TYPE_ENUM,
7254 + 0, /* quantifier_offset */
7255 + offsetof(Sr__Change, changeoperation),
7256 + &sr__change_operation__descriptor,
7257 + NULL,
7258 + 0, /* flags */
7259 + 0,NULL,NULL /* reserved1,reserved2, etc */
7260 + },
7261 + {
7262 + "new_value",
7263 + 2,
7264 + PROTOBUF_C_LABEL_OPTIONAL,
7265 + PROTOBUF_C_TYPE_MESSAGE,
7266 + 0, /* quantifier_offset */
7267 + offsetof(Sr__Change, new_value),
7268 + &sr__value__descriptor,
7269 + NULL,
7270 + 0, /* flags */
7271 + 0,NULL,NULL /* reserved1,reserved2, etc */
7272 + },
7273 + {
7274 + "old_value",
7275 + 3,
7276 + PROTOBUF_C_LABEL_OPTIONAL,
7277 + PROTOBUF_C_TYPE_MESSAGE,
7278 + 0, /* quantifier_offset */
7279 + offsetof(Sr__Change, old_value),
7280 + &sr__value__descriptor,
7281 + NULL,
7282 + 0, /* flags */
7283 + 0,NULL,NULL /* reserved1,reserved2, etc */
7284 + },
7285 +};
7286 +static const unsigned sr__change__field_indices_by_name[] = {
7287 + 0, /* field[0] = changeOperation */
7288 + 1, /* field[1] = new_value */
7289 + 2, /* field[2] = old_value */
7290 +};
7291 +static const ProtobufCIntRange sr__change__number_ranges[1 + 1] =
7292 +{
7293 + { 1, 0 },
7294 + { 0, 3 }
7295 +};
7296 +const ProtobufCMessageDescriptor sr__change__descriptor =
7297 +{
7298 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
7299 + "sr.Change",
7300 + "Change",
7301 + "Sr__Change",
7302 + "sr",
7303 + sizeof(Sr__Change),
7304 + 3,
7305 + sr__change__field_descriptors,
7306 + sr__change__field_indices_by_name,
7307 + 1, sr__change__number_ranges,
7308 + (ProtobufCMessageInit) sr__change__init,
7309 + NULL,NULL,NULL /* reserved[123] */
7310 +};
7311 +static const ProtobufCFieldDescriptor sr__get_changes_req__field_descriptors[3] =
7312 +{
7313 + {
7314 + "xpath",
7315 + 1,
7316 + PROTOBUF_C_LABEL_REQUIRED,
7317 + PROTOBUF_C_TYPE_STRING,
7318 + 0, /* quantifier_offset */
7319 + offsetof(Sr__GetChangesReq, xpath),
7320 + NULL,
7321 + NULL,
7322 + 0, /* flags */
7323 + 0,NULL,NULL /* reserved1,reserved2, etc */
7324 + },
7325 + {
7326 + "limit",
7327 + 2,
7328 + PROTOBUF_C_LABEL_REQUIRED,
7329 + PROTOBUF_C_TYPE_UINT32,
7330 + 0, /* quantifier_offset */
7331 + offsetof(Sr__GetChangesReq, limit),
7332 + NULL,
7333 + NULL,
7334 + 0, /* flags */
7335 + 0,NULL,NULL /* reserved1,reserved2, etc */
7336 + },
7337 + {
7338 + "offset",
7339 + 3,
7340 + PROTOBUF_C_LABEL_REQUIRED,
7341 + PROTOBUF_C_TYPE_UINT32,
7342 + 0, /* quantifier_offset */
7343 + offsetof(Sr__GetChangesReq, offset),
7344 + NULL,
7345 + NULL,
7346 + 0, /* flags */
7347 + 0,NULL,NULL /* reserved1,reserved2, etc */
7348 + },
7349 +};
7350 +static const unsigned sr__get_changes_req__field_indices_by_name[] = {
7351 + 1, /* field[1] = limit */
7352 + 2, /* field[2] = offset */
7353 + 0, /* field[0] = xpath */
7354 +};
7355 +static const ProtobufCIntRange sr__get_changes_req__number_ranges[1 + 1] =
7356 +{
7357 + { 1, 0 },
7358 + { 0, 3 }
7359 +};
7360 +const ProtobufCMessageDescriptor sr__get_changes_req__descriptor =
7361 +{
7362 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
7363 + "sr.GetChangesReq",
7364 + "GetChangesReq",
7365 + "Sr__GetChangesReq",
7366 + "sr",
7367 + sizeof(Sr__GetChangesReq),
7368 + 3,
7369 + sr__get_changes_req__field_descriptors,
7370 + sr__get_changes_req__field_indices_by_name,
7371 + 1, sr__get_changes_req__number_ranges,
7372 + (ProtobufCMessageInit) sr__get_changes_req__init,
7373 + NULL,NULL,NULL /* reserved[123] */
7374 +};
7375 +static const ProtobufCFieldDescriptor sr__get_changes_resp__field_descriptors[1] =
7376 +{
7377 + {
7378 + "changes",
7379 + 1,
7380 + PROTOBUF_C_LABEL_REPEATED,
7381 + PROTOBUF_C_TYPE_MESSAGE,
7382 + offsetof(Sr__GetChangesResp, n_changes),
7383 + offsetof(Sr__GetChangesResp, changes),
7384 + &sr__change__descriptor,
7385 + NULL,
7386 + 0, /* flags */
7387 + 0,NULL,NULL /* reserved1,reserved2, etc */
7388 + },
7389 +};
7390 +static const unsigned sr__get_changes_resp__field_indices_by_name[] = {
7391 + 0, /* field[0] = changes */
7392 +};
7393 +static const ProtobufCIntRange sr__get_changes_resp__number_ranges[1 + 1] =
7394 +{
7395 + { 1, 0 },
7396 + { 0, 1 }
7397 +};
7398 +const ProtobufCMessageDescriptor sr__get_changes_resp__descriptor =
7399 +{
7400 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
7401 + "sr.GetChangesResp",
7402 + "GetChangesResp",
7403 + "Sr__GetChangesResp",
7404 + "sr",
7405 + sizeof(Sr__GetChangesResp),
7406 + 1,
7407 + sr__get_changes_resp__field_descriptors,
7408 + sr__get_changes_resp__field_indices_by_name,
7409 + 1, sr__get_changes_resp__number_ranges,
7410 + (ProtobufCMessageInit) sr__get_changes_resp__init,
7411 + NULL,NULL,NULL /* reserved[123] */
7412 +};
7413 +static const ProtobufCFieldDescriptor sr__check_exec_perm_req__field_descriptors[1] =
7414 +{
7415 + {
7416 + "xpath",
7417 + 1,
7418 + PROTOBUF_C_LABEL_REQUIRED,
7419 + PROTOBUF_C_TYPE_STRING,
7420 + 0, /* quantifier_offset */
7421 + offsetof(Sr__CheckExecPermReq, xpath),
7422 + NULL,
7423 + NULL,
7424 + 0, /* flags */
7425 + 0,NULL,NULL /* reserved1,reserved2, etc */
7426 + },
7427 +};
7428 +static const unsigned sr__check_exec_perm_req__field_indices_by_name[] = {
7429 + 0, /* field[0] = xpath */
7430 +};
7431 +static const ProtobufCIntRange sr__check_exec_perm_req__number_ranges[1 + 1] =
7432 +{
7433 + { 1, 0 },
7434 + { 0, 1 }
7435 +};
7436 +const ProtobufCMessageDescriptor sr__check_exec_perm_req__descriptor =
7437 +{
7438 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
7439 + "sr.CheckExecPermReq",
7440 + "CheckExecPermReq",
7441 + "Sr__CheckExecPermReq",
7442 + "sr",
7443 + sizeof(Sr__CheckExecPermReq),
7444 + 1,
7445 + sr__check_exec_perm_req__field_descriptors,
7446 + sr__check_exec_perm_req__field_indices_by_name,
7447 + 1, sr__check_exec_perm_req__number_ranges,
7448 + (ProtobufCMessageInit) sr__check_exec_perm_req__init,
7449 + NULL,NULL,NULL /* reserved[123] */
7450 +};
7451 +static const ProtobufCFieldDescriptor sr__check_exec_perm_resp__field_descriptors[1] =
7452 +{
7453 + {
7454 + "permitted",
7455 + 1,
7456 + PROTOBUF_C_LABEL_REQUIRED,
7457 + PROTOBUF_C_TYPE_BOOL,
7458 + 0, /* quantifier_offset */
7459 + offsetof(Sr__CheckExecPermResp, permitted),
7460 + NULL,
7461 + NULL,
7462 + 0, /* flags */
7463 + 0,NULL,NULL /* reserved1,reserved2, etc */
7464 + },
7465 +};
7466 +static const unsigned sr__check_exec_perm_resp__field_indices_by_name[] = {
7467 + 0, /* field[0] = permitted */
7468 +};
7469 +static const ProtobufCIntRange sr__check_exec_perm_resp__number_ranges[1 + 1] =
7470 +{
7471 + { 1, 0 },
7472 + { 0, 1 }
7473 +};
7474 +const ProtobufCMessageDescriptor sr__check_exec_perm_resp__descriptor =
7475 +{
7476 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
7477 + "sr.CheckExecPermResp",
7478 + "CheckExecPermResp",
7479 + "Sr__CheckExecPermResp",
7480 + "sr",
7481 + sizeof(Sr__CheckExecPermResp),
7482 + 1,
7483 + sr__check_exec_perm_resp__field_descriptors,
7484 + sr__check_exec_perm_resp__field_indices_by_name,
7485 + 1, sr__check_exec_perm_resp__number_ranges,
7486 + (ProtobufCMessageInit) sr__check_exec_perm_resp__init,
7487 + NULL,NULL,NULL /* reserved[123] */
7488 +};
7489 +static const ProtobufCFieldDescriptor sr__rpcreq__field_descriptors[7] =
7490 +{
7491 + {
7492 + "action",
7493 + 1,
7494 + PROTOBUF_C_LABEL_REQUIRED,
7495 + PROTOBUF_C_TYPE_BOOL,
7496 + 0, /* quantifier_offset */
7497 + offsetof(Sr__RPCReq, action),
7498 + NULL,
7499 + NULL,
7500 + 0, /* flags */
7501 + 0,NULL,NULL /* reserved1,reserved2, etc */
7502 + },
7503 + {
7504 + "xpath",
7505 + 2,
7506 + PROTOBUF_C_LABEL_REQUIRED,
7507 + PROTOBUF_C_TYPE_STRING,
7508 + 0, /* quantifier_offset */
7509 + offsetof(Sr__RPCReq, xpath),
7510 + NULL,
7511 + NULL,
7512 + 0, /* flags */
7513 + 0,NULL,NULL /* reserved1,reserved2, etc */
7514 + },
7515 + {
7516 + "orig_api_variant",
7517 + 3,
7518 + PROTOBUF_C_LABEL_REQUIRED,
7519 + PROTOBUF_C_TYPE_ENUM,
7520 + 0, /* quantifier_offset */
7521 + offsetof(Sr__RPCReq, orig_api_variant),
7522 + &sr__api_variant__descriptor,
7523 + NULL,
7524 + 0, /* flags */
7525 + 0,NULL,NULL /* reserved1,reserved2, etc */
7526 + },
7527 + {
7528 + "input",
7529 + 4,
7530 + PROTOBUF_C_LABEL_REPEATED,
7531 + PROTOBUF_C_TYPE_MESSAGE,
7532 + offsetof(Sr__RPCReq, n_input),
7533 + offsetof(Sr__RPCReq, input),
7534 + &sr__value__descriptor,
7535 + NULL,
7536 + 0, /* flags */
7537 + 0,NULL,NULL /* reserved1,reserved2, etc */
7538 + },
7539 + {
7540 + "input_tree",
7541 + 5,
7542 + PROTOBUF_C_LABEL_REPEATED,
7543 + PROTOBUF_C_TYPE_MESSAGE,
7544 + offsetof(Sr__RPCReq, n_input_tree),
7545 + offsetof(Sr__RPCReq, input_tree),
7546 + &sr__node__descriptor,
7547 + NULL,
7548 + 0, /* flags */
7549 + 0,NULL,NULL /* reserved1,reserved2, etc */
7550 + },
7551 + {
7552 + "subscriber_address",
7553 + 10,
7554 + PROTOBUF_C_LABEL_OPTIONAL,
7555 + PROTOBUF_C_TYPE_STRING,
7556 + 0, /* quantifier_offset */
7557 + offsetof(Sr__RPCReq, subscriber_address),
7558 + NULL,
7559 + NULL,
7560 + 0, /* flags */
7561 + 0,NULL,NULL /* reserved1,reserved2, etc */
7562 + },
7563 + {
7564 + "subscription_id",
7565 + 11,
7566 + PROTOBUF_C_LABEL_OPTIONAL,
7567 + PROTOBUF_C_TYPE_UINT32,
7568 + offsetof(Sr__RPCReq, has_subscription_id),
7569 + offsetof(Sr__RPCReq, subscription_id),
7570 + NULL,
7571 + NULL,
7572 + 0, /* flags */
7573 + 0,NULL,NULL /* reserved1,reserved2, etc */
7574 + },
7575 +};
7576 +static const unsigned sr__rpcreq__field_indices_by_name[] = {
7577 + 0, /* field[0] = action */
7578 + 3, /* field[3] = input */
7579 + 4, /* field[4] = input_tree */
7580 + 2, /* field[2] = orig_api_variant */
7581 + 5, /* field[5] = subscriber_address */
7582 + 6, /* field[6] = subscription_id */
7583 + 1, /* field[1] = xpath */
7584 +};
7585 +static const ProtobufCIntRange sr__rpcreq__number_ranges[2 + 1] =
7586 +{
7587 + { 1, 0 },
7588 + { 10, 5 },
7589 + { 0, 7 }
7590 +};
7591 +const ProtobufCMessageDescriptor sr__rpcreq__descriptor =
7592 +{
7593 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
7594 + "sr.RPCReq",
7595 + "RPCReq",
7596 + "Sr__RPCReq",
7597 + "sr",
7598 + sizeof(Sr__RPCReq),
7599 + 7,
7600 + sr__rpcreq__field_descriptors,
7601 + sr__rpcreq__field_indices_by_name,
7602 + 2, sr__rpcreq__number_ranges,
7603 + (ProtobufCMessageInit) sr__rpcreq__init,
7604 + NULL,NULL,NULL /* reserved[123] */
7605 +};
7606 +static const ProtobufCFieldDescriptor sr__rpcresp__field_descriptors[5] =
7607 +{
7608 + {
7609 + "action",
7610 + 1,
7611 + PROTOBUF_C_LABEL_REQUIRED,
7612 + PROTOBUF_C_TYPE_BOOL,
7613 + 0, /* quantifier_offset */
7614 + offsetof(Sr__RPCResp, action),
7615 + NULL,
7616 + NULL,
7617 + 0, /* flags */
7618 + 0,NULL,NULL /* reserved1,reserved2, etc */
7619 + },
7620 + {
7621 + "xpath",
7622 + 2,
7623 + PROTOBUF_C_LABEL_REQUIRED,
7624 + PROTOBUF_C_TYPE_STRING,
7625 + 0, /* quantifier_offset */
7626 + offsetof(Sr__RPCResp, xpath),
7627 + NULL,
7628 + NULL,
7629 + 0, /* flags */
7630 + 0,NULL,NULL /* reserved1,reserved2, etc */
7631 + },
7632 + {
7633 + "orig_api_variant",
7634 + 3,
7635 + PROTOBUF_C_LABEL_REQUIRED,
7636 + PROTOBUF_C_TYPE_ENUM,
7637 + 0, /* quantifier_offset */
7638 + offsetof(Sr__RPCResp, orig_api_variant),
7639 + &sr__api_variant__descriptor,
7640 + NULL,
7641 + 0, /* flags */
7642 + 0,NULL,NULL /* reserved1,reserved2, etc */
7643 + },
7644 + {
7645 + "output",
7646 + 4,
7647 + PROTOBUF_C_LABEL_REPEATED,
7648 + PROTOBUF_C_TYPE_MESSAGE,
7649 + offsetof(Sr__RPCResp, n_output),
7650 + offsetof(Sr__RPCResp, output),
7651 + &sr__value__descriptor,
7652 + NULL,
7653 + 0, /* flags */
7654 + 0,NULL,NULL /* reserved1,reserved2, etc */
7655 + },
7656 + {
7657 + "output_tree",
7658 + 5,
7659 + PROTOBUF_C_LABEL_REPEATED,
7660 + PROTOBUF_C_TYPE_MESSAGE,
7661 + offsetof(Sr__RPCResp, n_output_tree),
7662 + offsetof(Sr__RPCResp, output_tree),
7663 + &sr__node__descriptor,
7664 + NULL,
7665 + 0, /* flags */
7666 + 0,NULL,NULL /* reserved1,reserved2, etc */
7667 + },
7668 +};
7669 +static const unsigned sr__rpcresp__field_indices_by_name[] = {
7670 + 0, /* field[0] = action */
7671 + 2, /* field[2] = orig_api_variant */
7672 + 3, /* field[3] = output */
7673 + 4, /* field[4] = output_tree */
7674 + 1, /* field[1] = xpath */
7675 +};
7676 +static const ProtobufCIntRange sr__rpcresp__number_ranges[1 + 1] =
7677 +{
7678 + { 1, 0 },
7679 + { 0, 5 }
7680 +};
7681 +const ProtobufCMessageDescriptor sr__rpcresp__descriptor =
7682 +{
7683 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
7684 + "sr.RPCResp",
7685 + "RPCResp",
7686 + "Sr__RPCResp",
7687 + "sr",
7688 + sizeof(Sr__RPCResp),
7689 + 5,
7690 + sr__rpcresp__field_descriptors,
7691 + sr__rpcresp__field_indices_by_name,
7692 + 1, sr__rpcresp__number_ranges,
7693 + (ProtobufCMessageInit) sr__rpcresp__init,
7694 + NULL,NULL,NULL /* reserved[123] */
7695 +};
7696 +static const ProtobufCEnumValue sr__event_notif_req__notif_type__enum_values_by_number[4] =
7697 +{
7698 + { "REALTIME", "SR__EVENT_NOTIF_REQ__NOTIF_TYPE__REALTIME", 1 },
7699 + { "REPLAY", "SR__EVENT_NOTIF_REQ__NOTIF_TYPE__REPLAY", 2 },
7700 + { "REPLAY_COMPLETE", "SR__EVENT_NOTIF_REQ__NOTIF_TYPE__REPLAY_COMPLETE", 3 },
7701 + { "REPLAY_STOP", "SR__EVENT_NOTIF_REQ__NOTIF_TYPE__REPLAY_STOP", 4 },
7702 +};
7703 +static const ProtobufCIntRange sr__event_notif_req__notif_type__value_ranges[] = {
7704 +{1, 0},{0, 4}
7705 +};
7706 +static const ProtobufCEnumValueIndex sr__event_notif_req__notif_type__enum_values_by_name[4] =
7707 +{
7708 + { "REALTIME", 0 },
7709 + { "REPLAY", 1 },
7710 + { "REPLAY_COMPLETE", 2 },
7711 + { "REPLAY_STOP", 3 },
7712 +};
7713 +const ProtobufCEnumDescriptor sr__event_notif_req__notif_type__descriptor =
7714 +{
7715 + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
7716 + "sr.EventNotifReq.NotifType",
7717 + "NotifType",
7718 + "Sr__EventNotifReq__NotifType",
7719 + "sr",
7720 + 4,
7721 + sr__event_notif_req__notif_type__enum_values_by_number,
7722 + 4,
7723 + sr__event_notif_req__notif_type__enum_values_by_name,
7724 + 1,
7725 + sr__event_notif_req__notif_type__value_ranges,
7726 + NULL,NULL,NULL,NULL /* reserved[1234] */
7727 +};
7728 +static const ProtobufCEnumValue sr__event_notif_req__notif_flags__enum_values_by_number[2] =
7729 +{
7730 + { "DEFAULT", "SR__EVENT_NOTIF_REQ__NOTIF_FLAGS__DEFAULT", 0 },
7731 + { "EPHEMERAL", "SR__EVENT_NOTIF_REQ__NOTIF_FLAGS__EPHEMERAL", 1 },
7732 +};
7733 +static const ProtobufCIntRange sr__event_notif_req__notif_flags__value_ranges[] = {
7734 +{0, 0},{0, 2}
7735 +};
7736 +static const ProtobufCEnumValueIndex sr__event_notif_req__notif_flags__enum_values_by_name[2] =
7737 +{
7738 + { "DEFAULT", 0 },
7739 + { "EPHEMERAL", 1 },
7740 +};
7741 +const ProtobufCEnumDescriptor sr__event_notif_req__notif_flags__descriptor =
7742 +{
7743 + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
7744 + "sr.EventNotifReq.NotifFlags",
7745 + "NotifFlags",
7746 + "Sr__EventNotifReq__NotifFlags",
7747 + "sr",
7748 + 2,
7749 + sr__event_notif_req__notif_flags__enum_values_by_number,
7750 + 2,
7751 + sr__event_notif_req__notif_flags__enum_values_by_name,
7752 + 1,
7753 + sr__event_notif_req__notif_flags__value_ranges,
7754 + NULL,NULL,NULL,NULL /* reserved[1234] */
7755 +};
7756 +static const ProtobufCFieldDescriptor sr__event_notif_req__field_descriptors[9] =
7757 +{
7758 + {
7759 + "type",
7760 + 1,
7761 + PROTOBUF_C_LABEL_REQUIRED,
7762 + PROTOBUF_C_TYPE_ENUM,
7763 + 0, /* quantifier_offset */
7764 + offsetof(Sr__EventNotifReq, type),
7765 + &sr__event_notif_req__notif_type__descriptor,
7766 + NULL,
7767 + 0, /* flags */
7768 + 0,NULL,NULL /* reserved1,reserved2, etc */
7769 + },
7770 + {
7771 + "options",
7772 + 2,
7773 + PROTOBUF_C_LABEL_REQUIRED,
7774 + PROTOBUF_C_TYPE_UINT32,
7775 + 0, /* quantifier_offset */
7776 + offsetof(Sr__EventNotifReq, options),
7777 + NULL,
7778 + NULL,
7779 + 0, /* flags */
7780 + 0,NULL,NULL /* reserved1,reserved2, etc */
7781 + },
7782 + {
7783 + "xpath",
7784 + 3,
7785 + PROTOBUF_C_LABEL_REQUIRED,
7786 + PROTOBUF_C_TYPE_STRING,
7787 + 0, /* quantifier_offset */
7788 + offsetof(Sr__EventNotifReq, xpath),
7789 + NULL,
7790 + NULL,
7791 + 0, /* flags */
7792 + 0,NULL,NULL /* reserved1,reserved2, etc */
7793 + },
7794 + {
7795 + "values",
7796 + 4,
7797 + PROTOBUF_C_LABEL_REPEATED,
7798 + PROTOBUF_C_TYPE_MESSAGE,
7799 + offsetof(Sr__EventNotifReq, n_values),
7800 + offsetof(Sr__EventNotifReq, values),
7801 + &sr__value__descriptor,
7802 + NULL,
7803 + 0, /* flags */
7804 + 0,NULL,NULL /* reserved1,reserved2, etc */
7805 + },
7806 + {
7807 + "trees",
7808 + 5,
7809 + PROTOBUF_C_LABEL_REPEATED,
7810 + PROTOBUF_C_TYPE_MESSAGE,
7811 + offsetof(Sr__EventNotifReq, n_trees),
7812 + offsetof(Sr__EventNotifReq, trees),
7813 + &sr__node__descriptor,
7814 + NULL,
7815 + 0, /* flags */
7816 + 0,NULL,NULL /* reserved1,reserved2, etc */
7817 + },
7818 + {
7819 + "timestamp",
7820 + 6,
7821 + PROTOBUF_C_LABEL_REQUIRED,
7822 + PROTOBUF_C_TYPE_UINT64,
7823 + 0, /* quantifier_offset */
7824 + offsetof(Sr__EventNotifReq, timestamp),
7825 + NULL,
7826 + NULL,
7827 + 0, /* flags */
7828 + 0,NULL,NULL /* reserved1,reserved2, etc */
7829 + },
7830 + {
7831 + "subscriber_address",
7832 + 10,
7833 + PROTOBUF_C_LABEL_OPTIONAL,
7834 + PROTOBUF_C_TYPE_STRING,
7835 + 0, /* quantifier_offset */
7836 + offsetof(Sr__EventNotifReq, subscriber_address),
7837 + NULL,
7838 + NULL,
7839 + 0, /* flags */
7840 + 0,NULL,NULL /* reserved1,reserved2, etc */
7841 + },
7842 + {
7843 + "subscription_id",
7844 + 11,
7845 + PROTOBUF_C_LABEL_OPTIONAL,
7846 + PROTOBUF_C_TYPE_UINT32,
7847 + offsetof(Sr__EventNotifReq, has_subscription_id),
7848 + offsetof(Sr__EventNotifReq, subscription_id),
7849 + NULL,
7850 + NULL,
7851 + 0, /* flags */
7852 + 0,NULL,NULL /* reserved1,reserved2, etc */
7853 + },
7854 + {
7855 + "do_not_send_reply",
7856 + 20,
7857 + PROTOBUF_C_LABEL_REQUIRED,
7858 + PROTOBUF_C_TYPE_BOOL,
7859 + 0, /* quantifier_offset */
7860 + offsetof(Sr__EventNotifReq, do_not_send_reply),
7861 + NULL,
7862 + NULL,
7863 + 0, /* flags */
7864 + 0,NULL,NULL /* reserved1,reserved2, etc */
7865 + },
7866 +};
7867 +static const unsigned sr__event_notif_req__field_indices_by_name[] = {
7868 + 8, /* field[8] = do_not_send_reply */
7869 + 1, /* field[1] = options */
7870 + 6, /* field[6] = subscriber_address */
7871 + 7, /* field[7] = subscription_id */
7872 + 5, /* field[5] = timestamp */
7873 + 4, /* field[4] = trees */
7874 + 0, /* field[0] = type */
7875 + 3, /* field[3] = values */
7876 + 2, /* field[2] = xpath */
7877 +};
7878 +static const ProtobufCIntRange sr__event_notif_req__number_ranges[3 + 1] =
7879 +{
7880 + { 1, 0 },
7881 + { 10, 6 },
7882 + { 20, 8 },
7883 + { 0, 9 }
7884 +};
7885 +const ProtobufCMessageDescriptor sr__event_notif_req__descriptor =
7886 +{
7887 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
7888 + "sr.EventNotifReq",
7889 + "EventNotifReq",
7890 + "Sr__EventNotifReq",
7891 + "sr",
7892 + sizeof(Sr__EventNotifReq),
7893 + 9,
7894 + sr__event_notif_req__field_descriptors,
7895 + sr__event_notif_req__field_indices_by_name,
7896 + 3, sr__event_notif_req__number_ranges,
7897 + (ProtobufCMessageInit) sr__event_notif_req__init,
7898 + NULL,NULL,NULL /* reserved[123] */
7899 +};
7900 +#define sr__event_notif_resp__field_descriptors NULL
7901 +#define sr__event_notif_resp__field_indices_by_name NULL
7902 +#define sr__event_notif_resp__number_ranges NULL
7903 +const ProtobufCMessageDescriptor sr__event_notif_resp__descriptor =
7904 +{
7905 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
7906 + "sr.EventNotifResp",
7907 + "EventNotifResp",
7908 + "Sr__EventNotifResp",
7909 + "sr",
7910 + sizeof(Sr__EventNotifResp),
7911 + 0,
7912 + sr__event_notif_resp__field_descriptors,
7913 + sr__event_notif_resp__field_indices_by_name,
7914 + 0, sr__event_notif_resp__number_ranges,
7915 + (ProtobufCMessageInit) sr__event_notif_resp__init,
7916 + NULL,NULL,NULL /* reserved[123] */
7917 +};
7918 +static const ProtobufCFieldDescriptor sr__event_notif_replay_req__field_descriptors[6] =
7919 +{
7920 + {
7921 + "xpath",
7922 + 1,
7923 + PROTOBUF_C_LABEL_REQUIRED,
7924 + PROTOBUF_C_TYPE_STRING,
7925 + 0, /* quantifier_offset */
7926 + offsetof(Sr__EventNotifReplayReq, xpath),
7927 + NULL,
7928 + NULL,
7929 + 0, /* flags */
7930 + 0,NULL,NULL /* reserved1,reserved2, etc */
7931 + },
7932 + {
7933 + "start_time",
7934 + 2,
7935 + PROTOBUF_C_LABEL_REQUIRED,
7936 + PROTOBUF_C_TYPE_UINT64,
7937 + 0, /* quantifier_offset */
7938 + offsetof(Sr__EventNotifReplayReq, start_time),
7939 + NULL,
7940 + NULL,
7941 + 0, /* flags */
7942 + 0,NULL,NULL /* reserved1,reserved2, etc */
7943 + },
7944 + {
7945 + "stop_time",
7946 + 3,
7947 + PROTOBUF_C_LABEL_REQUIRED,
7948 + PROTOBUF_C_TYPE_UINT64,
7949 + 0, /* quantifier_offset */
7950 + offsetof(Sr__EventNotifReplayReq, stop_time),
7951 + NULL,
7952 + NULL,
7953 + 0, /* flags */
7954 + 0,NULL,NULL /* reserved1,reserved2, etc */
7955 + },
7956 + {
7957 + "subscriber_address",
7958 + 10,
7959 + PROTOBUF_C_LABEL_REQUIRED,
7960 + PROTOBUF_C_TYPE_STRING,
7961 + 0, /* quantifier_offset */
7962 + offsetof(Sr__EventNotifReplayReq, subscriber_address),
7963 + NULL,
7964 + NULL,
7965 + 0, /* flags */
7966 + 0,NULL,NULL /* reserved1,reserved2, etc */
7967 + },
7968 + {
7969 + "subscription_id",
7970 + 11,
7971 + PROTOBUF_C_LABEL_REQUIRED,
7972 + PROTOBUF_C_TYPE_UINT32,
7973 + 0, /* quantifier_offset */
7974 + offsetof(Sr__EventNotifReplayReq, subscription_id),
7975 + NULL,
7976 + NULL,
7977 + 0, /* flags */
7978 + 0,NULL,NULL /* reserved1,reserved2, etc */
7979 + },
7980 + {
7981 + "api_variant",
7982 + 12,
7983 + PROTOBUF_C_LABEL_REQUIRED,
7984 + PROTOBUF_C_TYPE_ENUM,
7985 + 0, /* quantifier_offset */
7986 + offsetof(Sr__EventNotifReplayReq, api_variant),
7987 + &sr__api_variant__descriptor,
7988 + NULL,
7989 + 0, /* flags */
7990 + 0,NULL,NULL /* reserved1,reserved2, etc */
7991 + },
7992 +};
7993 +static const unsigned sr__event_notif_replay_req__field_indices_by_name[] = {
7994 + 5, /* field[5] = api_variant */
7995 + 1, /* field[1] = start_time */
7996 + 2, /* field[2] = stop_time */
7997 + 3, /* field[3] = subscriber_address */
7998 + 4, /* field[4] = subscription_id */
7999 + 0, /* field[0] = xpath */
8000 +};
8001 +static const ProtobufCIntRange sr__event_notif_replay_req__number_ranges[2 + 1] =
8002 +{
8003 + { 1, 0 },
8004 + { 10, 3 },
8005 + { 0, 6 }
8006 +};
8007 +const ProtobufCMessageDescriptor sr__event_notif_replay_req__descriptor =
8008 +{
8009 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
8010 + "sr.EventNotifReplayReq",
8011 + "EventNotifReplayReq",
8012 + "Sr__EventNotifReplayReq",
8013 + "sr",
8014 + sizeof(Sr__EventNotifReplayReq),
8015 + 6,
8016 + sr__event_notif_replay_req__field_descriptors,
8017 + sr__event_notif_replay_req__field_indices_by_name,
8018 + 2, sr__event_notif_replay_req__number_ranges,
8019 + (ProtobufCMessageInit) sr__event_notif_replay_req__init,
8020 + NULL,NULL,NULL /* reserved[123] */
8021 +};
8022 +#define sr__event_notif_replay_resp__field_descriptors NULL
8023 +#define sr__event_notif_replay_resp__field_indices_by_name NULL
8024 +#define sr__event_notif_replay_resp__number_ranges NULL
8025 +const ProtobufCMessageDescriptor sr__event_notif_replay_resp__descriptor =
8026 +{
8027 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
8028 + "sr.EventNotifReplayResp",
8029 + "EventNotifReplayResp",
8030 + "Sr__EventNotifReplayResp",
8031 + "sr",
8032 + sizeof(Sr__EventNotifReplayResp),
8033 + 0,
8034 + sr__event_notif_replay_resp__field_descriptors,
8035 + sr__event_notif_replay_resp__field_indices_by_name,
8036 + 0, sr__event_notif_replay_resp__number_ranges,
8037 + (ProtobufCMessageInit) sr__event_notif_replay_resp__init,
8038 + NULL,NULL,NULL /* reserved[123] */
8039 +};
8040 +static const ProtobufCFieldDescriptor sr__data_provide_req__field_descriptors[4] =
8041 +{
8042 + {
8043 + "xpath",
8044 + 1,
8045 + PROTOBUF_C_LABEL_REQUIRED,
8046 + PROTOBUF_C_TYPE_STRING,
8047 + 0, /* quantifier_offset */
8048 + offsetof(Sr__DataProvideReq, xpath),
8049 + NULL,
8050 + NULL,
8051 + 0, /* flags */
8052 + 0,NULL,NULL /* reserved1,reserved2, etc */
8053 + },
8054 + {
8055 + "subscriber_address",
8056 + 10,
8057 + PROTOBUF_C_LABEL_REQUIRED,
8058 + PROTOBUF_C_TYPE_STRING,
8059 + 0, /* quantifier_offset */
8060 + offsetof(Sr__DataProvideReq, subscriber_address),
8061 + NULL,
8062 + NULL,
8063 + 0, /* flags */
8064 + 0,NULL,NULL /* reserved1,reserved2, etc */
8065 + },
8066 + {
8067 + "subscription_id",
8068 + 11,
8069 + PROTOBUF_C_LABEL_REQUIRED,
8070 + PROTOBUF_C_TYPE_UINT32,
8071 + 0, /* quantifier_offset */
8072 + offsetof(Sr__DataProvideReq, subscription_id),
8073 + NULL,
8074 + NULL,
8075 + 0, /* flags */
8076 + 0,NULL,NULL /* reserved1,reserved2, etc */
8077 + },
8078 + {
8079 + "request_id",
8080 + 20,
8081 + PROTOBUF_C_LABEL_REQUIRED,
8082 + PROTOBUF_C_TYPE_UINT64,
8083 + 0, /* quantifier_offset */
8084 + offsetof(Sr__DataProvideReq, request_id),
8085 + NULL,
8086 + NULL,
8087 + 0, /* flags */
8088 + 0,NULL,NULL /* reserved1,reserved2, etc */
8089 + },
8090 +};
8091 +static const unsigned sr__data_provide_req__field_indices_by_name[] = {
8092 + 3, /* field[3] = request_id */
8093 + 1, /* field[1] = subscriber_address */
8094 + 2, /* field[2] = subscription_id */
8095 + 0, /* field[0] = xpath */
8096 +};
8097 +static const ProtobufCIntRange sr__data_provide_req__number_ranges[3 + 1] =
8098 +{
8099 + { 1, 0 },
8100 + { 10, 1 },
8101 + { 20, 3 },
8102 + { 0, 4 }
8103 +};
8104 +const ProtobufCMessageDescriptor sr__data_provide_req__descriptor =
8105 +{
8106 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
8107 + "sr.DataProvideReq",
8108 + "DataProvideReq",
8109 + "Sr__DataProvideReq",
8110 + "sr",
8111 + sizeof(Sr__DataProvideReq),
8112 + 4,
8113 + sr__data_provide_req__field_descriptors,
8114 + sr__data_provide_req__field_indices_by_name,
8115 + 3, sr__data_provide_req__number_ranges,
8116 + (ProtobufCMessageInit) sr__data_provide_req__init,
8117 + NULL,NULL,NULL /* reserved[123] */
8118 +};
8119 +static const ProtobufCFieldDescriptor sr__data_provide_resp__field_descriptors[3] =
8120 +{
8121 + {
8122 + "xpath",
8123 + 1,
8124 + PROTOBUF_C_LABEL_REQUIRED,
8125 + PROTOBUF_C_TYPE_STRING,
8126 + 0, /* quantifier_offset */
8127 + offsetof(Sr__DataProvideResp, xpath),
8128 + NULL,
8129 + NULL,
8130 + 0, /* flags */
8131 + 0,NULL,NULL /* reserved1,reserved2, etc */
8132 + },
8133 + {
8134 + "values",
8135 + 2,
8136 + PROTOBUF_C_LABEL_REPEATED,
8137 + PROTOBUF_C_TYPE_MESSAGE,
8138 + offsetof(Sr__DataProvideResp, n_values),
8139 + offsetof(Sr__DataProvideResp, values),
8140 + &sr__value__descriptor,
8141 + NULL,
8142 + 0, /* flags */
8143 + 0,NULL,NULL /* reserved1,reserved2, etc */
8144 + },
8145 + {
8146 + "request_id",
8147 + 10,
8148 + PROTOBUF_C_LABEL_REQUIRED,
8149 + PROTOBUF_C_TYPE_UINT64,
8150 + 0, /* quantifier_offset */
8151 + offsetof(Sr__DataProvideResp, request_id),
8152 + NULL,
8153 + NULL,
8154 + 0, /* flags */
8155 + 0,NULL,NULL /* reserved1,reserved2, etc */
8156 + },
8157 +};
8158 +static const unsigned sr__data_provide_resp__field_indices_by_name[] = {
8159 + 2, /* field[2] = request_id */
8160 + 1, /* field[1] = values */
8161 + 0, /* field[0] = xpath */
8162 +};
8163 +static const ProtobufCIntRange sr__data_provide_resp__number_ranges[2 + 1] =
8164 +{
8165 + { 1, 0 },
8166 + { 10, 2 },
8167 + { 0, 3 }
8168 +};
8169 +const ProtobufCMessageDescriptor sr__data_provide_resp__descriptor =
8170 +{
8171 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
8172 + "sr.DataProvideResp",
8173 + "DataProvideResp",
8174 + "Sr__DataProvideResp",
8175 + "sr",
8176 + sizeof(Sr__DataProvideResp),
8177 + 3,
8178 + sr__data_provide_resp__field_descriptors,
8179 + sr__data_provide_resp__field_indices_by_name,
8180 + 2, sr__data_provide_resp__number_ranges,
8181 + (ProtobufCMessageInit) sr__data_provide_resp__init,
8182 + NULL,NULL,NULL /* reserved[123] */
8183 +};
8184 +static const ProtobufCFieldDescriptor sr__module_install_req__field_descriptors[4] =
8185 +{
8186 + {
8187 + "module_name",
8188 + 1,
8189 + PROTOBUF_C_LABEL_REQUIRED,
8190 + PROTOBUF_C_TYPE_STRING,
8191 + 0, /* quantifier_offset */
8192 + offsetof(Sr__ModuleInstallReq, module_name),
8193 + NULL,
8194 + NULL,
8195 + 0, /* flags */
8196 + 0,NULL,NULL /* reserved1,reserved2, etc */
8197 + },
8198 + {
8199 + "revision",
8200 + 2,
8201 + PROTOBUF_C_LABEL_OPTIONAL,
8202 + PROTOBUF_C_TYPE_STRING,
8203 + 0, /* quantifier_offset */
8204 + offsetof(Sr__ModuleInstallReq, revision),
8205 + NULL,
8206 + NULL,
8207 + 0, /* flags */
8208 + 0,NULL,NULL /* reserved1,reserved2, etc */
8209 + },
8210 + {
8211 + "file_name",
8212 + 3,
8213 + PROTOBUF_C_LABEL_OPTIONAL,
8214 + PROTOBUF_C_TYPE_STRING,
8215 + 0, /* quantifier_offset */
8216 + offsetof(Sr__ModuleInstallReq, file_name),
8217 + NULL,
8218 + NULL,
8219 + 0, /* flags */
8220 + 0,NULL,NULL /* reserved1,reserved2, etc */
8221 + },
8222 + {
8223 + "installed",
8224 + 4,
8225 + PROTOBUF_C_LABEL_REQUIRED,
8226 + PROTOBUF_C_TYPE_BOOL,
8227 + 0, /* quantifier_offset */
8228 + offsetof(Sr__ModuleInstallReq, installed),
8229 + NULL,
8230 + NULL,
8231 + 0, /* flags */
8232 + 0,NULL,NULL /* reserved1,reserved2, etc */
8233 + },
8234 +};
8235 +static const unsigned sr__module_install_req__field_indices_by_name[] = {
8236 + 2, /* field[2] = file_name */
8237 + 3, /* field[3] = installed */
8238 + 0, /* field[0] = module_name */
8239 + 1, /* field[1] = revision */
8240 +};
8241 +static const ProtobufCIntRange sr__module_install_req__number_ranges[1 + 1] =
8242 +{
8243 + { 1, 0 },
8244 + { 0, 4 }
8245 +};
8246 +const ProtobufCMessageDescriptor sr__module_install_req__descriptor =
8247 +{
8248 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
8249 + "sr.ModuleInstallReq",
8250 + "ModuleInstallReq",
8251 + "Sr__ModuleInstallReq",
8252 + "sr",
8253 + sizeof(Sr__ModuleInstallReq),
8254 + 4,
8255 + sr__module_install_req__field_descriptors,
8256 + sr__module_install_req__field_indices_by_name,
8257 + 1, sr__module_install_req__number_ranges,
8258 + (ProtobufCMessageInit) sr__module_install_req__init,
8259 + NULL,NULL,NULL /* reserved[123] */
8260 +};
8261 +#define sr__module_install_resp__field_descriptors NULL
8262 +#define sr__module_install_resp__field_indices_by_name NULL
8263 +#define sr__module_install_resp__number_ranges NULL
8264 +const ProtobufCMessageDescriptor sr__module_install_resp__descriptor =
8265 +{
8266 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
8267 + "sr.ModuleInstallResp",
8268 + "ModuleInstallResp",
8269 + "Sr__ModuleInstallResp",
8270 + "sr",
8271 + sizeof(Sr__ModuleInstallResp),
8272 + 0,
8273 + sr__module_install_resp__field_descriptors,
8274 + sr__module_install_resp__field_indices_by_name,
8275 + 0, sr__module_install_resp__number_ranges,
8276 + (ProtobufCMessageInit) sr__module_install_resp__init,
8277 + NULL,NULL,NULL /* reserved[123] */
8278 +};
8279 +static const ProtobufCFieldDescriptor sr__feature_enable_req__field_descriptors[3] =
8280 +{
8281 + {
8282 + "module_name",
8283 + 1,
8284 + PROTOBUF_C_LABEL_REQUIRED,
8285 + PROTOBUF_C_TYPE_STRING,
8286 + 0, /* quantifier_offset */
8287 + offsetof(Sr__FeatureEnableReq, module_name),
8288 + NULL,
8289 + NULL,
8290 + 0, /* flags */
8291 + 0,NULL,NULL /* reserved1,reserved2, etc */
8292 + },
8293 + {
8294 + "feature_name",
8295 + 2,
8296 + PROTOBUF_C_LABEL_REQUIRED,
8297 + PROTOBUF_C_TYPE_STRING,
8298 + 0, /* quantifier_offset */
8299 + offsetof(Sr__FeatureEnableReq, feature_name),
8300 + NULL,
8301 + NULL,
8302 + 0, /* flags */
8303 + 0,NULL,NULL /* reserved1,reserved2, etc */
8304 + },
8305 + {
8306 + "enabled",
8307 + 3,
8308 + PROTOBUF_C_LABEL_REQUIRED,
8309 + PROTOBUF_C_TYPE_BOOL,
8310 + 0, /* quantifier_offset */
8311 + offsetof(Sr__FeatureEnableReq, enabled),
8312 + NULL,
8313 + NULL,
8314 + 0, /* flags */
8315 + 0,NULL,NULL /* reserved1,reserved2, etc */
8316 + },
8317 +};
8318 +static const unsigned sr__feature_enable_req__field_indices_by_name[] = {
8319 + 2, /* field[2] = enabled */
8320 + 1, /* field[1] = feature_name */
8321 + 0, /* field[0] = module_name */
8322 +};
8323 +static const ProtobufCIntRange sr__feature_enable_req__number_ranges[1 + 1] =
8324 +{
8325 + { 1, 0 },
8326 + { 0, 3 }
8327 +};
8328 +const ProtobufCMessageDescriptor sr__feature_enable_req__descriptor =
8329 +{
8330 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
8331 + "sr.FeatureEnableReq",
8332 + "FeatureEnableReq",
8333 + "Sr__FeatureEnableReq",
8334 + "sr",
8335 + sizeof(Sr__FeatureEnableReq),
8336 + 3,
8337 + sr__feature_enable_req__field_descriptors,
8338 + sr__feature_enable_req__field_indices_by_name,
8339 + 1, sr__feature_enable_req__number_ranges,
8340 + (ProtobufCMessageInit) sr__feature_enable_req__init,
8341 + NULL,NULL,NULL /* reserved[123] */
8342 +};
8343 +#define sr__feature_enable_resp__field_descriptors NULL
8344 +#define sr__feature_enable_resp__field_indices_by_name NULL
8345 +#define sr__feature_enable_resp__number_ranges NULL
8346 +const ProtobufCMessageDescriptor sr__feature_enable_resp__descriptor =
8347 +{
8348 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
8349 + "sr.FeatureEnableResp",
8350 + "FeatureEnableResp",
8351 + "Sr__FeatureEnableResp",
8352 + "sr",
8353 + sizeof(Sr__FeatureEnableResp),
8354 + 0,
8355 + sr__feature_enable_resp__field_descriptors,
8356 + sr__feature_enable_resp__field_indices_by_name,
8357 + 0, sr__feature_enable_resp__number_ranges,
8358 + (ProtobufCMessageInit) sr__feature_enable_resp__init,
8359 + NULL,NULL,NULL /* reserved[123] */
8360 +};
8361 +static const ProtobufCFieldDescriptor sr__unsubscribe_destination_req__field_descriptors[1] =
8362 +{
8363 + {
8364 + "destination",
8365 + 1,
8366 + PROTOBUF_C_LABEL_REQUIRED,
8367 + PROTOBUF_C_TYPE_STRING,
8368 + 0, /* quantifier_offset */
8369 + offsetof(Sr__UnsubscribeDestinationReq, destination),
8370 + NULL,
8371 + NULL,
8372 + 0, /* flags */
8373 + 0,NULL,NULL /* reserved1,reserved2, etc */
8374 + },
8375 +};
8376 +static const unsigned sr__unsubscribe_destination_req__field_indices_by_name[] = {
8377 + 0, /* field[0] = destination */
8378 +};
8379 +static const ProtobufCIntRange sr__unsubscribe_destination_req__number_ranges[1 + 1] =
8380 +{
8381 + { 1, 0 },
8382 + { 0, 1 }
8383 +};
8384 +const ProtobufCMessageDescriptor sr__unsubscribe_destination_req__descriptor =
8385 +{
8386 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
8387 + "sr.UnsubscribeDestinationReq",
8388 + "UnsubscribeDestinationReq",
8389 + "Sr__UnsubscribeDestinationReq",
8390 + "sr",
8391 + sizeof(Sr__UnsubscribeDestinationReq),
8392 + 1,
8393 + sr__unsubscribe_destination_req__field_descriptors,
8394 + sr__unsubscribe_destination_req__field_indices_by_name,
8395 + 1, sr__unsubscribe_destination_req__number_ranges,
8396 + (ProtobufCMessageInit) sr__unsubscribe_destination_req__init,
8397 + NULL,NULL,NULL /* reserved[123] */
8398 +};
8399 +static const ProtobufCFieldDescriptor sr__commit_timeout_req__field_descriptors[2] =
8400 +{
8401 + {
8402 + "commit_id",
8403 + 1,
8404 + PROTOBUF_C_LABEL_REQUIRED,
8405 + PROTOBUF_C_TYPE_UINT32,
8406 + 0, /* quantifier_offset */
8407 + offsetof(Sr__CommitTimeoutReq, commit_id),
8408 + NULL,
8409 + NULL,
8410 + 0, /* flags */
8411 + 0,NULL,NULL /* reserved1,reserved2, etc */
8412 + },
8413 + {
8414 + "expired",
8415 + 2,
8416 + PROTOBUF_C_LABEL_REQUIRED,
8417 + PROTOBUF_C_TYPE_BOOL,
8418 + 0, /* quantifier_offset */
8419 + offsetof(Sr__CommitTimeoutReq, expired),
8420 + NULL,
8421 + NULL,
8422 + 0, /* flags */
8423 + 0,NULL,NULL /* reserved1,reserved2, etc */
8424 + },
8425 +};
8426 +static const unsigned sr__commit_timeout_req__field_indices_by_name[] = {
8427 + 0, /* field[0] = commit_id */
8428 + 1, /* field[1] = expired */
8429 +};
8430 +static const ProtobufCIntRange sr__commit_timeout_req__number_ranges[1 + 1] =
8431 +{
8432 + { 1, 0 },
8433 + { 0, 2 }
8434 +};
8435 +const ProtobufCMessageDescriptor sr__commit_timeout_req__descriptor =
8436 +{
8437 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
8438 + "sr.CommitTimeoutReq",
8439 + "CommitTimeoutReq",
8440 + "Sr__CommitTimeoutReq",
8441 + "sr",
8442 + sizeof(Sr__CommitTimeoutReq),
8443 + 2,
8444 + sr__commit_timeout_req__field_descriptors,
8445 + sr__commit_timeout_req__field_indices_by_name,
8446 + 1, sr__commit_timeout_req__number_ranges,
8447 + (ProtobufCMessageInit) sr__commit_timeout_req__init,
8448 + NULL,NULL,NULL /* reserved[123] */
8449 +};
8450 +static const ProtobufCFieldDescriptor sr__oper_data_timeout_req__field_descriptors[1] =
8451 +{
8452 + {
8453 + "request_id",
8454 + 1,
8455 + PROTOBUF_C_LABEL_REQUIRED,
8456 + PROTOBUF_C_TYPE_UINT64,
8457 + 0, /* quantifier_offset */
8458 + offsetof(Sr__OperDataTimeoutReq, request_id),
8459 + NULL,
8460 + NULL,
8461 + 0, /* flags */
8462 + 0,NULL,NULL /* reserved1,reserved2, etc */
8463 + },
8464 +};
8465 +static const unsigned sr__oper_data_timeout_req__field_indices_by_name[] = {
8466 + 0, /* field[0] = request_id */
8467 +};
8468 +static const ProtobufCIntRange sr__oper_data_timeout_req__number_ranges[1 + 1] =
8469 +{
8470 + { 1, 0 },
8471 + { 0, 1 }
8472 +};
8473 +const ProtobufCMessageDescriptor sr__oper_data_timeout_req__descriptor =
8474 +{
8475 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
8476 + "sr.OperDataTimeoutReq",
8477 + "OperDataTimeoutReq",
8478 + "Sr__OperDataTimeoutReq",
8479 + "sr",
8480 + sizeof(Sr__OperDataTimeoutReq),
8481 + 1,
8482 + sr__oper_data_timeout_req__field_descriptors,
8483 + sr__oper_data_timeout_req__field_indices_by_name,
8484 + 1, sr__oper_data_timeout_req__number_ranges,
8485 + (ProtobufCMessageInit) sr__oper_data_timeout_req__init,
8486 + NULL,NULL,NULL /* reserved[123] */
8487 +};
8488 +static const ProtobufCFieldDescriptor sr__internal_state_data_req__field_descriptors[2] =
8489 +{
8490 + {
8491 + "request_id",
8492 + 1,
8493 + PROTOBUF_C_LABEL_REQUIRED,
8494 + PROTOBUF_C_TYPE_UINT64,
8495 + 0, /* quantifier_offset */
8496 + offsetof(Sr__InternalStateDataReq, request_id),
8497 + NULL,
8498 + NULL,
8499 + 0, /* flags */
8500 + 0,NULL,NULL /* reserved1,reserved2, etc */
8501 + },
8502 + {
8503 + "xpath",
8504 + 2,
8505 + PROTOBUF_C_LABEL_REQUIRED,
8506 + PROTOBUF_C_TYPE_STRING,
8507 + 0, /* quantifier_offset */
8508 + offsetof(Sr__InternalStateDataReq, xpath),
8509 + NULL,
8510 + NULL,
8511 + 0, /* flags */
8512 + 0,NULL,NULL /* reserved1,reserved2, etc */
8513 + },
8514 +};
8515 +static const unsigned sr__internal_state_data_req__field_indices_by_name[] = {
8516 + 0, /* field[0] = request_id */
8517 + 1, /* field[1] = xpath */
8518 +};
8519 +static const ProtobufCIntRange sr__internal_state_data_req__number_ranges[1 + 1] =
8520 +{
8521 + { 1, 0 },
8522 + { 0, 2 }
8523 +};
8524 +const ProtobufCMessageDescriptor sr__internal_state_data_req__descriptor =
8525 +{
8526 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
8527 + "sr.InternalStateDataReq",
8528 + "InternalStateDataReq",
8529 + "Sr__InternalStateDataReq",
8530 + "sr",
8531 + sizeof(Sr__InternalStateDataReq),
8532 + 2,
8533 + sr__internal_state_data_req__field_descriptors,
8534 + sr__internal_state_data_req__field_indices_by_name,
8535 + 1, sr__internal_state_data_req__number_ranges,
8536 + (ProtobufCMessageInit) sr__internal_state_data_req__init,
8537 + NULL,NULL,NULL /* reserved[123] */
8538 +};
8539 +#define sr__notif_store_cleanup_req__field_descriptors NULL
8540 +#define sr__notif_store_cleanup_req__field_indices_by_name NULL
8541 +#define sr__notif_store_cleanup_req__number_ranges NULL
8542 +const ProtobufCMessageDescriptor sr__notif_store_cleanup_req__descriptor =
8543 +{
8544 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
8545 + "sr.NotifStoreCleanupReq",
8546 + "NotifStoreCleanupReq",
8547 + "Sr__NotifStoreCleanupReq",
8548 + "sr",
8549 + sizeof(Sr__NotifStoreCleanupReq),
8550 + 0,
8551 + sr__notif_store_cleanup_req__field_descriptors,
8552 + sr__notif_store_cleanup_req__field_indices_by_name,
8553 + 0, sr__notif_store_cleanup_req__number_ranges,
8554 + (ProtobufCMessageInit) sr__notif_store_cleanup_req__init,
8555 + NULL,NULL,NULL /* reserved[123] */
8556 +};
8557 +static const ProtobufCFieldDescriptor sr__delayed_msg_req__field_descriptors[1] =
8558 +{
8559 + {
8560 + "message",
8561 + 1,
8562 + PROTOBUF_C_LABEL_REQUIRED,
8563 + PROTOBUF_C_TYPE_MESSAGE,
8564 + 0, /* quantifier_offset */
8565 + offsetof(Sr__DelayedMsgReq, message),
8566 + &sr__msg__descriptor,
8567 + NULL,
8568 + 0, /* flags */
8569 + 0,NULL,NULL /* reserved1,reserved2, etc */
8570 + },
8571 +};
8572 +static const unsigned sr__delayed_msg_req__field_indices_by_name[] = {
8573 + 0, /* field[0] = message */
8574 +};
8575 +static const ProtobufCIntRange sr__delayed_msg_req__number_ranges[1 + 1] =
8576 +{
8577 + { 1, 0 },
8578 + { 0, 1 }
8579 +};
8580 +const ProtobufCMessageDescriptor sr__delayed_msg_req__descriptor =
8581 +{
8582 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
8583 + "sr.DelayedMsgReq",
8584 + "DelayedMsgReq",
8585 + "Sr__DelayedMsgReq",
8586 + "sr",
8587 + sizeof(Sr__DelayedMsgReq),
8588 + 1,
8589 + sr__delayed_msg_req__field_descriptors,
8590 + sr__delayed_msg_req__field_indices_by_name,
8591 + 1, sr__delayed_msg_req__number_ranges,
8592 + (ProtobufCMessageInit) sr__delayed_msg_req__init,
8593 + NULL,NULL,NULL /* reserved[123] */
8594 +};
8595 +#define sr__nacm_reload_req__field_descriptors NULL
8596 +#define sr__nacm_reload_req__field_indices_by_name NULL
8597 +#define sr__nacm_reload_req__number_ranges NULL
8598 +const ProtobufCMessageDescriptor sr__nacm_reload_req__descriptor =
8599 +{
8600 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
8601 + "sr.NacmReloadReq",
8602 + "NacmReloadReq",
8603 + "Sr__NacmReloadReq",
8604 + "sr",
8605 + sizeof(Sr__NacmReloadReq),
8606 + 0,
8607 + sr__nacm_reload_req__field_descriptors,
8608 + sr__nacm_reload_req__field_indices_by_name,
8609 + 0, sr__nacm_reload_req__number_ranges,
8610 + (ProtobufCMessageInit) sr__nacm_reload_req__init,
8611 + NULL,NULL,NULL /* reserved[123] */
8612 +};
8613 +static const ProtobufCFieldDescriptor sr__request__field_descriptors[37] =
8614 +{
8615 + {
8616 + "_id",
8617 + 1,
8618 + PROTOBUF_C_LABEL_REQUIRED,
8619 + PROTOBUF_C_TYPE_UINT64,
8620 + 0, /* quantifier_offset */
8621 + offsetof(Sr__Request, _id),
8622 + NULL,
8623 + NULL,
8624 + 0, /* flags */
8625 + 0,NULL,NULL /* reserved1,reserved2, etc */
8626 + },
8627 + {
8628 + "operation",
8629 + 2,
8630 + PROTOBUF_C_LABEL_REQUIRED,
8631 + PROTOBUF_C_TYPE_ENUM,
8632 + 0, /* quantifier_offset */
8633 + offsetof(Sr__Request, operation),
8634 + &sr__operation__descriptor,
8635 + NULL,
8636 + 0, /* flags */
8637 + 0,NULL,NULL /* reserved1,reserved2, etc */
8638 + },
8639 + {
8640 + "session_start_req",
8641 + 10,
8642 + PROTOBUF_C_LABEL_OPTIONAL,
8643 + PROTOBUF_C_TYPE_MESSAGE,
8644 + 0, /* quantifier_offset */
8645 + offsetof(Sr__Request, session_start_req),
8646 + &sr__session_start_req__descriptor,
8647 + NULL,
8648 + 0, /* flags */
8649 + 0,NULL,NULL /* reserved1,reserved2, etc */
8650 + },
8651 + {
8652 + "session_stop_req",
8653 + 11,
8654 + PROTOBUF_C_LABEL_OPTIONAL,
8655 + PROTOBUF_C_TYPE_MESSAGE,
8656 + 0, /* quantifier_offset */
8657 + offsetof(Sr__Request, session_stop_req),
8658 + &sr__session_stop_req__descriptor,
8659 + NULL,
8660 + 0, /* flags */
8661 + 0,NULL,NULL /* reserved1,reserved2, etc */
8662 + },
8663 + {
8664 + "session_refresh_req",
8665 + 12,
8666 + PROTOBUF_C_LABEL_OPTIONAL,
8667 + PROTOBUF_C_TYPE_MESSAGE,
8668 + 0, /* quantifier_offset */
8669 + offsetof(Sr__Request, session_refresh_req),
8670 + &sr__session_refresh_req__descriptor,
8671 + NULL,
8672 + 0, /* flags */
8673 + 0,NULL,NULL /* reserved1,reserved2, etc */
8674 + },
8675 + {
8676 + "session_check_req",
8677 + 13,
8678 + PROTOBUF_C_LABEL_OPTIONAL,
8679 + PROTOBUF_C_TYPE_MESSAGE,
8680 + 0, /* quantifier_offset */
8681 + offsetof(Sr__Request, session_check_req),
8682 + &sr__session_check_req__descriptor,
8683 + NULL,
8684 + 0, /* flags */
8685 + 0,NULL,NULL /* reserved1,reserved2, etc */
8686 + },
8687 + {
8688 + "session_switch_ds_req",
8689 + 14,
8690 + PROTOBUF_C_LABEL_OPTIONAL,
8691 + PROTOBUF_C_TYPE_MESSAGE,
8692 + 0, /* quantifier_offset */
8693 + offsetof(Sr__Request, session_switch_ds_req),
8694 + &sr__session_switch_ds_req__descriptor,
8695 + NULL,
8696 + 0, /* flags */
8697 + 0,NULL,NULL /* reserved1,reserved2, etc */
8698 + },
8699 + {
8700 + "session_set_opts_req",
8701 + 15,
8702 + PROTOBUF_C_LABEL_OPTIONAL,
8703 + PROTOBUF_C_TYPE_MESSAGE,
8704 + 0, /* quantifier_offset */
8705 + offsetof(Sr__Request, session_set_opts_req),
8706 + &sr__session_set_opts_req__descriptor,
8707 + NULL,
8708 + 0, /* flags */
8709 + 0,NULL,NULL /* reserved1,reserved2, etc */
8710 + },
8711 + {
8712 + "version_verify_req",
8713 + 16,
8714 + PROTOBUF_C_LABEL_OPTIONAL,
8715 + PROTOBUF_C_TYPE_MESSAGE,
8716 + 0, /* quantifier_offset */
8717 + offsetof(Sr__Request, version_verify_req),
8718 + &sr__version_verify_req__descriptor,
8719 + NULL,
8720 + 0, /* flags */
8721 + 0,NULL,NULL /* reserved1,reserved2, etc */
8722 + },
8723 + {
8724 + "list_schemas_req",
8725 + 20,
8726 + PROTOBUF_C_LABEL_OPTIONAL,
8727 + PROTOBUF_C_TYPE_MESSAGE,
8728 + 0, /* quantifier_offset */
8729 + offsetof(Sr__Request, list_schemas_req),
8730 + &sr__list_schemas_req__descriptor,
8731 + NULL,
8732 + 0, /* flags */
8733 + 0,NULL,NULL /* reserved1,reserved2, etc */
8734 + },
8735 + {
8736 + "get_schema_req",
8737 + 21,
8738 + PROTOBUF_C_LABEL_OPTIONAL,
8739 + PROTOBUF_C_TYPE_MESSAGE,
8740 + 0, /* quantifier_offset */
8741 + offsetof(Sr__Request, get_schema_req),
8742 + &sr__get_schema_req__descriptor,
8743 + NULL,
8744 + 0, /* flags */
8745 + 0,NULL,NULL /* reserved1,reserved2, etc */
8746 + },
8747 + {
8748 + "module_install_req",
8749 + 22,
8750 + PROTOBUF_C_LABEL_OPTIONAL,
8751 + PROTOBUF_C_TYPE_MESSAGE,
8752 + 0, /* quantifier_offset */
8753 + offsetof(Sr__Request, module_install_req),
8754 + &sr__module_install_req__descriptor,
8755 + NULL,
8756 + 0, /* flags */
8757 + 0,NULL,NULL /* reserved1,reserved2, etc */
8758 + },
8759 + {
8760 + "feature_enable_req",
8761 + 23,
8762 + PROTOBUF_C_LABEL_OPTIONAL,
8763 + PROTOBUF_C_TYPE_MESSAGE,
8764 + 0, /* quantifier_offset */
8765 + offsetof(Sr__Request, feature_enable_req),
8766 + &sr__feature_enable_req__descriptor,
8767 + NULL,
8768 + 0, /* flags */
8769 + 0,NULL,NULL /* reserved1,reserved2, etc */
8770 + },
8771 + {
8772 + "get_item_req",
8773 + 30,
8774 + PROTOBUF_C_LABEL_OPTIONAL,
8775 + PROTOBUF_C_TYPE_MESSAGE,
8776 + 0, /* quantifier_offset */
8777 + offsetof(Sr__Request, get_item_req),
8778 + &sr__get_item_req__descriptor,
8779 + NULL,
8780 + 0, /* flags */
8781 + 0,NULL,NULL /* reserved1,reserved2, etc */
8782 + },
8783 + {
8784 + "get_items_req",
8785 + 31,
8786 + PROTOBUF_C_LABEL_OPTIONAL,
8787 + PROTOBUF_C_TYPE_MESSAGE,
8788 + 0, /* quantifier_offset */
8789 + offsetof(Sr__Request, get_items_req),
8790 + &sr__get_items_req__descriptor,
8791 + NULL,
8792 + 0, /* flags */
8793 + 0,NULL,NULL /* reserved1,reserved2, etc */
8794 + },
8795 + {
8796 + "get_subtree_req",
8797 + 32,
8798 + PROTOBUF_C_LABEL_OPTIONAL,
8799 + PROTOBUF_C_TYPE_MESSAGE,
8800 + 0, /* quantifier_offset */
8801 + offsetof(Sr__Request, get_subtree_req),
8802 + &sr__get_subtree_req__descriptor,
8803 + NULL,
8804 + 0, /* flags */
8805 + 0,NULL,NULL /* reserved1,reserved2, etc */
8806 + },
8807 + {
8808 + "get_subtrees_req",
8809 + 33,
8810 + PROTOBUF_C_LABEL_OPTIONAL,
8811 + PROTOBUF_C_TYPE_MESSAGE,
8812 + 0, /* quantifier_offset */
8813 + offsetof(Sr__Request, get_subtrees_req),
8814 + &sr__get_subtrees_req__descriptor,
8815 + NULL,
8816 + 0, /* flags */
8817 + 0,NULL,NULL /* reserved1,reserved2, etc */
8818 + },
8819 + {
8820 + "get_subtree_chunk_req",
8821 + 34,
8822 + PROTOBUF_C_LABEL_OPTIONAL,
8823 + PROTOBUF_C_TYPE_MESSAGE,
8824 + 0, /* quantifier_offset */
8825 + offsetof(Sr__Request, get_subtree_chunk_req),
8826 + &sr__get_subtree_chunk_req__descriptor,
8827 + NULL,
8828 + 0, /* flags */
8829 + 0,NULL,NULL /* reserved1,reserved2, etc */
8830 + },
8831 + {
8832 + "set_item_req",
8833 + 40,
8834 + PROTOBUF_C_LABEL_OPTIONAL,
8835 + PROTOBUF_C_TYPE_MESSAGE,
8836 + 0, /* quantifier_offset */
8837 + offsetof(Sr__Request, set_item_req),
8838 + &sr__set_item_req__descriptor,
8839 + NULL,
8840 + 0, /* flags */
8841 + 0,NULL,NULL /* reserved1,reserved2, etc */
8842 + },
8843 + {
8844 + "delete_item_req",
8845 + 41,
8846 + PROTOBUF_C_LABEL_OPTIONAL,
8847 + PROTOBUF_C_TYPE_MESSAGE,
8848 + 0, /* quantifier_offset */
8849 + offsetof(Sr__Request, delete_item_req),
8850 + &sr__delete_item_req__descriptor,
8851 + NULL,
8852 + 0, /* flags */
8853 + 0,NULL,NULL /* reserved1,reserved2, etc */
8854 + },
8855 + {
8856 + "move_item_req",
8857 + 42,
8858 + PROTOBUF_C_LABEL_OPTIONAL,
8859 + PROTOBUF_C_TYPE_MESSAGE,
8860 + 0, /* quantifier_offset */
8861 + offsetof(Sr__Request, move_item_req),
8862 + &sr__move_item_req__descriptor,
8863 + NULL,
8864 + 0, /* flags */
8865 + 0,NULL,NULL /* reserved1,reserved2, etc */
8866 + },
8867 + {
8868 + "set_item_str_req",
8869 + 43,
8870 + PROTOBUF_C_LABEL_OPTIONAL,
8871 + PROTOBUF_C_TYPE_MESSAGE,
8872 + 0, /* quantifier_offset */
8873 + offsetof(Sr__Request, set_item_str_req),
8874 + &sr__set_item_str_req__descriptor,
8875 + NULL,
8876 + 0, /* flags */
8877 + 0,NULL,NULL /* reserved1,reserved2, etc */
8878 + },
8879 + {
8880 + "validate_req",
8881 + 50,
8882 + PROTOBUF_C_LABEL_OPTIONAL,
8883 + PROTOBUF_C_TYPE_MESSAGE,
8884 + 0, /* quantifier_offset */
8885 + offsetof(Sr__Request, validate_req),
8886 + &sr__validate_req__descriptor,
8887 + NULL,
8888 + 0, /* flags */
8889 + 0,NULL,NULL /* reserved1,reserved2, etc */
8890 + },
8891 + {
8892 + "commit_req",
8893 + 51,
8894 + PROTOBUF_C_LABEL_OPTIONAL,
8895 + PROTOBUF_C_TYPE_MESSAGE,
8896 + 0, /* quantifier_offset */
8897 + offsetof(Sr__Request, commit_req),
8898 + &sr__commit_req__descriptor,
8899 + NULL,
8900 + 0, /* flags */
8901 + 0,NULL,NULL /* reserved1,reserved2, etc */
8902 + },
8903 + {
8904 + "discard_changes_req",
8905 + 52,
8906 + PROTOBUF_C_LABEL_OPTIONAL,
8907 + PROTOBUF_C_TYPE_MESSAGE,
8908 + 0, /* quantifier_offset */
8909 + offsetof(Sr__Request, discard_changes_req),
8910 + &sr__discard_changes_req__descriptor,
8911 + NULL,
8912 + 0, /* flags */
8913 + 0,NULL,NULL /* reserved1,reserved2, etc */
8914 + },
8915 + {
8916 + "copy_config_req",
8917 + 53,
8918 + PROTOBUF_C_LABEL_OPTIONAL,
8919 + PROTOBUF_C_TYPE_MESSAGE,
8920 + 0, /* quantifier_offset */
8921 + offsetof(Sr__Request, copy_config_req),
8922 + &sr__copy_config_req__descriptor,
8923 + NULL,
8924 + 0, /* flags */
8925 + 0,NULL,NULL /* reserved1,reserved2, etc */
8926 + },
8927 + {
8928 + "lock_req",
8929 + 60,
8930 + PROTOBUF_C_LABEL_OPTIONAL,
8931 + PROTOBUF_C_TYPE_MESSAGE,
8932 + 0, /* quantifier_offset */
8933 + offsetof(Sr__Request, lock_req),
8934 + &sr__lock_req__descriptor,
8935 + NULL,
8936 + 0, /* flags */
8937 + 0,NULL,NULL /* reserved1,reserved2, etc */
8938 + },
8939 + {
8940 + "unlock_req",
8941 + 61,
8942 + PROTOBUF_C_LABEL_OPTIONAL,
8943 + PROTOBUF_C_TYPE_MESSAGE,
8944 + 0, /* quantifier_offset */
8945 + offsetof(Sr__Request, unlock_req),
8946 + &sr__unlock_req__descriptor,
8947 + NULL,
8948 + 0, /* flags */
8949 + 0,NULL,NULL /* reserved1,reserved2, etc */
8950 + },
8951 + {
8952 + "subscribe_req",
8953 + 70,
8954 + PROTOBUF_C_LABEL_OPTIONAL,
8955 + PROTOBUF_C_TYPE_MESSAGE,
8956 + 0, /* quantifier_offset */
8957 + offsetof(Sr__Request, subscribe_req),
8958 + &sr__subscribe_req__descriptor,
8959 + NULL,
8960 + 0, /* flags */
8961 + 0,NULL,NULL /* reserved1,reserved2, etc */
8962 + },
8963 + {
8964 + "unsubscribe_req",
8965 + 71,
8966 + PROTOBUF_C_LABEL_OPTIONAL,
8967 + PROTOBUF_C_TYPE_MESSAGE,
8968 + 0, /* quantifier_offset */
8969 + offsetof(Sr__Request, unsubscribe_req),
8970 + &sr__unsubscribe_req__descriptor,
8971 + NULL,
8972 + 0, /* flags */
8973 + 0,NULL,NULL /* reserved1,reserved2, etc */
8974 + },
8975 + {
8976 + "check_enabled_running_req",
8977 + 72,
8978 + PROTOBUF_C_LABEL_OPTIONAL,
8979 + PROTOBUF_C_TYPE_MESSAGE,
8980 + 0, /* quantifier_offset */
8981 + offsetof(Sr__Request, check_enabled_running_req),
8982 + &sr__check_enabled_running_req__descriptor,
8983 + NULL,
8984 + 0, /* flags */
8985 + 0,NULL,NULL /* reserved1,reserved2, etc */
8986 + },
8987 + {
8988 + "get_changes_req",
8989 + 73,
8990 + PROTOBUF_C_LABEL_OPTIONAL,
8991 + PROTOBUF_C_TYPE_MESSAGE,
8992 + 0, /* quantifier_offset */
8993 + offsetof(Sr__Request, get_changes_req),
8994 + &sr__get_changes_req__descriptor,
8995 + NULL,
8996 + 0, /* flags */
8997 + 0,NULL,NULL /* reserved1,reserved2, etc */
8998 + },
8999 + {
9000 + "data_provide_req",
9001 + 80,
9002 + PROTOBUF_C_LABEL_OPTIONAL,
9003 + PROTOBUF_C_TYPE_MESSAGE,
9004 + 0, /* quantifier_offset */
9005 + offsetof(Sr__Request, data_provide_req),
9006 + &sr__data_provide_req__descriptor,
9007 + NULL,
9008 + 0, /* flags */
9009 + 0,NULL,NULL /* reserved1,reserved2, etc */
9010 + },
9011 + {
9012 + "check_exec_perm_req",
9013 + 81,
9014 + PROTOBUF_C_LABEL_OPTIONAL,
9015 + PROTOBUF_C_TYPE_MESSAGE,
9016 + 0, /* quantifier_offset */
9017 + offsetof(Sr__Request, check_exec_perm_req),
9018 + &sr__check_exec_perm_req__descriptor,
9019 + NULL,
9020 + 0, /* flags */
9021 + 0,NULL,NULL /* reserved1,reserved2, etc */
9022 + },
9023 + {
9024 + "rpc_req",
9025 + 82,
9026 + PROTOBUF_C_LABEL_OPTIONAL,
9027 + PROTOBUF_C_TYPE_MESSAGE,
9028 + 0, /* quantifier_offset */
9029 + offsetof(Sr__Request, rpc_req),
9030 + &sr__rpcreq__descriptor,
9031 + NULL,
9032 + 0, /* flags */
9033 + 0,NULL,NULL /* reserved1,reserved2, etc */
9034 + },
9035 + {
9036 + "event_notif_req",
9037 + 83,
9038 + PROTOBUF_C_LABEL_OPTIONAL,
9039 + PROTOBUF_C_TYPE_MESSAGE,
9040 + 0, /* quantifier_offset */
9041 + offsetof(Sr__Request, event_notif_req),
9042 + &sr__event_notif_req__descriptor,
9043 + NULL,
9044 + 0, /* flags */
9045 + 0,NULL,NULL /* reserved1,reserved2, etc */
9046 + },
9047 + {
9048 + "event_notif_replay_req",
9049 + 84,
9050 + PROTOBUF_C_LABEL_OPTIONAL,
9051 + PROTOBUF_C_TYPE_MESSAGE,
9052 + 0, /* quantifier_offset */
9053 + offsetof(Sr__Request, event_notif_replay_req),
9054 + &sr__event_notif_replay_req__descriptor,
9055 + NULL,
9056 + 0, /* flags */
9057 + 0,NULL,NULL /* reserved1,reserved2, etc */
9058 + },
9059 +};
9060 +static const unsigned sr__request__field_indices_by_name[] = {
9061 + 0, /* field[0] = _id */
9062 + 30, /* field[30] = check_enabled_running_req */
9063 + 33, /* field[33] = check_exec_perm_req */
9064 + 23, /* field[23] = commit_req */
9065 + 25, /* field[25] = copy_config_req */
9066 + 32, /* field[32] = data_provide_req */
9067 + 19, /* field[19] = delete_item_req */
9068 + 24, /* field[24] = discard_changes_req */
9069 + 36, /* field[36] = event_notif_replay_req */
9070 + 35, /* field[35] = event_notif_req */
9071 + 12, /* field[12] = feature_enable_req */
9072 + 31, /* field[31] = get_changes_req */
9073 + 13, /* field[13] = get_item_req */
9074 + 14, /* field[14] = get_items_req */
9075 + 10, /* field[10] = get_schema_req */
9076 + 17, /* field[17] = get_subtree_chunk_req */
9077 + 15, /* field[15] = get_subtree_req */
9078 + 16, /* field[16] = get_subtrees_req */
9079 + 9, /* field[9] = list_schemas_req */
9080 + 26, /* field[26] = lock_req */
9081 + 11, /* field[11] = module_install_req */
9082 + 20, /* field[20] = move_item_req */
9083 + 1, /* field[1] = operation */
9084 + 34, /* field[34] = rpc_req */
9085 + 5, /* field[5] = session_check_req */
9086 + 4, /* field[4] = session_refresh_req */
9087 + 7, /* field[7] = session_set_opts_req */
9088 + 2, /* field[2] = session_start_req */
9089 + 3, /* field[3] = session_stop_req */
9090 + 6, /* field[6] = session_switch_ds_req */
9091 + 18, /* field[18] = set_item_req */
9092 + 21, /* field[21] = set_item_str_req */
9093 + 28, /* field[28] = subscribe_req */
9094 + 27, /* field[27] = unlock_req */
9095 + 29, /* field[29] = unsubscribe_req */
9096 + 22, /* field[22] = validate_req */
9097 + 8, /* field[8] = version_verify_req */
9098 +};
9099 +static const ProtobufCIntRange sr__request__number_ranges[9 + 1] =
9100 +{
9101 + { 1, 0 },
9102 + { 10, 2 },
9103 + { 20, 9 },
9104 + { 30, 13 },
9105 + { 40, 18 },
9106 + { 50, 22 },
9107 + { 60, 26 },
9108 + { 70, 28 },
9109 + { 80, 32 },
9110 + { 0, 37 }
9111 +};
9112 +const ProtobufCMessageDescriptor sr__request__descriptor =
9113 +{
9114 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
9115 + "sr.Request",
9116 + "Request",
9117 + "Sr__Request",
9118 + "sr",
9119 + sizeof(Sr__Request),
9120 + 37,
9121 + sr__request__field_descriptors,
9122 + sr__request__field_indices_by_name,
9123 + 9, sr__request__number_ranges,
9124 + (ProtobufCMessageInit) sr__request__init,
9125 + NULL,NULL,NULL /* reserved[123] */
9126 +};
9127 +static const ProtobufCFieldDescriptor sr__response__field_descriptors[38] =
9128 +{
9129 + {
9130 + "operation",
9131 + 1,
9132 + PROTOBUF_C_LABEL_REQUIRED,
9133 + PROTOBUF_C_TYPE_ENUM,
9134 + 0, /* quantifier_offset */
9135 + offsetof(Sr__Response, operation),
9136 + &sr__operation__descriptor,
9137 + NULL,
9138 + 0, /* flags */
9139 + 0,NULL,NULL /* reserved1,reserved2, etc */
9140 + },
9141 + {
9142 + "result",
9143 + 2,
9144 + PROTOBUF_C_LABEL_REQUIRED,
9145 + PROTOBUF_C_TYPE_UINT32,
9146 + 0, /* quantifier_offset */
9147 + offsetof(Sr__Response, result),
9148 + NULL,
9149 + NULL,
9150 + 0, /* flags */
9151 + 0,NULL,NULL /* reserved1,reserved2, etc */
9152 + },
9153 + {
9154 + "error",
9155 + 3,
9156 + PROTOBUF_C_LABEL_OPTIONAL,
9157 + PROTOBUF_C_TYPE_MESSAGE,
9158 + 0, /* quantifier_offset */
9159 + offsetof(Sr__Response, error),
9160 + &sr__error__descriptor,
9161 + NULL,
9162 + 0, /* flags */
9163 + 0,NULL,NULL /* reserved1,reserved2, etc */
9164 + },
9165 + {
9166 + "session_start_resp",
9167 + 10,
9168 + PROTOBUF_C_LABEL_OPTIONAL,
9169 + PROTOBUF_C_TYPE_MESSAGE,
9170 + 0, /* quantifier_offset */
9171 + offsetof(Sr__Response, session_start_resp),
9172 + &sr__session_start_resp__descriptor,
9173 + NULL,
9174 + 0, /* flags */
9175 + 0,NULL,NULL /* reserved1,reserved2, etc */
9176 + },
9177 + {
9178 + "session_stop_resp",
9179 + 11,
9180 + PROTOBUF_C_LABEL_OPTIONAL,
9181 + PROTOBUF_C_TYPE_MESSAGE,
9182 + 0, /* quantifier_offset */
9183 + offsetof(Sr__Response, session_stop_resp),
9184 + &sr__session_stop_resp__descriptor,
9185 + NULL,
9186 + 0, /* flags */
9187 + 0,NULL,NULL /* reserved1,reserved2, etc */
9188 + },
9189 + {
9190 + "session_refresh_resp",
9191 + 12,
9192 + PROTOBUF_C_LABEL_OPTIONAL,
9193 + PROTOBUF_C_TYPE_MESSAGE,
9194 + 0, /* quantifier_offset */
9195 + offsetof(Sr__Response, session_refresh_resp),
9196 + &sr__session_refresh_resp__descriptor,
9197 + NULL,
9198 + 0, /* flags */
9199 + 0,NULL,NULL /* reserved1,reserved2, etc */
9200 + },
9201 + {
9202 + "session_check_resp",
9203 + 13,
9204 + PROTOBUF_C_LABEL_OPTIONAL,
9205 + PROTOBUF_C_TYPE_MESSAGE,
9206 + 0, /* quantifier_offset */
9207 + offsetof(Sr__Response, session_check_resp),
9208 + &sr__session_check_resp__descriptor,
9209 + NULL,
9210 + 0, /* flags */
9211 + 0,NULL,NULL /* reserved1,reserved2, etc */
9212 + },
9213 + {
9214 + "session_switch_ds_resp",
9215 + 14,
9216 + PROTOBUF_C_LABEL_OPTIONAL,
9217 + PROTOBUF_C_TYPE_MESSAGE,
9218 + 0, /* quantifier_offset */
9219 + offsetof(Sr__Response, session_switch_ds_resp),
9220 + &sr__session_switch_ds_resp__descriptor,
9221 + NULL,
9222 + 0, /* flags */
9223 + 0,NULL,NULL /* reserved1,reserved2, etc */
9224 + },
9225 + {
9226 + "session_set_opts_resp",
9227 + 15,
9228 + PROTOBUF_C_LABEL_OPTIONAL,
9229 + PROTOBUF_C_TYPE_MESSAGE,
9230 + 0, /* quantifier_offset */
9231 + offsetof(Sr__Response, session_set_opts_resp),
9232 + &sr__session_set_opts_resp__descriptor,
9233 + NULL,
9234 + 0, /* flags */
9235 + 0,NULL,NULL /* reserved1,reserved2, etc */
9236 + },
9237 + {
9238 + "version_verify_resp",
9239 + 16,
9240 + PROTOBUF_C_LABEL_OPTIONAL,
9241 + PROTOBUF_C_TYPE_MESSAGE,
9242 + 0, /* quantifier_offset */
9243 + offsetof(Sr__Response, version_verify_resp),
9244 + &sr__version_verify_resp__descriptor,
9245 + NULL,
9246 + 0, /* flags */
9247 + 0,NULL,NULL /* reserved1,reserved2, etc */
9248 + },
9249 + {
9250 + "list_schemas_resp",
9251 + 20,
9252 + PROTOBUF_C_LABEL_OPTIONAL,
9253 + PROTOBUF_C_TYPE_MESSAGE,
9254 + 0, /* quantifier_offset */
9255 + offsetof(Sr__Response, list_schemas_resp),
9256 + &sr__list_schemas_resp__descriptor,
9257 + NULL,
9258 + 0, /* flags */
9259 + 0,NULL,NULL /* reserved1,reserved2, etc */
9260 + },
9261 + {
9262 + "get_schema_resp",
9263 + 21,
9264 + PROTOBUF_C_LABEL_OPTIONAL,
9265 + PROTOBUF_C_TYPE_MESSAGE,
9266 + 0, /* quantifier_offset */
9267 + offsetof(Sr__Response, get_schema_resp),
9268 + &sr__get_schema_resp__descriptor,
9269 + NULL,
9270 + 0, /* flags */
9271 + 0,NULL,NULL /* reserved1,reserved2, etc */
9272 + },
9273 + {
9274 + "module_install_resp",
9275 + 22,
9276 + PROTOBUF_C_LABEL_OPTIONAL,
9277 + PROTOBUF_C_TYPE_MESSAGE,
9278 + 0, /* quantifier_offset */
9279 + offsetof(Sr__Response, module_install_resp),
9280 + &sr__module_install_resp__descriptor,
9281 + NULL,
9282 + 0, /* flags */
9283 + 0,NULL,NULL /* reserved1,reserved2, etc */
9284 + },
9285 + {
9286 + "feature_enable_resp",
9287 + 23,
9288 + PROTOBUF_C_LABEL_OPTIONAL,
9289 + PROTOBUF_C_TYPE_MESSAGE,
9290 + 0, /* quantifier_offset */
9291 + offsetof(Sr__Response, feature_enable_resp),
9292 + &sr__feature_enable_resp__descriptor,
9293 + NULL,
9294 + 0, /* flags */
9295 + 0,NULL,NULL /* reserved1,reserved2, etc */
9296 + },
9297 + {
9298 + "get_item_resp",
9299 + 30,
9300 + PROTOBUF_C_LABEL_OPTIONAL,
9301 + PROTOBUF_C_TYPE_MESSAGE,
9302 + 0, /* quantifier_offset */
9303 + offsetof(Sr__Response, get_item_resp),
9304 + &sr__get_item_resp__descriptor,
9305 + NULL,
9306 + 0, /* flags */
9307 + 0,NULL,NULL /* reserved1,reserved2, etc */
9308 + },
9309 + {
9310 + "get_items_resp",
9311 + 31,
9312 + PROTOBUF_C_LABEL_OPTIONAL,
9313 + PROTOBUF_C_TYPE_MESSAGE,
9314 + 0, /* quantifier_offset */
9315 + offsetof(Sr__Response, get_items_resp),
9316 + &sr__get_items_resp__descriptor,
9317 + NULL,
9318 + 0, /* flags */
9319 + 0,NULL,NULL /* reserved1,reserved2, etc */
9320 + },
9321 + {
9322 + "get_subtree_resp",
9323 + 32,
9324 + PROTOBUF_C_LABEL_OPTIONAL,
9325 + PROTOBUF_C_TYPE_MESSAGE,
9326 + 0, /* quantifier_offset */
9327 + offsetof(Sr__Response, get_subtree_resp),
9328 + &sr__get_subtree_resp__descriptor,
9329 + NULL,
9330 + 0, /* flags */
9331 + 0,NULL,NULL /* reserved1,reserved2, etc */
9332 + },
9333 + {
9334 + "get_subtrees_resp",
9335 + 33,
9336 + PROTOBUF_C_LABEL_OPTIONAL,
9337 + PROTOBUF_C_TYPE_MESSAGE,
9338 + 0, /* quantifier_offset */
9339 + offsetof(Sr__Response, get_subtrees_resp),
9340 + &sr__get_subtrees_resp__descriptor,
9341 + NULL,
9342 + 0, /* flags */
9343 + 0,NULL,NULL /* reserved1,reserved2, etc */
9344 + },
9345 + {
9346 + "get_subtree_chunk_resp",
9347 + 34,
9348 + PROTOBUF_C_LABEL_OPTIONAL,
9349 + PROTOBUF_C_TYPE_MESSAGE,
9350 + 0, /* quantifier_offset */
9351 + offsetof(Sr__Response, get_subtree_chunk_resp),
9352 + &sr__get_subtree_chunk_resp__descriptor,
9353 + NULL,
9354 + 0, /* flags */
9355 + 0,NULL,NULL /* reserved1,reserved2, etc */
9356 + },
9357 + {
9358 + "set_item_resp",
9359 + 40,
9360 + PROTOBUF_C_LABEL_OPTIONAL,
9361 + PROTOBUF_C_TYPE_MESSAGE,
9362 + 0, /* quantifier_offset */
9363 + offsetof(Sr__Response, set_item_resp),
9364 + &sr__set_item_resp__descriptor,
9365 + NULL,
9366 + 0, /* flags */
9367 + 0,NULL,NULL /* reserved1,reserved2, etc */
9368 + },
9369 + {
9370 + "delete_item_resp",
9371 + 41,
9372 + PROTOBUF_C_LABEL_OPTIONAL,
9373 + PROTOBUF_C_TYPE_MESSAGE,
9374 + 0, /* quantifier_offset */
9375 + offsetof(Sr__Response, delete_item_resp),
9376 + &sr__delete_item_resp__descriptor,
9377 + NULL,
9378 + 0, /* flags */
9379 + 0,NULL,NULL /* reserved1,reserved2, etc */
9380 + },
9381 + {
9382 + "move_item_resp",
9383 + 42,
9384 + PROTOBUF_C_LABEL_OPTIONAL,
9385 + PROTOBUF_C_TYPE_MESSAGE,
9386 + 0, /* quantifier_offset */
9387 + offsetof(Sr__Response, move_item_resp),
9388 + &sr__move_item_resp__descriptor,
9389 + NULL,
9390 + 0, /* flags */
9391 + 0,NULL,NULL /* reserved1,reserved2, etc */
9392 + },
9393 + {
9394 + "set_item_str_resp",
9395 + 43,
9396 + PROTOBUF_C_LABEL_OPTIONAL,
9397 + PROTOBUF_C_TYPE_MESSAGE,
9398 + 0, /* quantifier_offset */
9399 + offsetof(Sr__Response, set_item_str_resp),
9400 + &sr__set_item_str_resp__descriptor,
9401 + NULL,
9402 + 0, /* flags */
9403 + 0,NULL,NULL /* reserved1,reserved2, etc */
9404 + },
9405 + {
9406 + "validate_resp",
9407 + 50,
9408 + PROTOBUF_C_LABEL_OPTIONAL,
9409 + PROTOBUF_C_TYPE_MESSAGE,
9410 + 0, /* quantifier_offset */
9411 + offsetof(Sr__Response, validate_resp),
9412 + &sr__validate_resp__descriptor,
9413 + NULL,
9414 + 0, /* flags */
9415 + 0,NULL,NULL /* reserved1,reserved2, etc */
9416 + },
9417 + {
9418 + "commit_resp",
9419 + 51,
9420 + PROTOBUF_C_LABEL_OPTIONAL,
9421 + PROTOBUF_C_TYPE_MESSAGE,
9422 + 0, /* quantifier_offset */
9423 + offsetof(Sr__Response, commit_resp),
9424 + &sr__commit_resp__descriptor,
9425 + NULL,
9426 + 0, /* flags */
9427 + 0,NULL,NULL /* reserved1,reserved2, etc */
9428 + },
9429 + {
9430 + "discard_changes_resp",
9431 + 52,
9432 + PROTOBUF_C_LABEL_OPTIONAL,
9433 + PROTOBUF_C_TYPE_MESSAGE,
9434 + 0, /* quantifier_offset */
9435 + offsetof(Sr__Response, discard_changes_resp),
9436 + &sr__discard_changes_resp__descriptor,
9437 + NULL,
9438 + 0, /* flags */
9439 + 0,NULL,NULL /* reserved1,reserved2, etc */
9440 + },
9441 + {
9442 + "copy_config_resp",
9443 + 53,
9444 + PROTOBUF_C_LABEL_OPTIONAL,
9445 + PROTOBUF_C_TYPE_MESSAGE,
9446 + 0, /* quantifier_offset */
9447 + offsetof(Sr__Response, copy_config_resp),
9448 + &sr__copy_config_resp__descriptor,
9449 + NULL,
9450 + 0, /* flags */
9451 + 0,NULL,NULL /* reserved1,reserved2, etc */
9452 + },
9453 + {
9454 + "lock_resp",
9455 + 60,
9456 + PROTOBUF_C_LABEL_OPTIONAL,
9457 + PROTOBUF_C_TYPE_MESSAGE,
9458 + 0, /* quantifier_offset */
9459 + offsetof(Sr__Response, lock_resp),
9460 + &sr__lock_resp__descriptor,
9461 + NULL,
9462 + 0, /* flags */
9463 + 0,NULL,NULL /* reserved1,reserved2, etc */
9464 + },
9465 + {
9466 + "unlock_resp",
9467 + 61,
9468 + PROTOBUF_C_LABEL_OPTIONAL,
9469 + PROTOBUF_C_TYPE_MESSAGE,
9470 + 0, /* quantifier_offset */
9471 + offsetof(Sr__Response, unlock_resp),
9472 + &sr__unlock_resp__descriptor,
9473 + NULL,
9474 + 0, /* flags */
9475 + 0,NULL,NULL /* reserved1,reserved2, etc */
9476 + },
9477 + {
9478 + "subscribe_resp",
9479 + 70,
9480 + PROTOBUF_C_LABEL_OPTIONAL,
9481 + PROTOBUF_C_TYPE_MESSAGE,
9482 + 0, /* quantifier_offset */
9483 + offsetof(Sr__Response, subscribe_resp),
9484 + &sr__subscribe_resp__descriptor,
9485 + NULL,
9486 + 0, /* flags */
9487 + 0,NULL,NULL /* reserved1,reserved2, etc */
9488 + },
9489 + {
9490 + "unsubscribe_resp",
9491 + 71,
9492 + PROTOBUF_C_LABEL_OPTIONAL,
9493 + PROTOBUF_C_TYPE_MESSAGE,
9494 + 0, /* quantifier_offset */
9495 + offsetof(Sr__Response, unsubscribe_resp),
9496 + &sr__unsubscribe_resp__descriptor,
9497 + NULL,
9498 + 0, /* flags */
9499 + 0,NULL,NULL /* reserved1,reserved2, etc */
9500 + },
9501 + {
9502 + "check_enabled_running_resp",
9503 + 72,
9504 + PROTOBUF_C_LABEL_OPTIONAL,
9505 + PROTOBUF_C_TYPE_MESSAGE,
9506 + 0, /* quantifier_offset */
9507 + offsetof(Sr__Response, check_enabled_running_resp),
9508 + &sr__check_enabled_running_resp__descriptor,
9509 + NULL,
9510 + 0, /* flags */
9511 + 0,NULL,NULL /* reserved1,reserved2, etc */
9512 + },
9513 + {
9514 + "get_changes_resp",
9515 + 73,
9516 + PROTOBUF_C_LABEL_OPTIONAL,
9517 + PROTOBUF_C_TYPE_MESSAGE,
9518 + 0, /* quantifier_offset */
9519 + offsetof(Sr__Response, get_changes_resp),
9520 + &sr__get_changes_resp__descriptor,
9521 + NULL,
9522 + 0, /* flags */
9523 + 0,NULL,NULL /* reserved1,reserved2, etc */
9524 + },
9525 + {
9526 + "data_provide_resp",
9527 + 80,
9528 + PROTOBUF_C_LABEL_OPTIONAL,
9529 + PROTOBUF_C_TYPE_MESSAGE,
9530 + 0, /* quantifier_offset */
9531 + offsetof(Sr__Response, data_provide_resp),
9532 + &sr__data_provide_resp__descriptor,
9533 + NULL,
9534 + 0, /* flags */
9535 + 0,NULL,NULL /* reserved1,reserved2, etc */
9536 + },
9537 + {
9538 + "check_exec_perm_resp",
9539 + 81,
9540 + PROTOBUF_C_LABEL_OPTIONAL,
9541 + PROTOBUF_C_TYPE_MESSAGE,
9542 + 0, /* quantifier_offset */
9543 + offsetof(Sr__Response, check_exec_perm_resp),
9544 + &sr__check_exec_perm_resp__descriptor,
9545 + NULL,
9546 + 0, /* flags */
9547 + 0,NULL,NULL /* reserved1,reserved2, etc */
9548 + },
9549 + {
9550 + "rpc_resp",
9551 + 82,
9552 + PROTOBUF_C_LABEL_OPTIONAL,
9553 + PROTOBUF_C_TYPE_MESSAGE,
9554 + 0, /* quantifier_offset */
9555 + offsetof(Sr__Response, rpc_resp),
9556 + &sr__rpcresp__descriptor,
9557 + NULL,
9558 + 0, /* flags */
9559 + 0,NULL,NULL /* reserved1,reserved2, etc */
9560 + },
9561 + {
9562 + "event_notif_resp",
9563 + 83,
9564 + PROTOBUF_C_LABEL_OPTIONAL,
9565 + PROTOBUF_C_TYPE_MESSAGE,
9566 + 0, /* quantifier_offset */
9567 + offsetof(Sr__Response, event_notif_resp),
9568 + &sr__event_notif_resp__descriptor,
9569 + NULL,
9570 + 0, /* flags */
9571 + 0,NULL,NULL /* reserved1,reserved2, etc */
9572 + },
9573 + {
9574 + "event_notif_replay_resp",
9575 + 84,
9576 + PROTOBUF_C_LABEL_OPTIONAL,
9577 + PROTOBUF_C_TYPE_MESSAGE,
9578 + 0, /* quantifier_offset */
9579 + offsetof(Sr__Response, event_notif_replay_resp),
9580 + &sr__event_notif_replay_resp__descriptor,
9581 + NULL,
9582 + 0, /* flags */
9583 + 0,NULL,NULL /* reserved1,reserved2, etc */
9584 + },
9585 +};
9586 +static const unsigned sr__response__field_indices_by_name[] = {
9587 + 31, /* field[31] = check_enabled_running_resp */
9588 + 34, /* field[34] = check_exec_perm_resp */
9589 + 24, /* field[24] = commit_resp */
9590 + 26, /* field[26] = copy_config_resp */
9591 + 33, /* field[33] = data_provide_resp */
9592 + 20, /* field[20] = delete_item_resp */
9593 + 25, /* field[25] = discard_changes_resp */
9594 + 2, /* field[2] = error */
9595 + 37, /* field[37] = event_notif_replay_resp */
9596 + 36, /* field[36] = event_notif_resp */
9597 + 13, /* field[13] = feature_enable_resp */
9598 + 32, /* field[32] = get_changes_resp */
9599 + 14, /* field[14] = get_item_resp */
9600 + 15, /* field[15] = get_items_resp */
9601 + 11, /* field[11] = get_schema_resp */
9602 + 18, /* field[18] = get_subtree_chunk_resp */
9603 + 16, /* field[16] = get_subtree_resp */
9604 + 17, /* field[17] = get_subtrees_resp */
9605 + 10, /* field[10] = list_schemas_resp */
9606 + 27, /* field[27] = lock_resp */
9607 + 12, /* field[12] = module_install_resp */
9608 + 21, /* field[21] = move_item_resp */
9609 + 0, /* field[0] = operation */
9610 + 1, /* field[1] = result */
9611 + 35, /* field[35] = rpc_resp */
9612 + 6, /* field[6] = session_check_resp */
9613 + 5, /* field[5] = session_refresh_resp */
9614 + 8, /* field[8] = session_set_opts_resp */
9615 + 3, /* field[3] = session_start_resp */
9616 + 4, /* field[4] = session_stop_resp */
9617 + 7, /* field[7] = session_switch_ds_resp */
9618 + 19, /* field[19] = set_item_resp */
9619 + 22, /* field[22] = set_item_str_resp */
9620 + 29, /* field[29] = subscribe_resp */
9621 + 28, /* field[28] = unlock_resp */
9622 + 30, /* field[30] = unsubscribe_resp */
9623 + 23, /* field[23] = validate_resp */
9624 + 9, /* field[9] = version_verify_resp */
9625 +};
9626 +static const ProtobufCIntRange sr__response__number_ranges[9 + 1] =
9627 +{
9628 + { 1, 0 },
9629 + { 10, 3 },
9630 + { 20, 10 },
9631 + { 30, 14 },
9632 + { 40, 19 },
9633 + { 50, 23 },
9634 + { 60, 27 },
9635 + { 70, 29 },
9636 + { 80, 33 },
9637 + { 0, 38 }
9638 +};
9639 +const ProtobufCMessageDescriptor sr__response__descriptor =
9640 +{
9641 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
9642 + "sr.Response",
9643 + "Response",
9644 + "Sr__Response",
9645 + "sr",
9646 + sizeof(Sr__Response),
9647 + 38,
9648 + sr__response__field_descriptors,
9649 + sr__response__field_indices_by_name,
9650 + 9, sr__response__number_ranges,
9651 + (ProtobufCMessageInit) sr__response__init,
9652 + NULL,NULL,NULL /* reserved[123] */
9653 +};
9654 +static const ProtobufCFieldDescriptor sr__notification__field_descriptors[10] =
9655 +{
9656 + {
9657 + "type",
9658 + 1,
9659 + PROTOBUF_C_LABEL_REQUIRED,
9660 + PROTOBUF_C_TYPE_ENUM,
9661 + 0, /* quantifier_offset */
9662 + offsetof(Sr__Notification, type),
9663 + &sr__subscription_type__descriptor,
9664 + NULL,
9665 + 0, /* flags */
9666 + 0,NULL,NULL /* reserved1,reserved2, etc */
9667 + },
9668 + {
9669 + "destination_address",
9670 + 2,
9671 + PROTOBUF_C_LABEL_REQUIRED,
9672 + PROTOBUF_C_TYPE_STRING,
9673 + 0, /* quantifier_offset */
9674 + offsetof(Sr__Notification, destination_address),
9675 + NULL,
9676 + NULL,
9677 + 0, /* flags */
9678 + 0,NULL,NULL /* reserved1,reserved2, etc */
9679 + },
9680 + {
9681 + "source_address",
9682 + 3,
9683 + PROTOBUF_C_LABEL_REQUIRED,
9684 + PROTOBUF_C_TYPE_STRING,
9685 + 0, /* quantifier_offset */
9686 + offsetof(Sr__Notification, source_address),
9687 + NULL,
9688 + NULL,
9689 + 0, /* flags */
9690 + 0,NULL,NULL /* reserved1,reserved2, etc */
9691 + },
9692 + {
9693 + "source_pid",
9694 + 4,
9695 + PROTOBUF_C_LABEL_REQUIRED,
9696 + PROTOBUF_C_TYPE_UINT32,
9697 + 0, /* quantifier_offset */
9698 + offsetof(Sr__Notification, source_pid),
9699 + NULL,
9700 + NULL,
9701 + 0, /* flags */
9702 + 0,NULL,NULL /* reserved1,reserved2, etc */
9703 + },
9704 + {
9705 + "subscription_id",
9706 + 5,
9707 + PROTOBUF_C_LABEL_REQUIRED,
9708 + PROTOBUF_C_TYPE_UINT32,
9709 + 0, /* quantifier_offset */
9710 + offsetof(Sr__Notification, subscription_id),
9711 + NULL,
9712 + NULL,
9713 + 0, /* flags */
9714 + 0,NULL,NULL /* reserved1,reserved2, etc */
9715 + },
9716 + {
9717 + "commit_id",
9718 + 6,
9719 + PROTOBUF_C_LABEL_OPTIONAL,
9720 + PROTOBUF_C_TYPE_UINT32,
9721 + offsetof(Sr__Notification, has_commit_id),
9722 + offsetof(Sr__Notification, commit_id),
9723 + NULL,
9724 + NULL,
9725 + 0, /* flags */
9726 + 0,NULL,NULL /* reserved1,reserved2, etc */
9727 + },
9728 + {
9729 + "module_install_notif",
9730 + 10,
9731 + PROTOBUF_C_LABEL_OPTIONAL,
9732 + PROTOBUF_C_TYPE_MESSAGE,
9733 + 0, /* quantifier_offset */
9734 + offsetof(Sr__Notification, module_install_notif),
9735 + &sr__module_install_notification__descriptor,
9736 + NULL,
9737 + 0, /* flags */
9738 + 0,NULL,NULL /* reserved1,reserved2, etc */
9739 + },
9740 + {
9741 + "feature_enable_notif",
9742 + 11,
9743 + PROTOBUF_C_LABEL_OPTIONAL,
9744 + PROTOBUF_C_TYPE_MESSAGE,
9745 + 0, /* quantifier_offset */
9746 + offsetof(Sr__Notification, feature_enable_notif),
9747 + &sr__feature_enable_notification__descriptor,
9748 + NULL,
9749 + 0, /* flags */
9750 + 0,NULL,NULL /* reserved1,reserved2, etc */
9751 + },
9752 + {
9753 + "module_change_notif",
9754 + 12,
9755 + PROTOBUF_C_LABEL_OPTIONAL,
9756 + PROTOBUF_C_TYPE_MESSAGE,
9757 + 0, /* quantifier_offset */
9758 + offsetof(Sr__Notification, module_change_notif),
9759 + &sr__module_change_notification__descriptor,
9760 + NULL,
9761 + 0, /* flags */
9762 + 0,NULL,NULL /* reserved1,reserved2, etc */
9763 + },
9764 + {
9765 + "subtree_change_notif",
9766 + 13,
9767 + PROTOBUF_C_LABEL_OPTIONAL,
9768 + PROTOBUF_C_TYPE_MESSAGE,
9769 + 0, /* quantifier_offset */
9770 + offsetof(Sr__Notification, subtree_change_notif),
9771 + &sr__subtree_change_notification__descriptor,
9772 + NULL,
9773 + 0, /* flags */
9774 + 0,NULL,NULL /* reserved1,reserved2, etc */
9775 + },
9776 +};
9777 +static const unsigned sr__notification__field_indices_by_name[] = {
9778 + 5, /* field[5] = commit_id */
9779 + 1, /* field[1] = destination_address */
9780 + 7, /* field[7] = feature_enable_notif */
9781 + 8, /* field[8] = module_change_notif */
9782 + 6, /* field[6] = module_install_notif */
9783 + 2, /* field[2] = source_address */
9784 + 3, /* field[3] = source_pid */
9785 + 4, /* field[4] = subscription_id */
9786 + 9, /* field[9] = subtree_change_notif */
9787 + 0, /* field[0] = type */
9788 +};
9789 +static const ProtobufCIntRange sr__notification__number_ranges[2 + 1] =
9790 +{
9791 + { 1, 0 },
9792 + { 10, 6 },
9793 + { 0, 10 }
9794 +};
9795 +const ProtobufCMessageDescriptor sr__notification__descriptor =
9796 +{
9797 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
9798 + "sr.Notification",
9799 + "Notification",
9800 + "Sr__Notification",
9801 + "sr",
9802 + sizeof(Sr__Notification),
9803 + 10,
9804 + sr__notification__field_descriptors,
9805 + sr__notification__field_indices_by_name,
9806 + 2, sr__notification__number_ranges,
9807 + (ProtobufCMessageInit) sr__notification__init,
9808 + NULL,NULL,NULL /* reserved[123] */
9809 +};
9810 +static const ProtobufCFieldDescriptor sr__notification_ack__field_descriptors[4] =
9811 +{
9812 + {
9813 + "notif",
9814 + 1,
9815 + PROTOBUF_C_LABEL_REQUIRED,
9816 + PROTOBUF_C_TYPE_MESSAGE,
9817 + 0, /* quantifier_offset */
9818 + offsetof(Sr__NotificationAck, notif),
9819 + &sr__notification__descriptor,
9820 + NULL,
9821 + 0, /* flags */
9822 + 0,NULL,NULL /* reserved1,reserved2, etc */
9823 + },
9824 + {
9825 + "result",
9826 + 2,
9827 + PROTOBUF_C_LABEL_REQUIRED,
9828 + PROTOBUF_C_TYPE_UINT32,
9829 + 0, /* quantifier_offset */
9830 + offsetof(Sr__NotificationAck, result),
9831 + NULL,
9832 + NULL,
9833 + 0, /* flags */
9834 + 0,NULL,NULL /* reserved1,reserved2, etc */
9835 + },
9836 + {
9837 + "error",
9838 + 3,
9839 + PROTOBUF_C_LABEL_OPTIONAL,
9840 + PROTOBUF_C_TYPE_MESSAGE,
9841 + 0, /* quantifier_offset */
9842 + offsetof(Sr__NotificationAck, error),
9843 + &sr__error__descriptor,
9844 + NULL,
9845 + 0, /* flags */
9846 + 0,NULL,NULL /* reserved1,reserved2, etc */
9847 + },
9848 + {
9849 + "do_not_send_abort",
9850 + 4,
9851 + PROTOBUF_C_LABEL_REQUIRED,
9852 + PROTOBUF_C_TYPE_BOOL,
9853 + 0, /* quantifier_offset */
9854 + offsetof(Sr__NotificationAck, do_not_send_abort),
9855 + NULL,
9856 + NULL,
9857 + 0, /* flags */
9858 + 0,NULL,NULL /* reserved1,reserved2, etc */
9859 + },
9860 +};
9861 +static const unsigned sr__notification_ack__field_indices_by_name[] = {
9862 + 3, /* field[3] = do_not_send_abort */
9863 + 2, /* field[2] = error */
9864 + 0, /* field[0] = notif */
9865 + 1, /* field[1] = result */
9866 +};
9867 +static const ProtobufCIntRange sr__notification_ack__number_ranges[1 + 1] =
9868 +{
9869 + { 1, 0 },
9870 + { 0, 4 }
9871 +};
9872 +const ProtobufCMessageDescriptor sr__notification_ack__descriptor =
9873 +{
9874 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
9875 + "sr.NotificationAck",
9876 + "NotificationAck",
9877 + "Sr__NotificationAck",
9878 + "sr",
9879 + sizeof(Sr__NotificationAck),
9880 + 4,
9881 + sr__notification_ack__field_descriptors,
9882 + sr__notification_ack__field_indices_by_name,
9883 + 1, sr__notification_ack__number_ranges,
9884 + (ProtobufCMessageInit) sr__notification_ack__init,
9885 + NULL,NULL,NULL /* reserved[123] */
9886 +};
9887 +static const ProtobufCFieldDescriptor sr__internal_request__field_descriptors[9] =
9888 +{
9889 + {
9890 + "operation",
9891 + 1,
9892 + PROTOBUF_C_LABEL_REQUIRED,
9893 + PROTOBUF_C_TYPE_ENUM,
9894 + 0, /* quantifier_offset */
9895 + offsetof(Sr__InternalRequest, operation),
9896 + &sr__operation__descriptor,
9897 + NULL,
9898 + 0, /* flags */
9899 + 0,NULL,NULL /* reserved1,reserved2, etc */
9900 + },
9901 + {
9902 + "postpone_timeout",
9903 + 2,
9904 + PROTOBUF_C_LABEL_OPTIONAL,
9905 + PROTOBUF_C_TYPE_UINT32,
9906 + offsetof(Sr__InternalRequest, has_postpone_timeout),
9907 + offsetof(Sr__InternalRequest, postpone_timeout),
9908 + NULL,
9909 + NULL,
9910 + 0, /* flags */
9911 + 0,NULL,NULL /* reserved1,reserved2, etc */
9912 + },
9913 + {
9914 + "unsubscribe_dst_req",
9915 + 10,
9916 + PROTOBUF_C_LABEL_OPTIONAL,
9917 + PROTOBUF_C_TYPE_MESSAGE,
9918 + 0, /* quantifier_offset */
9919 + offsetof(Sr__InternalRequest, unsubscribe_dst_req),
9920 + &sr__unsubscribe_destination_req__descriptor,
9921 + NULL,
9922 + 0, /* flags */
9923 + 0,NULL,NULL /* reserved1,reserved2, etc */
9924 + },
9925 + {
9926 + "commit_timeout_req",
9927 + 11,
9928 + PROTOBUF_C_LABEL_OPTIONAL,
9929 + PROTOBUF_C_TYPE_MESSAGE,
9930 + 0, /* quantifier_offset */
9931 + offsetof(Sr__InternalRequest, commit_timeout_req),
9932 + &sr__commit_timeout_req__descriptor,
9933 + NULL,
9934 + 0, /* flags */
9935 + 0,NULL,NULL /* reserved1,reserved2, etc */
9936 + },
9937 + {
9938 + "oper_data_timeout_req",
9939 + 12,
9940 + PROTOBUF_C_LABEL_OPTIONAL,
9941 + PROTOBUF_C_TYPE_MESSAGE,
9942 + 0, /* quantifier_offset */
9943 + offsetof(Sr__InternalRequest, oper_data_timeout_req),
9944 + &sr__oper_data_timeout_req__descriptor,
9945 + NULL,
9946 + 0, /* flags */
9947 + 0,NULL,NULL /* reserved1,reserved2, etc */
9948 + },
9949 + {
9950 + "internal_state_data_req",
9951 + 13,
9952 + PROTOBUF_C_LABEL_OPTIONAL,
9953 + PROTOBUF_C_TYPE_MESSAGE,
9954 + 0, /* quantifier_offset */
9955 + offsetof(Sr__InternalRequest, internal_state_data_req),
9956 + &sr__internal_state_data_req__descriptor,
9957 + NULL,
9958 + 0, /* flags */
9959 + 0,NULL,NULL /* reserved1,reserved2, etc */
9960 + },
9961 + {
9962 + "notif_store_cleanup_req",
9963 + 14,
9964 + PROTOBUF_C_LABEL_OPTIONAL,
9965 + PROTOBUF_C_TYPE_MESSAGE,
9966 + 0, /* quantifier_offset */
9967 + offsetof(Sr__InternalRequest, notif_store_cleanup_req),
9968 + &sr__notif_store_cleanup_req__descriptor,
9969 + NULL,
9970 + 0, /* flags */
9971 + 0,NULL,NULL /* reserved1,reserved2, etc */
9972 + },
9973 + {
9974 + "delayed_msg_req",
9975 + 15,
9976 + PROTOBUF_C_LABEL_OPTIONAL,
9977 + PROTOBUF_C_TYPE_MESSAGE,
9978 + 0, /* quantifier_offset */
9979 + offsetof(Sr__InternalRequest, delayed_msg_req),
9980 + &sr__delayed_msg_req__descriptor,
9981 + NULL,
9982 + 0, /* flags */
9983 + 0,NULL,NULL /* reserved1,reserved2, etc */
9984 + },
9985 + {
9986 + "nacm_reload_req",
9987 + 16,
9988 + PROTOBUF_C_LABEL_OPTIONAL,
9989 + PROTOBUF_C_TYPE_MESSAGE,
9990 + 0, /* quantifier_offset */
9991 + offsetof(Sr__InternalRequest, nacm_reload_req),
9992 + &sr__nacm_reload_req__descriptor,
9993 + NULL,
9994 + 0, /* flags */
9995 + 0,NULL,NULL /* reserved1,reserved2, etc */
9996 + },
9997 +};
9998 +static const unsigned sr__internal_request__field_indices_by_name[] = {
9999 + 3, /* field[3] = commit_timeout_req */
10000 + 7, /* field[7] = delayed_msg_req */
10001 + 5, /* field[5] = internal_state_data_req */
10002 + 8, /* field[8] = nacm_reload_req */
10003 + 6, /* field[6] = notif_store_cleanup_req */
10004 + 4, /* field[4] = oper_data_timeout_req */
10005 + 0, /* field[0] = operation */
10006 + 1, /* field[1] = postpone_timeout */
10007 + 2, /* field[2] = unsubscribe_dst_req */
10008 +};
10009 +static const ProtobufCIntRange sr__internal_request__number_ranges[2 + 1] =
10010 +{
10011 + { 1, 0 },
10012 + { 10, 2 },
10013 + { 0, 9 }
10014 +};
10015 +const ProtobufCMessageDescriptor sr__internal_request__descriptor =
10016 +{
10017 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
10018 + "sr.InternalRequest",
10019 + "InternalRequest",
10020 + "Sr__InternalRequest",
10021 + "sr",
10022 + sizeof(Sr__InternalRequest),
10023 + 9,
10024 + sr__internal_request__field_descriptors,
10025 + sr__internal_request__field_indices_by_name,
10026 + 2, sr__internal_request__number_ranges,
10027 + (ProtobufCMessageInit) sr__internal_request__init,
10028 + NULL,NULL,NULL /* reserved[123] */
10029 +};
10030 +static const ProtobufCEnumValue sr__msg__msg_type__enum_values_by_number[5] =
10031 +{
10032 + { "REQUEST", "SR__MSG__MSG_TYPE__REQUEST", 1 },
10033 + { "RESPONSE", "SR__MSG__MSG_TYPE__RESPONSE", 2 },
10034 + { "NOTIFICATION", "SR__MSG__MSG_TYPE__NOTIFICATION", 3 },
10035 + { "NOTIFICATION_ACK", "SR__MSG__MSG_TYPE__NOTIFICATION_ACK", 4 },
10036 + { "INTERNAL_REQUEST", "SR__MSG__MSG_TYPE__INTERNAL_REQUEST", 5 },
10037 +};
10038 +static const ProtobufCIntRange sr__msg__msg_type__value_ranges[] = {
10039 +{1, 0},{0, 5}
10040 +};
10041 +static const ProtobufCEnumValueIndex sr__msg__msg_type__enum_values_by_name[5] =
10042 +{
10043 + { "INTERNAL_REQUEST", 4 },
10044 + { "NOTIFICATION", 2 },
10045 + { "NOTIFICATION_ACK", 3 },
10046 + { "REQUEST", 0 },
10047 + { "RESPONSE", 1 },
10048 +};
10049 +const ProtobufCEnumDescriptor sr__msg__msg_type__descriptor =
10050 +{
10051 + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
10052 + "sr.Msg.MsgType",
10053 + "MsgType",
10054 + "Sr__Msg__MsgType",
10055 + "sr",
10056 + 5,
10057 + sr__msg__msg_type__enum_values_by_number,
10058 + 5,
10059 + sr__msg__msg_type__enum_values_by_name,
10060 + 1,
10061 + sr__msg__msg_type__value_ranges,
10062 + NULL,NULL,NULL,NULL /* reserved[1234] */
10063 +};
10064 +static const ProtobufCFieldDescriptor sr__msg__field_descriptors[8] =
10065 +{
10066 + {
10067 + "type",
10068 + 1,
10069 + PROTOBUF_C_LABEL_REQUIRED,
10070 + PROTOBUF_C_TYPE_ENUM,
10071 + 0, /* quantifier_offset */
10072 + offsetof(Sr__Msg, type),
10073 + &sr__msg__msg_type__descriptor,
10074 + NULL,
10075 + 0, /* flags */
10076 + 0,NULL,NULL /* reserved1,reserved2, etc */
10077 + },
10078 + {
10079 + "session_id",
10080 + 2,
10081 + PROTOBUF_C_LABEL_REQUIRED,
10082 + PROTOBUF_C_TYPE_UINT32,
10083 + 0, /* quantifier_offset */
10084 + offsetof(Sr__Msg, session_id),
10085 + NULL,
10086 + NULL,
10087 + 0, /* flags */
10088 + 0,NULL,NULL /* reserved1,reserved2, etc */
10089 + },
10090 + {
10091 + "request",
10092 + 3,
10093 + PROTOBUF_C_LABEL_OPTIONAL,
10094 + PROTOBUF_C_TYPE_MESSAGE,
10095 + 0, /* quantifier_offset */
10096 + offsetof(Sr__Msg, request),
10097 + &sr__request__descriptor,
10098 + NULL,
10099 + 0, /* flags */
10100 + 0,NULL,NULL /* reserved1,reserved2, etc */
10101 + },
10102 + {
10103 + "response",
10104 + 4,
10105 + PROTOBUF_C_LABEL_OPTIONAL,
10106 + PROTOBUF_C_TYPE_MESSAGE,
10107 + 0, /* quantifier_offset */
10108 + offsetof(Sr__Msg, response),
10109 + &sr__response__descriptor,
10110 + NULL,
10111 + 0, /* flags */
10112 + 0,NULL,NULL /* reserved1,reserved2, etc */
10113 + },
10114 + {
10115 + "notification",
10116 + 5,
10117 + PROTOBUF_C_LABEL_OPTIONAL,
10118 + PROTOBUF_C_TYPE_MESSAGE,
10119 + 0, /* quantifier_offset */
10120 + offsetof(Sr__Msg, notification),
10121 + &sr__notification__descriptor,
10122 + NULL,
10123 + 0, /* flags */
10124 + 0,NULL,NULL /* reserved1,reserved2, etc */
10125 + },
10126 + {
10127 + "notification_ack",
10128 + 6,
10129 + PROTOBUF_C_LABEL_OPTIONAL,
10130 + PROTOBUF_C_TYPE_MESSAGE,
10131 + 0, /* quantifier_offset */
10132 + offsetof(Sr__Msg, notification_ack),
10133 + &sr__notification_ack__descriptor,
10134 + NULL,
10135 + 0, /* flags */
10136 + 0,NULL,NULL /* reserved1,reserved2, etc */
10137 + },
10138 + {
10139 + "internal_request",
10140 + 7,
10141 + PROTOBUF_C_LABEL_OPTIONAL,
10142 + PROTOBUF_C_TYPE_MESSAGE,
10143 + 0, /* quantifier_offset */
10144 + offsetof(Sr__Msg, internal_request),
10145 + &sr__internal_request__descriptor,
10146 + NULL,
10147 + 0, /* flags */
10148 + 0,NULL,NULL /* reserved1,reserved2, etc */
10149 + },
10150 + {
10151 + "_sysrepo_mem_ctx",
10152 + 20,
10153 + PROTOBUF_C_LABEL_REQUIRED,
10154 + PROTOBUF_C_TYPE_UINT64,
10155 + 0, /* quantifier_offset */
10156 + offsetof(Sr__Msg, _sysrepo_mem_ctx),
10157 + NULL,
10158 + NULL,
10159 + 0, /* flags */
10160 + 0,NULL,NULL /* reserved1,reserved2, etc */
10161 + },
10162 +};
10163 +static const unsigned sr__msg__field_indices_by_name[] = {
10164 + 7, /* field[7] = _sysrepo_mem_ctx */
10165 + 6, /* field[6] = internal_request */
10166 + 4, /* field[4] = notification */
10167 + 5, /* field[5] = notification_ack */
10168 + 2, /* field[2] = request */
10169 + 3, /* field[3] = response */
10170 + 1, /* field[1] = session_id */
10171 + 0, /* field[0] = type */
10172 +};
10173 +static const ProtobufCIntRange sr__msg__number_ranges[2 + 1] =
10174 +{
10175 + { 1, 0 },
10176 + { 20, 7 },
10177 + { 0, 8 }
10178 +};
10179 +const ProtobufCMessageDescriptor sr__msg__descriptor =
10180 +{
10181 + PROTOBUF_C__MESSAGE_DESCRIPTOR_MAGIC,
10182 + "sr.Msg",
10183 + "Msg",
10184 + "Sr__Msg",
10185 + "sr",
10186 + sizeof(Sr__Msg),
10187 + 8,
10188 + sr__msg__field_descriptors,
10189 + sr__msg__field_indices_by_name,
10190 + 2, sr__msg__number_ranges,
10191 + (ProtobufCMessageInit) sr__msg__init,
10192 + NULL,NULL,NULL /* reserved[123] */
10193 +};
10194 +static const ProtobufCEnumValue sr__api_variant__enum_values_by_number[2] =
10195 +{
10196 + { "VALUES", "SR__API_VARIANT__VALUES", 1 },
10197 + { "TREES", "SR__API_VARIANT__TREES", 2 },
10198 +};
10199 +static const ProtobufCIntRange sr__api_variant__value_ranges[] = {
10200 +{1, 0},{0, 2}
10201 +};
10202 +static const ProtobufCEnumValueIndex sr__api_variant__enum_values_by_name[2] =
10203 +{
10204 + { "TREES", 1 },
10205 + { "VALUES", 0 },
10206 +};
10207 +const ProtobufCEnumDescriptor sr__api_variant__descriptor =
10208 +{
10209 + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
10210 + "sr.ApiVariant",
10211 + "ApiVariant",
10212 + "Sr__ApiVariant",
10213 + "sr",
10214 + 2,
10215 + sr__api_variant__enum_values_by_number,
10216 + 2,
10217 + sr__api_variant__enum_values_by_name,
10218 + 1,
10219 + sr__api_variant__value_ranges,
10220 + NULL,NULL,NULL,NULL /* reserved[1234] */
10221 +};
10222 +static const ProtobufCEnumValue sr__data_store__enum_values_by_number[3] =
10223 +{
10224 + { "STARTUP", "SR__DATA_STORE__STARTUP", 1 },
10225 + { "RUNNING", "SR__DATA_STORE__RUNNING", 2 },
10226 + { "CANDIDATE", "SR__DATA_STORE__CANDIDATE", 3 },
10227 +};
10228 +static const ProtobufCIntRange sr__data_store__value_ranges[] = {
10229 +{1, 0},{0, 3}
10230 +};
10231 +static const ProtobufCEnumValueIndex sr__data_store__enum_values_by_name[3] =
10232 +{
10233 + { "CANDIDATE", 2 },
10234 + { "RUNNING", 1 },
10235 + { "STARTUP", 0 },
10236 +};
10237 +const ProtobufCEnumDescriptor sr__data_store__descriptor =
10238 +{
10239 + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
10240 + "sr.DataStore",
10241 + "DataStore",
10242 + "Sr__DataStore",
10243 + "sr",
10244 + 3,
10245 + sr__data_store__enum_values_by_number,
10246 + 3,
10247 + sr__data_store__enum_values_by_name,
10248 + 1,
10249 + sr__data_store__value_ranges,
10250 + NULL,NULL,NULL,NULL /* reserved[1234] */
10251 +};
10252 +static const ProtobufCEnumValue sr__session_flags__enum_values_by_number[4] =
10253 +{
10254 + { "SESS_DEFAULT", "SR__SESSION_FLAGS__SESS_DEFAULT", 0 },
10255 + { "SESS_CONFIG_ONLY", "SR__SESSION_FLAGS__SESS_CONFIG_ONLY", 1 },
10256 + { "SESS_ENABLE_NACM", "SR__SESSION_FLAGS__SESS_ENABLE_NACM", 2 },
10257 + { "SESS_NOTIFICATION", "SR__SESSION_FLAGS__SESS_NOTIFICATION", 1024 },
10258 +};
10259 +static const ProtobufCIntRange sr__session_flags__value_ranges[] = {
10260 +{0, 0},{1024, 3},{0, 4}
10261 +};
10262 +static const ProtobufCEnumValueIndex sr__session_flags__enum_values_by_name[4] =
10263 +{
10264 + { "SESS_CONFIG_ONLY", 1 },
10265 + { "SESS_DEFAULT", 0 },
10266 + { "SESS_ENABLE_NACM", 2 },
10267 + { "SESS_NOTIFICATION", 3 },
10268 +};
10269 +const ProtobufCEnumDescriptor sr__session_flags__descriptor =
10270 +{
10271 + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
10272 + "sr.SessionFlags",
10273 + "SessionFlags",
10274 + "Sr__SessionFlags",
10275 + "sr",
10276 + 4,
10277 + sr__session_flags__enum_values_by_number,
10278 + 4,
10279 + sr__session_flags__enum_values_by_name,
10280 + 2,
10281 + sr__session_flags__value_ranges,
10282 + NULL,NULL,NULL,NULL /* reserved[1234] */
10283 +};
10284 +static const ProtobufCEnumValue sr__edit_flags__enum_values_by_number[3] =
10285 +{
10286 + { "EDIT_DEFAULT", "SR__EDIT_FLAGS__EDIT_DEFAULT", 0 },
10287 + { "EDIT_NON_RECURSIVE", "SR__EDIT_FLAGS__EDIT_NON_RECURSIVE", 1 },
10288 + { "EDIT_STRICT", "SR__EDIT_FLAGS__EDIT_STRICT", 2 },
10289 +};
10290 +static const ProtobufCIntRange sr__edit_flags__value_ranges[] = {
10291 +{0, 0},{0, 3}
10292 +};
10293 +static const ProtobufCEnumValueIndex sr__edit_flags__enum_values_by_name[3] =
10294 +{
10295 + { "EDIT_DEFAULT", 0 },
10296 + { "EDIT_NON_RECURSIVE", 1 },
10297 + { "EDIT_STRICT", 2 },
10298 +};
10299 +const ProtobufCEnumDescriptor sr__edit_flags__descriptor =
10300 +{
10301 + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
10302 + "sr.EditFlags",
10303 + "EditFlags",
10304 + "Sr__EditFlags",
10305 + "sr",
10306 + 3,
10307 + sr__edit_flags__enum_values_by_number,
10308 + 3,
10309 + sr__edit_flags__enum_values_by_name,
10310 + 1,
10311 + sr__edit_flags__value_ranges,
10312 + NULL,NULL,NULL,NULL /* reserved[1234] */
10313 +};
10314 +static const ProtobufCEnumValue sr__subscription_type__enum_values_by_number[10] =
10315 +{
10316 + { "MODULE_INSTALL_SUBS", "SR__SUBSCRIPTION_TYPE__MODULE_INSTALL_SUBS", 1 },
10317 + { "FEATURE_ENABLE_SUBS", "SR__SUBSCRIPTION_TYPE__FEATURE_ENABLE_SUBS", 2 },
10318 + { "MODULE_CHANGE_SUBS", "SR__SUBSCRIPTION_TYPE__MODULE_CHANGE_SUBS", 10 },
10319 + { "SUBTREE_CHANGE_SUBS", "SR__SUBSCRIPTION_TYPE__SUBTREE_CHANGE_SUBS", 11 },
10320 + { "DP_GET_ITEMS_SUBS", "SR__SUBSCRIPTION_TYPE__DP_GET_ITEMS_SUBS", 20 },
10321 + { "RPC_SUBS", "SR__SUBSCRIPTION_TYPE__RPC_SUBS", 30 },
10322 + { "ACTION_SUBS", "SR__SUBSCRIPTION_TYPE__ACTION_SUBS", 31 },
10323 + { "EVENT_NOTIF_SUBS", "SR__SUBSCRIPTION_TYPE__EVENT_NOTIF_SUBS", 40 },
10324 + { "HELLO_SUBS", "SR__SUBSCRIPTION_TYPE__HELLO_SUBS", 50 },
10325 + { "COMMIT_END_SUBS", "SR__SUBSCRIPTION_TYPE__COMMIT_END_SUBS", 51 },
10326 +};
10327 +static const ProtobufCIntRange sr__subscription_type__value_ranges[] = {
10328 +{1, 0},{10, 2},{20, 4},{30, 5},{40, 7},{50, 8},{0, 10}
10329 +};
10330 +static const ProtobufCEnumValueIndex sr__subscription_type__enum_values_by_name[10] =
10331 +{
10332 + { "ACTION_SUBS", 6 },
10333 + { "COMMIT_END_SUBS", 9 },
10334 + { "DP_GET_ITEMS_SUBS", 4 },
10335 + { "EVENT_NOTIF_SUBS", 7 },
10336 + { "FEATURE_ENABLE_SUBS", 1 },
10337 + { "HELLO_SUBS", 8 },
10338 + { "MODULE_CHANGE_SUBS", 2 },
10339 + { "MODULE_INSTALL_SUBS", 0 },
10340 + { "RPC_SUBS", 5 },
10341 + { "SUBTREE_CHANGE_SUBS", 3 },
10342 +};
10343 +const ProtobufCEnumDescriptor sr__subscription_type__descriptor =
10344 +{
10345 + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
10346 + "sr.SubscriptionType",
10347 + "SubscriptionType",
10348 + "Sr__SubscriptionType",
10349 + "sr",
10350 + 10,
10351 + sr__subscription_type__enum_values_by_number,
10352 + 10,
10353 + sr__subscription_type__enum_values_by_name,
10354 + 6,
10355 + sr__subscription_type__value_ranges,
10356 + NULL,NULL,NULL,NULL /* reserved[1234] */
10357 +};
10358 +static const ProtobufCEnumValue sr__notification_event__enum_values_by_number[4] =
10359 +{
10360 + { "VERIFY_EV", "SR__NOTIFICATION_EVENT__VERIFY_EV", 1 },
10361 + { "APPLY_EV", "SR__NOTIFICATION_EVENT__APPLY_EV", 2 },
10362 + { "ABORT_EV", "SR__NOTIFICATION_EVENT__ABORT_EV", 3 },
10363 + { "ENABLED_EV", "SR__NOTIFICATION_EVENT__ENABLED_EV", 4 },
10364 +};
10365 +static const ProtobufCIntRange sr__notification_event__value_ranges[] = {
10366 +{1, 0},{0, 4}
10367 +};
10368 +static const ProtobufCEnumValueIndex sr__notification_event__enum_values_by_name[4] =
10369 +{
10370 + { "ABORT_EV", 2 },
10371 + { "APPLY_EV", 1 },
10372 + { "ENABLED_EV", 3 },
10373 + { "VERIFY_EV", 0 },
10374 +};
10375 +const ProtobufCEnumDescriptor sr__notification_event__descriptor =
10376 +{
10377 + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
10378 + "sr.NotificationEvent",
10379 + "NotificationEvent",
10380 + "Sr__NotificationEvent",
10381 + "sr",
10382 + 4,
10383 + sr__notification_event__enum_values_by_number,
10384 + 4,
10385 + sr__notification_event__enum_values_by_name,
10386 + 1,
10387 + sr__notification_event__value_ranges,
10388 + NULL,NULL,NULL,NULL /* reserved[1234] */
10389 +};
10390 +static const ProtobufCEnumValue sr__module_state__enum_values_by_number[3] =
10391 +{
10392 + { "UNINSTALLED", "SR__MODULE_STATE__UNINSTALLED", 1 },
10393 + { "IMPORTED", "SR__MODULE_STATE__IMPORTED", 2 },
10394 + { "IMPLEMENTED", "SR__MODULE_STATE__IMPLEMENTED", 3 },
10395 +};
10396 +static const ProtobufCIntRange sr__module_state__value_ranges[] = {
10397 +{1, 0},{0, 3}
10398 +};
10399 +static const ProtobufCEnumValueIndex sr__module_state__enum_values_by_name[3] =
10400 +{
10401 + { "IMPLEMENTED", 2 },
10402 + { "IMPORTED", 1 },
10403 + { "UNINSTALLED", 0 },
10404 +};
10405 +const ProtobufCEnumDescriptor sr__module_state__descriptor =
10406 +{
10407 + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
10408 + "sr.ModuleState",
10409 + "ModuleState",
10410 + "Sr__ModuleState",
10411 + "sr",
10412 + 3,
10413 + sr__module_state__enum_values_by_number,
10414 + 3,
10415 + sr__module_state__enum_values_by_name,
10416 + 1,
10417 + sr__module_state__value_ranges,
10418 + NULL,NULL,NULL,NULL /* reserved[1234] */
10419 +};
10420 +static const ProtobufCEnumValue sr__change_operation__enum_values_by_number[4] =
10421 +{
10422 + { "CREATED", "SR__CHANGE_OPERATION__CREATED", 1 },
10423 + { "MODIFIED", "SR__CHANGE_OPERATION__MODIFIED", 2 },
10424 + { "DELETED", "SR__CHANGE_OPERATION__DELETED", 3 },
10425 + { "MOVED", "SR__CHANGE_OPERATION__MOVED", 4 },
10426 +};
10427 +static const ProtobufCIntRange sr__change_operation__value_ranges[] = {
10428 +{1, 0},{0, 4}
10429 +};
10430 +static const ProtobufCEnumValueIndex sr__change_operation__enum_values_by_name[4] =
10431 +{
10432 + { "CREATED", 0 },
10433 + { "DELETED", 2 },
10434 + { "MODIFIED", 1 },
10435 + { "MOVED", 3 },
10436 +};
10437 +const ProtobufCEnumDescriptor sr__change_operation__descriptor =
10438 +{
10439 + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
10440 + "sr.ChangeOperation",
10441 + "ChangeOperation",
10442 + "Sr__ChangeOperation",
10443 + "sr",
10444 + 4,
10445 + sr__change_operation__enum_values_by_number,
10446 + 4,
10447 + sr__change_operation__enum_values_by_name,
10448 + 1,
10449 + sr__change_operation__value_ranges,
10450 + NULL,NULL,NULL,NULL /* reserved[1234] */
10451 +};
10452 +static const ProtobufCEnumValue sr__operation__enum_values_by_number[43] =
10453 +{
10454 + { "SESSION_START", "SR__OPERATION__SESSION_START", 10 },
10455 + { "SESSION_STOP", "SR__OPERATION__SESSION_STOP", 11 },
10456 + { "SESSION_REFRESH", "SR__OPERATION__SESSION_REFRESH", 12 },
10457 + { "SESSION_CHECK", "SR__OPERATION__SESSION_CHECK", 13 },
10458 + { "SESSION_SWITCH_DS", "SR__OPERATION__SESSION_SWITCH_DS", 14 },
10459 + { "SESSION_SET_OPTS", "SR__OPERATION__SESSION_SET_OPTS", 15 },
10460 + { "VERSION_VERIFY", "SR__OPERATION__VERSION_VERIFY", 16 },
10461 + { "LIST_SCHEMAS", "SR__OPERATION__LIST_SCHEMAS", 20 },
10462 + { "GET_SCHEMA", "SR__OPERATION__GET_SCHEMA", 21 },
10463 + { "MODULE_INSTALL", "SR__OPERATION__MODULE_INSTALL", 22 },
10464 + { "FEATURE_ENABLE", "SR__OPERATION__FEATURE_ENABLE", 23 },
10465 + { "GET_ITEM", "SR__OPERATION__GET_ITEM", 30 },
10466 + { "GET_ITEMS", "SR__OPERATION__GET_ITEMS", 31 },
10467 + { "GET_SUBTREE", "SR__OPERATION__GET_SUBTREE", 32 },
10468 + { "GET_SUBTREES", "SR__OPERATION__GET_SUBTREES", 33 },
10469 + { "GET_SUBTREE_CHUNK", "SR__OPERATION__GET_SUBTREE_CHUNK", 34 },
10470 + { "SET_ITEM", "SR__OPERATION__SET_ITEM", 40 },
10471 + { "DELETE_ITEM", "SR__OPERATION__DELETE_ITEM", 41 },
10472 + { "MOVE_ITEM", "SR__OPERATION__MOVE_ITEM", 42 },
10473 + { "SET_ITEM_STR", "SR__OPERATION__SET_ITEM_STR", 43 },
10474 + { "VALIDATE", "SR__OPERATION__VALIDATE", 50 },
10475 + { "COMMIT", "SR__OPERATION__COMMIT", 51 },
10476 + { "DISCARD_CHANGES", "SR__OPERATION__DISCARD_CHANGES", 52 },
10477 + { "COPY_CONFIG", "SR__OPERATION__COPY_CONFIG", 53 },
10478 + { "LOCK", "SR__OPERATION__LOCK", 60 },
10479 + { "UNLOCK", "SR__OPERATION__UNLOCK", 61 },
10480 + { "SUBSCRIBE", "SR__OPERATION__SUBSCRIBE", 70 },
10481 + { "UNSUBSCRIBE", "SR__OPERATION__UNSUBSCRIBE", 71 },
10482 + { "CHECK_ENABLED_RUNNING", "SR__OPERATION__CHECK_ENABLED_RUNNING", 72 },
10483 + { "GET_CHANGES", "SR__OPERATION__GET_CHANGES", 73 },
10484 + { "DATA_PROVIDE", "SR__OPERATION__DATA_PROVIDE", 80 },
10485 + { "CHECK_EXEC_PERMISSION", "SR__OPERATION__CHECK_EXEC_PERMISSION", 81 },
10486 + { "RPC", "SR__OPERATION__RPC", 82 },
10487 + { "ACTION", "SR__OPERATION__ACTION", 83 },
10488 + { "EVENT_NOTIF", "SR__OPERATION__EVENT_NOTIF", 84 },
10489 + { "EVENT_NOTIF_REPLAY", "SR__OPERATION__EVENT_NOTIF_REPLAY", 85 },
10490 + { "UNSUBSCRIBE_DESTINATION", "SR__OPERATION__UNSUBSCRIBE_DESTINATION", 101 },
10491 + { "COMMIT_TIMEOUT", "SR__OPERATION__COMMIT_TIMEOUT", 102 },
10492 + { "OPER_DATA_TIMEOUT", "SR__OPERATION__OPER_DATA_TIMEOUT", 103 },
10493 + { "INTERNAL_STATE_DATA", "SR__OPERATION__INTERNAL_STATE_DATA", 104 },
10494 + { "NOTIF_STORE_CLEANUP", "SR__OPERATION__NOTIF_STORE_CLEANUP", 105 },
10495 + { "DELAYED_MSG", "SR__OPERATION__DELAYED_MSG", 106 },
10496 + { "NACM_RELOAD", "SR__OPERATION__NACM_RELOAD", 107 },
10497 +};
10498 +static const ProtobufCIntRange sr__operation__value_ranges[] = {
10499 +{10, 0},{20, 7},{30, 11},{40, 16},{50, 20},{60, 24},{70, 26},{80, 30},{101, 36},{0, 43}
10500 +};
10501 +static const ProtobufCEnumValueIndex sr__operation__enum_values_by_name[43] =
10502 +{
10503 + { "ACTION", 33 },
10504 + { "CHECK_ENABLED_RUNNING", 28 },
10505 + { "CHECK_EXEC_PERMISSION", 31 },
10506 + { "COMMIT", 21 },
10507 + { "COMMIT_TIMEOUT", 37 },
10508 + { "COPY_CONFIG", 23 },
10509 + { "DATA_PROVIDE", 30 },
10510 + { "DELAYED_MSG", 41 },
10511 + { "DELETE_ITEM", 17 },
10512 + { "DISCARD_CHANGES", 22 },
10513 + { "EVENT_NOTIF", 34 },
10514 + { "EVENT_NOTIF_REPLAY", 35 },
10515 + { "FEATURE_ENABLE", 10 },
10516 + { "GET_CHANGES", 29 },
10517 + { "GET_ITEM", 11 },
10518 + { "GET_ITEMS", 12 },
10519 + { "GET_SCHEMA", 8 },
10520 + { "GET_SUBTREE", 13 },
10521 + { "GET_SUBTREES", 14 },
10522 + { "GET_SUBTREE_CHUNK", 15 },
10523 + { "INTERNAL_STATE_DATA", 39 },
10524 + { "LIST_SCHEMAS", 7 },
10525 + { "LOCK", 24 },
10526 + { "MODULE_INSTALL", 9 },
10527 + { "MOVE_ITEM", 18 },
10528 + { "NACM_RELOAD", 42 },
10529 + { "NOTIF_STORE_CLEANUP", 40 },
10530 + { "OPER_DATA_TIMEOUT", 38 },
10531 + { "RPC", 32 },
10532 + { "SESSION_CHECK", 3 },
10533 + { "SESSION_REFRESH", 2 },
10534 + { "SESSION_SET_OPTS", 5 },
10535 + { "SESSION_START", 0 },
10536 + { "SESSION_STOP", 1 },
10537 + { "SESSION_SWITCH_DS", 4 },
10538 + { "SET_ITEM", 16 },
10539 + { "SET_ITEM_STR", 19 },
10540 + { "SUBSCRIBE", 26 },
10541 + { "UNLOCK", 25 },
10542 + { "UNSUBSCRIBE", 27 },
10543 + { "UNSUBSCRIBE_DESTINATION", 36 },
10544 + { "VALIDATE", 20 },
10545 + { "VERSION_VERIFY", 6 },
10546 +};
10547 +const ProtobufCEnumDescriptor sr__operation__descriptor =
10548 +{
10549 + PROTOBUF_C__ENUM_DESCRIPTOR_MAGIC,
10550 + "sr.Operation",
10551 + "Operation",
10552 + "Sr__Operation",
10553 + "sr",
10554 + 43,
10555 + sr__operation__enum_values_by_number,
10556 + 43,
10557 + sr__operation__enum_values_by_name,
10558 + 9,
10559 + sr__operation__value_ranges,
10560 + NULL,NULL,NULL,NULL /* reserved[1234] */
10561 +};
10562 Index: sysrepo-7aa2f18d234267403147df92c0005c871f0aa840/src/common/sysrepo.pb-c.h
10563 ===================================================================
10564 --- /dev/null
10565 +++ sysrepo-7aa2f18d234267403147df92c0005c871f0aa840/src/common/sysrepo.pb-c.h
10566 @@ -0,0 +1,4238 @@
10567 +/* Generated by the protocol buffer compiler. DO NOT EDIT! */
10568 +/* Generated from: sysrepo.proto */
10569 +
10570 +#ifndef PROTOBUF_C_sysrepo_2eproto__INCLUDED
10571 +#define PROTOBUF_C_sysrepo_2eproto__INCLUDED
10572 +
10573 +#include <protobuf-c/protobuf-c.h>
10574 +
10575 +PROTOBUF_C__BEGIN_DECLS
10576 +
10577 +#if PROTOBUF_C_VERSION_NUMBER < 1000000
10578 +# error This file was generated by a newer version of protoc-c which is incompatible with your libprotobuf-c headers. Please update your headers.
10579 +#elif 1002001 < PROTOBUF_C_MIN_COMPILER_VERSION
10580 +# 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.
10581 +#endif
10582 +
10583 +
10584 +typedef struct _Sr__Value Sr__Value;
10585 +typedef struct _Sr__Node Sr__Node;
10586 +typedef struct _Sr__Error Sr__Error;
10587 +typedef struct _Sr__SessionStartReq Sr__SessionStartReq;
10588 +typedef struct _Sr__SessionStartResp Sr__SessionStartResp;
10589 +typedef struct _Sr__SessionStopReq Sr__SessionStopReq;
10590 +typedef struct _Sr__SessionStopResp Sr__SessionStopResp;
10591 +typedef struct _Sr__SessionRefreshReq Sr__SessionRefreshReq;
10592 +typedef struct _Sr__SessionRefreshResp Sr__SessionRefreshResp;
10593 +typedef struct _Sr__SessionCheckReq Sr__SessionCheckReq;
10594 +typedef struct _Sr__SessionCheckResp Sr__SessionCheckResp;
10595 +typedef struct _Sr__SessionSwitchDsReq Sr__SessionSwitchDsReq;
10596 +typedef struct _Sr__SessionSwitchDsResp Sr__SessionSwitchDsResp;
10597 +typedef struct _Sr__SessionSetOptsReq Sr__SessionSetOptsReq;
10598 +typedef struct _Sr__SessionSetOptsResp Sr__SessionSetOptsResp;
10599 +typedef struct _Sr__VersionVerifyReq Sr__VersionVerifyReq;
10600 +typedef struct _Sr__VersionVerifyResp Sr__VersionVerifyResp;
10601 +typedef struct _Sr__SchemaRevision Sr__SchemaRevision;
10602 +typedef struct _Sr__SchemaSubmodule Sr__SchemaSubmodule;
10603 +typedef struct _Sr__Schema Sr__Schema;
10604 +typedef struct _Sr__ListSchemasReq Sr__ListSchemasReq;
10605 +typedef struct _Sr__ListSchemasResp Sr__ListSchemasResp;
10606 +typedef struct _Sr__GetSchemaReq Sr__GetSchemaReq;
10607 +typedef struct _Sr__GetSchemaResp Sr__GetSchemaResp;
10608 +typedef struct _Sr__GetItemReq Sr__GetItemReq;
10609 +typedef struct _Sr__GetItemResp Sr__GetItemResp;
10610 +typedef struct _Sr__GetItemsReq Sr__GetItemsReq;
10611 +typedef struct _Sr__GetItemsResp Sr__GetItemsResp;
10612 +typedef struct _Sr__GetSubtreeReq Sr__GetSubtreeReq;
10613 +typedef struct _Sr__GetSubtreeResp Sr__GetSubtreeResp;
10614 +typedef struct _Sr__GetSubtreesReq Sr__GetSubtreesReq;
10615 +typedef struct _Sr__GetSubtreesResp Sr__GetSubtreesResp;
10616 +typedef struct _Sr__GetSubtreeChunkReq Sr__GetSubtreeChunkReq;
10617 +typedef struct _Sr__GetSubtreeChunkResp Sr__GetSubtreeChunkResp;
10618 +typedef struct _Sr__SetItemReq Sr__SetItemReq;
10619 +typedef struct _Sr__SetItemResp Sr__SetItemResp;
10620 +typedef struct _Sr__SetItemStrReq Sr__SetItemStrReq;
10621 +typedef struct _Sr__SetItemStrResp Sr__SetItemStrResp;
10622 +typedef struct _Sr__DeleteItemReq Sr__DeleteItemReq;
10623 +typedef struct _Sr__DeleteItemResp Sr__DeleteItemResp;
10624 +typedef struct _Sr__MoveItemReq Sr__MoveItemReq;
10625 +typedef struct _Sr__MoveItemResp Sr__MoveItemResp;
10626 +typedef struct _Sr__ValidateReq Sr__ValidateReq;
10627 +typedef struct _Sr__ValidateResp Sr__ValidateResp;
10628 +typedef struct _Sr__CommitReq Sr__CommitReq;
10629 +typedef struct _Sr__CommitResp Sr__CommitResp;
10630 +typedef struct _Sr__DiscardChangesReq Sr__DiscardChangesReq;
10631 +typedef struct _Sr__DiscardChangesResp Sr__DiscardChangesResp;
10632 +typedef struct _Sr__CopyConfigReq Sr__CopyConfigReq;
10633 +typedef struct _Sr__CopyConfigResp Sr__CopyConfigResp;
10634 +typedef struct _Sr__LockReq Sr__LockReq;
10635 +typedef struct _Sr__LockResp Sr__LockResp;
10636 +typedef struct _Sr__UnlockReq Sr__UnlockReq;
10637 +typedef struct _Sr__UnlockResp Sr__UnlockResp;
10638 +typedef struct _Sr__SubscribeReq Sr__SubscribeReq;
10639 +typedef struct _Sr__SubscribeResp Sr__SubscribeResp;
10640 +typedef struct _Sr__UnsubscribeReq Sr__UnsubscribeReq;
10641 +typedef struct _Sr__UnsubscribeResp Sr__UnsubscribeResp;
10642 +typedef struct _Sr__CheckEnabledRunningReq Sr__CheckEnabledRunningReq;
10643 +typedef struct _Sr__CheckEnabledRunningResp Sr__CheckEnabledRunningResp;
10644 +typedef struct _Sr__ModuleInstallNotification Sr__ModuleInstallNotification;
10645 +typedef struct _Sr__FeatureEnableNotification Sr__FeatureEnableNotification;
10646 +typedef struct _Sr__ModuleChangeNotification Sr__ModuleChangeNotification;
10647 +typedef struct _Sr__SubtreeChangeNotification Sr__SubtreeChangeNotification;
10648 +typedef struct _Sr__Change Sr__Change;
10649 +typedef struct _Sr__GetChangesReq Sr__GetChangesReq;
10650 +typedef struct _Sr__GetChangesResp Sr__GetChangesResp;
10651 +typedef struct _Sr__CheckExecPermReq Sr__CheckExecPermReq;
10652 +typedef struct _Sr__CheckExecPermResp Sr__CheckExecPermResp;
10653 +typedef struct _Sr__RPCReq Sr__RPCReq;
10654 +typedef struct _Sr__RPCResp Sr__RPCResp;
10655 +typedef struct _Sr__EventNotifReq Sr__EventNotifReq;
10656 +typedef struct _Sr__EventNotifResp Sr__EventNotifResp;
10657 +typedef struct _Sr__EventNotifReplayReq Sr__EventNotifReplayReq;
10658 +typedef struct _Sr__EventNotifReplayResp Sr__EventNotifReplayResp;
10659 +typedef struct _Sr__DataProvideReq Sr__DataProvideReq;
10660 +typedef struct _Sr__DataProvideResp Sr__DataProvideResp;
10661 +typedef struct _Sr__ModuleInstallReq Sr__ModuleInstallReq;
10662 +typedef struct _Sr__ModuleInstallResp Sr__ModuleInstallResp;
10663 +typedef struct _Sr__FeatureEnableReq Sr__FeatureEnableReq;
10664 +typedef struct _Sr__FeatureEnableResp Sr__FeatureEnableResp;
10665 +typedef struct _Sr__UnsubscribeDestinationReq Sr__UnsubscribeDestinationReq;
10666 +typedef struct _Sr__CommitTimeoutReq Sr__CommitTimeoutReq;
10667 +typedef struct _Sr__OperDataTimeoutReq Sr__OperDataTimeoutReq;
10668 +typedef struct _Sr__InternalStateDataReq Sr__InternalStateDataReq;
10669 +typedef struct _Sr__NotifStoreCleanupReq Sr__NotifStoreCleanupReq;
10670 +typedef struct _Sr__DelayedMsgReq Sr__DelayedMsgReq;
10671 +typedef struct _Sr__NacmReloadReq Sr__NacmReloadReq;
10672 +typedef struct _Sr__Request Sr__Request;
10673 +typedef struct _Sr__Response Sr__Response;
10674 +typedef struct _Sr__Notification Sr__Notification;
10675 +typedef struct _Sr__NotificationAck Sr__NotificationAck;
10676 +typedef struct _Sr__InternalRequest Sr__InternalRequest;
10677 +typedef struct _Sr__Msg Sr__Msg;
10678 +
10679 +
10680 +/* --- enums --- */
10681 +
10682 +typedef enum _Sr__Value__Types {
10683 + SR__VALUE__TYPES__LIST = 1,
10684 + SR__VALUE__TYPES__CONTAINER = 2,
10685 + SR__VALUE__TYPES__CONTAINER_PRESENCE = 3,
10686 + SR__VALUE__TYPES__LEAF_EMPTY = 4,
10687 + SR__VALUE__TYPES__BINARY = 10,
10688 + SR__VALUE__TYPES__BITS = 11,
10689 + SR__VALUE__TYPES__BOOL = 12,
10690 + SR__VALUE__TYPES__DECIMAL64 = 13,
10691 + SR__VALUE__TYPES__ENUM = 14,
10692 + SR__VALUE__TYPES__IDENTITYREF = 15,
10693 + SR__VALUE__TYPES__INSTANCEID = 16,
10694 + SR__VALUE__TYPES__INT8 = 17,
10695 + SR__VALUE__TYPES__INT16 = 18,
10696 + SR__VALUE__TYPES__INT32 = 19,
10697 + SR__VALUE__TYPES__INT64 = 20,
10698 + SR__VALUE__TYPES__STRING = 21,
10699 + SR__VALUE__TYPES__UINT8 = 22,
10700 + SR__VALUE__TYPES__UINT16 = 23,
10701 + SR__VALUE__TYPES__UINT32 = 24,
10702 + SR__VALUE__TYPES__UINT64 = 25,
10703 + SR__VALUE__TYPES__ANYXML = 26,
10704 + SR__VALUE__TYPES__ANYDATA = 27
10705 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SR__VALUE__TYPES)
10706 +} Sr__Value__Types;
10707 +typedef enum _Sr__MoveItemReq__MovePosition {
10708 + SR__MOVE_ITEM_REQ__MOVE_POSITION__BEFORE = 1,
10709 + SR__MOVE_ITEM_REQ__MOVE_POSITION__AFTER = 2,
10710 + SR__MOVE_ITEM_REQ__MOVE_POSITION__FIRST = 3,
10711 + SR__MOVE_ITEM_REQ__MOVE_POSITION__LAST = 4
10712 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SR__MOVE_ITEM_REQ__MOVE_POSITION)
10713 +} Sr__MoveItemReq__MovePosition;
10714 +/*
10715 + **
10716 + * @brief Type of the event notification.
10717 + */
10718 +typedef enum _Sr__EventNotifReq__NotifType {
10719 + SR__EVENT_NOTIF_REQ__NOTIF_TYPE__REALTIME = 1,
10720 + SR__EVENT_NOTIF_REQ__NOTIF_TYPE__REPLAY = 2,
10721 + SR__EVENT_NOTIF_REQ__NOTIF_TYPE__REPLAY_COMPLETE = 3,
10722 + SR__EVENT_NOTIF_REQ__NOTIF_TYPE__REPLAY_STOP = 4
10723 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SR__EVENT_NOTIF_REQ__NOTIF_TYPE)
10724 +} Sr__EventNotifReq__NotifType;
10725 +/*
10726 + **
10727 + * @brief Flags used to override default session handling.
10728 + */
10729 +typedef enum _Sr__EventNotifReq__NotifFlags {
10730 + /*
10731 + **< Notification will be handled normally.
10732 + */
10733 + SR__EVENT_NOTIF_REQ__NOTIF_FLAGS__DEFAULT = 0,
10734 + /*
10735 + **< Notification will not be stored in the notification store.
10736 + */
10737 + SR__EVENT_NOTIF_REQ__NOTIF_FLAGS__EPHEMERAL = 1
10738 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SR__EVENT_NOTIF_REQ__NOTIF_FLAGS)
10739 +} Sr__EventNotifReq__NotifFlags;
10740 +/*
10741 + **
10742 + * @brief Type of the message.
10743 + */
10744 +typedef enum _Sr__Msg__MsgType {
10745 + /*
10746 + **< The message is a request.
10747 + */
10748 + SR__MSG__MSG_TYPE__REQUEST = 1,
10749 + /*
10750 + **< The message is a response to the request.
10751 + */
10752 + SR__MSG__MSG_TYPE__RESPONSE = 2,
10753 + /*
10754 + **< The message is a notification.
10755 + */
10756 + SR__MSG__MSG_TYPE__NOTIFICATION = 3,
10757 + /*
10758 + **< The message is a notification acknowledgment.
10759 + */
10760 + SR__MSG__MSG_TYPE__NOTIFICATION_ACK = 4,
10761 + /*
10762 + **< The message is an internal request, should not be used from the public API.
10763 + */
10764 + SR__MSG__MSG_TYPE__INTERNAL_REQUEST = 5
10765 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SR__MSG__MSG_TYPE)
10766 +} Sr__Msg__MsgType;
10767 +/*
10768 + **
10769 + * @brief Variant of the API. Currently only values (sr_val_t) vs. trees (sr_node_t).
10770 + */
10771 +typedef enum _Sr__ApiVariant {
10772 + SR__API_VARIANT__VALUES = 1,
10773 + SR__API_VARIANT__TREES = 2
10774 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SR__API_VARIANT)
10775 +} Sr__ApiVariant;
10776 +/*
10777 + **
10778 + * @brief Datastore on which the configuration session will operate.
10779 + */
10780 +typedef enum _Sr__DataStore {
10781 + SR__DATA_STORE__STARTUP = 1,
10782 + SR__DATA_STORE__RUNNING = 2,
10783 + SR__DATA_STORE__CANDIDATE = 3
10784 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SR__DATA_STORE)
10785 +} Sr__DataStore;
10786 +/*
10787 + **
10788 + * @brief Flags used to override default session handling.
10789 + */
10790 +typedef enum _Sr__SessionFlags {
10791 + /*
10792 + **< Default (normal) session behavior.
10793 + */
10794 + SR__SESSION_FLAGS__SESS_DEFAULT = 0,
10795 + /*
10796 + **< Session will process only configuration data (e.g. sysrepo won't
10797 + *return any state data by ::sr_get_items / ::sr_get_items_iter calls).
10798 + */
10799 + SR__SESSION_FLAGS__SESS_CONFIG_ONLY = 1,
10800 + /*
10801 + **< Enable NETCONF access control for this session.
10802 + */
10803 + SR__SESSION_FLAGS__SESS_ENABLE_NACM = 2,
10804 + /*
10805 + **< Notification session (internal type of session).
10806 + */
10807 + SR__SESSION_FLAGS__SESS_NOTIFICATION = 1024
10808 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SR__SESSION_FLAGS)
10809 +} Sr__SessionFlags;
10810 +/*
10811 + **
10812 + * @brief Flags used to override default behavior of data manipulation calls.
10813 + */
10814 +typedef enum _Sr__EditFlags {
10815 + /*
10816 + **< Default behavior - recursive and non-strict.
10817 + */
10818 + SR__EDIT_FLAGS__EDIT_DEFAULT = 0,
10819 + /*
10820 + **< Non-recursive behavior:
10821 + *by ::SetItemReq, all preceding nodes (parents) of the identified element must exist,
10822 + *by ::DeleteItemReq xpath must not identify an non-empty list or non-empty container.
10823 + */
10824 + SR__EDIT_FLAGS__EDIT_NON_RECURSIVE = 1,
10825 + /*
10826 + **< Strict behavior:
10827 + *by ::SetItemReq the identified element must not exist (similar to netconf create operation),
10828 + *by ::DeleteItemReq the identified element must exist (similar to netconf delete operation).
10829 + */
10830 + SR__EDIT_FLAGS__EDIT_STRICT = 2
10831 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SR__EDIT_FLAGS)
10832 +} Sr__EditFlags;
10833 +typedef enum _Sr__SubscriptionType {
10834 + SR__SUBSCRIPTION_TYPE__MODULE_INSTALL_SUBS = 1,
10835 + SR__SUBSCRIPTION_TYPE__FEATURE_ENABLE_SUBS = 2,
10836 + SR__SUBSCRIPTION_TYPE__MODULE_CHANGE_SUBS = 10,
10837 + SR__SUBSCRIPTION_TYPE__SUBTREE_CHANGE_SUBS = 11,
10838 + SR__SUBSCRIPTION_TYPE__DP_GET_ITEMS_SUBS = 20,
10839 + SR__SUBSCRIPTION_TYPE__RPC_SUBS = 30,
10840 + SR__SUBSCRIPTION_TYPE__ACTION_SUBS = 31,
10841 + SR__SUBSCRIPTION_TYPE__EVENT_NOTIF_SUBS = 40,
10842 + /*
10843 + **< Used only internally to test for inactive notification subscriptions.
10844 + */
10845 + SR__SUBSCRIPTION_TYPE__HELLO_SUBS = 50,
10846 + /*
10847 + **< Used only internally to notify about the end of the commit process.
10848 + */
10849 + SR__SUBSCRIPTION_TYPE__COMMIT_END_SUBS = 51
10850 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SR__SUBSCRIPTION_TYPE)
10851 +} Sr__SubscriptionType;
10852 +typedef enum _Sr__NotificationEvent {
10853 + SR__NOTIFICATION_EVENT__VERIFY_EV = 1,
10854 + SR__NOTIFICATION_EVENT__APPLY_EV = 2,
10855 + SR__NOTIFICATION_EVENT__ABORT_EV = 3,
10856 + SR__NOTIFICATION_EVENT__ENABLED_EV = 4
10857 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SR__NOTIFICATION_EVENT)
10858 +} Sr__NotificationEvent;
10859 +typedef enum _Sr__ModuleState {
10860 + SR__MODULE_STATE__UNINSTALLED = 1,
10861 + SR__MODULE_STATE__IMPORTED = 2,
10862 + SR__MODULE_STATE__IMPLEMENTED = 3
10863 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SR__MODULE_STATE)
10864 +} Sr__ModuleState;
10865 +typedef enum _Sr__ChangeOperation {
10866 + SR__CHANGE_OPERATION__CREATED = 1,
10867 + SR__CHANGE_OPERATION__MODIFIED = 2,
10868 + SR__CHANGE_OPERATION__DELETED = 3,
10869 + SR__CHANGE_OPERATION__MOVED = 4
10870 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SR__CHANGE_OPERATION)
10871 +} Sr__ChangeOperation;
10872 +/*
10873 + **
10874 + * @brief Requested operation.
10875 + */
10876 +typedef enum _Sr__Operation {
10877 + SR__OPERATION__SESSION_START = 10,
10878 + SR__OPERATION__SESSION_STOP = 11,
10879 + SR__OPERATION__SESSION_REFRESH = 12,
10880 + SR__OPERATION__SESSION_CHECK = 13,
10881 + SR__OPERATION__SESSION_SWITCH_DS = 14,
10882 + SR__OPERATION__SESSION_SET_OPTS = 15,
10883 + SR__OPERATION__VERSION_VERIFY = 16,
10884 + SR__OPERATION__LIST_SCHEMAS = 20,
10885 + SR__OPERATION__GET_SCHEMA = 21,
10886 + SR__OPERATION__MODULE_INSTALL = 22,
10887 + SR__OPERATION__FEATURE_ENABLE = 23,
10888 + SR__OPERATION__GET_ITEM = 30,
10889 + SR__OPERATION__GET_ITEMS = 31,
10890 + SR__OPERATION__GET_SUBTREE = 32,
10891 + SR__OPERATION__GET_SUBTREES = 33,
10892 + SR__OPERATION__GET_SUBTREE_CHUNK = 34,
10893 + SR__OPERATION__SET_ITEM = 40,
10894 + SR__OPERATION__DELETE_ITEM = 41,
10895 + SR__OPERATION__MOVE_ITEM = 42,
10896 + SR__OPERATION__SET_ITEM_STR = 43,
10897 + SR__OPERATION__VALIDATE = 50,
10898 + SR__OPERATION__COMMIT = 51,
10899 + SR__OPERATION__DISCARD_CHANGES = 52,
10900 + SR__OPERATION__COPY_CONFIG = 53,
10901 + SR__OPERATION__LOCK = 60,
10902 + SR__OPERATION__UNLOCK = 61,
10903 + SR__OPERATION__SUBSCRIBE = 70,
10904 + SR__OPERATION__UNSUBSCRIBE = 71,
10905 + SR__OPERATION__CHECK_ENABLED_RUNNING = 72,
10906 + SR__OPERATION__GET_CHANGES = 73,
10907 + SR__OPERATION__DATA_PROVIDE = 80,
10908 + SR__OPERATION__CHECK_EXEC_PERMISSION = 81,
10909 + SR__OPERATION__RPC = 82,
10910 + SR__OPERATION__ACTION = 83,
10911 + SR__OPERATION__EVENT_NOTIF = 84,
10912 + SR__OPERATION__EVENT_NOTIF_REPLAY = 85,
10913 + SR__OPERATION__UNSUBSCRIBE_DESTINATION = 101,
10914 + SR__OPERATION__COMMIT_TIMEOUT = 102,
10915 + SR__OPERATION__OPER_DATA_TIMEOUT = 103,
10916 + SR__OPERATION__INTERNAL_STATE_DATA = 104,
10917 + SR__OPERATION__NOTIF_STORE_CLEANUP = 105,
10918 + SR__OPERATION__DELAYED_MSG = 106,
10919 + SR__OPERATION__NACM_RELOAD = 107
10920 + PROTOBUF_C__FORCE_ENUM_TO_BE_INT_SIZE(SR__OPERATION)
10921 +} Sr__Operation;
10922 +
10923 +/* --- messages --- */
10924 +
10925 +/*
10926 + **
10927 + * @brief Value of an item stored (or to be stored) in the datastore.
10928 + * Can be mapped to sr_val_t data structure from sysrepo library API.
10929 + */
10930 +struct _Sr__Value
10931 +{
10932 + ProtobufCMessage base;
10933 + char *xpath;
10934 + Sr__Value__Types type;
10935 + protobuf_c_boolean dflt;
10936 + char *binary_val;
10937 + char *bits_val;
10938 + protobuf_c_boolean has_bool_val;
10939 + protobuf_c_boolean bool_val;
10940 + protobuf_c_boolean has_decimal64_val;
10941 + double decimal64_val;
10942 + char *enum_val;
10943 + char *identityref_val;
10944 + char *instanceid_val;
10945 + protobuf_c_boolean has_int8_val;
10946 + int32_t int8_val;
10947 + protobuf_c_boolean has_int16_val;
10948 + int32_t int16_val;
10949 + protobuf_c_boolean has_int32_val;
10950 + int32_t int32_val;
10951 + protobuf_c_boolean has_int64_val;
10952 + int64_t int64_val;
10953 + char *string_val;
10954 + protobuf_c_boolean has_uint8_val;
10955 + uint32_t uint8_val;
10956 + protobuf_c_boolean has_uint16_val;
10957 + uint32_t uint16_val;
10958 + protobuf_c_boolean has_uint32_val;
10959 + uint32_t uint32_val;
10960 + protobuf_c_boolean has_uint64_val;
10961 + uint64_t uint64_val;
10962 + char *anyxml_val;
10963 + char *anydata_val;
10964 +};
10965 +#define SR__VALUE__INIT \
10966 + { PROTOBUF_C_MESSAGE_INIT (&sr__value__descriptor) \
10967 + , 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 }
10968 +
10969 +
10970 +/*
10971 + **
10972 + * @brief Item stored (or to be stored) in the datastore represented as a tree node
10973 + * reflecting module schema. Can be mapped to sr_node_t data structure from sysrepo library API.
10974 + */
10975 +struct _Sr__Node
10976 +{
10977 + ProtobufCMessage base;
10978 + /*
10979 + **< Value of the node; member *xpath* is used to store node's name.
10980 + */
10981 + Sr__Value *value;
10982 + /*
10983 + **< Name of the module that defines scheme of this node.
10984 + */
10985 + char *module_name;
10986 + /*
10987 + **< Direct descendands of this node.
10988 + */
10989 + size_t n_children;
10990 + Sr__Node **children;
10991 +};
10992 +#define SR__NODE__INIT \
10993 + { PROTOBUF_C_MESSAGE_INIT (&sr__node__descriptor) \
10994 + , NULL, NULL, 0,NULL }
10995 +
10996 +
10997 +/*
10998 + **
10999 + * @brief Error message retuned from the Sysrepo Engine.
11000 + */
11001 +struct _Sr__Error
11002 +{
11003 + ProtobufCMessage base;
11004 + char *message;
11005 + char *xpath;
11006 +};
11007 +#define SR__ERROR__INIT \
11008 + { PROTOBUF_C_MESSAGE_INIT (&sr__error__descriptor) \
11009 + , NULL, NULL }
11010 +
11011 +
11012 +/*
11013 + **
11014 + * @brief Request for starting a session. Sent by sr_session_start API call.
11015 + */
11016 +struct _Sr__SessionStartReq
11017 +{
11018 + ProtobufCMessage base;
11019 + Sr__DataStore datastore;
11020 + char *user_name;
11021 + /*
11022 + **< Bitwise OR of SessionFlags.
11023 + */
11024 + uint32_t options;
11025 + /*
11026 + **< Applicable if SESS_NOTIFICATION was specified.
11027 + */
11028 + protobuf_c_boolean has_commit_id;
11029 + uint32_t commit_id;
11030 +};
11031 +#define SR__SESSION_START_REQ__INIT \
11032 + { PROTOBUF_C_MESSAGE_INIT (&sr__session_start_req__descriptor) \
11033 + , 0, NULL, 0, 0,0 }
11034 +
11035 +
11036 +/*
11037 + **
11038 + * @brief Response to session_start request.
11039 + */
11040 +struct _Sr__SessionStartResp
11041 +{
11042 + ProtobufCMessage base;
11043 + uint32_t session_id;
11044 +};
11045 +#define SR__SESSION_START_RESP__INIT \
11046 + { PROTOBUF_C_MESSAGE_INIT (&sr__session_start_resp__descriptor) \
11047 + , 0 }
11048 +
11049 +
11050 +/*
11051 + **
11052 + * @brief Request for stopping the session. Sent by sr_session_stop API call.
11053 + */
11054 +struct _Sr__SessionStopReq
11055 +{
11056 + ProtobufCMessage base;
11057 + uint32_t session_id;
11058 +};
11059 +#define SR__SESSION_STOP_REQ__INIT \
11060 + { PROTOBUF_C_MESSAGE_INIT (&sr__session_stop_req__descriptor) \
11061 + , 0 }
11062 +
11063 +
11064 +/*
11065 + **
11066 + * @brief Response to session_stop request.
11067 + */
11068 +struct _Sr__SessionStopResp
11069 +{
11070 + ProtobufCMessage base;
11071 + uint32_t session_id;
11072 +};
11073 +#define SR__SESSION_STOP_RESP__INIT \
11074 + { PROTOBUF_C_MESSAGE_INIT (&sr__session_stop_resp__descriptor) \
11075 + , 0 }
11076 +
11077 +
11078 +/*
11079 + **
11080 + * @brief Refreshes configuration data cached within the session.
11081 + * Sent by sr_session_refresh API call.
11082 + */
11083 +struct _Sr__SessionRefreshReq
11084 +{
11085 + ProtobufCMessage base;
11086 +};
11087 +#define SR__SESSION_REFRESH_REQ__INIT \
11088 + { PROTOBUF_C_MESSAGE_INIT (&sr__session_refresh_req__descriptor) \
11089 + }
11090 +
11091 +
11092 +/*
11093 + **
11094 + * @brief Response to sr_session_refresh request.
11095 + */
11096 +struct _Sr__SessionRefreshResp
11097 +{
11098 + ProtobufCMessage base;
11099 + size_t n_errors;
11100 + Sr__Error **errors;
11101 +};
11102 +#define SR__SESSION_REFRESH_RESP__INIT \
11103 + { PROTOBUF_C_MESSAGE_INIT (&sr__session_refresh_resp__descriptor) \
11104 + , 0,NULL }
11105 +
11106 +
11107 +/*
11108 + **
11109 + * @brief Checks aliveness and validity of the session & connection tied to it.
11110 + * Sent by sr_session_check API call.
11111 + */
11112 +struct _Sr__SessionCheckReq
11113 +{
11114 + ProtobufCMessage base;
11115 +};
11116 +#define SR__SESSION_CHECK_REQ__INIT \
11117 + { PROTOBUF_C_MESSAGE_INIT (&sr__session_check_req__descriptor) \
11118 + }
11119 +
11120 +
11121 +/*
11122 + **
11123 + * @brief Response to sr_session_check request.
11124 + */
11125 +struct _Sr__SessionCheckResp
11126 +{
11127 + ProtobufCMessage base;
11128 + size_t n_errors;
11129 + Sr__Error **errors;
11130 +};
11131 +#define SR__SESSION_CHECK_RESP__INIT \
11132 + { PROTOBUF_C_MESSAGE_INIT (&sr__session_check_resp__descriptor) \
11133 + , 0,NULL }
11134 +
11135 +
11136 +/*
11137 + **
11138 + * @brief Changes the datastore to which the session is tied to.
11139 + */
11140 +struct _Sr__SessionSwitchDsReq
11141 +{
11142 + ProtobufCMessage base;
11143 + Sr__DataStore datastore;
11144 +};
11145 +#define SR__SESSION_SWITCH_DS_REQ__INIT \
11146 + { PROTOBUF_C_MESSAGE_INIT (&sr__session_switch_ds_req__descriptor) \
11147 + , 0 }
11148 +
11149 +
11150 +/*
11151 + **
11152 + * @brief Response to sr_session_switch_ds request.
11153 + */
11154 +struct _Sr__SessionSwitchDsResp
11155 +{
11156 + ProtobufCMessage base;
11157 +};
11158 +#define SR__SESSION_SWITCH_DS_RESP__INIT \
11159 + { PROTOBUF_C_MESSAGE_INIT (&sr__session_switch_ds_resp__descriptor) \
11160 + }
11161 +
11162 +
11163 +/*
11164 + **
11165 + * @brief Request for modification of session options.
11166 + */
11167 +struct _Sr__SessionSetOptsReq
11168 +{
11169 + ProtobufCMessage base;
11170 + uint32_t options;
11171 +};
11172 +#define SR__SESSION_SET_OPTS_REQ__INIT \
11173 + { PROTOBUF_C_MESSAGE_INIT (&sr__session_set_opts_req__descriptor) \
11174 + , 0 }
11175 +
11176 +
11177 +/*
11178 + **
11179 + * @brief Response to sr_session_set_options.
11180 + */
11181 +struct _Sr__SessionSetOptsResp
11182 +{
11183 + ProtobufCMessage base;
11184 +};
11185 +#define SR__SESSION_SET_OPTS_RESP__INIT \
11186 + { PROTOBUF_C_MESSAGE_INIT (&sr__session_set_opts_resp__descriptor) \
11187 + }
11188 +
11189 +
11190 +/*
11191 + **
11192 + * @brief Request to verify version compatibility.
11193 + */
11194 +struct _Sr__VersionVerifyReq
11195 +{
11196 + ProtobufCMessage base;
11197 + char *soname;
11198 +};
11199 +#define SR__VERSION_VERIFY_REQ__INIT \
11200 + { PROTOBUF_C_MESSAGE_INIT (&sr__version_verify_req__descriptor) \
11201 + , NULL }
11202 +
11203 +
11204 +/*
11205 + **
11206 + * @brief Response to version verification.
11207 + */
11208 +struct _Sr__VersionVerifyResp
11209 +{
11210 + ProtobufCMessage base;
11211 + /*
11212 + **< server-side SONAME version in case of versions incompatibility.
11213 + */
11214 + char *soname;
11215 +};
11216 +#define SR__VERSION_VERIFY_RESP__INIT \
11217 + { PROTOBUF_C_MESSAGE_INIT (&sr__version_verify_resp__descriptor) \
11218 + , NULL }
11219 +
11220 +
11221 +/*
11222 + **
11223 + * @brief Schema revision details.
11224 + */
11225 +struct _Sr__SchemaRevision
11226 +{
11227 + ProtobufCMessage base;
11228 + /*
11229 + **< Latest revision date of the module.
11230 + */
11231 + char *revision;
11232 + /*
11233 + **< Absolute path to file where the schema is stored (YANG format).
11234 + */
11235 + char *file_path_yang;
11236 + /*
11237 + **< Absolute path to file where the schema is stored (.yin format).
11238 + */
11239 + char *file_path_yin;
11240 +};
11241 +#define SR__SCHEMA_REVISION__INIT \
11242 + { PROTOBUF_C_MESSAGE_INIT (&sr__schema_revision__descriptor) \
11243 + , NULL, NULL, NULL }
11244 +
11245 +
11246 +/*
11247 + **
11248 + * @brief Schema submodule information.
11249 + */
11250 +struct _Sr__SchemaSubmodule
11251 +{
11252 + ProtobufCMessage base;
11253 + /*
11254 + **< Submodule name
11255 + */
11256 + char *submodule_name;
11257 + /*
11258 + **< Revision of the submodule
11259 + */
11260 + Sr__SchemaRevision *revision;
11261 +};
11262 +#define SR__SCHEMA_SUBMODULE__INIT \
11263 + { PROTOBUF_C_MESSAGE_INIT (&sr__schema_submodule__descriptor) \
11264 + , NULL, NULL }
11265 +
11266 +
11267 +/*
11268 + **
11269 + * @brief Information about a schema installed in sysrepo datastore.
11270 + */
11271 +struct _Sr__Schema
11272 +{
11273 + ProtobufCMessage base;
11274 + /*
11275 + **< Name of the module.
11276 + */
11277 + char *module_name;
11278 + /*
11279 + **< Namespace of the module.
11280 + */
11281 + char *ns;
11282 + /*
11283 + **< Prefix of he module.
11284 + */
11285 + char *prefix;
11286 + /*
11287 + **< TRUE only for explicitly installed modules (those are always implemented).
11288 + */
11289 + protobuf_c_boolean installed;
11290 + /*
11291 + **< TRUE for implemented modules (do not have to be installed if they have augments,
11292 + *deviations or are targets for leafrefs of other implemented modules).
11293 + */
11294 + protobuf_c_boolean implemented;
11295 + /*
11296 + **< Revision of the module
11297 + */
11298 + Sr__SchemaRevision *revision;
11299 + /*
11300 + **< Submodules
11301 + */
11302 + size_t n_submodules;
11303 + Sr__SchemaSubmodule **submodules;
11304 + /*
11305 + **< Features enabled for the module
11306 + */
11307 + size_t n_enabled_features;
11308 + char **enabled_features;
11309 +};
11310 +#define SR__SCHEMA__INIT \
11311 + { PROTOBUF_C_MESSAGE_INIT (&sr__schema__descriptor) \
11312 + , NULL, NULL, NULL, 0, 0, NULL, 0,NULL, 0,NULL }
11313 +
11314 +
11315 +/*
11316 + **
11317 + * @brief Retrieves an array of schemas installed in the sysrepo datastore.
11318 + * Sent by sr_list_schemas API call.
11319 + */
11320 +struct _Sr__ListSchemasReq
11321 +{
11322 + ProtobufCMessage base;
11323 +};
11324 +#define SR__LIST_SCHEMAS_REQ__INIT \
11325 + { PROTOBUF_C_MESSAGE_INIT (&sr__list_schemas_req__descriptor) \
11326 + }
11327 +
11328 +
11329 +/*
11330 + **
11331 + * @brief Response to sr_list_schemas request.
11332 + */
11333 +struct _Sr__ListSchemasResp
11334 +{
11335 + ProtobufCMessage base;
11336 + size_t n_schemas;
11337 + Sr__Schema **schemas;
11338 +};
11339 +#define SR__LIST_SCHEMAS_RESP__INIT \
11340 + { PROTOBUF_C_MESSAGE_INIT (&sr__list_schemas_resp__descriptor) \
11341 + , 0,NULL }
11342 +
11343 +
11344 +/*
11345 + **
11346 + * @brief Retrieves the content of specified schema file.
11347 + * Sent by sr_get_schema API call.
11348 + */
11349 +struct _Sr__GetSchemaReq
11350 +{
11351 + ProtobufCMessage base;
11352 + char *module_name;
11353 + char *revision;
11354 + char *submodule_name;
11355 + char *submodule_revision;
11356 + protobuf_c_boolean yang_format;
11357 +};
11358 +#define SR__GET_SCHEMA_REQ__INIT \
11359 + { PROTOBUF_C_MESSAGE_INIT (&sr__get_schema_req__descriptor) \
11360 + , NULL, NULL, NULL, NULL, 0 }
11361 +
11362 +
11363 +/*
11364 + **
11365 + * @brief Response to sr_get_schema request.
11366 + */
11367 +struct _Sr__GetSchemaResp
11368 +{
11369 + ProtobufCMessage base;
11370 + char *schema_content;
11371 +};
11372 +#define SR__GET_SCHEMA_RESP__INIT \
11373 + { PROTOBUF_C_MESSAGE_INIT (&sr__get_schema_resp__descriptor) \
11374 + , NULL }
11375 +
11376 +
11377 +/*
11378 + **
11379 + * @brief Retrieves a single data element stored under provided path.
11380 + * Sent by sr_get_item API call.
11381 + */
11382 +struct _Sr__GetItemReq
11383 +{
11384 + ProtobufCMessage base;
11385 + char *xpath;
11386 +};
11387 +#define SR__GET_ITEM_REQ__INIT \
11388 + { PROTOBUF_C_MESSAGE_INIT (&sr__get_item_req__descriptor) \
11389 + , NULL }
11390 +
11391 +
11392 +/*
11393 + **
11394 + * @brief Response to get_item request.
11395 + */
11396 +struct _Sr__GetItemResp
11397 +{
11398 + ProtobufCMessage base;
11399 + Sr__Value *value;
11400 +};
11401 +#define SR__GET_ITEM_RESP__INIT \
11402 + { PROTOBUF_C_MESSAGE_INIT (&sr__get_item_resp__descriptor) \
11403 + , NULL }
11404 +
11405 +
11406 +/*
11407 + **
11408 + * @brief Retrieves an array of data elements stored under provided path.
11409 + * Sent by sr_get_items and sr_get_items_iter API calls.
11410 + */
11411 +struct _Sr__GetItemsReq
11412 +{
11413 + ProtobufCMessage base;
11414 + char *xpath;
11415 + /*
11416 + * The options below are applicable only for sr_get_items_iter
11417 + * (not set by sr_get_items).
11418 + */
11419 + protobuf_c_boolean has_limit;
11420 + uint32_t limit;
11421 + protobuf_c_boolean has_offset;
11422 + uint32_t offset;
11423 +};
11424 +#define SR__GET_ITEMS_REQ__INIT \
11425 + { PROTOBUF_C_MESSAGE_INIT (&sr__get_items_req__descriptor) \
11426 + , NULL, 0,0, 0,0 }
11427 +
11428 +
11429 +/*
11430 + **
11431 + * @brief Response to get_items / sr_get_items_iter request.
11432 + */
11433 +struct _Sr__GetItemsResp
11434 +{
11435 + ProtobufCMessage base;
11436 + size_t n_values;
11437 + Sr__Value **values;
11438 +};
11439 +#define SR__GET_ITEMS_RESP__INIT \
11440 + { PROTOBUF_C_MESSAGE_INIT (&sr__get_items_resp__descriptor) \
11441 + , 0,NULL }
11442 +
11443 +
11444 +/*
11445 + **
11446 + * @brief Retrieves a single subtree whose root is stored under provided path.
11447 + * Sent by sr_get_subtree API call.
11448 + */
11449 +struct _Sr__GetSubtreeReq
11450 +{
11451 + ProtobufCMessage base;
11452 + char *xpath;
11453 +};
11454 +#define SR__GET_SUBTREE_REQ__INIT \
11455 + { PROTOBUF_C_MESSAGE_INIT (&sr__get_subtree_req__descriptor) \
11456 + , NULL }
11457 +
11458 +
11459 +/*
11460 + **
11461 + * @brief Response to sr_get_subtree request.
11462 + */
11463 +struct _Sr__GetSubtreeResp
11464 +{
11465 + ProtobufCMessage base;
11466 + Sr__Node *tree;
11467 +};
11468 +#define SR__GET_SUBTREE_RESP__INIT \
11469 + { PROTOBUF_C_MESSAGE_INIT (&sr__get_subtree_resp__descriptor) \
11470 + , NULL }
11471 +
11472 +
11473 +/*
11474 + **
11475 + * @brief Retrieves an array of subtrees whose root nodes match provided path.
11476 + * Sent by sr_get_subtrees API call.
11477 + */
11478 +struct _Sr__GetSubtreesReq
11479 +{
11480 + ProtobufCMessage base;
11481 + char *xpath;
11482 +};
11483 +#define SR__GET_SUBTREES_REQ__INIT \
11484 + { PROTOBUF_C_MESSAGE_INIT (&sr__get_subtrees_req__descriptor) \
11485 + , NULL }
11486 +
11487 +
11488 +/*
11489 + **
11490 + * @brief Response to sr_get_subtrees request.
11491 + */
11492 +struct _Sr__GetSubtreesResp
11493 +{
11494 + ProtobufCMessage base;
11495 + size_t n_trees;
11496 + Sr__Node **trees;
11497 +};
11498 +#define SR__GET_SUBTREES_RESP__INIT \
11499 + { PROTOBUF_C_MESSAGE_INIT (&sr__get_subtrees_resp__descriptor) \
11500 + , 0,NULL }
11501 +
11502 +
11503 +/*
11504 + **
11505 + * @brief Retrieves a chunk of a single or multiple subtrees.
11506 + * A subtree chunk is also a tree, where the root node is the node referenced by XPath,
11507 + * the next level consists of its children skipping the first "slice_offset" nodes and including
11508 + * at most "slice_limit" nodes, while the remaining (depth_limit-2) levels always start with
11509 + * the first child (slice_offset is ignored) and include at most "child_limit" nodes.
11510 + * The chunk consists of at most "depth_limit" levels.
11511 + * @note Order of child nodes depends on the libyang implementation.
11512 + */
11513 +struct _Sr__GetSubtreeChunkReq
11514 +{
11515 + ProtobufCMessage base;
11516 + char *xpath;
11517 + protobuf_c_boolean single;
11518 + uint32_t slice_offset;
11519 + uint32_t slice_width;
11520 + uint32_t child_limit;
11521 + uint32_t depth_limit;
11522 +};
11523 +#define SR__GET_SUBTREE_CHUNK_REQ__INIT \
11524 + { PROTOBUF_C_MESSAGE_INIT (&sr__get_subtree_chunk_req__descriptor) \
11525 + , NULL, 0, 0, 0, 0, 0 }
11526 +
11527 +
11528 +/*
11529 + **
11530 + * @brief Response to sr_get_subtree_chunk request.
11531 + */
11532 +struct _Sr__GetSubtreeChunkResp
11533 +{
11534 + ProtobufCMessage base;
11535 + /*
11536 + **< JSON node-id of the root node for each subtree chunk
11537 + */
11538 + size_t n_xpath;
11539 + char **xpath;
11540 + /*
11541 + **< first chunk may carry mutliple trees
11542 + */
11543 + size_t n_chunk;
11544 + Sr__Node **chunk;
11545 +};
11546 +#define SR__GET_SUBTREE_CHUNK_RESP__INIT \
11547 + { PROTOBUF_C_MESSAGE_INIT (&sr__get_subtree_chunk_resp__descriptor) \
11548 + , 0,NULL, 0,NULL }
11549 +
11550 +
11551 +/*
11552 + **
11553 + * @brief Sets the value of the leaf, leaf-list or presence container.
11554 + * Sent by sr_set_item API call.
11555 + */
11556 +struct _Sr__SetItemReq
11557 +{
11558 + ProtobufCMessage base;
11559 + char *xpath;
11560 + Sr__Value *value;
11561 + /*
11562 + **< Bitwise OR of EditFlags
11563 + */
11564 + uint32_t options;
11565 +};
11566 +#define SR__SET_ITEM_REQ__INIT \
11567 + { PROTOBUF_C_MESSAGE_INIT (&sr__set_item_req__descriptor) \
11568 + , NULL, NULL, 0 }
11569 +
11570 +
11571 +/*
11572 + **
11573 + * @brief Response to sr_set_item request.
11574 + */
11575 +struct _Sr__SetItemResp
11576 +{
11577 + ProtobufCMessage base;
11578 +};
11579 +#define SR__SET_ITEM_RESP__INIT \
11580 + { PROTOBUF_C_MESSAGE_INIT (&sr__set_item_resp__descriptor) \
11581 + }
11582 +
11583 +
11584 +/*
11585 + **
11586 + * @brief Sets the value of the leaf, leaf-list or presence container.
11587 + * The value is transferred as string.
11588 + * Sent by sr_set_item_str API call.
11589 + */
11590 +struct _Sr__SetItemStrReq
11591 +{
11592 + ProtobufCMessage base;
11593 + char *xpath;
11594 + char *value;
11595 + /*
11596 + **< Bitwise OR of EditFlags
11597 + */
11598 + uint32_t options;
11599 +};
11600 +#define SR__SET_ITEM_STR_REQ__INIT \
11601 + { PROTOBUF_C_MESSAGE_INIT (&sr__set_item_str_req__descriptor) \
11602 + , NULL, NULL, 0 }
11603 +
11604 +
11605 +/*
11606 + **
11607 + * @brief Response to sr_set_item_str request.
11608 + */
11609 +struct _Sr__SetItemStrResp
11610 +{
11611 + ProtobufCMessage base;
11612 +};
11613 +#define SR__SET_ITEM_STR_RESP__INIT \
11614 + { PROTOBUF_C_MESSAGE_INIT (&sr__set_item_str_resp__descriptor) \
11615 + }
11616 +
11617 +
11618 +/*
11619 + **
11620 + * @brief Deletes the nodes under the specified xpath.
11621 + * Sent by sr_delete_item API call.
11622 + */
11623 +struct _Sr__DeleteItemReq
11624 +{
11625 + ProtobufCMessage base;
11626 + char *xpath;
11627 + /*
11628 + **< Bitwise OR of EditFlags
11629 + */
11630 + uint32_t options;
11631 +};
11632 +#define SR__DELETE_ITEM_REQ__INIT \
11633 + { PROTOBUF_C_MESSAGE_INIT (&sr__delete_item_req__descriptor) \
11634 + , NULL, 0 }
11635 +
11636 +
11637 +/*
11638 + **
11639 + * @brief Response to sr_delete_item request.
11640 + */
11641 +struct _Sr__DeleteItemResp
11642 +{
11643 + ProtobufCMessage base;
11644 +};
11645 +#define SR__DELETE_ITEM_RESP__INIT \
11646 + { PROTOBUF_C_MESSAGE_INIT (&sr__delete_item_resp__descriptor) \
11647 + }
11648 +
11649 +
11650 +/*
11651 + **
11652 + * @brief Move the instance of an ordered list in specified direction.
11653 + * Sent by sr_move_item API call.
11654 + */
11655 +struct _Sr__MoveItemReq
11656 +{
11657 + ProtobufCMessage base;
11658 + char *xpath;
11659 + Sr__MoveItemReq__MovePosition position;
11660 + char *relative_item;
11661 +};
11662 +#define SR__MOVE_ITEM_REQ__INIT \
11663 + { PROTOBUF_C_MESSAGE_INIT (&sr__move_item_req__descriptor) \
11664 + , NULL, 0, NULL }
11665 +
11666 +
11667 +/*
11668 + **
11669 + * @brief Response to sr_move_item request.
11670 + */
11671 +struct _Sr__MoveItemResp
11672 +{
11673 + ProtobufCMessage base;
11674 +};
11675 +#define SR__MOVE_ITEM_RESP__INIT \
11676 + { PROTOBUF_C_MESSAGE_INIT (&sr__move_item_resp__descriptor) \
11677 + }
11678 +
11679 +
11680 +/*
11681 + **
11682 + * @brief Perform the validation of changes made in current session, but do not
11683 + * commit nor discard them. Sent by sr_validate API call.
11684 + */
11685 +struct _Sr__ValidateReq
11686 +{
11687 + ProtobufCMessage base;
11688 +};
11689 +#define SR__VALIDATE_REQ__INIT \
11690 + { PROTOBUF_C_MESSAGE_INIT (&sr__validate_req__descriptor) \
11691 + }
11692 +
11693 +
11694 +/*
11695 + **
11696 + * @brief Response to sr_validate request.
11697 + */
11698 +struct _Sr__ValidateResp
11699 +{
11700 + ProtobufCMessage base;
11701 + size_t n_errors;
11702 + Sr__Error **errors;
11703 +};
11704 +#define SR__VALIDATE_RESP__INIT \
11705 + { PROTOBUF_C_MESSAGE_INIT (&sr__validate_resp__descriptor) \
11706 + , 0,NULL }
11707 +
11708 +
11709 +/*
11710 + **
11711 + * @brief Apply changes made in current session.
11712 + * Sent by sr_commit API call.
11713 + */
11714 +struct _Sr__CommitReq
11715 +{
11716 + ProtobufCMessage base;
11717 +};
11718 +#define SR__COMMIT_REQ__INIT \
11719 + { PROTOBUF_C_MESSAGE_INIT (&sr__commit_req__descriptor) \
11720 + }
11721 +
11722 +
11723 +/*
11724 + **
11725 + * @brief Response to sr_commit request.
11726 + */
11727 +struct _Sr__CommitResp
11728 +{
11729 + ProtobufCMessage base;
11730 + size_t n_errors;
11731 + Sr__Error **errors;
11732 +};
11733 +#define SR__COMMIT_RESP__INIT \
11734 + { PROTOBUF_C_MESSAGE_INIT (&sr__commit_resp__descriptor) \
11735 + , 0,NULL }
11736 +
11737 +
11738 +/*
11739 + **
11740 + * @brief Discard non-committed changes made in current session.
11741 + * Sent by sr_discard_changes API call.
11742 + */
11743 +struct _Sr__DiscardChangesReq
11744 +{
11745 + ProtobufCMessage base;
11746 +};
11747 +#define SR__DISCARD_CHANGES_REQ__INIT \
11748 + { PROTOBUF_C_MESSAGE_INIT (&sr__discard_changes_req__descriptor) \
11749 + }
11750 +
11751 +
11752 +/*
11753 + **
11754 + * @brief Response to sr_discard_changes request.
11755 + */
11756 +struct _Sr__DiscardChangesResp
11757 +{
11758 + ProtobufCMessage base;
11759 +};
11760 +#define SR__DISCARD_CHANGES_RESP__INIT \
11761 + { PROTOBUF_C_MESSAGE_INIT (&sr__discard_changes_resp__descriptor) \
11762 + }
11763 +
11764 +
11765 +/*
11766 + **
11767 + * @brief Replaces an entire configuration datastore with the contents of
11768 + * another complete configuration datastore. Sent by sr_copy_config request.
11769 + */
11770 +struct _Sr__CopyConfigReq
11771 +{
11772 + ProtobufCMessage base;
11773 + Sr__DataStore src_datastore;
11774 + Sr__DataStore dst_datastore;
11775 + /*
11776 + **< If not specified, the operation is performed on all
11777 + *modules that are currently active in the source datastore
11778 + */
11779 + char *module_name;
11780 +};
11781 +#define SR__COPY_CONFIG_REQ__INIT \
11782 + { PROTOBUF_C_MESSAGE_INIT (&sr__copy_config_req__descriptor) \
11783 + , 0, 0, NULL }
11784 +
11785 +
11786 +/*
11787 + **
11788 + * @brief Response to sr_copy_config request.
11789 + */
11790 +struct _Sr__CopyConfigResp
11791 +{
11792 + ProtobufCMessage base;
11793 + size_t n_errors;
11794 + Sr__Error **errors;
11795 +};
11796 +#define SR__COPY_CONFIG_RESP__INIT \
11797 + { PROTOBUF_C_MESSAGE_INIT (&sr__copy_config_resp__descriptor) \
11798 + , 0,NULL }
11799 +
11800 +
11801 +/*
11802 + **
11803 + * @brief Locks specified data model or the datastore which the session is tied to.
11804 + * Sent by sr_lock_datastore and sr_lock_model API calls.
11805 + */
11806 +struct _Sr__LockReq
11807 +{
11808 + ProtobufCMessage base;
11809 + /*
11810 + **< If module name is not set, LockReq locks whole datastore.
11811 + */
11812 + char *module_name;
11813 +};
11814 +#define SR__LOCK_REQ__INIT \
11815 + { PROTOBUF_C_MESSAGE_INIT (&sr__lock_req__descriptor) \
11816 + , NULL }
11817 +
11818 +
11819 +/*
11820 + **
11821 + * @brief Response to sr_lock_datastore or sr_lock_model request.
11822 + */
11823 +struct _Sr__LockResp
11824 +{
11825 + ProtobufCMessage base;
11826 +};
11827 +#define SR__LOCK_RESP__INIT \
11828 + { PROTOBUF_C_MESSAGE_INIT (&sr__lock_resp__descriptor) \
11829 + }
11830 +
11831 +
11832 +/*
11833 + **
11834 + * @brief Unlocks specified data model or the datastore which the session is tied to.
11835 + * Sent by sr_unlock_datastore and sr_unlock_model API calls.
11836 + */
11837 +struct _Sr__UnlockReq
11838 +{
11839 + ProtobufCMessage base;
11840 + /*
11841 + **< If module name is not set, UnlockReq unlocks whole datastore.
11842 + */
11843 + char *module_name;
11844 +};
11845 +#define SR__UNLOCK_REQ__INIT \
11846 + { PROTOBUF_C_MESSAGE_INIT (&sr__unlock_req__descriptor) \
11847 + , NULL }
11848 +
11849 +
11850 +/*
11851 + **
11852 + * @brief Response to sr_lock_datastore or sr_lock_model request.
11853 + */
11854 +struct _Sr__UnlockResp
11855 +{
11856 + ProtobufCMessage base;
11857 +};
11858 +#define SR__UNLOCK_RESP__INIT \
11859 + { PROTOBUF_C_MESSAGE_INIT (&sr__unlock_resp__descriptor) \
11860 + }
11861 +
11862 +
11863 +struct _Sr__SubscribeReq
11864 +{
11865 + ProtobufCMessage base;
11866 + Sr__SubscriptionType type;
11867 + char *destination;
11868 + uint32_t subscription_id;
11869 + char *module_name;
11870 + char *xpath;
11871 + protobuf_c_boolean has_notif_event;
11872 + Sr__NotificationEvent notif_event;
11873 + protobuf_c_boolean has_priority;
11874 + uint32_t priority;
11875 + protobuf_c_boolean has_enable_running;
11876 + protobuf_c_boolean enable_running;
11877 + protobuf_c_boolean has_enable_event;
11878 + protobuf_c_boolean enable_event;
11879 + Sr__ApiVariant api_variant;
11880 +};
11881 +#define SR__SUBSCRIBE_REQ__INIT \
11882 + { PROTOBUF_C_MESSAGE_INIT (&sr__subscribe_req__descriptor) \
11883 + , 0, NULL, 0, NULL, NULL, 0,0, 0,0, 0,0, 0,0, 0 }
11884 +
11885 +
11886 +struct _Sr__SubscribeResp
11887 +{
11888 + ProtobufCMessage base;
11889 +};
11890 +#define SR__SUBSCRIBE_RESP__INIT \
11891 + { PROTOBUF_C_MESSAGE_INIT (&sr__subscribe_resp__descriptor) \
11892 + }
11893 +
11894 +
11895 +struct _Sr__UnsubscribeReq
11896 +{
11897 + ProtobufCMessage base;
11898 + Sr__SubscriptionType type;
11899 + char *destination;
11900 + uint32_t subscription_id;
11901 + char *module_name;
11902 +};
11903 +#define SR__UNSUBSCRIBE_REQ__INIT \
11904 + { PROTOBUF_C_MESSAGE_INIT (&sr__unsubscribe_req__descriptor) \
11905 + , 0, NULL, 0, NULL }
11906 +
11907 +
11908 +struct _Sr__UnsubscribeResp
11909 +{
11910 + ProtobufCMessage base;
11911 +};
11912 +#define SR__UNSUBSCRIBE_RESP__INIT \
11913 + { PROTOBUF_C_MESSAGE_INIT (&sr__unsubscribe_resp__descriptor) \
11914 + }
11915 +
11916 +
11917 +/*
11918 + **
11919 + * @brief Checks whether the module has any enabled subtree.
11920 + * Sent by sr_check_enabled_running.
11921 + */
11922 +struct _Sr__CheckEnabledRunningReq
11923 +{
11924 + ProtobufCMessage base;
11925 + char *module_name;
11926 +};
11927 +#define SR__CHECK_ENABLED_RUNNING_REQ__INIT \
11928 + { PROTOBUF_C_MESSAGE_INIT (&sr__check_enabled_running_req__descriptor) \
11929 + , NULL }
11930 +
11931 +
11932 +struct _Sr__CheckEnabledRunningResp
11933 +{
11934 + ProtobufCMessage base;
11935 + protobuf_c_boolean enabled;
11936 +};
11937 +#define SR__CHECK_ENABLED_RUNNING_RESP__INIT \
11938 + { PROTOBUF_C_MESSAGE_INIT (&sr__check_enabled_running_resp__descriptor) \
11939 + , 0 }
11940 +
11941 +
11942 +struct _Sr__ModuleInstallNotification
11943 +{
11944 + ProtobufCMessage base;
11945 + char *module_name;
11946 + char *revision;
11947 + Sr__ModuleState state;
11948 +};
11949 +#define SR__MODULE_INSTALL_NOTIFICATION__INIT \
11950 + { PROTOBUF_C_MESSAGE_INIT (&sr__module_install_notification__descriptor) \
11951 + , NULL, NULL, 0 }
11952 +
11953 +
11954 +struct _Sr__FeatureEnableNotification
11955 +{
11956 + ProtobufCMessage base;
11957 + char *module_name;
11958 + char *feature_name;
11959 + protobuf_c_boolean enabled;
11960 +};
11961 +#define SR__FEATURE_ENABLE_NOTIFICATION__INIT \
11962 + { PROTOBUF_C_MESSAGE_INIT (&sr__feature_enable_notification__descriptor) \
11963 + , NULL, NULL, 0 }
11964 +
11965 +
11966 +struct _Sr__ModuleChangeNotification
11967 +{
11968 + ProtobufCMessage base;
11969 + Sr__NotificationEvent event;
11970 + char *module_name;
11971 +};
11972 +#define SR__MODULE_CHANGE_NOTIFICATION__INIT \
11973 + { PROTOBUF_C_MESSAGE_INIT (&sr__module_change_notification__descriptor) \
11974 + , 0, NULL }
11975 +
11976 +
11977 +struct _Sr__SubtreeChangeNotification
11978 +{
11979 + ProtobufCMessage base;
11980 + Sr__NotificationEvent event;
11981 + char *xpath;
11982 +};
11983 +#define SR__SUBTREE_CHANGE_NOTIFICATION__INIT \
11984 + { PROTOBUF_C_MESSAGE_INIT (&sr__subtree_change_notification__descriptor) \
11985 + , 0, NULL }
11986 +
11987 +
11988 +struct _Sr__Change
11989 +{
11990 + ProtobufCMessage base;
11991 + Sr__ChangeOperation changeoperation;
11992 + Sr__Value *new_value;
11993 + Sr__Value *old_value;
11994 +};
11995 +#define SR__CHANGE__INIT \
11996 + { PROTOBUF_C_MESSAGE_INIT (&sr__change__descriptor) \
11997 + , 0, NULL, NULL }
11998 +
11999 +
12000 +/*
12001 + **
12002 + * @brief Retrieves an array of changes made under provided path.
12003 + * Sent by sr_get_changes_iter or sr_get_change_next API calls.
12004 + */
12005 +struct _Sr__GetChangesReq
12006 +{
12007 + ProtobufCMessage base;
12008 + char *xpath;
12009 + uint32_t limit;
12010 + uint32_t offset;
12011 +};
12012 +#define SR__GET_CHANGES_REQ__INIT \
12013 + { PROTOBUF_C_MESSAGE_INIT (&sr__get_changes_req__descriptor) \
12014 + , NULL, 0, 0 }
12015 +
12016 +
12017 +/*
12018 + **
12019 + * @brief Response to get_changes request.
12020 + */
12021 +struct _Sr__GetChangesResp
12022 +{
12023 + ProtobufCMessage base;
12024 + size_t n_changes;
12025 + Sr__Change **changes;
12026 +};
12027 +#define SR__GET_CHANGES_RESP__INIT \
12028 + { PROTOBUF_C_MESSAGE_INIT (&sr__get_changes_resp__descriptor) \
12029 + , 0,NULL }
12030 +
12031 +
12032 +/*
12033 + **
12034 + * @brief Sends a request to check if the owner of this session is authorized to invoke
12035 + * the protocol operation referenced by the xpath.
12036 + * Sent by sr_check_exec_permission.
12037 + */
12038 +struct _Sr__CheckExecPermReq
12039 +{
12040 + ProtobufCMessage base;
12041 + char *xpath;
12042 +};
12043 +#define SR__CHECK_EXEC_PERM_REQ__INIT \
12044 + { PROTOBUF_C_MESSAGE_INIT (&sr__check_exec_perm_req__descriptor) \
12045 + , NULL }
12046 +
12047 +
12048 +/*
12049 + **
12050 + * @brief Response to sr_check_exec_permission request.
12051 + */
12052 +struct _Sr__CheckExecPermResp
12053 +{
12054 + ProtobufCMessage base;
12055 + protobuf_c_boolean permitted;
12056 +};
12057 +#define SR__CHECK_EXEC_PERM_RESP__INIT \
12058 + { PROTOBUF_C_MESSAGE_INIT (&sr__check_exec_perm_resp__descriptor) \
12059 + , 0 }
12060 +
12061 +
12062 +/*
12063 + **
12064 + * @brief Sends a RPC / action request into the datastore, will be delivered to the RPC subscriber.
12065 + * Sent by sr_rpc_send / sr_rpc_send_tree and sr_action_send / sr_action_send_tree API calls.
12066 + */
12067 +struct _Sr__RPCReq
12068 +{
12069 + ProtobufCMessage base;
12070 + protobuf_c_boolean action;
12071 + char *xpath;
12072 + /*
12073 + **< which API variant was used to send RPC req.
12074 + */
12075 + Sr__ApiVariant orig_api_variant;
12076 + size_t n_input;
12077 + Sr__Value **input;
12078 + size_t n_input_tree;
12079 + Sr__Node **input_tree;
12080 + char *subscriber_address;
12081 + protobuf_c_boolean has_subscription_id;
12082 + uint32_t subscription_id;
12083 +};
12084 +#define SR__RPCREQ__INIT \
12085 + { PROTOBUF_C_MESSAGE_INIT (&sr__rpcreq__descriptor) \
12086 + , 0, NULL, 0, 0,NULL, 0,NULL, NULL, 0,0 }
12087 +
12088 +
12089 +/*
12090 + **
12091 + * @brief Response to sr_rpc_send / sr_rpc_send_tree or sr_action_send / sr_action_send_tree request.
12092 + */
12093 +struct _Sr__RPCResp
12094 +{
12095 + ProtobufCMessage base;
12096 + protobuf_c_boolean action;
12097 + char *xpath;
12098 + /*
12099 + **< which API variant was used to send RPC req.
12100 + */
12101 + Sr__ApiVariant orig_api_variant;
12102 + size_t n_output;
12103 + Sr__Value **output;
12104 + size_t n_output_tree;
12105 + Sr__Node **output_tree;
12106 +};
12107 +#define SR__RPCRESP__INIT \
12108 + { PROTOBUF_C_MESSAGE_INIT (&sr__rpcresp__descriptor) \
12109 + , 0, NULL, 0, 0,NULL, 0,NULL }
12110 +
12111 +
12112 +/*
12113 + **
12114 + * @brief Sends an event notification into the datastore, will be delivered to all notification subscribers.
12115 + * Sent by sr_event_notif_send API call.
12116 + */
12117 +struct _Sr__EventNotifReq
12118 +{
12119 + ProtobufCMessage base;
12120 + Sr__EventNotifReq__NotifType type;
12121 + /*
12122 + **< Bitwise OR of NotifFlags.
12123 + */
12124 + uint32_t options;
12125 + char *xpath;
12126 + size_t n_values;
12127 + Sr__Value **values;
12128 + size_t n_trees;
12129 + Sr__Node **trees;
12130 + uint64_t timestamp;
12131 + char *subscriber_address;
12132 + protobuf_c_boolean has_subscription_id;
12133 + uint32_t subscription_id;
12134 + protobuf_c_boolean do_not_send_reply;
12135 +};
12136 +#define SR__EVENT_NOTIF_REQ__INIT \
12137 + { PROTOBUF_C_MESSAGE_INIT (&sr__event_notif_req__descriptor) \
12138 + , 0, 0, NULL, 0,NULL, 0,NULL, 0, NULL, 0,0, 0 }
12139 +
12140 +
12141 +/*
12142 + **
12143 + * @brief Response to sr_event_notif_send request.
12144 + */
12145 +struct _Sr__EventNotifResp
12146 +{
12147 + ProtobufCMessage base;
12148 +};
12149 +#define SR__EVENT_NOTIF_RESP__INIT \
12150 + { PROTOBUF_C_MESSAGE_INIT (&sr__event_notif_resp__descriptor) \
12151 + }
12152 +
12153 +
12154 +/*
12155 + **
12156 + * @brief Sends a request to replay event notifications stored in the datastore.
12157 + * Sent by sr_event_notif_replay API call.
12158 + */
12159 +struct _Sr__EventNotifReplayReq
12160 +{
12161 + ProtobufCMessage base;
12162 + char *xpath;
12163 + uint64_t start_time;
12164 + uint64_t stop_time;
12165 + char *subscriber_address;
12166 + uint32_t subscription_id;
12167 + Sr__ApiVariant api_variant;
12168 +};
12169 +#define SR__EVENT_NOTIF_REPLAY_REQ__INIT \
12170 + { PROTOBUF_C_MESSAGE_INIT (&sr__event_notif_replay_req__descriptor) \
12171 + , NULL, 0, 0, NULL, 0, 0 }
12172 +
12173 +
12174 +/*
12175 + **
12176 + * @brief Response to sr_event_notif_replay request.
12177 + */
12178 +struct _Sr__EventNotifReplayResp
12179 +{
12180 + ProtobufCMessage base;
12181 +};
12182 +#define SR__EVENT_NOTIF_REPLAY_RESP__INIT \
12183 + { PROTOBUF_C_MESSAGE_INIT (&sr__event_notif_replay_resp__descriptor) \
12184 + }
12185 +
12186 +
12187 +/*
12188 + **
12189 + * @brief Requests operational data under given path form an operational data
12190 + * provider.
12191 + */
12192 +struct _Sr__DataProvideReq
12193 +{
12194 + ProtobufCMessage base;
12195 + char *xpath;
12196 + char *subscriber_address;
12197 + uint32_t subscription_id;
12198 + uint64_t request_id;
12199 +};
12200 +#define SR__DATA_PROVIDE_REQ__INIT \
12201 + { PROTOBUF_C_MESSAGE_INIT (&sr__data_provide_req__descriptor) \
12202 + , NULL, NULL, 0, 0 }
12203 +
12204 +
12205 +/*
12206 + **
12207 + * @brief Response to a request of operational data under given path form an
12208 + * operational data provider.
12209 + */
12210 +struct _Sr__DataProvideResp
12211 +{
12212 + ProtobufCMessage base;
12213 + char *xpath;
12214 + size_t n_values;
12215 + Sr__Value **values;
12216 + uint64_t request_id;
12217 +};
12218 +#define SR__DATA_PROVIDE_RESP__INIT \
12219 + { PROTOBUF_C_MESSAGE_INIT (&sr__data_provide_resp__descriptor) \
12220 + , NULL, 0,NULL, 0 }
12221 +
12222 +
12223 +/*
12224 + **
12225 + * @brief Requests installation / uinstallation of specified YANG model.
12226 + * Sent by sr_module_install internal API calls.
12227 + */
12228 +struct _Sr__ModuleInstallReq
12229 +{
12230 + ProtobufCMessage base;
12231 + char *module_name;
12232 + char *revision;
12233 + char *file_name;
12234 + protobuf_c_boolean installed;
12235 +};
12236 +#define SR__MODULE_INSTALL_REQ__INIT \
12237 + { PROTOBUF_C_MESSAGE_INIT (&sr__module_install_req__descriptor) \
12238 + , NULL, NULL, NULL, 0 }
12239 +
12240 +
12241 +/*
12242 + **
12243 + * @brief Response to sr_module_install request.
12244 + */
12245 +struct _Sr__ModuleInstallResp
12246 +{
12247 + ProtobufCMessage base;
12248 +};
12249 +#define SR__MODULE_INSTALL_RESP__INIT \
12250 + { PROTOBUF_C_MESSAGE_INIT (&sr__module_install_resp__descriptor) \
12251 + }
12252 +
12253 +
12254 +/*
12255 + **
12256 + * @brief Requests enabling / disabling of specified YANG feature within the
12257 + * YANG model. Sent by sr_feature_enable internal API calls.
12258 + */
12259 +struct _Sr__FeatureEnableReq
12260 +{
12261 + ProtobufCMessage base;
12262 + char *module_name;
12263 + char *feature_name;
12264 + protobuf_c_boolean enabled;
12265 +};
12266 +#define SR__FEATURE_ENABLE_REQ__INIT \
12267 + { PROTOBUF_C_MESSAGE_INIT (&sr__feature_enable_req__descriptor) \
12268 + , NULL, NULL, 0 }
12269 +
12270 +
12271 +/*
12272 + **
12273 + * @brief Response to sr_feature_enable request.
12274 + */
12275 +struct _Sr__FeatureEnableResp
12276 +{
12277 + ProtobufCMessage base;
12278 +};
12279 +#define SR__FEATURE_ENABLE_RESP__INIT \
12280 + { PROTOBUF_C_MESSAGE_INIT (&sr__feature_enable_resp__descriptor) \
12281 + }
12282 +
12283 +
12284 +/*
12285 + **
12286 + * @brief Internal request to unsubscribe all subscriptions of a subscriber on given destination address.
12287 + */
12288 +struct _Sr__UnsubscribeDestinationReq
12289 +{
12290 + ProtobufCMessage base;
12291 + char *destination;
12292 +};
12293 +#define SR__UNSUBSCRIBE_DESTINATION_REQ__INIT \
12294 + { PROTOBUF_C_MESSAGE_INIT (&sr__unsubscribe_destination_req__descriptor) \
12295 + , NULL }
12296 +
12297 +
12298 +/*
12299 + **
12300 + * @brief Internal request to timeout a commit, if it hasn't been terminated yet.
12301 + */
12302 +struct _Sr__CommitTimeoutReq
12303 +{
12304 + ProtobufCMessage base;
12305 + uint32_t commit_id;
12306 + protobuf_c_boolean expired;
12307 +};
12308 +#define SR__COMMIT_TIMEOUT_REQ__INIT \
12309 + { PROTOBUF_C_MESSAGE_INIT (&sr__commit_timeout_req__descriptor) \
12310 + , 0, 0 }
12311 +
12312 +
12313 +/*
12314 + **
12315 + * @brief Internal request to timeout a request for operational data, if it hasn't been terminated yet.
12316 + */
12317 +struct _Sr__OperDataTimeoutReq
12318 +{
12319 + ProtobufCMessage base;
12320 + uint64_t request_id;
12321 +};
12322 +#define SR__OPER_DATA_TIMEOUT_REQ__INIT \
12323 + { PROTOBUF_C_MESSAGE_INIT (&sr__oper_data_timeout_req__descriptor) \
12324 + , 0 }
12325 +
12326 +
12327 +/*
12328 + **
12329 + * @brief Internal request for internal state data (state data provided by Sysrepo Engine itself).
12330 + */
12331 +struct _Sr__InternalStateDataReq
12332 +{
12333 + ProtobufCMessage base;
12334 + uint64_t request_id;
12335 + char *xpath;
12336 +};
12337 +#define SR__INTERNAL_STATE_DATA_REQ__INIT \
12338 + { PROTOBUF_C_MESSAGE_INIT (&sr__internal_state_data_req__descriptor) \
12339 + , 0, NULL }
12340 +
12341 +
12342 +/*
12343 + **
12344 + * @brief Internal request to cleanup aged notifications in the Notification Store.
12345 + */
12346 +struct _Sr__NotifStoreCleanupReq
12347 +{
12348 + ProtobufCMessage base;
12349 +};
12350 +#define SR__NOTIF_STORE_CLEANUP_REQ__INIT \
12351 + { PROTOBUF_C_MESSAGE_INIT (&sr__notif_store_cleanup_req__descriptor) \
12352 + }
12353 +
12354 +
12355 +/*
12356 + **
12357 + * @brief Message to be delivered to the client after some timeout.
12358 + */
12359 +struct _Sr__DelayedMsgReq
12360 +{
12361 + ProtobufCMessage base;
12362 + Sr__Msg *message;
12363 +};
12364 +#define SR__DELAYED_MSG_REQ__INIT \
12365 + { PROTOBUF_C_MESSAGE_INIT (&sr__delayed_msg_req__descriptor) \
12366 + , NULL }
12367 +
12368 +
12369 +/*
12370 + **
12371 + * @brief Internal request to reload NACM configuration from the running datastore.
12372 + */
12373 +struct _Sr__NacmReloadReq
12374 +{
12375 + ProtobufCMessage base;
12376 +};
12377 +#define SR__NACM_RELOAD_REQ__INIT \
12378 + { PROTOBUF_C_MESSAGE_INIT (&sr__nacm_reload_req__descriptor) \
12379 + }
12380 +
12381 +
12382 +/*
12383 + **
12384 + * @brief Request for an operation.
12385 + */
12386 +struct _Sr__Request
12387 +{
12388 + ProtobufCMessage base;
12389 + /*
12390 + * Request ID used internally by sysrepo
12391 + */
12392 + uint64_t _id;
12393 + Sr__Operation operation;
12394 + Sr__SessionStartReq *session_start_req;
12395 + Sr__SessionStopReq *session_stop_req;
12396 + Sr__SessionRefreshReq *session_refresh_req;
12397 + Sr__SessionCheckReq *session_check_req;
12398 + Sr__SessionSwitchDsReq *session_switch_ds_req;
12399 + Sr__SessionSetOptsReq *session_set_opts_req;
12400 + Sr__VersionVerifyReq *version_verify_req;
12401 + Sr__ListSchemasReq *list_schemas_req;
12402 + Sr__GetSchemaReq *get_schema_req;
12403 + Sr__ModuleInstallReq *module_install_req;
12404 + Sr__FeatureEnableReq *feature_enable_req;
12405 + Sr__GetItemReq *get_item_req;
12406 + Sr__GetItemsReq *get_items_req;
12407 + Sr__GetSubtreeReq *get_subtree_req;
12408 + Sr__GetSubtreesReq *get_subtrees_req;
12409 + Sr__GetSubtreeChunkReq *get_subtree_chunk_req;
12410 + Sr__SetItemReq *set_item_req;
12411 + Sr__DeleteItemReq *delete_item_req;
12412 + Sr__MoveItemReq *move_item_req;
12413 + Sr__SetItemStrReq *set_item_str_req;
12414 + Sr__ValidateReq *validate_req;
12415 + Sr__CommitReq *commit_req;
12416 + Sr__DiscardChangesReq *discard_changes_req;
12417 + Sr__CopyConfigReq *copy_config_req;
12418 + Sr__LockReq *lock_req;
12419 + Sr__UnlockReq *unlock_req;
12420 + Sr__SubscribeReq *subscribe_req;
12421 + Sr__UnsubscribeReq *unsubscribe_req;
12422 + Sr__CheckEnabledRunningReq *check_enabled_running_req;
12423 + Sr__GetChangesReq *get_changes_req;
12424 + Sr__DataProvideReq *data_provide_req;
12425 + Sr__CheckExecPermReq *check_exec_perm_req;
12426 + Sr__RPCReq *rpc_req;
12427 + Sr__EventNotifReq *event_notif_req;
12428 + Sr__EventNotifReplayReq *event_notif_replay_req;
12429 +};
12430 +#define SR__REQUEST__INIT \
12431 + { PROTOBUF_C_MESSAGE_INIT (&sr__request__descriptor) \
12432 + , 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 }
12433 +
12434 +
12435 +/*
12436 + **
12437 + * @brief Response to the received request.
12438 + */
12439 +struct _Sr__Response
12440 +{
12441 + ProtobufCMessage base;
12442 + Sr__Operation operation;
12443 + /*
12444 + **< Result of the operation. 0 on success, non-zero values map to sr_error_t enum in sysrepo.h.
12445 + */
12446 + uint32_t result;
12447 + /*
12448 + **< Additional error information.
12449 + */
12450 + Sr__Error *error;
12451 + Sr__SessionStartResp *session_start_resp;
12452 + Sr__SessionStopResp *session_stop_resp;
12453 + Sr__SessionRefreshResp *session_refresh_resp;
12454 + Sr__SessionCheckResp *session_check_resp;
12455 + Sr__SessionSwitchDsResp *session_switch_ds_resp;
12456 + Sr__SessionSetOptsResp *session_set_opts_resp;
12457 + Sr__VersionVerifyResp *version_verify_resp;
12458 + Sr__ListSchemasResp *list_schemas_resp;
12459 + Sr__GetSchemaResp *get_schema_resp;
12460 + Sr__ModuleInstallResp *module_install_resp;
12461 + Sr__FeatureEnableResp *feature_enable_resp;
12462 + Sr__GetItemResp *get_item_resp;
12463 + Sr__GetItemsResp *get_items_resp;
12464 + Sr__GetSubtreeResp *get_subtree_resp;
12465 + Sr__GetSubtreesResp *get_subtrees_resp;
12466 + Sr__GetSubtreeChunkResp *get_subtree_chunk_resp;
12467 + Sr__SetItemResp *set_item_resp;
12468 + Sr__DeleteItemResp *delete_item_resp;
12469 + Sr__MoveItemResp *move_item_resp;
12470 + Sr__SetItemStrResp *set_item_str_resp;
12471 + Sr__ValidateResp *validate_resp;
12472 + Sr__CommitResp *commit_resp;
12473 + Sr__DiscardChangesResp *discard_changes_resp;
12474 + Sr__CopyConfigResp *copy_config_resp;
12475 + Sr__LockResp *lock_resp;
12476 + Sr__UnlockResp *unlock_resp;
12477 + Sr__SubscribeResp *subscribe_resp;
12478 + Sr__UnsubscribeResp *unsubscribe_resp;
12479 + Sr__CheckEnabledRunningResp *check_enabled_running_resp;
12480 + Sr__GetChangesResp *get_changes_resp;
12481 + Sr__DataProvideResp *data_provide_resp;
12482 + Sr__CheckExecPermResp *check_exec_perm_resp;
12483 + Sr__RPCResp *rpc_resp;
12484 + Sr__EventNotifResp *event_notif_resp;
12485 + Sr__EventNotifReplayResp *event_notif_replay_resp;
12486 +};
12487 +#define SR__RESPONSE__INIT \
12488 + { PROTOBUF_C_MESSAGE_INIT (&sr__response__descriptor) \
12489 + , 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 }
12490 +
12491 +
12492 +/*
12493 + **
12494 + * @brief Notification about an event that occurred in the datastore.
12495 + */
12496 +struct _Sr__Notification
12497 +{
12498 + ProtobufCMessage base;
12499 + Sr__SubscriptionType type;
12500 + char *destination_address;
12501 + char *source_address;
12502 + uint32_t source_pid;
12503 + uint32_t subscription_id;
12504 + protobuf_c_boolean has_commit_id;
12505 + uint32_t commit_id;
12506 + Sr__ModuleInstallNotification *module_install_notif;
12507 + Sr__FeatureEnableNotification *feature_enable_notif;
12508 + Sr__ModuleChangeNotification *module_change_notif;
12509 + Sr__SubtreeChangeNotification *subtree_change_notif;
12510 +};
12511 +#define SR__NOTIFICATION__INIT \
12512 + { PROTOBUF_C_MESSAGE_INIT (&sr__notification__descriptor) \
12513 + , 0, NULL, NULL, 0, 0, 0,0, NULL, NULL, NULL, NULL }
12514 +
12515 +
12516 +/*
12517 + **
12518 + * @brief Notification Acknowledgment.
12519 + */
12520 +struct _Sr__NotificationAck
12521 +{
12522 + ProtobufCMessage base;
12523 + /*
12524 + **< Original notification.
12525 + */
12526 + Sr__Notification *notif;
12527 + /*
12528 + **< Result of the notification (success / error code).
12529 + */
12530 + uint32_t result;
12531 + /*
12532 + **< Additional error information.
12533 + */
12534 + Sr__Error *error;
12535 + /*
12536 + **< If the result is error and this flag is set to true abort notification
12537 + * will not be delivered to this subscriber
12538 + * (Subscriber doesn't want notification about changes that he refused).
12539 + */
12540 + protobuf_c_boolean do_not_send_abort;
12541 +};
12542 +#define SR__NOTIFICATION_ACK__INIT \
12543 + { PROTOBUF_C_MESSAGE_INIT (&sr__notification_ack__descriptor) \
12544 + , NULL, 0, NULL, 0 }
12545 +
12546 +
12547 +/*
12548 + **
12549 + * @brief Internal request sent by sysrepo. Should not be used from the public API.
12550 + */
12551 +struct _Sr__InternalRequest
12552 +{
12553 + ProtobufCMessage base;
12554 + Sr__Operation operation;
12555 + protobuf_c_boolean has_postpone_timeout;
12556 + uint32_t postpone_timeout;
12557 + Sr__UnsubscribeDestinationReq *unsubscribe_dst_req;
12558 + Sr__CommitTimeoutReq *commit_timeout_req;
12559 + Sr__OperDataTimeoutReq *oper_data_timeout_req;
12560 + Sr__InternalStateDataReq *internal_state_data_req;
12561 + Sr__NotifStoreCleanupReq *notif_store_cleanup_req;
12562 + Sr__DelayedMsgReq *delayed_msg_req;
12563 + Sr__NacmReloadReq *nacm_reload_req;
12564 +};
12565 +#define SR__INTERNAL_REQUEST__INIT \
12566 + { PROTOBUF_C_MESSAGE_INIT (&sr__internal_request__descriptor) \
12567 + , 0, 0,0, NULL, NULL, NULL, NULL, NULL, NULL, NULL }
12568 +
12569 +
12570 +/*
12571 + **
12572 + * @brief Umbrella sysrepo message used for communication between sysrepo
12573 + * engine and client library.
12574 + */
12575 +struct _Sr__Msg
12576 +{
12577 + ProtobufCMessage base;
12578 + /*
12579 + **< Indicates type of the message.
12580 + */
12581 + Sr__Msg__MsgType type;
12582 + /*
12583 + **< Session identifier. Can be 0 (value is ignored) for session_start and version_verify requests.
12584 + */
12585 + uint32_t session_id;
12586 + /*
12587 + **< Filled in in case of type == REQUEST.
12588 + */
12589 + Sr__Request *request;
12590 + /*
12591 + **< Filled in in case of type == RESPONSE.
12592 + */
12593 + Sr__Response *response;
12594 + /*
12595 + **< Filled in in case of type == NOTIFICATION.
12596 + */
12597 + Sr__Notification *notification;
12598 + /*
12599 + **< Filled in in case of type == NOTIFICATION_ACK
12600 + */
12601 + Sr__NotificationAck *notification_ack;
12602 + /*
12603 + **< Filled in in case of type == INTERNAL.
12604 + */
12605 + Sr__InternalRequest *internal_request;
12606 + /*
12607 + **< Not part of the protocol. Used internally by Sysrepo to store a pointer to memory context.
12608 + */
12609 + uint64_t _sysrepo_mem_ctx;
12610 +};
12611 +#define SR__MSG__INIT \
12612 + { PROTOBUF_C_MESSAGE_INIT (&sr__msg__descriptor) \
12613 + , 0, 0, NULL, NULL, NULL, NULL, NULL, 0 }
12614 +
12615 +
12616 +/* Sr__Value methods */
12617 +void sr__value__init
12618 + (Sr__Value *message);
12619 +size_t sr__value__get_packed_size
12620 + (const Sr__Value *message);
12621 +size_t sr__value__pack
12622 + (const Sr__Value *message,
12623 + uint8_t *out);
12624 +size_t sr__value__pack_to_buffer
12625 + (const Sr__Value *message,
12626 + ProtobufCBuffer *buffer);
12627 +Sr__Value *
12628 + sr__value__unpack
12629 + (ProtobufCAllocator *allocator,
12630 + size_t len,
12631 + const uint8_t *data);
12632 +void sr__value__free_unpacked
12633 + (Sr__Value *message,
12634 + ProtobufCAllocator *allocator);
12635 +/* Sr__Node methods */
12636 +void sr__node__init
12637 + (Sr__Node *message);
12638 +size_t sr__node__get_packed_size
12639 + (const Sr__Node *message);
12640 +size_t sr__node__pack
12641 + (const Sr__Node *message,
12642 + uint8_t *out);
12643 +size_t sr__node__pack_to_buffer
12644 + (const Sr__Node *message,
12645 + ProtobufCBuffer *buffer);
12646 +Sr__Node *
12647 + sr__node__unpack
12648 + (ProtobufCAllocator *allocator,
12649 + size_t len,
12650 + const uint8_t *data);
12651 +void sr__node__free_unpacked
12652 + (Sr__Node *message,
12653 + ProtobufCAllocator *allocator);
12654 +/* Sr__Error methods */
12655 +void sr__error__init
12656 + (Sr__Error *message);
12657 +size_t sr__error__get_packed_size
12658 + (const Sr__Error *message);
12659 +size_t sr__error__pack
12660 + (const Sr__Error *message,
12661 + uint8_t *out);
12662 +size_t sr__error__pack_to_buffer
12663 + (const Sr__Error *message,
12664 + ProtobufCBuffer *buffer);
12665 +Sr__Error *
12666 + sr__error__unpack
12667 + (ProtobufCAllocator *allocator,
12668 + size_t len,
12669 + const uint8_t *data);
12670 +void sr__error__free_unpacked
12671 + (Sr__Error *message,
12672 + ProtobufCAllocator *allocator);
12673 +/* Sr__SessionStartReq methods */
12674 +void sr__session_start_req__init
12675 + (Sr__SessionStartReq *message);
12676 +size_t sr__session_start_req__get_packed_size
12677 + (const Sr__SessionStartReq *message);
12678 +size_t sr__session_start_req__pack
12679 + (const Sr__SessionStartReq *message,
12680 + uint8_t *out);
12681 +size_t sr__session_start_req__pack_to_buffer
12682 + (const Sr__SessionStartReq *message,
12683 + ProtobufCBuffer *buffer);
12684 +Sr__SessionStartReq *
12685 + sr__session_start_req__unpack
12686 + (ProtobufCAllocator *allocator,
12687 + size_t len,
12688 + const uint8_t *data);
12689 +void sr__session_start_req__free_unpacked
12690 + (Sr__SessionStartReq *message,
12691 + ProtobufCAllocator *allocator);
12692 +/* Sr__SessionStartResp methods */
12693 +void sr__session_start_resp__init
12694 + (Sr__SessionStartResp *message);
12695 +size_t sr__session_start_resp__get_packed_size
12696 + (const Sr__SessionStartResp *message);
12697 +size_t sr__session_start_resp__pack
12698 + (const Sr__SessionStartResp *message,
12699 + uint8_t *out);
12700 +size_t sr__session_start_resp__pack_to_buffer
12701 + (const Sr__SessionStartResp *message,
12702 + ProtobufCBuffer *buffer);
12703 +Sr__SessionStartResp *
12704 + sr__session_start_resp__unpack
12705 + (ProtobufCAllocator *allocator,
12706 + size_t len,
12707 + const uint8_t *data);
12708 +void sr__session_start_resp__free_unpacked
12709 + (Sr__SessionStartResp *message,
12710 + ProtobufCAllocator *allocator);
12711 +/* Sr__SessionStopReq methods */
12712 +void sr__session_stop_req__init
12713 + (Sr__SessionStopReq *message);
12714 +size_t sr__session_stop_req__get_packed_size
12715 + (const Sr__SessionStopReq *message);
12716 +size_t sr__session_stop_req__pack
12717 + (const Sr__SessionStopReq *message,
12718 + uint8_t *out);
12719 +size_t sr__session_stop_req__pack_to_buffer
12720 + (const Sr__SessionStopReq *message,
12721 + ProtobufCBuffer *buffer);
12722 +Sr__SessionStopReq *
12723 + sr__session_stop_req__unpack
12724 + (ProtobufCAllocator *allocator,
12725 + size_t len,
12726 + const uint8_t *data);
12727 +void sr__session_stop_req__free_unpacked
12728 + (Sr__SessionStopReq *message,
12729 + ProtobufCAllocator *allocator);
12730 +/* Sr__SessionStopResp methods */
12731 +void sr__session_stop_resp__init
12732 + (Sr__SessionStopResp *message);
12733 +size_t sr__session_stop_resp__get_packed_size
12734 + (const Sr__SessionStopResp *message);
12735 +size_t sr__session_stop_resp__pack
12736 + (const Sr__SessionStopResp *message,
12737 + uint8_t *out);
12738 +size_t sr__session_stop_resp__pack_to_buffer
12739 + (const Sr__SessionStopResp *message,
12740 + ProtobufCBuffer *buffer);
12741 +Sr__SessionStopResp *
12742 + sr__session_stop_resp__unpack
12743 + (ProtobufCAllocator *allocator,
12744 + size_t len,
12745 + const uint8_t *data);
12746 +void sr__session_stop_resp__free_unpacked
12747 + (Sr__SessionStopResp *message,
12748 + ProtobufCAllocator *allocator);
12749 +/* Sr__SessionRefreshReq methods */
12750 +void sr__session_refresh_req__init
12751 + (Sr__SessionRefreshReq *message);
12752 +size_t sr__session_refresh_req__get_packed_size
12753 + (const Sr__SessionRefreshReq *message);
12754 +size_t sr__session_refresh_req__pack
12755 + (const Sr__SessionRefreshReq *message,
12756 + uint8_t *out);
12757 +size_t sr__session_refresh_req__pack_to_buffer
12758 + (const Sr__SessionRefreshReq *message,
12759 + ProtobufCBuffer *buffer);
12760 +Sr__SessionRefreshReq *
12761 + sr__session_refresh_req__unpack
12762 + (ProtobufCAllocator *allocator,
12763 + size_t len,
12764 + const uint8_t *data);
12765 +void sr__session_refresh_req__free_unpacked
12766 + (Sr__SessionRefreshReq *message,
12767 + ProtobufCAllocator *allocator);
12768 +/* Sr__SessionRefreshResp methods */
12769 +void sr__session_refresh_resp__init
12770 + (Sr__SessionRefreshResp *message);
12771 +size_t sr__session_refresh_resp__get_packed_size
12772 + (const Sr__SessionRefreshResp *message);
12773 +size_t sr__session_refresh_resp__pack
12774 + (const Sr__SessionRefreshResp *message,
12775 + uint8_t *out);
12776 +size_t sr__session_refresh_resp__pack_to_buffer
12777 + (const Sr__SessionRefreshResp *message,
12778 + ProtobufCBuffer *buffer);
12779 +Sr__SessionRefreshResp *
12780 + sr__session_refresh_resp__unpack
12781 + (ProtobufCAllocator *allocator,
12782 + size_t len,
12783 + const uint8_t *data);
12784 +void sr__session_refresh_resp__free_unpacked
12785 + (Sr__SessionRefreshResp *message,
12786 + ProtobufCAllocator *allocator);
12787 +/* Sr__SessionCheckReq methods */
12788 +void sr__session_check_req__init
12789 + (Sr__SessionCheckReq *message);
12790 +size_t sr__session_check_req__get_packed_size
12791 + (const Sr__SessionCheckReq *message);
12792 +size_t sr__session_check_req__pack
12793 + (const Sr__SessionCheckReq *message,
12794 + uint8_t *out);
12795 +size_t sr__session_check_req__pack_to_buffer
12796 + (const Sr__SessionCheckReq *message,
12797 + ProtobufCBuffer *buffer);
12798 +Sr__SessionCheckReq *
12799 + sr__session_check_req__unpack
12800 + (ProtobufCAllocator *allocator,
12801 + size_t len,
12802 + const uint8_t *data);
12803 +void sr__session_check_req__free_unpacked
12804 + (Sr__SessionCheckReq *message,
12805 + ProtobufCAllocator *allocator);
12806 +/* Sr__SessionCheckResp methods */
12807 +void sr__session_check_resp__init
12808 + (Sr__SessionCheckResp *message);
12809 +size_t sr__session_check_resp__get_packed_size
12810 + (const Sr__SessionCheckResp *message);
12811 +size_t sr__session_check_resp__pack
12812 + (const Sr__SessionCheckResp *message,
12813 + uint8_t *out);
12814 +size_t sr__session_check_resp__pack_to_buffer
12815 + (const Sr__SessionCheckResp *message,
12816 + ProtobufCBuffer *buffer);
12817 +Sr__SessionCheckResp *
12818 + sr__session_check_resp__unpack
12819 + (ProtobufCAllocator *allocator,
12820 + size_t len,
12821 + const uint8_t *data);
12822 +void sr__session_check_resp__free_unpacked
12823 + (Sr__SessionCheckResp *message,
12824 + ProtobufCAllocator *allocator);
12825 +/* Sr__SessionSwitchDsReq methods */
12826 +void sr__session_switch_ds_req__init
12827 + (Sr__SessionSwitchDsReq *message);
12828 +size_t sr__session_switch_ds_req__get_packed_size
12829 + (const Sr__SessionSwitchDsReq *message);
12830 +size_t sr__session_switch_ds_req__pack
12831 + (const Sr__SessionSwitchDsReq *message,
12832 + uint8_t *out);
12833 +size_t sr__session_switch_ds_req__pack_to_buffer
12834 + (const Sr__SessionSwitchDsReq *message,
12835 + ProtobufCBuffer *buffer);
12836 +Sr__SessionSwitchDsReq *
12837 + sr__session_switch_ds_req__unpack
12838 + (ProtobufCAllocator *allocator,
12839 + size_t len,
12840 + const uint8_t *data);
12841 +void sr__session_switch_ds_req__free_unpacked
12842 + (Sr__SessionSwitchDsReq *message,
12843 + ProtobufCAllocator *allocator);
12844 +/* Sr__SessionSwitchDsResp methods */
12845 +void sr__session_switch_ds_resp__init
12846 + (Sr__SessionSwitchDsResp *message);
12847 +size_t sr__session_switch_ds_resp__get_packed_size
12848 + (const Sr__SessionSwitchDsResp *message);
12849 +size_t sr__session_switch_ds_resp__pack
12850 + (const Sr__SessionSwitchDsResp *message,
12851 + uint8_t *out);
12852 +size_t sr__session_switch_ds_resp__pack_to_buffer
12853 + (const Sr__SessionSwitchDsResp *message,
12854 + ProtobufCBuffer *buffer);
12855 +Sr__SessionSwitchDsResp *
12856 + sr__session_switch_ds_resp__unpack
12857 + (ProtobufCAllocator *allocator,
12858 + size_t len,
12859 + const uint8_t *data);
12860 +void sr__session_switch_ds_resp__free_unpacked
12861 + (Sr__SessionSwitchDsResp *message,
12862 + ProtobufCAllocator *allocator);
12863 +/* Sr__SessionSetOptsReq methods */
12864 +void sr__session_set_opts_req__init
12865 + (Sr__SessionSetOptsReq *message);
12866 +size_t sr__session_set_opts_req__get_packed_size
12867 + (const Sr__SessionSetOptsReq *message);
12868 +size_t sr__session_set_opts_req__pack
12869 + (const Sr__SessionSetOptsReq *message,
12870 + uint8_t *out);
12871 +size_t sr__session_set_opts_req__pack_to_buffer
12872 + (const Sr__SessionSetOptsReq *message,
12873 + ProtobufCBuffer *buffer);
12874 +Sr__SessionSetOptsReq *
12875 + sr__session_set_opts_req__unpack
12876 + (ProtobufCAllocator *allocator,
12877 + size_t len,
12878 + const uint8_t *data);
12879 +void sr__session_set_opts_req__free_unpacked
12880 + (Sr__SessionSetOptsReq *message,
12881 + ProtobufCAllocator *allocator);
12882 +/* Sr__SessionSetOptsResp methods */
12883 +void sr__session_set_opts_resp__init
12884 + (Sr__SessionSetOptsResp *message);
12885 +size_t sr__session_set_opts_resp__get_packed_size
12886 + (const Sr__SessionSetOptsResp *message);
12887 +size_t sr__session_set_opts_resp__pack
12888 + (const Sr__SessionSetOptsResp *message,
12889 + uint8_t *out);
12890 +size_t sr__session_set_opts_resp__pack_to_buffer
12891 + (const Sr__SessionSetOptsResp *message,
12892 + ProtobufCBuffer *buffer);
12893 +Sr__SessionSetOptsResp *
12894 + sr__session_set_opts_resp__unpack
12895 + (ProtobufCAllocator *allocator,
12896 + size_t len,
12897 + const uint8_t *data);
12898 +void sr__session_set_opts_resp__free_unpacked
12899 + (Sr__SessionSetOptsResp *message,
12900 + ProtobufCAllocator *allocator);
12901 +/* Sr__VersionVerifyReq methods */
12902 +void sr__version_verify_req__init
12903 + (Sr__VersionVerifyReq *message);
12904 +size_t sr__version_verify_req__get_packed_size
12905 + (const Sr__VersionVerifyReq *message);
12906 +size_t sr__version_verify_req__pack
12907 + (const Sr__VersionVerifyReq *message,
12908 + uint8_t *out);
12909 +size_t sr__version_verify_req__pack_to_buffer
12910 + (const Sr__VersionVerifyReq *message,
12911 + ProtobufCBuffer *buffer);
12912 +Sr__VersionVerifyReq *
12913 + sr__version_verify_req__unpack
12914 + (ProtobufCAllocator *allocator,
12915 + size_t len,
12916 + const uint8_t *data);
12917 +void sr__version_verify_req__free_unpacked
12918 + (Sr__VersionVerifyReq *message,
12919 + ProtobufCAllocator *allocator);
12920 +/* Sr__VersionVerifyResp methods */
12921 +void sr__version_verify_resp__init
12922 + (Sr__VersionVerifyResp *message);
12923 +size_t sr__version_verify_resp__get_packed_size
12924 + (const Sr__VersionVerifyResp *message);
12925 +size_t sr__version_verify_resp__pack
12926 + (const Sr__VersionVerifyResp *message,
12927 + uint8_t *out);
12928 +size_t sr__version_verify_resp__pack_to_buffer
12929 + (const Sr__VersionVerifyResp *message,
12930 + ProtobufCBuffer *buffer);
12931 +Sr__VersionVerifyResp *
12932 + sr__version_verify_resp__unpack
12933 + (ProtobufCAllocator *allocator,
12934 + size_t len,
12935 + const uint8_t *data);
12936 +void sr__version_verify_resp__free_unpacked
12937 + (Sr__VersionVerifyResp *message,
12938 + ProtobufCAllocator *allocator);
12939 +/* Sr__SchemaRevision methods */
12940 +void sr__schema_revision__init
12941 + (Sr__SchemaRevision *message);
12942 +size_t sr__schema_revision__get_packed_size
12943 + (const Sr__SchemaRevision *message);
12944 +size_t sr__schema_revision__pack
12945 + (const Sr__SchemaRevision *message,
12946 + uint8_t *out);
12947 +size_t sr__schema_revision__pack_to_buffer
12948 + (const Sr__SchemaRevision *message,
12949 + ProtobufCBuffer *buffer);
12950 +Sr__SchemaRevision *
12951 + sr__schema_revision__unpack
12952 + (ProtobufCAllocator *allocator,
12953 + size_t len,
12954 + const uint8_t *data);
12955 +void sr__schema_revision__free_unpacked
12956 + (Sr__SchemaRevision *message,
12957 + ProtobufCAllocator *allocator);
12958 +/* Sr__SchemaSubmodule methods */
12959 +void sr__schema_submodule__init
12960 + (Sr__SchemaSubmodule *message);
12961 +size_t sr__schema_submodule__get_packed_size
12962 + (const Sr__SchemaSubmodule *message);
12963 +size_t sr__schema_submodule__pack
12964 + (const Sr__SchemaSubmodule *message,
12965 + uint8_t *out);
12966 +size_t sr__schema_submodule__pack_to_buffer
12967 + (const Sr__SchemaSubmodule *message,
12968 + ProtobufCBuffer *buffer);
12969 +Sr__SchemaSubmodule *
12970 + sr__schema_submodule__unpack
12971 + (ProtobufCAllocator *allocator,
12972 + size_t len,
12973 + const uint8_t *data);
12974 +void sr__schema_submodule__free_unpacked
12975 + (Sr__SchemaSubmodule *message,
12976 + ProtobufCAllocator *allocator);
12977 +/* Sr__Schema methods */
12978 +void sr__schema__init
12979 + (Sr__Schema *message);
12980 +size_t sr__schema__get_packed_size
12981 + (const Sr__Schema *message);
12982 +size_t sr__schema__pack
12983 + (const Sr__Schema *message,
12984 + uint8_t *out);
12985 +size_t sr__schema__pack_to_buffer
12986 + (const Sr__Schema *message,
12987 + ProtobufCBuffer *buffer);
12988 +Sr__Schema *
12989 + sr__schema__unpack
12990 + (ProtobufCAllocator *allocator,
12991 + size_t len,
12992 + const uint8_t *data);
12993 +void sr__schema__free_unpacked
12994 + (Sr__Schema *message,
12995 + ProtobufCAllocator *allocator);
12996 +/* Sr__ListSchemasReq methods */
12997 +void sr__list_schemas_req__init
12998 + (Sr__ListSchemasReq *message);
12999 +size_t sr__list_schemas_req__get_packed_size
13000 + (const Sr__ListSchemasReq *message);
13001 +size_t sr__list_schemas_req__pack
13002 + (const Sr__ListSchemasReq *message,
13003 + uint8_t *out);
13004 +size_t sr__list_schemas_req__pack_to_buffer
13005 + (const Sr__ListSchemasReq *message,
13006 + ProtobufCBuffer *buffer);
13007 +Sr__ListSchemasReq *
13008 + sr__list_schemas_req__unpack
13009 + (ProtobufCAllocator *allocator,
13010 + size_t len,
13011 + const uint8_t *data);
13012 +void sr__list_schemas_req__free_unpacked
13013 + (Sr__ListSchemasReq *message,
13014 + ProtobufCAllocator *allocator);
13015 +/* Sr__ListSchemasResp methods */
13016 +void sr__list_schemas_resp__init
13017 + (Sr__ListSchemasResp *message);
13018 +size_t sr__list_schemas_resp__get_packed_size
13019 + (const Sr__ListSchemasResp *message);
13020 +size_t sr__list_schemas_resp__pack
13021 + (const Sr__ListSchemasResp *message,
13022 + uint8_t *out);
13023 +size_t sr__list_schemas_resp__pack_to_buffer
13024 + (const Sr__ListSchemasResp *message,
13025 + ProtobufCBuffer *buffer);
13026 +Sr__ListSchemasResp *
13027 + sr__list_schemas_resp__unpack
13028 + (ProtobufCAllocator *allocator,
13029 + size_t len,
13030 + const uint8_t *data);
13031 +void sr__list_schemas_resp__free_unpacked
13032 + (Sr__ListSchemasResp *message,
13033 + ProtobufCAllocator *allocator);
13034 +/* Sr__GetSchemaReq methods */
13035 +void sr__get_schema_req__init
13036 + (Sr__GetSchemaReq *message);
13037 +size_t sr__get_schema_req__get_packed_size
13038 + (const Sr__GetSchemaReq *message);
13039 +size_t sr__get_schema_req__pack
13040 + (const Sr__GetSchemaReq *message,
13041 + uint8_t *out);
13042 +size_t sr__get_schema_req__pack_to_buffer
13043 + (const Sr__GetSchemaReq *message,
13044 + ProtobufCBuffer *buffer);
13045 +Sr__GetSchemaReq *
13046 + sr__get_schema_req__unpack
13047 + (ProtobufCAllocator *allocator,
13048 + size_t len,
13049 + const uint8_t *data);
13050 +void sr__get_schema_req__free_unpacked
13051 + (Sr__GetSchemaReq *message,
13052 + ProtobufCAllocator *allocator);
13053 +/* Sr__GetSchemaResp methods */
13054 +void sr__get_schema_resp__init
13055 + (Sr__GetSchemaResp *message);
13056 +size_t sr__get_schema_resp__get_packed_size
13057 + (const Sr__GetSchemaResp *message);
13058 +size_t sr__get_schema_resp__pack
13059 + (const Sr__GetSchemaResp *message,
13060 + uint8_t *out);
13061 +size_t sr__get_schema_resp__pack_to_buffer
13062 + (const Sr__GetSchemaResp *message,
13063 + ProtobufCBuffer *buffer);
13064 +Sr__GetSchemaResp *
13065 + sr__get_schema_resp__unpack
13066 + (ProtobufCAllocator *allocator,
13067 + size_t len,
13068 + const uint8_t *data);
13069 +void sr__get_schema_resp__free_unpacked
13070 + (Sr__GetSchemaResp *message,
13071 + ProtobufCAllocator *allocator);
13072 +/* Sr__GetItemReq methods */
13073 +void sr__get_item_req__init
13074 + (Sr__GetItemReq *message);
13075 +size_t sr__get_item_req__get_packed_size
13076 + (const Sr__GetItemReq *message);
13077 +size_t sr__get_item_req__pack
13078 + (const Sr__GetItemReq *message,
13079 + uint8_t *out);
13080 +size_t sr__get_item_req__pack_to_buffer
13081 + (const Sr__GetItemReq *message,
13082 + ProtobufCBuffer *buffer);
13083 +Sr__GetItemReq *
13084 + sr__get_item_req__unpack
13085 + (ProtobufCAllocator *allocator,
13086 + size_t len,
13087 + const uint8_t *data);
13088 +void sr__get_item_req__free_unpacked
13089 + (Sr__GetItemReq *message,
13090 + ProtobufCAllocator *allocator);
13091 +/* Sr__GetItemResp methods */
13092 +void sr__get_item_resp__init
13093 + (Sr__GetItemResp *message);
13094 +size_t sr__get_item_resp__get_packed_size
13095 + (const Sr__GetItemResp *message);
13096 +size_t sr__get_item_resp__pack
13097 + (const Sr__GetItemResp *message,
13098 + uint8_t *out);
13099 +size_t sr__get_item_resp__pack_to_buffer
13100 + (const Sr__GetItemResp *message,
13101 + ProtobufCBuffer *buffer);
13102 +Sr__GetItemResp *
13103 + sr__get_item_resp__unpack
13104 + (ProtobufCAllocator *allocator,
13105 + size_t len,
13106 + const uint8_t *data);
13107 +void sr__get_item_resp__free_unpacked
13108 + (Sr__GetItemResp *message,
13109 + ProtobufCAllocator *allocator);
13110 +/* Sr__GetItemsReq methods */
13111 +void sr__get_items_req__init
13112 + (Sr__GetItemsReq *message);
13113 +size_t sr__get_items_req__get_packed_size
13114 + (const Sr__GetItemsReq *message);
13115 +size_t sr__get_items_req__pack
13116 + (const Sr__GetItemsReq *message,
13117 + uint8_t *out);
13118 +size_t sr__get_items_req__pack_to_buffer
13119 + (const Sr__GetItemsReq *message,
13120 + ProtobufCBuffer *buffer);
13121 +Sr__GetItemsReq *
13122 + sr__get_items_req__unpack
13123 + (ProtobufCAllocator *allocator,
13124 + size_t len,
13125 + const uint8_t *data);
13126 +void sr__get_items_req__free_unpacked
13127 + (Sr__GetItemsReq *message,
13128 + ProtobufCAllocator *allocator);
13129 +/* Sr__GetItemsResp methods */
13130 +void sr__get_items_resp__init
13131 + (Sr__GetItemsResp *message);
13132 +size_t sr__get_items_resp__get_packed_size
13133 + (const Sr__GetItemsResp *message);
13134 +size_t sr__get_items_resp__pack
13135 + (const Sr__GetItemsResp *message,
13136 + uint8_t *out);
13137 +size_t sr__get_items_resp__pack_to_buffer
13138 + (const Sr__GetItemsResp *message,
13139 + ProtobufCBuffer *buffer);
13140 +Sr__GetItemsResp *
13141 + sr__get_items_resp__unpack
13142 + (ProtobufCAllocator *allocator,
13143 + size_t len,
13144 + const uint8_t *data);
13145 +void sr__get_items_resp__free_unpacked
13146 + (Sr__GetItemsResp *message,
13147 + ProtobufCAllocator *allocator);
13148 +/* Sr__GetSubtreeReq methods */
13149 +void sr__get_subtree_req__init
13150 + (Sr__GetSubtreeReq *message);
13151 +size_t sr__get_subtree_req__get_packed_size
13152 + (const Sr__GetSubtreeReq *message);
13153 +size_t sr__get_subtree_req__pack
13154 + (const Sr__GetSubtreeReq *message,
13155 + uint8_t *out);
13156 +size_t sr__get_subtree_req__pack_to_buffer
13157 + (const Sr__GetSubtreeReq *message,
13158 + ProtobufCBuffer *buffer);
13159 +Sr__GetSubtreeReq *
13160 + sr__get_subtree_req__unpack
13161 + (ProtobufCAllocator *allocator,
13162 + size_t len,
13163 + const uint8_t *data);
13164 +void sr__get_subtree_req__free_unpacked
13165 + (Sr__GetSubtreeReq *message,
13166 + ProtobufCAllocator *allocator);
13167 +/* Sr__GetSubtreeResp methods */
13168 +void sr__get_subtree_resp__init
13169 + (Sr__GetSubtreeResp *message);
13170 +size_t sr__get_subtree_resp__get_packed_size
13171 + (const Sr__GetSubtreeResp *message);
13172 +size_t sr__get_subtree_resp__pack
13173 + (const Sr__GetSubtreeResp *message,
13174 + uint8_t *out);
13175 +size_t sr__get_subtree_resp__pack_to_buffer
13176 + (const Sr__GetSubtreeResp *message,
13177 + ProtobufCBuffer *buffer);
13178 +Sr__GetSubtreeResp *
13179 + sr__get_subtree_resp__unpack
13180 + (ProtobufCAllocator *allocator,
13181 + size_t len,
13182 + const uint8_t *data);
13183 +void sr__get_subtree_resp__free_unpacked
13184 + (Sr__GetSubtreeResp *message,
13185 + ProtobufCAllocator *allocator);
13186 +/* Sr__GetSubtreesReq methods */
13187 +void sr__get_subtrees_req__init
13188 + (Sr__GetSubtreesReq *message);
13189 +size_t sr__get_subtrees_req__get_packed_size
13190 + (const Sr__GetSubtreesReq *message);
13191 +size_t sr__get_subtrees_req__pack
13192 + (const Sr__GetSubtreesReq *message,
13193 + uint8_t *out);
13194 +size_t sr__get_subtrees_req__pack_to_buffer
13195 + (const Sr__GetSubtreesReq *message,
13196 + ProtobufCBuffer *buffer);
13197 +Sr__GetSubtreesReq *
13198 + sr__get_subtrees_req__unpack
13199 + (ProtobufCAllocator *allocator,
13200 + size_t len,
13201 + const uint8_t *data);
13202 +void sr__get_subtrees_req__free_unpacked
13203 + (Sr__GetSubtreesReq *message,
13204 + ProtobufCAllocator *allocator);
13205 +/* Sr__GetSubtreesResp methods */
13206 +void sr__get_subtrees_resp__init
13207 + (Sr__GetSubtreesResp *message);
13208 +size_t sr__get_subtrees_resp__get_packed_size
13209 + (const Sr__GetSubtreesResp *message);
13210 +size_t sr__get_subtrees_resp__pack
13211 + (const Sr__GetSubtreesResp *message,
13212 + uint8_t *out);
13213 +size_t sr__get_subtrees_resp__pack_to_buffer
13214 + (const Sr__GetSubtreesResp *message,
13215 + ProtobufCBuffer *buffer);
13216 +Sr__GetSubtreesResp *
13217 + sr__get_subtrees_resp__unpack
13218 + (ProtobufCAllocator *allocator,
13219 + size_t len,
13220 + const uint8_t *data);
13221 +void sr__get_subtrees_resp__free_unpacked
13222 + (Sr__GetSubtreesResp *message,
13223 + ProtobufCAllocator *allocator);
13224 +/* Sr__GetSubtreeChunkReq methods */
13225 +void sr__get_subtree_chunk_req__init
13226 + (Sr__GetSubtreeChunkReq *message);
13227 +size_t sr__get_subtree_chunk_req__get_packed_size
13228 + (const Sr__GetSubtreeChunkReq *message);
13229 +size_t sr__get_subtree_chunk_req__pack
13230 + (const Sr__GetSubtreeChunkReq *message,
13231 + uint8_t *out);
13232 +size_t sr__get_subtree_chunk_req__pack_to_buffer
13233 + (const Sr__GetSubtreeChunkReq *message,
13234 + ProtobufCBuffer *buffer);
13235 +Sr__GetSubtreeChunkReq *
13236 + sr__get_subtree_chunk_req__unpack
13237 + (ProtobufCAllocator *allocator,
13238 + size_t len,
13239 + const uint8_t *data);
13240 +void sr__get_subtree_chunk_req__free_unpacked
13241 + (Sr__GetSubtreeChunkReq *message,
13242 + ProtobufCAllocator *allocator);
13243 +/* Sr__GetSubtreeChunkResp methods */
13244 +void sr__get_subtree_chunk_resp__init
13245 + (Sr__GetSubtreeChunkResp *message);
13246 +size_t sr__get_subtree_chunk_resp__get_packed_size
13247 + (const Sr__GetSubtreeChunkResp *message);
13248 +size_t sr__get_subtree_chunk_resp__pack
13249 + (const Sr__GetSubtreeChunkResp *message,
13250 + uint8_t *out);
13251 +size_t sr__get_subtree_chunk_resp__pack_to_buffer
13252 + (const Sr__GetSubtreeChunkResp *message,
13253 + ProtobufCBuffer *buffer);
13254 +Sr__GetSubtreeChunkResp *
13255 + sr__get_subtree_chunk_resp__unpack
13256 + (ProtobufCAllocator *allocator,
13257 + size_t len,
13258 + const uint8_t *data);
13259 +void sr__get_subtree_chunk_resp__free_unpacked
13260 + (Sr__GetSubtreeChunkResp *message,
13261 + ProtobufCAllocator *allocator);
13262 +/* Sr__SetItemReq methods */
13263 +void sr__set_item_req__init
13264 + (Sr__SetItemReq *message);
13265 +size_t sr__set_item_req__get_packed_size
13266 + (const Sr__SetItemReq *message);
13267 +size_t sr__set_item_req__pack
13268 + (const Sr__SetItemReq *message,
13269 + uint8_t *out);
13270 +size_t sr__set_item_req__pack_to_buffer
13271 + (const Sr__SetItemReq *message,
13272 + ProtobufCBuffer *buffer);
13273 +Sr__SetItemReq *
13274 + sr__set_item_req__unpack
13275 + (ProtobufCAllocator *allocator,
13276 + size_t len,
13277 + const uint8_t *data);
13278 +void sr__set_item_req__free_unpacked
13279 + (Sr__SetItemReq *message,
13280 + ProtobufCAllocator *allocator);
13281 +/* Sr__SetItemResp methods */
13282 +void sr__set_item_resp__init
13283 + (Sr__SetItemResp *message);
13284 +size_t sr__set_item_resp__get_packed_size
13285 + (const Sr__SetItemResp *message);
13286 +size_t sr__set_item_resp__pack
13287 + (const Sr__SetItemResp *message,
13288 + uint8_t *out);
13289 +size_t sr__set_item_resp__pack_to_buffer
13290 + (const Sr__SetItemResp *message,
13291 + ProtobufCBuffer *buffer);
13292 +Sr__SetItemResp *
13293 + sr__set_item_resp__unpack
13294 + (ProtobufCAllocator *allocator,
13295 + size_t len,
13296 + const uint8_t *data);
13297 +void sr__set_item_resp__free_unpacked
13298 + (Sr__SetItemResp *message,
13299 + ProtobufCAllocator *allocator);
13300 +/* Sr__SetItemStrReq methods */
13301 +void sr__set_item_str_req__init
13302 + (Sr__SetItemStrReq *message);
13303 +size_t sr__set_item_str_req__get_packed_size
13304 + (const Sr__SetItemStrReq *message);
13305 +size_t sr__set_item_str_req__pack
13306 + (const Sr__SetItemStrReq *message,
13307 + uint8_t *out);
13308 +size_t sr__set_item_str_req__pack_to_buffer
13309 + (const Sr__SetItemStrReq *message,
13310 + ProtobufCBuffer *buffer);
13311 +Sr__SetItemStrReq *
13312 + sr__set_item_str_req__unpack
13313 + (ProtobufCAllocator *allocator,
13314 + size_t len,
13315 + const uint8_t *data);
13316 +void sr__set_item_str_req__free_unpacked
13317 + (Sr__SetItemStrReq *message,
13318 + ProtobufCAllocator *allocator);
13319 +/* Sr__SetItemStrResp methods */
13320 +void sr__set_item_str_resp__init
13321 + (Sr__SetItemStrResp *message);
13322 +size_t sr__set_item_str_resp__get_packed_size
13323 + (const Sr__SetItemStrResp *message);
13324 +size_t sr__set_item_str_resp__pack
13325 + (const Sr__SetItemStrResp *message,
13326 + uint8_t *out);
13327 +size_t sr__set_item_str_resp__pack_to_buffer
13328 + (const Sr__SetItemStrResp *message,
13329 + ProtobufCBuffer *buffer);
13330 +Sr__SetItemStrResp *
13331 + sr__set_item_str_resp__unpack
13332 + (ProtobufCAllocator *allocator,
13333 + size_t len,
13334 + const uint8_t *data);
13335 +void sr__set_item_str_resp__free_unpacked
13336 + (Sr__SetItemStrResp *message,
13337 + ProtobufCAllocator *allocator);
13338 +/* Sr__DeleteItemReq methods */
13339 +void sr__delete_item_req__init
13340 + (Sr__DeleteItemReq *message);
13341 +size_t sr__delete_item_req__get_packed_size
13342 + (const Sr__DeleteItemReq *message);
13343 +size_t sr__delete_item_req__pack
13344 + (const Sr__DeleteItemReq *message,
13345 + uint8_t *out);
13346 +size_t sr__delete_item_req__pack_to_buffer
13347 + (const Sr__DeleteItemReq *message,
13348 + ProtobufCBuffer *buffer);
13349 +Sr__DeleteItemReq *
13350 + sr__delete_item_req__unpack
13351 + (ProtobufCAllocator *allocator,
13352 + size_t len,
13353 + const uint8_t *data);
13354 +void sr__delete_item_req__free_unpacked
13355 + (Sr__DeleteItemReq *message,
13356 + ProtobufCAllocator *allocator);
13357 +/* Sr__DeleteItemResp methods */
13358 +void sr__delete_item_resp__init
13359 + (Sr__DeleteItemResp *message);
13360 +size_t sr__delete_item_resp__get_packed_size
13361 + (const Sr__DeleteItemResp *message);
13362 +size_t sr__delete_item_resp__pack
13363 + (const Sr__DeleteItemResp *message,
13364 + uint8_t *out);
13365 +size_t sr__delete_item_resp__pack_to_buffer
13366 + (const Sr__DeleteItemResp *message,
13367 + ProtobufCBuffer *buffer);
13368 +Sr__DeleteItemResp *
13369 + sr__delete_item_resp__unpack
13370 + (ProtobufCAllocator *allocator,
13371 + size_t len,
13372 + const uint8_t *data);
13373 +void sr__delete_item_resp__free_unpacked
13374 + (Sr__DeleteItemResp *message,
13375 + ProtobufCAllocator *allocator);
13376 +/* Sr__MoveItemReq methods */
13377 +void sr__move_item_req__init
13378 + (Sr__MoveItemReq *message);
13379 +size_t sr__move_item_req__get_packed_size
13380 + (const Sr__MoveItemReq *message);
13381 +size_t sr__move_item_req__pack
13382 + (const Sr__MoveItemReq *message,
13383 + uint8_t *out);
13384 +size_t sr__move_item_req__pack_to_buffer
13385 + (const Sr__MoveItemReq *message,
13386 + ProtobufCBuffer *buffer);
13387 +Sr__MoveItemReq *
13388 + sr__move_item_req__unpack
13389 + (ProtobufCAllocator *allocator,
13390 + size_t len,
13391 + const uint8_t *data);
13392 +void sr__move_item_req__free_unpacked
13393 + (Sr__MoveItemReq *message,
13394 + ProtobufCAllocator *allocator);
13395 +/* Sr__MoveItemResp methods */
13396 +void sr__move_item_resp__init
13397 + (Sr__MoveItemResp *message);
13398 +size_t sr__move_item_resp__get_packed_size
13399 + (const Sr__MoveItemResp *message);
13400 +size_t sr__move_item_resp__pack
13401 + (const Sr__MoveItemResp *message,
13402 + uint8_t *out);
13403 +size_t sr__move_item_resp__pack_to_buffer
13404 + (const Sr__MoveItemResp *message,
13405 + ProtobufCBuffer *buffer);
13406 +Sr__MoveItemResp *
13407 + sr__move_item_resp__unpack
13408 + (ProtobufCAllocator *allocator,
13409 + size_t len,
13410 + const uint8_t *data);
13411 +void sr__move_item_resp__free_unpacked
13412 + (Sr__MoveItemResp *message,
13413 + ProtobufCAllocator *allocator);
13414 +/* Sr__ValidateReq methods */
13415 +void sr__validate_req__init
13416 + (Sr__ValidateReq *message);
13417 +size_t sr__validate_req__get_packed_size
13418 + (const Sr__ValidateReq *message);
13419 +size_t sr__validate_req__pack
13420 + (const Sr__ValidateReq *message,
13421 + uint8_t *out);
13422 +size_t sr__validate_req__pack_to_buffer
13423 + (const Sr__ValidateReq *message,
13424 + ProtobufCBuffer *buffer);
13425 +Sr__ValidateReq *
13426 + sr__validate_req__unpack
13427 + (ProtobufCAllocator *allocator,
13428 + size_t len,
13429 + const uint8_t *data);
13430 +void sr__validate_req__free_unpacked
13431 + (Sr__ValidateReq *message,
13432 + ProtobufCAllocator *allocator);
13433 +/* Sr__ValidateResp methods */
13434 +void sr__validate_resp__init
13435 + (Sr__ValidateResp *message);
13436 +size_t sr__validate_resp__get_packed_size
13437 + (const Sr__ValidateResp *message);
13438 +size_t sr__validate_resp__pack
13439 + (const Sr__ValidateResp *message,
13440 + uint8_t *out);
13441 +size_t sr__validate_resp__pack_to_buffer
13442 + (const Sr__ValidateResp *message,
13443 + ProtobufCBuffer *buffer);
13444 +Sr__ValidateResp *
13445 + sr__validate_resp__unpack
13446 + (ProtobufCAllocator *allocator,
13447 + size_t len,
13448 + const uint8_t *data);
13449 +void sr__validate_resp__free_unpacked
13450 + (Sr__ValidateResp *message,
13451 + ProtobufCAllocator *allocator);
13452 +/* Sr__CommitReq methods */
13453 +void sr__commit_req__init
13454 + (Sr__CommitReq *message);
13455 +size_t sr__commit_req__get_packed_size
13456 + (const Sr__CommitReq *message);
13457 +size_t sr__commit_req__pack
13458 + (const Sr__CommitReq *message,
13459 + uint8_t *out);
13460 +size_t sr__commit_req__pack_to_buffer
13461 + (const Sr__CommitReq *message,
13462 + ProtobufCBuffer *buffer);
13463 +Sr__CommitReq *
13464 + sr__commit_req__unpack
13465 + (ProtobufCAllocator *allocator,
13466 + size_t len,
13467 + const uint8_t *data);
13468 +void sr__commit_req__free_unpacked
13469 + (Sr__CommitReq *message,
13470 + ProtobufCAllocator *allocator);
13471 +/* Sr__CommitResp methods */
13472 +void sr__commit_resp__init
13473 + (Sr__CommitResp *message);
13474 +size_t sr__commit_resp__get_packed_size
13475 + (const Sr__CommitResp *message);
13476 +size_t sr__commit_resp__pack
13477 + (const Sr__CommitResp *message,
13478 + uint8_t *out);
13479 +size_t sr__commit_resp__pack_to_buffer
13480 + (const Sr__CommitResp *message,
13481 + ProtobufCBuffer *buffer);
13482 +Sr__CommitResp *
13483 + sr__commit_resp__unpack
13484 + (ProtobufCAllocator *allocator,
13485 + size_t len,
13486 + const uint8_t *data);
13487 +void sr__commit_resp__free_unpacked
13488 + (Sr__CommitResp *message,
13489 + ProtobufCAllocator *allocator);
13490 +/* Sr__DiscardChangesReq methods */
13491 +void sr__discard_changes_req__init
13492 + (Sr__DiscardChangesReq *message);
13493 +size_t sr__discard_changes_req__get_packed_size
13494 + (const Sr__DiscardChangesReq *message);
13495 +size_t sr__discard_changes_req__pack
13496 + (const Sr__DiscardChangesReq *message,
13497 + uint8_t *out);
13498 +size_t sr__discard_changes_req__pack_to_buffer
13499 + (const Sr__DiscardChangesReq *message,
13500 + ProtobufCBuffer *buffer);
13501 +Sr__DiscardChangesReq *
13502 + sr__discard_changes_req__unpack
13503 + (ProtobufCAllocator *allocator,
13504 + size_t len,
13505 + const uint8_t *data);
13506 +void sr__discard_changes_req__free_unpacked
13507 + (Sr__DiscardChangesReq *message,
13508 + ProtobufCAllocator *allocator);
13509 +/* Sr__DiscardChangesResp methods */
13510 +void sr__discard_changes_resp__init
13511 + (Sr__DiscardChangesResp *message);
13512 +size_t sr__discard_changes_resp__get_packed_size
13513 + (const Sr__DiscardChangesResp *message);
13514 +size_t sr__discard_changes_resp__pack
13515 + (const Sr__DiscardChangesResp *message,
13516 + uint8_t *out);
13517 +size_t sr__discard_changes_resp__pack_to_buffer
13518 + (const Sr__DiscardChangesResp *message,
13519 + ProtobufCBuffer *buffer);
13520 +Sr__DiscardChangesResp *
13521 + sr__discard_changes_resp__unpack
13522 + (ProtobufCAllocator *allocator,
13523 + size_t len,
13524 + const uint8_t *data);
13525 +void sr__discard_changes_resp__free_unpacked
13526 + (Sr__DiscardChangesResp *message,
13527 + ProtobufCAllocator *allocator);
13528 +/* Sr__CopyConfigReq methods */
13529 +void sr__copy_config_req__init
13530 + (Sr__CopyConfigReq *message);
13531 +size_t sr__copy_config_req__get_packed_size
13532 + (const Sr__CopyConfigReq *message);
13533 +size_t sr__copy_config_req__pack
13534 + (const Sr__CopyConfigReq *message,
13535 + uint8_t *out);
13536 +size_t sr__copy_config_req__pack_to_buffer
13537 + (const Sr__CopyConfigReq *message,
13538 + ProtobufCBuffer *buffer);
13539 +Sr__CopyConfigReq *
13540 + sr__copy_config_req__unpack
13541 + (ProtobufCAllocator *allocator,
13542 + size_t len,
13543 + const uint8_t *data);
13544 +void sr__copy_config_req__free_unpacked
13545 + (Sr__CopyConfigReq *message,
13546 + ProtobufCAllocator *allocator);
13547 +/* Sr__CopyConfigResp methods */
13548 +void sr__copy_config_resp__init
13549 + (Sr__CopyConfigResp *message);
13550 +size_t sr__copy_config_resp__get_packed_size
13551 + (const Sr__CopyConfigResp *message);
13552 +size_t sr__copy_config_resp__pack
13553 + (const Sr__CopyConfigResp *message,
13554 + uint8_t *out);
13555 +size_t sr__copy_config_resp__pack_to_buffer
13556 + (const Sr__CopyConfigResp *message,
13557 + ProtobufCBuffer *buffer);
13558 +Sr__CopyConfigResp *
13559 + sr__copy_config_resp__unpack
13560 + (ProtobufCAllocator *allocator,
13561 + size_t len,
13562 + const uint8_t *data);
13563 +void sr__copy_config_resp__free_unpacked
13564 + (Sr__CopyConfigResp *message,
13565 + ProtobufCAllocator *allocator);
13566 +/* Sr__LockReq methods */
13567 +void sr__lock_req__init
13568 + (Sr__LockReq *message);
13569 +size_t sr__lock_req__get_packed_size
13570 + (const Sr__LockReq *message);
13571 +size_t sr__lock_req__pack
13572 + (const Sr__LockReq *message,
13573 + uint8_t *out);
13574 +size_t sr__lock_req__pack_to_buffer
13575 + (const Sr__LockReq *message,
13576 + ProtobufCBuffer *buffer);
13577 +Sr__LockReq *
13578 + sr__lock_req__unpack
13579 + (ProtobufCAllocator *allocator,
13580 + size_t len,
13581 + const uint8_t *data);
13582 +void sr__lock_req__free_unpacked
13583 + (Sr__LockReq *message,
13584 + ProtobufCAllocator *allocator);
13585 +/* Sr__LockResp methods */
13586 +void sr__lock_resp__init
13587 + (Sr__LockResp *message);
13588 +size_t sr__lock_resp__get_packed_size
13589 + (const Sr__LockResp *message);
13590 +size_t sr__lock_resp__pack
13591 + (const Sr__LockResp *message,
13592 + uint8_t *out);
13593 +size_t sr__lock_resp__pack_to_buffer
13594 + (const Sr__LockResp *message,
13595 + ProtobufCBuffer *buffer);
13596 +Sr__LockResp *
13597 + sr__lock_resp__unpack
13598 + (ProtobufCAllocator *allocator,
13599 + size_t len,
13600 + const uint8_t *data);
13601 +void sr__lock_resp__free_unpacked
13602 + (Sr__LockResp *message,
13603 + ProtobufCAllocator *allocator);
13604 +/* Sr__UnlockReq methods */
13605 +void sr__unlock_req__init
13606 + (Sr__UnlockReq *message);
13607 +size_t sr__unlock_req__get_packed_size
13608 + (const Sr__UnlockReq *message);
13609 +size_t sr__unlock_req__pack
13610 + (const Sr__UnlockReq *message,
13611 + uint8_t *out);
13612 +size_t sr__unlock_req__pack_to_buffer
13613 + (const Sr__UnlockReq *message,
13614 + ProtobufCBuffer *buffer);
13615 +Sr__UnlockReq *
13616 + sr__unlock_req__unpack
13617 + (ProtobufCAllocator *allocator,
13618 + size_t len,
13619 + const uint8_t *data);
13620 +void sr__unlock_req__free_unpacked
13621 + (Sr__UnlockReq *message,
13622 + ProtobufCAllocator *allocator);
13623 +/* Sr__UnlockResp methods */
13624 +void sr__unlock_resp__init
13625 + (Sr__UnlockResp *message);
13626 +size_t sr__unlock_resp__get_packed_size
13627 + (const Sr__UnlockResp *message);
13628 +size_t sr__unlock_resp__pack
13629 + (const Sr__UnlockResp *message,
13630 + uint8_t *out);
13631 +size_t sr__unlock_resp__pack_to_buffer
13632 + (const Sr__UnlockResp *message,
13633 + ProtobufCBuffer *buffer);
13634 +Sr__UnlockResp *
13635 + sr__unlock_resp__unpack
13636 + (ProtobufCAllocator *allocator,
13637 + size_t len,
13638 + const uint8_t *data);
13639 +void sr__unlock_resp__free_unpacked
13640 + (Sr__UnlockResp *message,
13641 + ProtobufCAllocator *allocator);
13642 +/* Sr__SubscribeReq methods */
13643 +void sr__subscribe_req__init
13644 + (Sr__SubscribeReq *message);
13645 +size_t sr__subscribe_req__get_packed_size
13646 + (const Sr__SubscribeReq *message);
13647 +size_t sr__subscribe_req__pack
13648 + (const Sr__SubscribeReq *message,
13649 + uint8_t *out);
13650 +size_t sr__subscribe_req__pack_to_buffer
13651 + (const Sr__SubscribeReq *message,
13652 + ProtobufCBuffer *buffer);
13653 +Sr__SubscribeReq *
13654 + sr__subscribe_req__unpack
13655 + (ProtobufCAllocator *allocator,
13656 + size_t len,
13657 + const uint8_t *data);
13658 +void sr__subscribe_req__free_unpacked
13659 + (Sr__SubscribeReq *message,
13660 + ProtobufCAllocator *allocator);
13661 +/* Sr__SubscribeResp methods */
13662 +void sr__subscribe_resp__init
13663 + (Sr__SubscribeResp *message);
13664 +size_t sr__subscribe_resp__get_packed_size
13665 + (const Sr__SubscribeResp *message);
13666 +size_t sr__subscribe_resp__pack
13667 + (const Sr__SubscribeResp *message,
13668 + uint8_t *out);
13669 +size_t sr__subscribe_resp__pack_to_buffer
13670 + (const Sr__SubscribeResp *message,
13671 + ProtobufCBuffer *buffer);
13672 +Sr__SubscribeResp *
13673 + sr__subscribe_resp__unpack
13674 + (ProtobufCAllocator *allocator,
13675 + size_t len,
13676 + const uint8_t *data);
13677 +void sr__subscribe_resp__free_unpacked
13678 + (Sr__SubscribeResp *message,
13679 + ProtobufCAllocator *allocator);
13680 +/* Sr__UnsubscribeReq methods */
13681 +void sr__unsubscribe_req__init
13682 + (Sr__UnsubscribeReq *message);
13683 +size_t sr__unsubscribe_req__get_packed_size
13684 + (const Sr__UnsubscribeReq *message);
13685 +size_t sr__unsubscribe_req__pack
13686 + (const Sr__UnsubscribeReq *message,
13687 + uint8_t *out);
13688 +size_t sr__unsubscribe_req__pack_to_buffer
13689 + (const Sr__UnsubscribeReq *message,
13690 + ProtobufCBuffer *buffer);
13691 +Sr__UnsubscribeReq *
13692 + sr__unsubscribe_req__unpack
13693 + (ProtobufCAllocator *allocator,
13694 + size_t len,
13695 + const uint8_t *data);
13696 +void sr__unsubscribe_req__free_unpacked
13697 + (Sr__UnsubscribeReq *message,
13698 + ProtobufCAllocator *allocator);
13699 +/* Sr__UnsubscribeResp methods */
13700 +void sr__unsubscribe_resp__init
13701 + (Sr__UnsubscribeResp *message);
13702 +size_t sr__unsubscribe_resp__get_packed_size
13703 + (const Sr__UnsubscribeResp *message);
13704 +size_t sr__unsubscribe_resp__pack
13705 + (const Sr__UnsubscribeResp *message,
13706 + uint8_t *out);
13707 +size_t sr__unsubscribe_resp__pack_to_buffer
13708 + (const Sr__UnsubscribeResp *message,
13709 + ProtobufCBuffer *buffer);
13710 +Sr__UnsubscribeResp *
13711 + sr__unsubscribe_resp__unpack
13712 + (ProtobufCAllocator *allocator,
13713 + size_t len,
13714 + const uint8_t *data);
13715 +void sr__unsubscribe_resp__free_unpacked
13716 + (Sr__UnsubscribeResp *message,
13717 + ProtobufCAllocator *allocator);
13718 +/* Sr__CheckEnabledRunningReq methods */
13719 +void sr__check_enabled_running_req__init
13720 + (Sr__CheckEnabledRunningReq *message);
13721 +size_t sr__check_enabled_running_req__get_packed_size
13722 + (const Sr__CheckEnabledRunningReq *message);
13723 +size_t sr__check_enabled_running_req__pack
13724 + (const Sr__CheckEnabledRunningReq *message,
13725 + uint8_t *out);
13726 +size_t sr__check_enabled_running_req__pack_to_buffer
13727 + (const Sr__CheckEnabledRunningReq *message,
13728 + ProtobufCBuffer *buffer);
13729 +Sr__CheckEnabledRunningReq *
13730 + sr__check_enabled_running_req__unpack
13731 + (ProtobufCAllocator *allocator,
13732 + size_t len,
13733 + const uint8_t *data);
13734 +void sr__check_enabled_running_req__free_unpacked
13735 + (Sr__CheckEnabledRunningReq *message,
13736 + ProtobufCAllocator *allocator);
13737 +/* Sr__CheckEnabledRunningResp methods */
13738 +void sr__check_enabled_running_resp__init
13739 + (Sr__CheckEnabledRunningResp *message);
13740 +size_t sr__check_enabled_running_resp__get_packed_size
13741 + (const Sr__CheckEnabledRunningResp *message);
13742 +size_t sr__check_enabled_running_resp__pack
13743 + (const Sr__CheckEnabledRunningResp *message,
13744 + uint8_t *out);
13745 +size_t sr__check_enabled_running_resp__pack_to_buffer
13746 + (const Sr__CheckEnabledRunningResp *message,
13747 + ProtobufCBuffer *buffer);
13748 +Sr__CheckEnabledRunningResp *
13749 + sr__check_enabled_running_resp__unpack
13750 + (ProtobufCAllocator *allocator,
13751 + size_t len,
13752 + const uint8_t *data);
13753 +void sr__check_enabled_running_resp__free_unpacked
13754 + (Sr__CheckEnabledRunningResp *message,
13755 + ProtobufCAllocator *allocator);
13756 +/* Sr__ModuleInstallNotification methods */
13757 +void sr__module_install_notification__init
13758 + (Sr__ModuleInstallNotification *message);
13759 +size_t sr__module_install_notification__get_packed_size
13760 + (const Sr__ModuleInstallNotification *message);
13761 +size_t sr__module_install_notification__pack
13762 + (const Sr__ModuleInstallNotification *message,
13763 + uint8_t *out);
13764 +size_t sr__module_install_notification__pack_to_buffer
13765 + (const Sr__ModuleInstallNotification *message,
13766 + ProtobufCBuffer *buffer);
13767 +Sr__ModuleInstallNotification *
13768 + sr__module_install_notification__unpack
13769 + (ProtobufCAllocator *allocator,
13770 + size_t len,
13771 + const uint8_t *data);
13772 +void sr__module_install_notification__free_unpacked
13773 + (Sr__ModuleInstallNotification *message,
13774 + ProtobufCAllocator *allocator);
13775 +/* Sr__FeatureEnableNotification methods */
13776 +void sr__feature_enable_notification__init
13777 + (Sr__FeatureEnableNotification *message);
13778 +size_t sr__feature_enable_notification__get_packed_size
13779 + (const Sr__FeatureEnableNotification *message);
13780 +size_t sr__feature_enable_notification__pack
13781 + (const Sr__FeatureEnableNotification *message,
13782 + uint8_t *out);
13783 +size_t sr__feature_enable_notification__pack_to_buffer
13784 + (const Sr__FeatureEnableNotification *message,
13785 + ProtobufCBuffer *buffer);
13786 +Sr__FeatureEnableNotification *
13787 + sr__feature_enable_notification__unpack
13788 + (ProtobufCAllocator *allocator,
13789 + size_t len,
13790 + const uint8_t *data);
13791 +void sr__feature_enable_notification__free_unpacked
13792 + (Sr__FeatureEnableNotification *message,
13793 + ProtobufCAllocator *allocator);
13794 +/* Sr__ModuleChangeNotification methods */
13795 +void sr__module_change_notification__init
13796 + (Sr__ModuleChangeNotification *message);
13797 +size_t sr__module_change_notification__get_packed_size
13798 + (const Sr__ModuleChangeNotification *message);
13799 +size_t sr__module_change_notification__pack
13800 + (const Sr__ModuleChangeNotification *message,
13801 + uint8_t *out);
13802 +size_t sr__module_change_notification__pack_to_buffer
13803 + (const Sr__ModuleChangeNotification *message,
13804 + ProtobufCBuffer *buffer);
13805 +Sr__ModuleChangeNotification *
13806 + sr__module_change_notification__unpack
13807 + (ProtobufCAllocator *allocator,
13808 + size_t len,
13809 + const uint8_t *data);
13810 +void sr__module_change_notification__free_unpacked
13811 + (Sr__ModuleChangeNotification *message,
13812 + ProtobufCAllocator *allocator);
13813 +/* Sr__SubtreeChangeNotification methods */
13814 +void sr__subtree_change_notification__init
13815 + (Sr__SubtreeChangeNotification *message);
13816 +size_t sr__subtree_change_notification__get_packed_size
13817 + (const Sr__SubtreeChangeNotification *message);
13818 +size_t sr__subtree_change_notification__pack
13819 + (const Sr__SubtreeChangeNotification *message,
13820 + uint8_t *out);
13821 +size_t sr__subtree_change_notification__pack_to_buffer
13822 + (const Sr__SubtreeChangeNotification *message,
13823 + ProtobufCBuffer *buffer);
13824 +Sr__SubtreeChangeNotification *
13825 + sr__subtree_change_notification__unpack
13826 + (ProtobufCAllocator *allocator,
13827 + size_t len,
13828 + const uint8_t *data);
13829 +void sr__subtree_change_notification__free_unpacked
13830 + (Sr__SubtreeChangeNotification *message,
13831 + ProtobufCAllocator *allocator);
13832 +/* Sr__Change methods */
13833 +void sr__change__init
13834 + (Sr__Change *message);
13835 +size_t sr__change__get_packed_size
13836 + (const Sr__Change *message);
13837 +size_t sr__change__pack
13838 + (const Sr__Change *message,
13839 + uint8_t *out);
13840 +size_t sr__change__pack_to_buffer
13841 + (const Sr__Change *message,
13842 + ProtobufCBuffer *buffer);
13843 +Sr__Change *
13844 + sr__change__unpack
13845 + (ProtobufCAllocator *allocator,
13846 + size_t len,
13847 + const uint8_t *data);
13848 +void sr__change__free_unpacked
13849 + (Sr__Change *message,
13850 + ProtobufCAllocator *allocator);
13851 +/* Sr__GetChangesReq methods */
13852 +void sr__get_changes_req__init
13853 + (Sr__GetChangesReq *message);
13854 +size_t sr__get_changes_req__get_packed_size
13855 + (const Sr__GetChangesReq *message);
13856 +size_t sr__get_changes_req__pack
13857 + (const Sr__GetChangesReq *message,
13858 + uint8_t *out);
13859 +size_t sr__get_changes_req__pack_to_buffer
13860 + (const Sr__GetChangesReq *message,
13861 + ProtobufCBuffer *buffer);
13862 +Sr__GetChangesReq *
13863 + sr__get_changes_req__unpack
13864 + (ProtobufCAllocator *allocator,
13865 + size_t len,
13866 + const uint8_t *data);
13867 +void sr__get_changes_req__free_unpacked
13868 + (Sr__GetChangesReq *message,
13869 + ProtobufCAllocator *allocator);
13870 +/* Sr__GetChangesResp methods */
13871 +void sr__get_changes_resp__init
13872 + (Sr__GetChangesResp *message);
13873 +size_t sr__get_changes_resp__get_packed_size
13874 + (const Sr__GetChangesResp *message);
13875 +size_t sr__get_changes_resp__pack
13876 + (const Sr__GetChangesResp *message,
13877 + uint8_t *out);
13878 +size_t sr__get_changes_resp__pack_to_buffer
13879 + (const Sr__GetChangesResp *message,
13880 + ProtobufCBuffer *buffer);
13881 +Sr__GetChangesResp *
13882 + sr__get_changes_resp__unpack
13883 + (ProtobufCAllocator *allocator,
13884 + size_t len,
13885 + const uint8_t *data);
13886 +void sr__get_changes_resp__free_unpacked
13887 + (Sr__GetChangesResp *message,
13888 + ProtobufCAllocator *allocator);
13889 +/* Sr__CheckExecPermReq methods */
13890 +void sr__check_exec_perm_req__init
13891 + (Sr__CheckExecPermReq *message);
13892 +size_t sr__check_exec_perm_req__get_packed_size
13893 + (const Sr__CheckExecPermReq *message);
13894 +size_t sr__check_exec_perm_req__pack
13895 + (const Sr__CheckExecPermReq *message,
13896 + uint8_t *out);
13897 +size_t sr__check_exec_perm_req__pack_to_buffer
13898 + (const Sr__CheckExecPermReq *message,
13899 + ProtobufCBuffer *buffer);
13900 +Sr__CheckExecPermReq *
13901 + sr__check_exec_perm_req__unpack
13902 + (ProtobufCAllocator *allocator,
13903 + size_t len,
13904 + const uint8_t *data);
13905 +void sr__check_exec_perm_req__free_unpacked
13906 + (Sr__CheckExecPermReq *message,
13907 + ProtobufCAllocator *allocator);
13908 +/* Sr__CheckExecPermResp methods */
13909 +void sr__check_exec_perm_resp__init
13910 + (Sr__CheckExecPermResp *message);
13911 +size_t sr__check_exec_perm_resp__get_packed_size
13912 + (const Sr__CheckExecPermResp *message);
13913 +size_t sr__check_exec_perm_resp__pack
13914 + (const Sr__CheckExecPermResp *message,
13915 + uint8_t *out);
13916 +size_t sr__check_exec_perm_resp__pack_to_buffer
13917 + (const Sr__CheckExecPermResp *message,
13918 + ProtobufCBuffer *buffer);
13919 +Sr__CheckExecPermResp *
13920 + sr__check_exec_perm_resp__unpack
13921 + (ProtobufCAllocator *allocator,
13922 + size_t len,
13923 + const uint8_t *data);
13924 +void sr__check_exec_perm_resp__free_unpacked
13925 + (Sr__CheckExecPermResp *message,
13926 + ProtobufCAllocator *allocator);
13927 +/* Sr__RPCReq methods */
13928 +void sr__rpcreq__init
13929 + (Sr__RPCReq *message);
13930 +size_t sr__rpcreq__get_packed_size
13931 + (const Sr__RPCReq *message);
13932 +size_t sr__rpcreq__pack
13933 + (const Sr__RPCReq *message,
13934 + uint8_t *out);
13935 +size_t sr__rpcreq__pack_to_buffer
13936 + (const Sr__RPCReq *message,
13937 + ProtobufCBuffer *buffer);
13938 +Sr__RPCReq *
13939 + sr__rpcreq__unpack
13940 + (ProtobufCAllocator *allocator,
13941 + size_t len,
13942 + const uint8_t *data);
13943 +void sr__rpcreq__free_unpacked
13944 + (Sr__RPCReq *message,
13945 + ProtobufCAllocator *allocator);
13946 +/* Sr__RPCResp methods */
13947 +void sr__rpcresp__init
13948 + (Sr__RPCResp *message);
13949 +size_t sr__rpcresp__get_packed_size
13950 + (const Sr__RPCResp *message);
13951 +size_t sr__rpcresp__pack
13952 + (const Sr__RPCResp *message,
13953 + uint8_t *out);
13954 +size_t sr__rpcresp__pack_to_buffer
13955 + (const Sr__RPCResp *message,
13956 + ProtobufCBuffer *buffer);
13957 +Sr__RPCResp *
13958 + sr__rpcresp__unpack
13959 + (ProtobufCAllocator *allocator,
13960 + size_t len,
13961 + const uint8_t *data);
13962 +void sr__rpcresp__free_unpacked
13963 + (Sr__RPCResp *message,
13964 + ProtobufCAllocator *allocator);
13965 +/* Sr__EventNotifReq methods */
13966 +void sr__event_notif_req__init
13967 + (Sr__EventNotifReq *message);
13968 +size_t sr__event_notif_req__get_packed_size
13969 + (const Sr__EventNotifReq *message);
13970 +size_t sr__event_notif_req__pack
13971 + (const Sr__EventNotifReq *message,
13972 + uint8_t *out);
13973 +size_t sr__event_notif_req__pack_to_buffer
13974 + (const Sr__EventNotifReq *message,
13975 + ProtobufCBuffer *buffer);
13976 +Sr__EventNotifReq *
13977 + sr__event_notif_req__unpack
13978 + (ProtobufCAllocator *allocator,
13979 + size_t len,
13980 + const uint8_t *data);
13981 +void sr__event_notif_req__free_unpacked
13982 + (Sr__EventNotifReq *message,
13983 + ProtobufCAllocator *allocator);
13984 +/* Sr__EventNotifResp methods */
13985 +void sr__event_notif_resp__init
13986 + (Sr__EventNotifResp *message);
13987 +size_t sr__event_notif_resp__get_packed_size
13988 + (const Sr__EventNotifResp *message);
13989 +size_t sr__event_notif_resp__pack
13990 + (const Sr__EventNotifResp *message,
13991 + uint8_t *out);
13992 +size_t sr__event_notif_resp__pack_to_buffer
13993 + (const Sr__EventNotifResp *message,
13994 + ProtobufCBuffer *buffer);
13995 +Sr__EventNotifResp *
13996 + sr__event_notif_resp__unpack
13997 + (ProtobufCAllocator *allocator,
13998 + size_t len,
13999 + const uint8_t *data);
14000 +void sr__event_notif_resp__free_unpacked
14001 + (Sr__EventNotifResp *message,
14002 + ProtobufCAllocator *allocator);
14003 +/* Sr__EventNotifReplayReq methods */
14004 +void sr__event_notif_replay_req__init
14005 + (Sr__EventNotifReplayReq *message);
14006 +size_t sr__event_notif_replay_req__get_packed_size
14007 + (const Sr__EventNotifReplayReq *message);
14008 +size_t sr__event_notif_replay_req__pack
14009 + (const Sr__EventNotifReplayReq *message,
14010 + uint8_t *out);
14011 +size_t sr__event_notif_replay_req__pack_to_buffer
14012 + (const Sr__EventNotifReplayReq *message,
14013 + ProtobufCBuffer *buffer);
14014 +Sr__EventNotifReplayReq *
14015 + sr__event_notif_replay_req__unpack
14016 + (ProtobufCAllocator *allocator,
14017 + size_t len,
14018 + const uint8_t *data);
14019 +void sr__event_notif_replay_req__free_unpacked
14020 + (Sr__EventNotifReplayReq *message,
14021 + ProtobufCAllocator *allocator);
14022 +/* Sr__EventNotifReplayResp methods */
14023 +void sr__event_notif_replay_resp__init
14024 + (Sr__EventNotifReplayResp *message);
14025 +size_t sr__event_notif_replay_resp__get_packed_size
14026 + (const Sr__EventNotifReplayResp *message);
14027 +size_t sr__event_notif_replay_resp__pack
14028 + (const Sr__EventNotifReplayResp *message,
14029 + uint8_t *out);
14030 +size_t sr__event_notif_replay_resp__pack_to_buffer
14031 + (const Sr__EventNotifReplayResp *message,
14032 + ProtobufCBuffer *buffer);
14033 +Sr__EventNotifReplayResp *
14034 + sr__event_notif_replay_resp__unpack
14035 + (ProtobufCAllocator *allocator,
14036 + size_t len,
14037 + const uint8_t *data);
14038 +void sr__event_notif_replay_resp__free_unpacked
14039 + (Sr__EventNotifReplayResp *message,
14040 + ProtobufCAllocator *allocator);
14041 +/* Sr__DataProvideReq methods */
14042 +void sr__data_provide_req__init
14043 + (Sr__DataProvideReq *message);
14044 +size_t sr__data_provide_req__get_packed_size
14045 + (const Sr__DataProvideReq *message);
14046 +size_t sr__data_provide_req__pack
14047 + (const Sr__DataProvideReq *message,
14048 + uint8_t *out);
14049 +size_t sr__data_provide_req__pack_to_buffer
14050 + (const Sr__DataProvideReq *message,
14051 + ProtobufCBuffer *buffer);
14052 +Sr__DataProvideReq *
14053 + sr__data_provide_req__unpack
14054 + (ProtobufCAllocator *allocator,
14055 + size_t len,
14056 + const uint8_t *data);
14057 +void sr__data_provide_req__free_unpacked
14058 + (Sr__DataProvideReq *message,
14059 + ProtobufCAllocator *allocator);
14060 +/* Sr__DataProvideResp methods */
14061 +void sr__data_provide_resp__init
14062 + (Sr__DataProvideResp *message);
14063 +size_t sr__data_provide_resp__get_packed_size
14064 + (const Sr__DataProvideResp *message);
14065 +size_t sr__data_provide_resp__pack
14066 + (const Sr__DataProvideResp *message,
14067 + uint8_t *out);
14068 +size_t sr__data_provide_resp__pack_to_buffer
14069 + (const Sr__DataProvideResp *message,
14070 + ProtobufCBuffer *buffer);
14071 +Sr__DataProvideResp *
14072 + sr__data_provide_resp__unpack
14073 + (ProtobufCAllocator *allocator,
14074 + size_t len,
14075 + const uint8_t *data);
14076 +void sr__data_provide_resp__free_unpacked
14077 + (Sr__DataProvideResp *message,
14078 + ProtobufCAllocator *allocator);
14079 +/* Sr__ModuleInstallReq methods */
14080 +void sr__module_install_req__init
14081 + (Sr__ModuleInstallReq *message);
14082 +size_t sr__module_install_req__get_packed_size
14083 + (const Sr__ModuleInstallReq *message);
14084 +size_t sr__module_install_req__pack
14085 + (const Sr__ModuleInstallReq *message,
14086 + uint8_t *out);
14087 +size_t sr__module_install_req__pack_to_buffer
14088 + (const Sr__ModuleInstallReq *message,
14089 + ProtobufCBuffer *buffer);
14090 +Sr__ModuleInstallReq *
14091 + sr__module_install_req__unpack
14092 + (ProtobufCAllocator *allocator,
14093 + size_t len,
14094 + const uint8_t *data);
14095 +void sr__module_install_req__free_unpacked
14096 + (Sr__ModuleInstallReq *message,
14097 + ProtobufCAllocator *allocator);
14098 +/* Sr__ModuleInstallResp methods */
14099 +void sr__module_install_resp__init
14100 + (Sr__ModuleInstallResp *message);
14101 +size_t sr__module_install_resp__get_packed_size
14102 + (const Sr__ModuleInstallResp *message);
14103 +size_t sr__module_install_resp__pack
14104 + (const Sr__ModuleInstallResp *message,
14105 + uint8_t *out);
14106 +size_t sr__module_install_resp__pack_to_buffer
14107 + (const Sr__ModuleInstallResp *message,
14108 + ProtobufCBuffer *buffer);
14109 +Sr__ModuleInstallResp *
14110 + sr__module_install_resp__unpack
14111 + (ProtobufCAllocator *allocator,
14112 + size_t len,
14113 + const uint8_t *data);
14114 +void sr__module_install_resp__free_unpacked
14115 + (Sr__ModuleInstallResp *message,
14116 + ProtobufCAllocator *allocator);
14117 +/* Sr__FeatureEnableReq methods */
14118 +void sr__feature_enable_req__init
14119 + (Sr__FeatureEnableReq *message);
14120 +size_t sr__feature_enable_req__get_packed_size
14121 + (const Sr__FeatureEnableReq *message);
14122 +size_t sr__feature_enable_req__pack
14123 + (const Sr__FeatureEnableReq *message,
14124 + uint8_t *out);
14125 +size_t sr__feature_enable_req__pack_to_buffer
14126 + (const Sr__FeatureEnableReq *message,
14127 + ProtobufCBuffer *buffer);
14128 +Sr__FeatureEnableReq *
14129 + sr__feature_enable_req__unpack
14130 + (ProtobufCAllocator *allocator,
14131 + size_t len,
14132 + const uint8_t *data);
14133 +void sr__feature_enable_req__free_unpacked
14134 + (Sr__FeatureEnableReq *message,
14135 + ProtobufCAllocator *allocator);
14136 +/* Sr__FeatureEnableResp methods */
14137 +void sr__feature_enable_resp__init
14138 + (Sr__FeatureEnableResp *message);
14139 +size_t sr__feature_enable_resp__get_packed_size
14140 + (const Sr__FeatureEnableResp *message);
14141 +size_t sr__feature_enable_resp__pack
14142 + (const Sr__FeatureEnableResp *message,
14143 + uint8_t *out);
14144 +size_t sr__feature_enable_resp__pack_to_buffer
14145 + (const Sr__FeatureEnableResp *message,
14146 + ProtobufCBuffer *buffer);
14147 +Sr__FeatureEnableResp *
14148 + sr__feature_enable_resp__unpack
14149 + (ProtobufCAllocator *allocator,
14150 + size_t len,
14151 + const uint8_t *data);
14152 +void sr__feature_enable_resp__free_unpacked
14153 + (Sr__FeatureEnableResp *message,
14154 + ProtobufCAllocator *allocator);
14155 +/* Sr__UnsubscribeDestinationReq methods */
14156 +void sr__unsubscribe_destination_req__init
14157 + (Sr__UnsubscribeDestinationReq *message);
14158 +size_t sr__unsubscribe_destination_req__get_packed_size
14159 + (const Sr__UnsubscribeDestinationReq *message);
14160 +size_t sr__unsubscribe_destination_req__pack
14161 + (const Sr__UnsubscribeDestinationReq *message,
14162 + uint8_t *out);
14163 +size_t sr__unsubscribe_destination_req__pack_to_buffer
14164 + (const Sr__UnsubscribeDestinationReq *message,
14165 + ProtobufCBuffer *buffer);
14166 +Sr__UnsubscribeDestinationReq *
14167 + sr__unsubscribe_destination_req__unpack
14168 + (ProtobufCAllocator *allocator,
14169 + size_t len,
14170 + const uint8_t *data);
14171 +void sr__unsubscribe_destination_req__free_unpacked
14172 + (Sr__UnsubscribeDestinationReq *message,
14173 + ProtobufCAllocator *allocator);
14174 +/* Sr__CommitTimeoutReq methods */
14175 +void sr__commit_timeout_req__init
14176 + (Sr__CommitTimeoutReq *message);
14177 +size_t sr__commit_timeout_req__get_packed_size
14178 + (const Sr__CommitTimeoutReq *message);
14179 +size_t sr__commit_timeout_req__pack
14180 + (const Sr__CommitTimeoutReq *message,
14181 + uint8_t *out);
14182 +size_t sr__commit_timeout_req__pack_to_buffer
14183 + (const Sr__CommitTimeoutReq *message,
14184 + ProtobufCBuffer *buffer);
14185 +Sr__CommitTimeoutReq *
14186 + sr__commit_timeout_req__unpack
14187 + (ProtobufCAllocator *allocator,
14188 + size_t len,
14189 + const uint8_t *data);
14190 +void sr__commit_timeout_req__free_unpacked
14191 + (Sr__CommitTimeoutReq *message,
14192 + ProtobufCAllocator *allocator);
14193 +/* Sr__OperDataTimeoutReq methods */
14194 +void sr__oper_data_timeout_req__init
14195 + (Sr__OperDataTimeoutReq *message);
14196 +size_t sr__oper_data_timeout_req__get_packed_size
14197 + (const Sr__OperDataTimeoutReq *message);
14198 +size_t sr__oper_data_timeout_req__pack
14199 + (const Sr__OperDataTimeoutReq *message,
14200 + uint8_t *out);
14201 +size_t sr__oper_data_timeout_req__pack_to_buffer
14202 + (const Sr__OperDataTimeoutReq *message,
14203 + ProtobufCBuffer *buffer);
14204 +Sr__OperDataTimeoutReq *
14205 + sr__oper_data_timeout_req__unpack
14206 + (ProtobufCAllocator *allocator,
14207 + size_t len,
14208 + const uint8_t *data);
14209 +void sr__oper_data_timeout_req__free_unpacked
14210 + (Sr__OperDataTimeoutReq *message,
14211 + ProtobufCAllocator *allocator);
14212 +/* Sr__InternalStateDataReq methods */
14213 +void sr__internal_state_data_req__init
14214 + (Sr__InternalStateDataReq *message);
14215 +size_t sr__internal_state_data_req__get_packed_size
14216 + (const Sr__InternalStateDataReq *message);
14217 +size_t sr__internal_state_data_req__pack
14218 + (const Sr__InternalStateDataReq *message,
14219 + uint8_t *out);
14220 +size_t sr__internal_state_data_req__pack_to_buffer
14221 + (const Sr__InternalStateDataReq *message,
14222 + ProtobufCBuffer *buffer);
14223 +Sr__InternalStateDataReq *
14224 + sr__internal_state_data_req__unpack
14225 + (ProtobufCAllocator *allocator,
14226 + size_t len,
14227 + const uint8_t *data);
14228 +void sr__internal_state_data_req__free_unpacked
14229 + (Sr__InternalStateDataReq *message,
14230 + ProtobufCAllocator *allocator);
14231 +/* Sr__NotifStoreCleanupReq methods */
14232 +void sr__notif_store_cleanup_req__init
14233 + (Sr__NotifStoreCleanupReq *message);
14234 +size_t sr__notif_store_cleanup_req__get_packed_size
14235 + (const Sr__NotifStoreCleanupReq *message);
14236 +size_t sr__notif_store_cleanup_req__pack
14237 + (const Sr__NotifStoreCleanupReq *message,
14238 + uint8_t *out);
14239 +size_t sr__notif_store_cleanup_req__pack_to_buffer
14240 + (const Sr__NotifStoreCleanupReq *message,
14241 + ProtobufCBuffer *buffer);
14242 +Sr__NotifStoreCleanupReq *
14243 + sr__notif_store_cleanup_req__unpack
14244 + (ProtobufCAllocator *allocator,
14245 + size_t len,
14246 + const uint8_t *data);
14247 +void sr__notif_store_cleanup_req__free_unpacked
14248 + (Sr__NotifStoreCleanupReq *message,
14249 + ProtobufCAllocator *allocator);
14250 +/* Sr__DelayedMsgReq methods */
14251 +void sr__delayed_msg_req__init
14252 + (Sr__DelayedMsgReq *message);
14253 +size_t sr__delayed_msg_req__get_packed_size
14254 + (const Sr__DelayedMsgReq *message);
14255 +size_t sr__delayed_msg_req__pack
14256 + (const Sr__DelayedMsgReq *message,
14257 + uint8_t *out);
14258 +size_t sr__delayed_msg_req__pack_to_buffer
14259 + (const Sr__DelayedMsgReq *message,
14260 + ProtobufCBuffer *buffer);
14261 +Sr__DelayedMsgReq *
14262 + sr__delayed_msg_req__unpack
14263 + (ProtobufCAllocator *allocator,
14264 + size_t len,
14265 + const uint8_t *data);
14266 +void sr__delayed_msg_req__free_unpacked
14267 + (Sr__DelayedMsgReq *message,
14268 + ProtobufCAllocator *allocator);
14269 +/* Sr__NacmReloadReq methods */
14270 +void sr__nacm_reload_req__init
14271 + (Sr__NacmReloadReq *message);
14272 +size_t sr__nacm_reload_req__get_packed_size
14273 + (const Sr__NacmReloadReq *message);
14274 +size_t sr__nacm_reload_req__pack
14275 + (const Sr__NacmReloadReq *message,
14276 + uint8_t *out);
14277 +size_t sr__nacm_reload_req__pack_to_buffer
14278 + (const Sr__NacmReloadReq *message,
14279 + ProtobufCBuffer *buffer);
14280 +Sr__NacmReloadReq *
14281 + sr__nacm_reload_req__unpack
14282 + (ProtobufCAllocator *allocator,
14283 + size_t len,
14284 + const uint8_t *data);
14285 +void sr__nacm_reload_req__free_unpacked
14286 + (Sr__NacmReloadReq *message,
14287 + ProtobufCAllocator *allocator);
14288 +/* Sr__Request methods */
14289 +void sr__request__init
14290 + (Sr__Request *message);
14291 +size_t sr__request__get_packed_size
14292 + (const Sr__Request *message);
14293 +size_t sr__request__pack
14294 + (const Sr__Request *message,
14295 + uint8_t *out);
14296 +size_t sr__request__pack_to_buffer
14297 + (const Sr__Request *message,
14298 + ProtobufCBuffer *buffer);
14299 +Sr__Request *
14300 + sr__request__unpack
14301 + (ProtobufCAllocator *allocator,
14302 + size_t len,
14303 + const uint8_t *data);
14304 +void sr__request__free_unpacked
14305 + (Sr__Request *message,
14306 + ProtobufCAllocator *allocator);
14307 +/* Sr__Response methods */
14308 +void sr__response__init
14309 + (Sr__Response *message);
14310 +size_t sr__response__get_packed_size
14311 + (const Sr__Response *message);
14312 +size_t sr__response__pack
14313 + (const Sr__Response *message,
14314 + uint8_t *out);
14315 +size_t sr__response__pack_to_buffer
14316 + (const Sr__Response *message,
14317 + ProtobufCBuffer *buffer);
14318 +Sr__Response *
14319 + sr__response__unpack
14320 + (ProtobufCAllocator *allocator,
14321 + size_t len,
14322 + const uint8_t *data);
14323 +void sr__response__free_unpacked
14324 + (Sr__Response *message,
14325 + ProtobufCAllocator *allocator);
14326 +/* Sr__Notification methods */
14327 +void sr__notification__init
14328 + (Sr__Notification *message);
14329 +size_t sr__notification__get_packed_size
14330 + (const Sr__Notification *message);
14331 +size_t sr__notification__pack
14332 + (const Sr__Notification *message,
14333 + uint8_t *out);
14334 +size_t sr__notification__pack_to_buffer
14335 + (const Sr__Notification *message,
14336 + ProtobufCBuffer *buffer);
14337 +Sr__Notification *
14338 + sr__notification__unpack
14339 + (ProtobufCAllocator *allocator,
14340 + size_t len,
14341 + const uint8_t *data);
14342 +void sr__notification__free_unpacked
14343 + (Sr__Notification *message,
14344 + ProtobufCAllocator *allocator);
14345 +/* Sr__NotificationAck methods */
14346 +void sr__notification_ack__init
14347 + (Sr__NotificationAck *message);
14348 +size_t sr__notification_ack__get_packed_size
14349 + (const Sr__NotificationAck *message);
14350 +size_t sr__notification_ack__pack
14351 + (const Sr__NotificationAck *message,
14352 + uint8_t *out);
14353 +size_t sr__notification_ack__pack_to_buffer
14354 + (const Sr__NotificationAck *message,
14355 + ProtobufCBuffer *buffer);
14356 +Sr__NotificationAck *
14357 + sr__notification_ack__unpack
14358 + (ProtobufCAllocator *allocator,
14359 + size_t len,
14360 + const uint8_t *data);
14361 +void sr__notification_ack__free_unpacked
14362 + (Sr__NotificationAck *message,
14363 + ProtobufCAllocator *allocator);
14364 +/* Sr__InternalRequest methods */
14365 +void sr__internal_request__init
14366 + (Sr__InternalRequest *message);
14367 +size_t sr__internal_request__get_packed_size
14368 + (const Sr__InternalRequest *message);
14369 +size_t sr__internal_request__pack
14370 + (const Sr__InternalRequest *message,
14371 + uint8_t *out);
14372 +size_t sr__internal_request__pack_to_buffer
14373 + (const Sr__InternalRequest *message,
14374 + ProtobufCBuffer *buffer);
14375 +Sr__InternalRequest *
14376 + sr__internal_request__unpack
14377 + (ProtobufCAllocator *allocator,
14378 + size_t len,
14379 + const uint8_t *data);
14380 +void sr__internal_request__free_unpacked
14381 + (Sr__InternalRequest *message,
14382 + ProtobufCAllocator *allocator);
14383 +/* Sr__Msg methods */
14384 +void sr__msg__init
14385 + (Sr__Msg *message);
14386 +size_t sr__msg__get_packed_size
14387 + (const Sr__Msg *message);
14388 +size_t sr__msg__pack
14389 + (const Sr__Msg *message,
14390 + uint8_t *out);
14391 +size_t sr__msg__pack_to_buffer
14392 + (const Sr__Msg *message,
14393 + ProtobufCBuffer *buffer);
14394 +Sr__Msg *
14395 + sr__msg__unpack
14396 + (ProtobufCAllocator *allocator,
14397 + size_t len,
14398 + const uint8_t *data);
14399 +void sr__msg__free_unpacked
14400 + (Sr__Msg *message,
14401 + ProtobufCAllocator *allocator);
14402 +/* --- per-message closures --- */
14403 +
14404 +typedef void (*Sr__Value_Closure)
14405 + (const Sr__Value *message,
14406 + void *closure_data);
14407 +typedef void (*Sr__Node_Closure)
14408 + (const Sr__Node *message,
14409 + void *closure_data);
14410 +typedef void (*Sr__Error_Closure)
14411 + (const Sr__Error *message,
14412 + void *closure_data);
14413 +typedef void (*Sr__SessionStartReq_Closure)
14414 + (const Sr__SessionStartReq *message,
14415 + void *closure_data);
14416 +typedef void (*Sr__SessionStartResp_Closure)
14417 + (const Sr__SessionStartResp *message,
14418 + void *closure_data);
14419 +typedef void (*Sr__SessionStopReq_Closure)
14420 + (const Sr__SessionStopReq *message,
14421 + void *closure_data);
14422 +typedef void (*Sr__SessionStopResp_Closure)
14423 + (const Sr__SessionStopResp *message,
14424 + void *closure_data);
14425 +typedef void (*Sr__SessionRefreshReq_Closure)
14426 + (const Sr__SessionRefreshReq *message,
14427 + void *closure_data);
14428 +typedef void (*Sr__SessionRefreshResp_Closure)
14429 + (const Sr__SessionRefreshResp *message,
14430 + void *closure_data);
14431 +typedef void (*Sr__SessionCheckReq_Closure)
14432 + (const Sr__SessionCheckReq *message,
14433 + void *closure_data);
14434 +typedef void (*Sr__SessionCheckResp_Closure)
14435 + (const Sr__SessionCheckResp *message,
14436 + void *closure_data);
14437 +typedef void (*Sr__SessionSwitchDsReq_Closure)
14438 + (const Sr__SessionSwitchDsReq *message,
14439 + void *closure_data);
14440 +typedef void (*Sr__SessionSwitchDsResp_Closure)
14441 + (const Sr__SessionSwitchDsResp *message,
14442 + void *closure_data);
14443 +typedef void (*Sr__SessionSetOptsReq_Closure)
14444 + (const Sr__SessionSetOptsReq *message,
14445 + void *closure_data);
14446 +typedef void (*Sr__SessionSetOptsResp_Closure)
14447 + (const Sr__SessionSetOptsResp *message,
14448 + void *closure_data);
14449 +typedef void (*Sr__VersionVerifyReq_Closure)
14450 + (const Sr__VersionVerifyReq *message,
14451 + void *closure_data);
14452 +typedef void (*Sr__VersionVerifyResp_Closure)
14453 + (const Sr__VersionVerifyResp *message,
14454 + void *closure_data);
14455 +typedef void (*Sr__SchemaRevision_Closure)
14456 + (const Sr__SchemaRevision *message,
14457 + void *closure_data);
14458 +typedef void (*Sr__SchemaSubmodule_Closure)
14459 + (const Sr__SchemaSubmodule *message,
14460 + void *closure_data);
14461 +typedef void (*Sr__Schema_Closure)
14462 + (const Sr__Schema *message,
14463 + void *closure_data);
14464 +typedef void (*Sr__ListSchemasReq_Closure)
14465 + (const Sr__ListSchemasReq *message,
14466 + void *closure_data);
14467 +typedef void (*Sr__ListSchemasResp_Closure)
14468 + (const Sr__ListSchemasResp *message,
14469 + void *closure_data);
14470 +typedef void (*Sr__GetSchemaReq_Closure)
14471 + (const Sr__GetSchemaReq *message,
14472 + void *closure_data);
14473 +typedef void (*Sr__GetSchemaResp_Closure)
14474 + (const Sr__GetSchemaResp *message,
14475 + void *closure_data);
14476 +typedef void (*Sr__GetItemReq_Closure)
14477 + (const Sr__GetItemReq *message,
14478 + void *closure_data);
14479 +typedef void (*Sr__GetItemResp_Closure)
14480 + (const Sr__GetItemResp *message,
14481 + void *closure_data);
14482 +typedef void (*Sr__GetItemsReq_Closure)
14483 + (const Sr__GetItemsReq *message,
14484 + void *closure_data);
14485 +typedef void (*Sr__GetItemsResp_Closure)
14486 + (const Sr__GetItemsResp *message,
14487 + void *closure_data);
14488 +typedef void (*Sr__GetSubtreeReq_Closure)
14489 + (const Sr__GetSubtreeReq *message,
14490 + void *closure_data);
14491 +typedef void (*Sr__GetSubtreeResp_Closure)
14492 + (const Sr__GetSubtreeResp *message,
14493 + void *closure_data);
14494 +typedef void (*Sr__GetSubtreesReq_Closure)
14495 + (const Sr__GetSubtreesReq *message,
14496 + void *closure_data);
14497 +typedef void (*Sr__GetSubtreesResp_Closure)
14498 + (const Sr__GetSubtreesResp *message,
14499 + void *closure_data);
14500 +typedef void (*Sr__GetSubtreeChunkReq_Closure)
14501 + (const Sr__GetSubtreeChunkReq *message,
14502 + void *closure_data);
14503 +typedef void (*Sr__GetSubtreeChunkResp_Closure)
14504 + (const Sr__GetSubtreeChunkResp *message,
14505 + void *closure_data);
14506 +typedef void (*Sr__SetItemReq_Closure)
14507 + (const Sr__SetItemReq *message,
14508 + void *closure_data);
14509 +typedef void (*Sr__SetItemResp_Closure)
14510 + (const Sr__SetItemResp *message,
14511 + void *closure_data);
14512 +typedef void (*Sr__SetItemStrReq_Closure)
14513 + (const Sr__SetItemStrReq *message,
14514 + void *closure_data);
14515 +typedef void (*Sr__SetItemStrResp_Closure)
14516 + (const Sr__SetItemStrResp *message,
14517 + void *closure_data);
14518 +typedef void (*Sr__DeleteItemReq_Closure)
14519 + (const Sr__DeleteItemReq *message,
14520 + void *closure_data);
14521 +typedef void (*Sr__DeleteItemResp_Closure)
14522 + (const Sr__DeleteItemResp *message,
14523 + void *closure_data);
14524 +typedef void (*Sr__MoveItemReq_Closure)
14525 + (const Sr__MoveItemReq *message,
14526 + void *closure_data);
14527 +typedef void (*Sr__MoveItemResp_Closure)
14528 + (const Sr__MoveItemResp *message,
14529 + void *closure_data);
14530 +typedef void (*Sr__ValidateReq_Closure)
14531 + (const Sr__ValidateReq *message,
14532 + void *closure_data);
14533 +typedef void (*Sr__ValidateResp_Closure)
14534 + (const Sr__ValidateResp *message,
14535 + void *closure_data);
14536 +typedef void (*Sr__CommitReq_Closure)
14537 + (const Sr__CommitReq *message,
14538 + void *closure_data);
14539 +typedef void (*Sr__CommitResp_Closure)
14540 + (const Sr__CommitResp *message,
14541 + void *closure_data);
14542 +typedef void (*Sr__DiscardChangesReq_Closure)
14543 + (const Sr__DiscardChangesReq *message,
14544 + void *closure_data);
14545 +typedef void (*Sr__DiscardChangesResp_Closure)
14546 + (const Sr__DiscardChangesResp *message,
14547 + void *closure_data);
14548 +typedef void (*Sr__CopyConfigReq_Closure)
14549 + (const Sr__CopyConfigReq *message,
14550 + void *closure_data);
14551 +typedef void (*Sr__CopyConfigResp_Closure)
14552 + (const Sr__CopyConfigResp *message,
14553 + void *closure_data);
14554 +typedef void (*Sr__LockReq_Closure)
14555 + (const Sr__LockReq *message,
14556 + void *closure_data);
14557 +typedef void (*Sr__LockResp_Closure)
14558 + (const Sr__LockResp *message,
14559 + void *closure_data);
14560 +typedef void (*Sr__UnlockReq_Closure)
14561 + (const Sr__UnlockReq *message,
14562 + void *closure_data);
14563 +typedef void (*Sr__UnlockResp_Closure)
14564 + (const Sr__UnlockResp *message,
14565 + void *closure_data);
14566 +typedef void (*Sr__SubscribeReq_Closure)
14567 + (const Sr__SubscribeReq *message,
14568 + void *closure_data);
14569 +typedef void (*Sr__SubscribeResp_Closure)
14570 + (const Sr__SubscribeResp *message,
14571 + void *closure_data);
14572 +typedef void (*Sr__UnsubscribeReq_Closure)
14573 + (const Sr__UnsubscribeReq *message,
14574 + void *closure_data);
14575 +typedef void (*Sr__UnsubscribeResp_Closure)
14576 + (const Sr__UnsubscribeResp *message,
14577 + void *closure_data);
14578 +typedef void (*Sr__CheckEnabledRunningReq_Closure)
14579 + (const Sr__CheckEnabledRunningReq *message,
14580 + void *closure_data);
14581 +typedef void (*Sr__CheckEnabledRunningResp_Closure)
14582 + (const Sr__CheckEnabledRunningResp *message,
14583 + void *closure_data);
14584 +typedef void (*Sr__ModuleInstallNotification_Closure)
14585 + (const Sr__ModuleInstallNotification *message,
14586 + void *closure_data);
14587 +typedef void (*Sr__FeatureEnableNotification_Closure)
14588 + (const Sr__FeatureEnableNotification *message,
14589 + void *closure_data);
14590 +typedef void (*Sr__ModuleChangeNotification_Closure)
14591 + (const Sr__ModuleChangeNotification *message,
14592 + void *closure_data);
14593 +typedef void (*Sr__SubtreeChangeNotification_Closure)
14594 + (const Sr__SubtreeChangeNotification *message,
14595 + void *closure_data);
14596 +typedef void (*Sr__Change_Closure)
14597 + (const Sr__Change *message,
14598 + void *closure_data);
14599 +typedef void (*Sr__GetChangesReq_Closure)
14600 + (const Sr__GetChangesReq *message,
14601 + void *closure_data);
14602 +typedef void (*Sr__GetChangesResp_Closure)
14603 + (const Sr__GetChangesResp *message,
14604 + void *closure_data);
14605 +typedef void (*Sr__CheckExecPermReq_Closure)
14606 + (const Sr__CheckExecPermReq *message,
14607 + void *closure_data);
14608 +typedef void (*Sr__CheckExecPermResp_Closure)
14609 + (const Sr__CheckExecPermResp *message,
14610 + void *closure_data);
14611 +typedef void (*Sr__RPCReq_Closure)
14612 + (const Sr__RPCReq *message,
14613 + void *closure_data);
14614 +typedef void (*Sr__RPCResp_Closure)
14615 + (const Sr__RPCResp *message,
14616 + void *closure_data);
14617 +typedef void (*Sr__EventNotifReq_Closure)
14618 + (const Sr__EventNotifReq *message,
14619 + void *closure_data);
14620 +typedef void (*Sr__EventNotifResp_Closure)
14621 + (const Sr__EventNotifResp *message,
14622 + void *closure_data);
14623 +typedef void (*Sr__EventNotifReplayReq_Closure)
14624 + (const Sr__EventNotifReplayReq *message,
14625 + void *closure_data);
14626 +typedef void (*Sr__EventNotifReplayResp_Closure)
14627 + (const Sr__EventNotifReplayResp *message,
14628 + void *closure_data);
14629 +typedef void (*Sr__DataProvideReq_Closure)
14630 + (const Sr__DataProvideReq *message,
14631 + void *closure_data);
14632 +typedef void (*Sr__DataProvideResp_Closure)
14633 + (const Sr__DataProvideResp *message,
14634 + void *closure_data);
14635 +typedef void (*Sr__ModuleInstallReq_Closure)
14636 + (const Sr__ModuleInstallReq *message,
14637 + void *closure_data);
14638 +typedef void (*Sr__ModuleInstallResp_Closure)
14639 + (const Sr__ModuleInstallResp *message,
14640 + void *closure_data);
14641 +typedef void (*Sr__FeatureEnableReq_Closure)
14642 + (const Sr__FeatureEnableReq *message,
14643 + void *closure_data);
14644 +typedef void (*Sr__FeatureEnableResp_Closure)
14645 + (const Sr__FeatureEnableResp *message,
14646 + void *closure_data);
14647 +typedef void (*Sr__UnsubscribeDestinationReq_Closure)
14648 + (const Sr__UnsubscribeDestinationReq *message,
14649 + void *closure_data);
14650 +typedef void (*Sr__CommitTimeoutReq_Closure)
14651 + (const Sr__CommitTimeoutReq *message,
14652 + void *closure_data);
14653 +typedef void (*Sr__OperDataTimeoutReq_Closure)
14654 + (const Sr__OperDataTimeoutReq *message,
14655 + void *closure_data);
14656 +typedef void (*Sr__InternalStateDataReq_Closure)
14657 + (const Sr__InternalStateDataReq *message,
14658 + void *closure_data);
14659 +typedef void (*Sr__NotifStoreCleanupReq_Closure)
14660 + (const Sr__NotifStoreCleanupReq *message,
14661 + void *closure_data);
14662 +typedef void (*Sr__DelayedMsgReq_Closure)
14663 + (const Sr__DelayedMsgReq *message,
14664 + void *closure_data);
14665 +typedef void (*Sr__NacmReloadReq_Closure)
14666 + (const Sr__NacmReloadReq *message,
14667 + void *closure_data);
14668 +typedef void (*Sr__Request_Closure)
14669 + (const Sr__Request *message,
14670 + void *closure_data);
14671 +typedef void (*Sr__Response_Closure)
14672 + (const Sr__Response *message,
14673 + void *closure_data);
14674 +typedef void (*Sr__Notification_Closure)
14675 + (const Sr__Notification *message,
14676 + void *closure_data);
14677 +typedef void (*Sr__NotificationAck_Closure)
14678 + (const Sr__NotificationAck *message,
14679 + void *closure_data);
14680 +typedef void (*Sr__InternalRequest_Closure)
14681 + (const Sr__InternalRequest *message,
14682 + void *closure_data);
14683 +typedef void (*Sr__Msg_Closure)
14684 + (const Sr__Msg *message,
14685 + void *closure_data);
14686 +
14687 +/* --- services --- */
14688 +
14689 +
14690 +/* --- descriptors --- */
14691 +
14692 +extern const ProtobufCEnumDescriptor sr__api_variant__descriptor;
14693 +extern const ProtobufCEnumDescriptor sr__data_store__descriptor;
14694 +extern const ProtobufCEnumDescriptor sr__session_flags__descriptor;
14695 +extern const ProtobufCEnumDescriptor sr__edit_flags__descriptor;
14696 +extern const ProtobufCEnumDescriptor sr__subscription_type__descriptor;
14697 +extern const ProtobufCEnumDescriptor sr__notification_event__descriptor;
14698 +extern const ProtobufCEnumDescriptor sr__module_state__descriptor;
14699 +extern const ProtobufCEnumDescriptor sr__change_operation__descriptor;
14700 +extern const ProtobufCEnumDescriptor sr__operation__descriptor;
14701 +extern const ProtobufCMessageDescriptor sr__value__descriptor;
14702 +extern const ProtobufCEnumDescriptor sr__value__types__descriptor;
14703 +extern const ProtobufCMessageDescriptor sr__node__descriptor;
14704 +extern const ProtobufCMessageDescriptor sr__error__descriptor;
14705 +extern const ProtobufCMessageDescriptor sr__session_start_req__descriptor;
14706 +extern const ProtobufCMessageDescriptor sr__session_start_resp__descriptor;
14707 +extern const ProtobufCMessageDescriptor sr__session_stop_req__descriptor;
14708 +extern const ProtobufCMessageDescriptor sr__session_stop_resp__descriptor;
14709 +extern const ProtobufCMessageDescriptor sr__session_refresh_req__descriptor;
14710 +extern const ProtobufCMessageDescriptor sr__session_refresh_resp__descriptor;
14711 +extern const ProtobufCMessageDescriptor sr__session_check_req__descriptor;
14712 +extern const ProtobufCMessageDescriptor sr__session_check_resp__descriptor;
14713 +extern const ProtobufCMessageDescriptor sr__session_switch_ds_req__descriptor;
14714 +extern const ProtobufCMessageDescriptor sr__session_switch_ds_resp__descriptor;
14715 +extern const ProtobufCMessageDescriptor sr__session_set_opts_req__descriptor;
14716 +extern const ProtobufCMessageDescriptor sr__session_set_opts_resp__descriptor;
14717 +extern const ProtobufCMessageDescriptor sr__version_verify_req__descriptor;
14718 +extern const ProtobufCMessageDescriptor sr__version_verify_resp__descriptor;
14719 +extern const ProtobufCMessageDescriptor sr__schema_revision__descriptor;
14720 +extern const ProtobufCMessageDescriptor sr__schema_submodule__descriptor;
14721 +extern const ProtobufCMessageDescriptor sr__schema__descriptor;
14722 +extern const ProtobufCMessageDescriptor sr__list_schemas_req__descriptor;
14723 +extern const ProtobufCMessageDescriptor sr__list_schemas_resp__descriptor;
14724 +extern const ProtobufCMessageDescriptor sr__get_schema_req__descriptor;
14725 +extern const ProtobufCMessageDescriptor sr__get_schema_resp__descriptor;
14726 +extern const ProtobufCMessageDescriptor sr__get_item_req__descriptor;
14727 +extern const ProtobufCMessageDescriptor sr__get_item_resp__descriptor;
14728 +extern const ProtobufCMessageDescriptor sr__get_items_req__descriptor;
14729 +extern const ProtobufCMessageDescriptor sr__get_items_resp__descriptor;
14730 +extern const ProtobufCMessageDescriptor sr__get_subtree_req__descriptor;
14731 +extern const ProtobufCMessageDescriptor sr__get_subtree_resp__descriptor;
14732 +extern const ProtobufCMessageDescriptor sr__get_subtrees_req__descriptor;
14733 +extern const ProtobufCMessageDescriptor sr__get_subtrees_resp__descriptor;
14734 +extern const ProtobufCMessageDescriptor sr__get_subtree_chunk_req__descriptor;
14735 +extern const ProtobufCMessageDescriptor sr__get_subtree_chunk_resp__descriptor;
14736 +extern const ProtobufCMessageDescriptor sr__set_item_req__descriptor;
14737 +extern const ProtobufCMessageDescriptor sr__set_item_resp__descriptor;
14738 +extern const ProtobufCMessageDescriptor sr__set_item_str_req__descriptor;
14739 +extern const ProtobufCMessageDescriptor sr__set_item_str_resp__descriptor;
14740 +extern const ProtobufCMessageDescriptor sr__delete_item_req__descriptor;
14741 +extern const ProtobufCMessageDescriptor sr__delete_item_resp__descriptor;
14742 +extern const ProtobufCMessageDescriptor sr__move_item_req__descriptor;
14743 +extern const ProtobufCEnumDescriptor sr__move_item_req__move_position__descriptor;
14744 +extern const ProtobufCMessageDescriptor sr__move_item_resp__descriptor;
14745 +extern const ProtobufCMessageDescriptor sr__validate_req__descriptor;
14746 +extern const ProtobufCMessageDescriptor sr__validate_resp__descriptor;
14747 +extern const ProtobufCMessageDescriptor sr__commit_req__descriptor;
14748 +extern const ProtobufCMessageDescriptor sr__commit_resp__descriptor;
14749 +extern const ProtobufCMessageDescriptor sr__discard_changes_req__descriptor;
14750 +extern const ProtobufCMessageDescriptor sr__discard_changes_resp__descriptor;
14751 +extern const ProtobufCMessageDescriptor sr__copy_config_req__descriptor;
14752 +extern const ProtobufCMessageDescriptor sr__copy_config_resp__descriptor;
14753 +extern const ProtobufCMessageDescriptor sr__lock_req__descriptor;
14754 +extern const ProtobufCMessageDescriptor sr__lock_resp__descriptor;
14755 +extern const ProtobufCMessageDescriptor sr__unlock_req__descriptor;
14756 +extern const ProtobufCMessageDescriptor sr__unlock_resp__descriptor;
14757 +extern const ProtobufCMessageDescriptor sr__subscribe_req__descriptor;
14758 +extern const ProtobufCMessageDescriptor sr__subscribe_resp__descriptor;
14759 +extern const ProtobufCMessageDescriptor sr__unsubscribe_req__descriptor;
14760 +extern const ProtobufCMessageDescriptor sr__unsubscribe_resp__descriptor;
14761 +extern const ProtobufCMessageDescriptor sr__check_enabled_running_req__descriptor;
14762 +extern const ProtobufCMessageDescriptor sr__check_enabled_running_resp__descriptor;
14763 +extern const ProtobufCMessageDescriptor sr__module_install_notification__descriptor;
14764 +extern const ProtobufCMessageDescriptor sr__feature_enable_notification__descriptor;
14765 +extern const ProtobufCMessageDescriptor sr__module_change_notification__descriptor;
14766 +extern const ProtobufCMessageDescriptor sr__subtree_change_notification__descriptor;
14767 +extern const ProtobufCMessageDescriptor sr__change__descriptor;
14768 +extern const ProtobufCMessageDescriptor sr__get_changes_req__descriptor;
14769 +extern const ProtobufCMessageDescriptor sr__get_changes_resp__descriptor;
14770 +extern const ProtobufCMessageDescriptor sr__check_exec_perm_req__descriptor;
14771 +extern const ProtobufCMessageDescriptor sr__check_exec_perm_resp__descriptor;
14772 +extern const ProtobufCMessageDescriptor sr__rpcreq__descriptor;
14773 +extern const ProtobufCMessageDescriptor sr__rpcresp__descriptor;
14774 +extern const ProtobufCMessageDescriptor sr__event_notif_req__descriptor;
14775 +extern const ProtobufCEnumDescriptor sr__event_notif_req__notif_type__descriptor;
14776 +extern const ProtobufCEnumDescriptor sr__event_notif_req__notif_flags__descriptor;
14777 +extern const ProtobufCMessageDescriptor sr__event_notif_resp__descriptor;
14778 +extern const ProtobufCMessageDescriptor sr__event_notif_replay_req__descriptor;
14779 +extern const ProtobufCMessageDescriptor sr__event_notif_replay_resp__descriptor;
14780 +extern const ProtobufCMessageDescriptor sr__data_provide_req__descriptor;
14781 +extern const ProtobufCMessageDescriptor sr__data_provide_resp__descriptor;
14782 +extern const ProtobufCMessageDescriptor sr__module_install_req__descriptor;
14783 +extern const ProtobufCMessageDescriptor sr__module_install_resp__descriptor;
14784 +extern const ProtobufCMessageDescriptor sr__feature_enable_req__descriptor;
14785 +extern const ProtobufCMessageDescriptor sr__feature_enable_resp__descriptor;
14786 +extern const ProtobufCMessageDescriptor sr__unsubscribe_destination_req__descriptor;
14787 +extern const ProtobufCMessageDescriptor sr__commit_timeout_req__descriptor;
14788 +extern const ProtobufCMessageDescriptor sr__oper_data_timeout_req__descriptor;
14789 +extern const ProtobufCMessageDescriptor sr__internal_state_data_req__descriptor;
14790 +extern const ProtobufCMessageDescriptor sr__notif_store_cleanup_req__descriptor;
14791 +extern const ProtobufCMessageDescriptor sr__delayed_msg_req__descriptor;
14792 +extern const ProtobufCMessageDescriptor sr__nacm_reload_req__descriptor;
14793 +extern const ProtobufCMessageDescriptor sr__request__descriptor;
14794 +extern const ProtobufCMessageDescriptor sr__response__descriptor;
14795 +extern const ProtobufCMessageDescriptor sr__notification__descriptor;
14796 +extern const ProtobufCMessageDescriptor sr__notification_ack__descriptor;
14797 +extern const ProtobufCMessageDescriptor sr__internal_request__descriptor;
14798 +extern const ProtobufCMessageDescriptor sr__msg__descriptor;
14799 +extern const ProtobufCEnumDescriptor sr__msg__msg_type__descriptor;
14800 +
14801 +PROTOBUF_C__END_DECLS
14802 +
14803 +
14804 +#endif /* PROTOBUF_C_sysrepo_2eproto__INCLUDED */
Mirror of packages feed