Skip to content
rachel/specter
File

Blob: spec/protocol/tunnel_vtproto.pb.go

go5892 lines
1// Code generated by protoc-gen-go-vtproto. DO NOT EDIT.
2// protoc-gen-go-vtproto version: v0.6.0
3// source: spec/proto/tunnel.proto
4 
5package protocol
6 
7import (
8	fmt "fmt"
9	protohelpers "github.com/planetscale/vtprotobuf/protohelpers"
10	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
11	io "io"
12)
13 
14const (
15	// Verify that this generated code is sufficiently up-to-date.
16	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
17	// Verify that runtime/protoimpl is sufficiently up-to-date.
18	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
19)
20 
21func (m *Link) MarshalVT() (dAtA []byte, err error) {
22	if m == nil {
23		return nil, nil
24	}
25	size := m.SizeVT()
26	dAtA = make([]byte, size)
27	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
28	if err != nil {
29		return nil, err
30	}
31	return dAtA[:n], nil
32}
33 
34func (m *Link) MarshalToVT(dAtA []byte) (int, error) {
35	size := m.SizeVT()
36	return m.MarshalToSizedBufferVT(dAtA[:size])
37}
38 
39func (m *Link) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
40	if m == nil {
41		return 0, nil
42	}
43	i := len(dAtA)
44	_ = i
45	var l int
46	_ = l
47	if m.unknownFields != nil {
48		i -= len(m.unknownFields)
49		copy(dAtA[i:], m.unknownFields)
50	}
51	if len(m.Remote) > 0 {
52		i -= len(m.Remote)
53		copy(dAtA[i:], m.Remote)
54		i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Remote)))
55		i--
56		dAtA[i] = 0x1a
57	}
58	if len(m.Hostname) > 0 {
59		i -= len(m.Hostname)
60		copy(dAtA[i:], m.Hostname)
61		i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Hostname)))
62		i--
63		dAtA[i] = 0x12
64	}
65	if m.Alpn != 0 {
66		i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Alpn))
67		i--
68		dAtA[i] = 0x8
69	}
70	return len(dAtA) - i, nil
71}
72 
73func (m *CustomHostname) MarshalVT() (dAtA []byte, err error) {
74	if m == nil {
75		return nil, nil
76	}
77	size := m.SizeVT()
78	dAtA = make([]byte, size)
79	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
80	if err != nil {
81		return nil, err
82	}
83	return dAtA[:n], nil
84}
85 
86func (m *CustomHostname) MarshalToVT(dAtA []byte) (int, error) {
87	size := m.SizeVT()
88	return m.MarshalToSizedBufferVT(dAtA[:size])
89}
90 
91func (m *CustomHostname) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
92	if m == nil {
93		return 0, nil
94	}
95	i := len(dAtA)
96	_ = i
97	var l int
98	_ = l
99	if m.unknownFields != nil {
100		i -= len(m.unknownFields)
101		copy(dAtA[i:], m.unknownFields)
102	}
103	if m.ClientToken != nil {
104		size, err := m.ClientToken.MarshalToSizedBufferVT(dAtA[:i])
105		if err != nil {
106			return 0, err
107		}
108		i -= size
109		i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
110		i--
111		dAtA[i] = 0x12
112	}
113	if m.ClientIdentity != nil {
114		size, err := m.ClientIdentity.MarshalToSizedBufferVT(dAtA[:i])
115		if err != nil {
116			return 0, err
117		}
118		i -= size
119		i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
120		i--
121		dAtA[i] = 0xa
122	}
123	return len(dAtA) - i, nil
124}
125 
126func (m *TunnelRoute) MarshalVT() (dAtA []byte, err error) {
127	if m == nil {
128		return nil, nil
129	}
130	size := m.SizeVT()
131	dAtA = make([]byte, size)
132	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
133	if err != nil {
134		return nil, err
135	}
136	return dAtA[:n], nil
137}
138 
139func (m *TunnelRoute) MarshalToVT(dAtA []byte) (int, error) {
140	size := m.SizeVT()
141	return m.MarshalToSizedBufferVT(dAtA[:size])
142}
143 
144func (m *TunnelRoute) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
145	if m == nil {
146		return 0, nil
147	}
148	i := len(dAtA)
149	_ = i
150	var l int
151	_ = l
152	if m.unknownFields != nil {
153		i -= len(m.unknownFields)
154		copy(dAtA[i:], m.unknownFields)
155	}
156	if len(m.Hostname) > 0 {
157		i -= len(m.Hostname)
158		copy(dAtA[i:], m.Hostname)
159		i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Hostname)))
160		i--
161		dAtA[i] = 0x52
162	}
163	if m.TunnelDestination != nil {
164		size, err := m.TunnelDestination.MarshalToSizedBufferVT(dAtA[:i])
165		if err != nil {
166			return 0, err
167		}
168		i -= size
169		i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
170		i--
171		dAtA[i] = 0x1a
172	}
173	if m.ChordDestination != nil {
174		size, err := m.ChordDestination.MarshalToSizedBufferVT(dAtA[:i])
175		if err != nil {
176			return 0, err
177		}
178		i -= size
179		i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
180		i--
181		dAtA[i] = 0x12
182	}
183	if m.ClientDestination != nil {
184		size, err := m.ClientDestination.MarshalToSizedBufferVT(dAtA[:i])
185		if err != nil {
186			return 0, err
187		}
188		i -= size
189		i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
190		i--
191		dAtA[i] = 0xa
192	}
193	return len(dAtA) - i, nil
194}
195 
196func (m *TunnelDestination) MarshalVT() (dAtA []byte, err error) {
197	if m == nil {
198		return nil, nil
199	}
200	size := m.SizeVT()
201	dAtA = make([]byte, size)
202	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
203	if err != nil {
204		return nil, err
205	}
206	return dAtA[:n], nil
207}
208 
209func (m *TunnelDestination) MarshalToVT(dAtA []byte) (int, error) {
210	size := m.SizeVT()
211	return m.MarshalToSizedBufferVT(dAtA[:size])
212}
213 
214func (m *TunnelDestination) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
215	if m == nil {
216		return 0, nil
217	}
218	i := len(dAtA)
219	_ = i
220	var l int
221	_ = l
222	if m.unknownFields != nil {
223		i -= len(m.unknownFields)
224		copy(dAtA[i:], m.unknownFields)
225	}
226	if m.Tunnel != nil {
227		size, err := m.Tunnel.MarshalToSizedBufferVT(dAtA[:i])
228		if err != nil {
229			return 0, err
230		}
231		i -= size
232		i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
233		i--
234		dAtA[i] = 0x12
235	}
236	if m.Chord != nil {
237		size, err := m.Chord.MarshalToSizedBufferVT(dAtA[:i])
238		if err != nil {
239			return 0, err
240		}
241		i -= size
242		i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
243		i--
244		dAtA[i] = 0xa
245	}
246	return len(dAtA) - i, nil
247}
248 
249func (m *TunnelStatus) MarshalVT() (dAtA []byte, err error) {
250	if m == nil {
251		return nil, nil
252	}
253	size := m.SizeVT()
254	dAtA = make([]byte, size)
255	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
256	if err != nil {
257		return nil, err
258	}
259	return dAtA[:n], nil
260}
261 
262func (m *TunnelStatus) MarshalToVT(dAtA []byte) (int, error) {
263	size := m.SizeVT()
264	return m.MarshalToSizedBufferVT(dAtA[:size])
265}
266 
267func (m *TunnelStatus) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
268	if m == nil {
269		return 0, nil
270	}
271	i := len(dAtA)
272	_ = i
273	var l int
274	_ = l
275	if m.unknownFields != nil {
276		i -= len(m.unknownFields)
277		copy(dAtA[i:], m.unknownFields)
278	}
279	if len(m.Error) > 0 {
280		i -= len(m.Error)
281		copy(dAtA[i:], m.Error)
282		i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Error)))
283		i--
284		dAtA[i] = 0x1a
285	}
286	if m.Status != 0 {
287		i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Status))
288		i--
289		dAtA[i] = 0x10
290	}
291	return len(dAtA) - i, nil
292}
293 
294func (m *ClientToken) MarshalVT() (dAtA []byte, err error) {
295	if m == nil {
296		return nil, nil
297	}
298	size := m.SizeVT()
299	dAtA = make([]byte, size)
300	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
301	if err != nil {
302		return nil, err
303	}
304	return dAtA[:n], nil
305}
306 
307func (m *ClientToken) MarshalToVT(dAtA []byte) (int, error) {
308	size := m.SizeVT()
309	return m.MarshalToSizedBufferVT(dAtA[:size])
310}
311 
312func (m *ClientToken) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
313	if m == nil {
314		return 0, nil
315	}
316	i := len(dAtA)
317	_ = i
318	var l int
319	_ = l
320	if m.unknownFields != nil {
321		i -= len(m.unknownFields)
322		copy(dAtA[i:], m.unknownFields)
323	}
324	if len(m.Token) > 0 {
325		i -= len(m.Token)
326		copy(dAtA[i:], m.Token)
327		i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Token)))
328		i--
329		dAtA[i] = 0xa
330	}
331	return len(dAtA) - i, nil
332}
333 
334func (m *ClientPingRequest) MarshalVT() (dAtA []byte, err error) {
335	if m == nil {
336		return nil, nil
337	}
338	size := m.SizeVT()
339	dAtA = make([]byte, size)
340	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
341	if err != nil {
342		return nil, err
343	}
344	return dAtA[:n], nil
345}
346 
347func (m *ClientPingRequest) MarshalToVT(dAtA []byte) (int, error) {
348	size := m.SizeVT()
349	return m.MarshalToSizedBufferVT(dAtA[:size])
350}
351 
352func (m *ClientPingRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
353	if m == nil {
354		return 0, nil
355	}
356	i := len(dAtA)
357	_ = i
358	var l int
359	_ = l
360	if m.unknownFields != nil {
361		i -= len(m.unknownFields)
362		copy(dAtA[i:], m.unknownFields)
363	}
364	return len(dAtA) - i, nil
365}
366 
367func (m *ClientPingResponse) MarshalVT() (dAtA []byte, err error) {
368	if m == nil {
369		return nil, nil
370	}
371	size := m.SizeVT()
372	dAtA = make([]byte, size)
373	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
374	if err != nil {
375		return nil, err
376	}
377	return dAtA[:n], nil
378}
379 
380func (m *ClientPingResponse) MarshalToVT(dAtA []byte) (int, error) {
381	size := m.SizeVT()
382	return m.MarshalToSizedBufferVT(dAtA[:size])
383}
384 
385func (m *ClientPingResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
386	if m == nil {
387		return 0, nil
388	}
389	i := len(dAtA)
390	_ = i
391	var l int
392	_ = l
393	if m.unknownFields != nil {
394		i -= len(m.unknownFields)
395		copy(dAtA[i:], m.unknownFields)
396	}
397	if len(m.Apex) > 0 {
398		i -= len(m.Apex)
399		copy(dAtA[i:], m.Apex)
400		i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Apex)))
401		i--
402		dAtA[i] = 0x12
403	}
404	if m.Node != nil {
405		size, err := m.Node.MarshalToSizedBufferVT(dAtA[:i])
406		if err != nil {
407			return 0, err
408		}
409		i -= size
410		i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
411		i--
412		dAtA[i] = 0xa
413	}
414	return len(dAtA) - i, nil
415}
416 
417func (m *RegisterIdentityRequest) MarshalVT() (dAtA []byte, err error) {
418	if m == nil {
419		return nil, nil
420	}
421	size := m.SizeVT()
422	dAtA = make([]byte, size)
423	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
424	if err != nil {
425		return nil, err
426	}
427	return dAtA[:n], nil
428}
429 
430func (m *RegisterIdentityRequest) MarshalToVT(dAtA []byte) (int, error) {
431	size := m.SizeVT()
432	return m.MarshalToSizedBufferVT(dAtA[:size])
433}
434 
435func (m *RegisterIdentityRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
436	if m == nil {
437		return 0, nil
438	}
439	i := len(dAtA)
440	_ = i
441	var l int
442	_ = l
443	if m.unknownFields != nil {
444		i -= len(m.unknownFields)
445		copy(dAtA[i:], m.unknownFields)
446	}
447	return len(dAtA) - i, nil
448}
449 
450func (m *RegisterIdentityResponse) MarshalVT() (dAtA []byte, err error) {
451	if m == nil {
452		return nil, nil
453	}
454	size := m.SizeVT()
455	dAtA = make([]byte, size)
456	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
457	if err != nil {
458		return nil, err
459	}
460	return dAtA[:n], nil
461}
462 
463func (m *RegisterIdentityResponse) MarshalToVT(dAtA []byte) (int, error) {
464	size := m.SizeVT()
465	return m.MarshalToSizedBufferVT(dAtA[:size])
466}
467 
468func (m *RegisterIdentityResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
469	if m == nil {
470		return 0, nil
471	}
472	i := len(dAtA)
473	_ = i
474	var l int
475	_ = l
476	if m.unknownFields != nil {
477		i -= len(m.unknownFields)
478		copy(dAtA[i:], m.unknownFields)
479	}
480	if len(m.Apex) > 0 {
481		i -= len(m.Apex)
482		copy(dAtA[i:], m.Apex)
483		i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Apex)))
484		i--
485		dAtA[i] = 0x12
486	}
487	return len(dAtA) - i, nil
488}
489 
490func (m *GetNodesRequest) MarshalVT() (dAtA []byte, err error) {
491	if m == nil {
492		return nil, nil
493	}
494	size := m.SizeVT()
495	dAtA = make([]byte, size)
496	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
497	if err != nil {
498		return nil, err
499	}
500	return dAtA[:n], nil
501}
502 
503func (m *GetNodesRequest) MarshalToVT(dAtA []byte) (int, error) {
504	size := m.SizeVT()
505	return m.MarshalToSizedBufferVT(dAtA[:size])
506}
507 
508func (m *GetNodesRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
509	if m == nil {
510		return 0, nil
511	}
512	i := len(dAtA)
513	_ = i
514	var l int
515	_ = l
516	if m.unknownFields != nil {
517		i -= len(m.unknownFields)
518		copy(dAtA[i:], m.unknownFields)
519	}
520	return len(dAtA) - i, nil
521}
522 
523func (m *GetNodesResponse) MarshalVT() (dAtA []byte, err error) {
524	if m == nil {
525		return nil, nil
526	}
527	size := m.SizeVT()
528	dAtA = make([]byte, size)
529	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
530	if err != nil {
531		return nil, err
532	}
533	return dAtA[:n], nil
534}
535 
536func (m *GetNodesResponse) MarshalToVT(dAtA []byte) (int, error) {
537	size := m.SizeVT()
538	return m.MarshalToSizedBufferVT(dAtA[:size])
539}
540 
541func (m *GetNodesResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
542	if m == nil {
543		return 0, nil
544	}
545	i := len(dAtA)
546	_ = i
547	var l int
548	_ = l
549	if m.unknownFields != nil {
550		i -= len(m.unknownFields)
551		copy(dAtA[i:], m.unknownFields)
552	}
553	if len(m.Nodes) > 0 {
554		for iNdEx := len(m.Nodes) - 1; iNdEx >= 0; iNdEx-- {
555			size, err := m.Nodes[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
556			if err != nil {
557				return 0, err
558			}
559			i -= size
560			i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
561			i--
562			dAtA[i] = 0xa
563		}
564	}
565	return len(dAtA) - i, nil
566}
567 
568func (m *GenerateHostnameRequest) MarshalVT() (dAtA []byte, err error) {
569	if m == nil {
570		return nil, nil
571	}
572	size := m.SizeVT()
573	dAtA = make([]byte, size)
574	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
575	if err != nil {
576		return nil, err
577	}
578	return dAtA[:n], nil
579}
580 
581func (m *GenerateHostnameRequest) MarshalToVT(dAtA []byte) (int, error) {
582	size := m.SizeVT()
583	return m.MarshalToSizedBufferVT(dAtA[:size])
584}
585 
586func (m *GenerateHostnameRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
587	if m == nil {
588		return 0, nil
589	}
590	i := len(dAtA)
591	_ = i
592	var l int
593	_ = l
594	if m.unknownFields != nil {
595		i -= len(m.unknownFields)
596		copy(dAtA[i:], m.unknownFields)
597	}
598	return len(dAtA) - i, nil
599}
600 
601func (m *GenerateHostnameResponse) MarshalVT() (dAtA []byte, err error) {
602	if m == nil {
603		return nil, nil
604	}
605	size := m.SizeVT()
606	dAtA = make([]byte, size)
607	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
608	if err != nil {
609		return nil, err
610	}
611	return dAtA[:n], nil
612}
613 
614func (m *GenerateHostnameResponse) MarshalToVT(dAtA []byte) (int, error) {
615	size := m.SizeVT()
616	return m.MarshalToSizedBufferVT(dAtA[:size])
617}
618 
619func (m *GenerateHostnameResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
620	if m == nil {
621		return 0, nil
622	}
623	i := len(dAtA)
624	_ = i
625	var l int
626	_ = l
627	if m.unknownFields != nil {
628		i -= len(m.unknownFields)
629		copy(dAtA[i:], m.unknownFields)
630	}
631	if len(m.Hostname) > 0 {
632		i -= len(m.Hostname)
633		copy(dAtA[i:], m.Hostname)
634		i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Hostname)))
635		i--
636		dAtA[i] = 0xa
637	}
638	return len(dAtA) - i, nil
639}
640 
641func (m *RegisteredHostnamesRequest) MarshalVT() (dAtA []byte, err error) {
642	if m == nil {
643		return nil, nil
644	}
645	size := m.SizeVT()
646	dAtA = make([]byte, size)
647	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
648	if err != nil {
649		return nil, err
650	}
651	return dAtA[:n], nil
652}
653 
654func (m *RegisteredHostnamesRequest) MarshalToVT(dAtA []byte) (int, error) {
655	size := m.SizeVT()
656	return m.MarshalToSizedBufferVT(dAtA[:size])
657}
658 
659func (m *RegisteredHostnamesRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
660	if m == nil {
661		return 0, nil
662	}
663	i := len(dAtA)
664	_ = i
665	var l int
666	_ = l
667	if m.unknownFields != nil {
668		i -= len(m.unknownFields)
669		copy(dAtA[i:], m.unknownFields)
670	}
671	return len(dAtA) - i, nil
672}
673 
674func (m *RegisteredHostnamesResponse) MarshalVT() (dAtA []byte, err error) {
675	if m == nil {
676		return nil, nil
677	}
678	size := m.SizeVT()
679	dAtA = make([]byte, size)
680	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
681	if err != nil {
682		return nil, err
683	}
684	return dAtA[:n], nil
685}
686 
687func (m *RegisteredHostnamesResponse) MarshalToVT(dAtA []byte) (int, error) {
688	size := m.SizeVT()
689	return m.MarshalToSizedBufferVT(dAtA[:size])
690}
691 
692func (m *RegisteredHostnamesResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
693	if m == nil {
694		return 0, nil
695	}
696	i := len(dAtA)
697	_ = i
698	var l int
699	_ = l
700	if m.unknownFields != nil {
701		i -= len(m.unknownFields)
702		copy(dAtA[i:], m.unknownFields)
703	}
704	if len(m.Hostnames) > 0 {
705		for iNdEx := len(m.Hostnames) - 1; iNdEx >= 0; iNdEx-- {
706			i -= len(m.Hostnames[iNdEx])
707			copy(dAtA[i:], m.Hostnames[iNdEx])
708			i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Hostnames[iNdEx])))
709			i--
710			dAtA[i] = 0xa
711		}
712	}
713	return len(dAtA) - i, nil
714}
715 
716func (m *PublishTunnelRequest) MarshalVT() (dAtA []byte, err error) {
717	if m == nil {
718		return nil, nil
719	}
720	size := m.SizeVT()
721	dAtA = make([]byte, size)
722	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
723	if err != nil {
724		return nil, err
725	}
726	return dAtA[:n], nil
727}
728 
729func (m *PublishTunnelRequest) MarshalToVT(dAtA []byte) (int, error) {
730	size := m.SizeVT()
731	return m.MarshalToSizedBufferVT(dAtA[:size])
732}
733 
734func (m *PublishTunnelRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
735	if m == nil {
736		return 0, nil
737	}
738	i := len(dAtA)
739	_ = i
740	var l int
741	_ = l
742	if m.unknownFields != nil {
743		i -= len(m.unknownFields)
744		copy(dAtA[i:], m.unknownFields)
745	}
746	if len(m.Servers) > 0 {
747		for iNdEx := len(m.Servers) - 1; iNdEx >= 0; iNdEx-- {
748			size, err := m.Servers[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
749			if err != nil {
750				return 0, err
751			}
752			i -= size
753			i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
754			i--
755			dAtA[i] = 0x12
756		}
757	}
758	if len(m.Hostname) > 0 {
759		i -= len(m.Hostname)
760		copy(dAtA[i:], m.Hostname)
761		i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Hostname)))
762		i--
763		dAtA[i] = 0xa
764	}
765	return len(dAtA) - i, nil
766}
767 
768func (m *PublishTunnelResponse) MarshalVT() (dAtA []byte, err error) {
769	if m == nil {
770		return nil, nil
771	}
772	size := m.SizeVT()
773	dAtA = make([]byte, size)
774	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
775	if err != nil {
776		return nil, err
777	}
778	return dAtA[:n], nil
779}
780 
781func (m *PublishTunnelResponse) MarshalToVT(dAtA []byte) (int, error) {
782	size := m.SizeVT()
783	return m.MarshalToSizedBufferVT(dAtA[:size])
784}
785 
786func (m *PublishTunnelResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
787	if m == nil {
788		return 0, nil
789	}
790	i := len(dAtA)
791	_ = i
792	var l int
793	_ = l
794	if m.unknownFields != nil {
795		i -= len(m.unknownFields)
796		copy(dAtA[i:], m.unknownFields)
797	}
798	if len(m.Published) > 0 {
799		for iNdEx := len(m.Published) - 1; iNdEx >= 0; iNdEx-- {
800			size, err := m.Published[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
801			if err != nil {
802				return 0, err
803			}
804			i -= size
805			i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
806			i--
807			dAtA[i] = 0xa
808		}
809	}
810	return len(dAtA) - i, nil
811}
812 
813func (m *UnpublishTunnelRequest) MarshalVT() (dAtA []byte, err error) {
814	if m == nil {
815		return nil, nil
816	}
817	size := m.SizeVT()
818	dAtA = make([]byte, size)
819	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
820	if err != nil {
821		return nil, err
822	}
823	return dAtA[:n], nil
824}
825 
826func (m *UnpublishTunnelRequest) MarshalToVT(dAtA []byte) (int, error) {
827	size := m.SizeVT()
828	return m.MarshalToSizedBufferVT(dAtA[:size])
829}
830 
831func (m *UnpublishTunnelRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
832	if m == nil {
833		return 0, nil
834	}
835	i := len(dAtA)
836	_ = i
837	var l int
838	_ = l
839	if m.unknownFields != nil {
840		i -= len(m.unknownFields)
841		copy(dAtA[i:], m.unknownFields)
842	}
843	if len(m.Hostname) > 0 {
844		i -= len(m.Hostname)
845		copy(dAtA[i:], m.Hostname)
846		i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Hostname)))
847		i--
848		dAtA[i] = 0xa
849	}
850	return len(dAtA) - i, nil
851}
852 
853func (m *UnpublishTunnelResponse) MarshalVT() (dAtA []byte, err error) {
854	if m == nil {
855		return nil, nil
856	}
857	size := m.SizeVT()
858	dAtA = make([]byte, size)
859	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
860	if err != nil {
861		return nil, err
862	}
863	return dAtA[:n], nil
864}
865 
866func (m *UnpublishTunnelResponse) MarshalToVT(dAtA []byte) (int, error) {
867	size := m.SizeVT()
868	return m.MarshalToSizedBufferVT(dAtA[:size])
869}
870 
871func (m *UnpublishTunnelResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
872	if m == nil {
873		return 0, nil
874	}
875	i := len(dAtA)
876	_ = i
877	var l int
878	_ = l
879	if m.unknownFields != nil {
880		i -= len(m.unknownFields)
881		copy(dAtA[i:], m.unknownFields)
882	}
883	return len(dAtA) - i, nil
884}
885 
886func (m *ReleaseTunnelRequest) MarshalVT() (dAtA []byte, err error) {
887	if m == nil {
888		return nil, nil
889	}
890	size := m.SizeVT()
891	dAtA = make([]byte, size)
892	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
893	if err != nil {
894		return nil, err
895	}
896	return dAtA[:n], nil
897}
898 
899func (m *ReleaseTunnelRequest) MarshalToVT(dAtA []byte) (int, error) {
900	size := m.SizeVT()
901	return m.MarshalToSizedBufferVT(dAtA[:size])
902}
903 
904func (m *ReleaseTunnelRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
905	if m == nil {
906		return 0, nil
907	}
908	i := len(dAtA)
909	_ = i
910	var l int
911	_ = l
912	if m.unknownFields != nil {
913		i -= len(m.unknownFields)
914		copy(dAtA[i:], m.unknownFields)
915	}
916	if len(m.Hostname) > 0 {
917		i -= len(m.Hostname)
918		copy(dAtA[i:], m.Hostname)
919		i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Hostname)))
920		i--
921		dAtA[i] = 0xa
922	}
923	return len(dAtA) - i, nil
924}
925 
926func (m *ReleaseTunnelResponse) MarshalVT() (dAtA []byte, err error) {
927	if m == nil {
928		return nil, nil
929	}
930	size := m.SizeVT()
931	dAtA = make([]byte, size)
932	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
933	if err != nil {
934		return nil, err
935	}
936	return dAtA[:n], nil
937}
938 
939func (m *ReleaseTunnelResponse) MarshalToVT(dAtA []byte) (int, error) {
940	size := m.SizeVT()
941	return m.MarshalToSizedBufferVT(dAtA[:size])
942}
943 
944func (m *ReleaseTunnelResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
945	if m == nil {
946		return 0, nil
947	}
948	i := len(dAtA)
949	_ = i
950	var l int
951	_ = l
952	if m.unknownFields != nil {
953		i -= len(m.unknownFields)
954		copy(dAtA[i:], m.unknownFields)
955	}
956	return len(dAtA) - i, nil
957}
958 
959func (m *InstructionRequest) MarshalVT() (dAtA []byte, err error) {
960	if m == nil {
961		return nil, nil
962	}
963	size := m.SizeVT()
964	dAtA = make([]byte, size)
965	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
966	if err != nil {
967		return nil, err
968	}
969	return dAtA[:n], nil
970}
971 
972func (m *InstructionRequest) MarshalToVT(dAtA []byte) (int, error) {
973	size := m.SizeVT()
974	return m.MarshalToSizedBufferVT(dAtA[:size])
975}
976 
977func (m *InstructionRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
978	if m == nil {
979		return 0, nil
980	}
981	i := len(dAtA)
982	_ = i
983	var l int
984	_ = l
985	if m.unknownFields != nil {
986		i -= len(m.unknownFields)
987		copy(dAtA[i:], m.unknownFields)
988	}
989	if len(m.Hostname) > 0 {
990		i -= len(m.Hostname)
991		copy(dAtA[i:], m.Hostname)
992		i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Hostname)))
993		i--
994		dAtA[i] = 0x12
995	}
996	if m.Proof != nil {
997		size, err := m.Proof.MarshalToSizedBufferVT(dAtA[:i])
998		if err != nil {
999			return 0, err
1000		}
1001		i -= size
1002		i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1003		i--
1004		dAtA[i] = 0xa
1005	}
1006	return len(dAtA) - i, nil
1007}
1008 
1009func (m *InstructionResponse) MarshalVT() (dAtA []byte, err error) {
1010	if m == nil {
1011		return nil, nil
1012	}
1013	size := m.SizeVT()
1014	dAtA = make([]byte, size)
1015	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
1016	if err != nil {
1017		return nil, err
1018	}
1019	return dAtA[:n], nil
1020}
1021 
1022func (m *InstructionResponse) MarshalToVT(dAtA []byte) (int, error) {
1023	size := m.SizeVT()
1024	return m.MarshalToSizedBufferVT(dAtA[:size])
1025}
1026 
1027func (m *InstructionResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
1028	if m == nil {
1029		return 0, nil
1030	}
1031	i := len(dAtA)
1032	_ = i
1033	var l int
1034	_ = l
1035	if m.unknownFields != nil {
1036		i -= len(m.unknownFields)
1037		copy(dAtA[i:], m.unknownFields)
1038	}
1039	if len(m.Content) > 0 {
1040		i -= len(m.Content)
1041		copy(dAtA[i:], m.Content)
1042		i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Content)))
1043		i--
1044		dAtA[i] = 0x12
1045	}
1046	if len(m.Name) > 0 {
1047		i -= len(m.Name)
1048		copy(dAtA[i:], m.Name)
1049		i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Name)))
1050		i--
1051		dAtA[i] = 0xa
1052	}
1053	return len(dAtA) - i, nil
1054}
1055 
1056func (m *ValidateRequest) MarshalVT() (dAtA []byte, err error) {
1057	if m == nil {
1058		return nil, nil
1059	}
1060	size := m.SizeVT()
1061	dAtA = make([]byte, size)
1062	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
1063	if err != nil {
1064		return nil, err
1065	}
1066	return dAtA[:n], nil
1067}
1068 
1069func (m *ValidateRequest) MarshalToVT(dAtA []byte) (int, error) {
1070	size := m.SizeVT()
1071	return m.MarshalToSizedBufferVT(dAtA[:size])
1072}
1073 
1074func (m *ValidateRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
1075	if m == nil {
1076		return 0, nil
1077	}
1078	i := len(dAtA)
1079	_ = i
1080	var l int
1081	_ = l
1082	if m.unknownFields != nil {
1083		i -= len(m.unknownFields)
1084		copy(dAtA[i:], m.unknownFields)
1085	}
1086	if len(m.Hostname) > 0 {
1087		i -= len(m.Hostname)
1088		copy(dAtA[i:], m.Hostname)
1089		i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Hostname)))
1090		i--
1091		dAtA[i] = 0x12
1092	}
1093	if m.Proof != nil {
1094		size, err := m.Proof.MarshalToSizedBufferVT(dAtA[:i])
1095		if err != nil {
1096			return 0, err
1097		}
1098		i -= size
1099		i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1100		i--
1101		dAtA[i] = 0xa
1102	}
1103	return len(dAtA) - i, nil
1104}
1105 
1106func (m *ValidateResponse) MarshalVT() (dAtA []byte, err error) {
1107	if m == nil {
1108		return nil, nil
1109	}
1110	size := m.SizeVT()
1111	dAtA = make([]byte, size)
1112	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
1113	if err != nil {
1114		return nil, err
1115	}
1116	return dAtA[:n], nil
1117}
1118 
1119func (m *ValidateResponse) MarshalToVT(dAtA []byte) (int, error) {
1120	size := m.SizeVT()
1121	return m.MarshalToSizedBufferVT(dAtA[:size])
1122}
1123 
1124func (m *ValidateResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
1125	if m == nil {
1126		return 0, nil
1127	}
1128	i := len(dAtA)
1129	_ = i
1130	var l int
1131	_ = l
1132	if m.unknownFields != nil {
1133		i -= len(m.unknownFields)
1134		copy(dAtA[i:], m.unknownFields)
1135	}
1136	if len(m.Apex) > 0 {
1137		i -= len(m.Apex)
1138		copy(dAtA[i:], m.Apex)
1139		i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Apex)))
1140		i--
1141		dAtA[i] = 0xa
1142	}
1143	return len(dAtA) - i, nil
1144}
1145 
1146func (m *DelegationRecord) MarshalVT() (dAtA []byte, err error) {
1147	if m == nil {
1148		return nil, nil
1149	}
1150	size := m.SizeVT()
1151	dAtA = make([]byte, size)
1152	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
1153	if err != nil {
1154		return nil, err
1155	}
1156	return dAtA[:n], nil
1157}
1158 
1159func (m *DelegationRecord) MarshalToVT(dAtA []byte) (int, error) {
1160	size := m.SizeVT()
1161	return m.MarshalToSizedBufferVT(dAtA[:size])
1162}
1163 
1164func (m *DelegationRecord) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
1165	if m == nil {
1166		return 0, nil
1167	}
1168	i := len(dAtA)
1169	_ = i
1170	var l int
1171	_ = l
1172	if m.unknownFields != nil {
1173		i -= len(m.unknownFields)
1174		copy(dAtA[i:], m.unknownFields)
1175	}
1176	if m.ExpiresAt != 0 {
1177		i = protohelpers.EncodeVarint(dAtA, i, uint64(m.ExpiresAt))
1178		i--
1179		dAtA[i] = 0x28
1180	}
1181	if len(m.Hostname) > 0 {
1182		i -= len(m.Hostname)
1183		copy(dAtA[i:], m.Hostname)
1184		i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Hostname)))
1185		i--
1186		dAtA[i] = 0x22
1187	}
1188	if m.Owner != nil {
1189		size, err := m.Owner.MarshalToSizedBufferVT(dAtA[:i])
1190		if err != nil {
1191			return 0, err
1192		}
1193		i -= size
1194		i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1195		i--
1196		dAtA[i] = 0x1a
1197	}
1198	if len(m.Id) > 0 {
1199		i -= len(m.Id)
1200		copy(dAtA[i:], m.Id)
1201		i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Id)))
1202		i--
1203		dAtA[i] = 0x12
1204	}
1205	if m.Version != 0 {
1206		i = protohelpers.EncodeVarint(dAtA, i, uint64(m.Version))
1207		i--
1208		dAtA[i] = 0x8
1209	}
1210	return len(dAtA) - i, nil
1211}
1212 
1213func (m *DelegationGrant) MarshalVT() (dAtA []byte, err error) {
1214	if m == nil {
1215		return nil, nil
1216	}
1217	size := m.SizeVT()
1218	dAtA = make([]byte, size)
1219	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
1220	if err != nil {
1221		return nil, err
1222	}
1223	return dAtA[:n], nil
1224}
1225 
1226func (m *DelegationGrant) MarshalToVT(dAtA []byte) (int, error) {
1227	size := m.SizeVT()
1228	return m.MarshalToSizedBufferVT(dAtA[:size])
1229}
1230 
1231func (m *DelegationGrant) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
1232	if m == nil {
1233		return 0, nil
1234	}
1235	i := len(dAtA)
1236	_ = i
1237	var l int
1238	_ = l
1239	if m.unknownFields != nil {
1240		i -= len(m.unknownFields)
1241		copy(dAtA[i:], m.unknownFields)
1242	}
1243	if m.Incomplete {
1244		i--
1245		if m.Incomplete {
1246			dAtA[i] = 1
1247		} else {
1248			dAtA[i] = 0
1249		}
1250		i--
1251		dAtA[i] = 0x20
1252	}
1253	if m.ExpiresAt != 0 {
1254		i = protohelpers.EncodeVarint(dAtA, i, uint64(m.ExpiresAt))
1255		i--
1256		dAtA[i] = 0x18
1257	}
1258	if len(m.Hostname) > 0 {
1259		i -= len(m.Hostname)
1260		copy(dAtA[i:], m.Hostname)
1261		i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Hostname)))
1262		i--
1263		dAtA[i] = 0x12
1264	}
1265	if len(m.Id) > 0 {
1266		i -= len(m.Id)
1267		copy(dAtA[i:], m.Id)
1268		i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Id)))
1269		i--
1270		dAtA[i] = 0xa
1271	}
1272	return len(dAtA) - i, nil
1273}
1274 
1275func (m *MintDelegationRequest) MarshalVT() (dAtA []byte, err error) {
1276	if m == nil {
1277		return nil, nil
1278	}
1279	size := m.SizeVT()
1280	dAtA = make([]byte, size)
1281	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
1282	if err != nil {
1283		return nil, err
1284	}
1285	return dAtA[:n], nil
1286}
1287 
1288func (m *MintDelegationRequest) MarshalToVT(dAtA []byte) (int, error) {
1289	size := m.SizeVT()
1290	return m.MarshalToSizedBufferVT(dAtA[:size])
1291}
1292 
1293func (m *MintDelegationRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
1294	if m == nil {
1295		return 0, nil
1296	}
1297	i := len(dAtA)
1298	_ = i
1299	var l int
1300	_ = l
1301	if m.unknownFields != nil {
1302		i -= len(m.unknownFields)
1303		copy(dAtA[i:], m.unknownFields)
1304	}
1305	if m.ExpiresAt != 0 {
1306		i = protohelpers.EncodeVarint(dAtA, i, uint64(m.ExpiresAt))
1307		i--
1308		dAtA[i] = 0x10
1309	}
1310	if len(m.Hostname) > 0 {
1311		i -= len(m.Hostname)
1312		copy(dAtA[i:], m.Hostname)
1313		i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Hostname)))
1314		i--
1315		dAtA[i] = 0xa
1316	}
1317	return len(dAtA) - i, nil
1318}
1319 
1320func (m *MintDelegationResponse) MarshalVT() (dAtA []byte, err error) {
1321	if m == nil {
1322		return nil, nil
1323	}
1324	size := m.SizeVT()
1325	dAtA = make([]byte, size)
1326	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
1327	if err != nil {
1328		return nil, err
1329	}
1330	return dAtA[:n], nil
1331}
1332 
1333func (m *MintDelegationResponse) MarshalToVT(dAtA []byte) (int, error) {
1334	size := m.SizeVT()
1335	return m.MarshalToSizedBufferVT(dAtA[:size])
1336}
1337 
1338func (m *MintDelegationResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
1339	if m == nil {
1340		return 0, nil
1341	}
1342	i := len(dAtA)
1343	_ = i
1344	var l int
1345	_ = l
1346	if m.unknownFields != nil {
1347		i -= len(m.unknownFields)
1348		copy(dAtA[i:], m.unknownFields)
1349	}
1350	if len(m.Token) > 0 {
1351		i -= len(m.Token)
1352		copy(dAtA[i:], m.Token)
1353		i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Token)))
1354		i--
1355		dAtA[i] = 0x12
1356	}
1357	if m.Grant != nil {
1358		size, err := m.Grant.MarshalToSizedBufferVT(dAtA[:i])
1359		if err != nil {
1360			return 0, err
1361		}
1362		i -= size
1363		i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1364		i--
1365		dAtA[i] = 0xa
1366	}
1367	return len(dAtA) - i, nil
1368}
1369 
1370func (m *ListDelegationsRequest) MarshalVT() (dAtA []byte, err error) {
1371	if m == nil {
1372		return nil, nil
1373	}
1374	size := m.SizeVT()
1375	dAtA = make([]byte, size)
1376	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
1377	if err != nil {
1378		return nil, err
1379	}
1380	return dAtA[:n], nil
1381}
1382 
1383func (m *ListDelegationsRequest) MarshalToVT(dAtA []byte) (int, error) {
1384	size := m.SizeVT()
1385	return m.MarshalToSizedBufferVT(dAtA[:size])
1386}
1387 
1388func (m *ListDelegationsRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
1389	if m == nil {
1390		return 0, nil
1391	}
1392	i := len(dAtA)
1393	_ = i
1394	var l int
1395	_ = l
1396	if m.unknownFields != nil {
1397		i -= len(m.unknownFields)
1398		copy(dAtA[i:], m.unknownFields)
1399	}
1400	return len(dAtA) - i, nil
1401}
1402 
1403func (m *ListDelegationsResponse) MarshalVT() (dAtA []byte, err error) {
1404	if m == nil {
1405		return nil, nil
1406	}
1407	size := m.SizeVT()
1408	dAtA = make([]byte, size)
1409	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
1410	if err != nil {
1411		return nil, err
1412	}
1413	return dAtA[:n], nil
1414}
1415 
1416func (m *ListDelegationsResponse) MarshalToVT(dAtA []byte) (int, error) {
1417	size := m.SizeVT()
1418	return m.MarshalToSizedBufferVT(dAtA[:size])
1419}
1420 
1421func (m *ListDelegationsResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
1422	if m == nil {
1423		return 0, nil
1424	}
1425	i := len(dAtA)
1426	_ = i
1427	var l int
1428	_ = l
1429	if m.unknownFields != nil {
1430		i -= len(m.unknownFields)
1431		copy(dAtA[i:], m.unknownFields)
1432	}
1433	if len(m.Grants) > 0 {
1434		for iNdEx := len(m.Grants) - 1; iNdEx >= 0; iNdEx-- {
1435			size, err := m.Grants[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
1436			if err != nil {
1437				return 0, err
1438			}
1439			i -= size
1440			i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1441			i--
1442			dAtA[i] = 0xa
1443		}
1444	}
1445	return len(dAtA) - i, nil
1446}
1447 
1448func (m *RevokeDelegationRequest) MarshalVT() (dAtA []byte, err error) {
1449	if m == nil {
1450		return nil, nil
1451	}
1452	size := m.SizeVT()
1453	dAtA = make([]byte, size)
1454	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
1455	if err != nil {
1456		return nil, err
1457	}
1458	return dAtA[:n], nil
1459}
1460 
1461func (m *RevokeDelegationRequest) MarshalToVT(dAtA []byte) (int, error) {
1462	size := m.SizeVT()
1463	return m.MarshalToSizedBufferVT(dAtA[:size])
1464}
1465 
1466func (m *RevokeDelegationRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
1467	if m == nil {
1468		return 0, nil
1469	}
1470	i := len(dAtA)
1471	_ = i
1472	var l int
1473	_ = l
1474	if m.unknownFields != nil {
1475		i -= len(m.unknownFields)
1476		copy(dAtA[i:], m.unknownFields)
1477	}
1478	if len(m.Id) > 0 {
1479		i -= len(m.Id)
1480		copy(dAtA[i:], m.Id)
1481		i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Id)))
1482		i--
1483		dAtA[i] = 0xa
1484	}
1485	return len(dAtA) - i, nil
1486}
1487 
1488func (m *RevokeDelegationResponse) MarshalVT() (dAtA []byte, err error) {
1489	if m == nil {
1490		return nil, nil
1491	}
1492	size := m.SizeVT()
1493	dAtA = make([]byte, size)
1494	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
1495	if err != nil {
1496		return nil, err
1497	}
1498	return dAtA[:n], nil
1499}
1500 
1501func (m *RevokeDelegationResponse) MarshalToVT(dAtA []byte) (int, error) {
1502	size := m.SizeVT()
1503	return m.MarshalToSizedBufferVT(dAtA[:size])
1504}
1505 
1506func (m *RevokeDelegationResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
1507	if m == nil {
1508		return 0, nil
1509	}
1510	i := len(dAtA)
1511	_ = i
1512	var l int
1513	_ = l
1514	if m.unknownFields != nil {
1515		i -= len(m.unknownFields)
1516		copy(dAtA[i:], m.unknownFields)
1517	}
1518	if len(m.IndexError) > 0 {
1519		i -= len(m.IndexError)
1520		copy(dAtA[i:], m.IndexError)
1521		i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.IndexError)))
1522		i--
1523		dAtA[i] = 0x12
1524	}
1525	if m.Revoked {
1526		i--
1527		if m.Revoked {
1528			dAtA[i] = 1
1529		} else {
1530			dAtA[i] = 0
1531		}
1532		i--
1533		dAtA[i] = 0x8
1534	}
1535	return len(dAtA) - i, nil
1536}
1537 
1538func (m *OpenEphemeralSessionRequest) MarshalVT() (dAtA []byte, err error) {
1539	if m == nil {
1540		return nil, nil
1541	}
1542	size := m.SizeVT()
1543	dAtA = make([]byte, size)
1544	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
1545	if err != nil {
1546		return nil, err
1547	}
1548	return dAtA[:n], nil
1549}
1550 
1551func (m *OpenEphemeralSessionRequest) MarshalToVT(dAtA []byte) (int, error) {
1552	size := m.SizeVT()
1553	return m.MarshalToSizedBufferVT(dAtA[:size])
1554}
1555 
1556func (m *OpenEphemeralSessionRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
1557	if m == nil {
1558		return 0, nil
1559	}
1560	i := len(dAtA)
1561	_ = i
1562	var l int
1563	_ = l
1564	if m.unknownFields != nil {
1565		i -= len(m.unknownFields)
1566		copy(dAtA[i:], m.unknownFields)
1567	}
1568	return len(dAtA) - i, nil
1569}
1570 
1571func (m *OpenDelegatedSessionRequest) MarshalVT() (dAtA []byte, err error) {
1572	if m == nil {
1573		return nil, nil
1574	}
1575	size := m.SizeVT()
1576	dAtA = make([]byte, size)
1577	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
1578	if err != nil {
1579		return nil, err
1580	}
1581	return dAtA[:n], nil
1582}
1583 
1584func (m *OpenDelegatedSessionRequest) MarshalToVT(dAtA []byte) (int, error) {
1585	size := m.SizeVT()
1586	return m.MarshalToSizedBufferVT(dAtA[:size])
1587}
1588 
1589func (m *OpenDelegatedSessionRequest) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
1590	if m == nil {
1591		return 0, nil
1592	}
1593	i := len(dAtA)
1594	_ = i
1595	var l int
1596	_ = l
1597	if m.unknownFields != nil {
1598		i -= len(m.unknownFields)
1599		copy(dAtA[i:], m.unknownFields)
1600	}
1601	if m.RouteSlot != 0 {
1602		i = protohelpers.EncodeVarint(dAtA, i, uint64(m.RouteSlot))
1603		i--
1604		dAtA[i] = 0x10
1605	}
1606	if len(m.Token) > 0 {
1607		i -= len(m.Token)
1608		copy(dAtA[i:], m.Token)
1609		i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Token)))
1610		i--
1611		dAtA[i] = 0xa
1612	}
1613	return len(dAtA) - i, nil
1614}
1615 
1616func (m *OpenSessionResponse) MarshalVT() (dAtA []byte, err error) {
1617	if m == nil {
1618		return nil, nil
1619	}
1620	size := m.SizeVT()
1621	dAtA = make([]byte, size)
1622	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
1623	if err != nil {
1624		return nil, err
1625	}
1626	return dAtA[:n], nil
1627}
1628 
1629func (m *OpenSessionResponse) MarshalToVT(dAtA []byte) (int, error) {
1630	size := m.SizeVT()
1631	return m.MarshalToSizedBufferVT(dAtA[:size])
1632}
1633 
1634func (m *OpenSessionResponse) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
1635	if m == nil {
1636		return 0, nil
1637	}
1638	i := len(dAtA)
1639	_ = i
1640	var l int
1641	_ = l
1642	if m.unknownFields != nil {
1643		i -= len(m.unknownFields)
1644		copy(dAtA[i:], m.unknownFields)
1645	}
1646	if m.Node != nil {
1647		size, err := m.Node.MarshalToSizedBufferVT(dAtA[:i])
1648		if err != nil {
1649			return 0, err
1650		}
1651		i -= size
1652		i = protohelpers.EncodeVarint(dAtA, i, uint64(size))
1653		i--
1654		dAtA[i] = 0x2a
1655	}
1656	if m.ExpiresAt != 0 {
1657		i = protohelpers.EncodeVarint(dAtA, i, uint64(m.ExpiresAt))
1658		i--
1659		dAtA[i] = 0x20
1660	}
1661	if len(m.GrantId) > 0 {
1662		i -= len(m.GrantId)
1663		copy(dAtA[i:], m.GrantId)
1664		i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.GrantId)))
1665		i--
1666		dAtA[i] = 0x1a
1667	}
1668	if len(m.Apex) > 0 {
1669		i -= len(m.Apex)
1670		copy(dAtA[i:], m.Apex)
1671		i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Apex)))
1672		i--
1673		dAtA[i] = 0x12
1674	}
1675	if len(m.Hostname) > 0 {
1676		i -= len(m.Hostname)
1677		copy(dAtA[i:], m.Hostname)
1678		i = protohelpers.EncodeVarint(dAtA, i, uint64(len(m.Hostname)))
1679		i--
1680		dAtA[i] = 0xa
1681	}
1682	return len(dAtA) - i, nil
1683}
1684 
1685func (m *Link) SizeVT() (n int) {
1686	if m == nil {
1687		return 0
1688	}
1689	var l int
1690	_ = l
1691	if m.Alpn != 0 {
1692		n += 1 + protohelpers.SizeOfVarint(uint64(m.Alpn))
1693	}
1694	l = len(m.Hostname)
1695	if l > 0 {
1696		n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1697	}
1698	l = len(m.Remote)
1699	if l > 0 {
1700		n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1701	}
1702	n += len(m.unknownFields)
1703	return n
1704}
1705 
1706func (m *CustomHostname) SizeVT() (n int) {
1707	if m == nil {
1708		return 0
1709	}
1710	var l int
1711	_ = l
1712	if m.ClientIdentity != nil {
1713		l = m.ClientIdentity.SizeVT()
1714		n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1715	}
1716	if m.ClientToken != nil {
1717		l = m.ClientToken.SizeVT()
1718		n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1719	}
1720	n += len(m.unknownFields)
1721	return n
1722}
1723 
1724func (m *TunnelRoute) SizeVT() (n int) {
1725	if m == nil {
1726		return 0
1727	}
1728	var l int
1729	_ = l
1730	if m.ClientDestination != nil {
1731		l = m.ClientDestination.SizeVT()
1732		n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1733	}
1734	if m.ChordDestination != nil {
1735		l = m.ChordDestination.SizeVT()
1736		n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1737	}
1738	if m.TunnelDestination != nil {
1739		l = m.TunnelDestination.SizeVT()
1740		n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1741	}
1742	l = len(m.Hostname)
1743	if l > 0 {
1744		n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1745	}
1746	n += len(m.unknownFields)
1747	return n
1748}
1749 
1750func (m *TunnelDestination) SizeVT() (n int) {
1751	if m == nil {
1752		return 0
1753	}
1754	var l int
1755	_ = l
1756	if m.Chord != nil {
1757		l = m.Chord.SizeVT()
1758		n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1759	}
1760	if m.Tunnel != nil {
1761		l = m.Tunnel.SizeVT()
1762		n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1763	}
1764	n += len(m.unknownFields)
1765	return n
1766}
1767 
1768func (m *TunnelStatus) SizeVT() (n int) {
1769	if m == nil {
1770		return 0
1771	}
1772	var l int
1773	_ = l
1774	if m.Status != 0 {
1775		n += 1 + protohelpers.SizeOfVarint(uint64(m.Status))
1776	}
1777	l = len(m.Error)
1778	if l > 0 {
1779		n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1780	}
1781	n += len(m.unknownFields)
1782	return n
1783}
1784 
1785func (m *ClientToken) SizeVT() (n int) {
1786	if m == nil {
1787		return 0
1788	}
1789	var l int
1790	_ = l
1791	l = len(m.Token)
1792	if l > 0 {
1793		n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1794	}
1795	n += len(m.unknownFields)
1796	return n
1797}
1798 
1799func (m *ClientPingRequest) SizeVT() (n int) {
1800	if m == nil {
1801		return 0
1802	}
1803	var l int
1804	_ = l
1805	n += len(m.unknownFields)
1806	return n
1807}
1808 
1809func (m *ClientPingResponse) SizeVT() (n int) {
1810	if m == nil {
1811		return 0
1812	}
1813	var l int
1814	_ = l
1815	if m.Node != nil {
1816		l = m.Node.SizeVT()
1817		n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1818	}
1819	l = len(m.Apex)
1820	if l > 0 {
1821		n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1822	}
1823	n += len(m.unknownFields)
1824	return n
1825}
1826 
1827func (m *RegisterIdentityRequest) SizeVT() (n int) {
1828	if m == nil {
1829		return 0
1830	}
1831	var l int
1832	_ = l
1833	n += len(m.unknownFields)
1834	return n
1835}
1836 
1837func (m *RegisterIdentityResponse) SizeVT() (n int) {
1838	if m == nil {
1839		return 0
1840	}
1841	var l int
1842	_ = l
1843	l = len(m.Apex)
1844	if l > 0 {
1845		n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1846	}
1847	n += len(m.unknownFields)
1848	return n
1849}
1850 
1851func (m *GetNodesRequest) SizeVT() (n int) {
1852	if m == nil {
1853		return 0
1854	}
1855	var l int
1856	_ = l
1857	n += len(m.unknownFields)
1858	return n
1859}
1860 
1861func (m *GetNodesResponse) SizeVT() (n int) {
1862	if m == nil {
1863		return 0
1864	}
1865	var l int
1866	_ = l
1867	if len(m.Nodes) > 0 {
1868		for _, e := range m.Nodes {
1869			l = e.SizeVT()
1870			n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1871		}
1872	}
1873	n += len(m.unknownFields)
1874	return n
1875}
1876 
1877func (m *GenerateHostnameRequest) SizeVT() (n int) {
1878	if m == nil {
1879		return 0
1880	}
1881	var l int
1882	_ = l
1883	n += len(m.unknownFields)
1884	return n
1885}
1886 
1887func (m *GenerateHostnameResponse) SizeVT() (n int) {
1888	if m == nil {
1889		return 0
1890	}
1891	var l int
1892	_ = l
1893	l = len(m.Hostname)
1894	if l > 0 {
1895		n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1896	}
1897	n += len(m.unknownFields)
1898	return n
1899}
1900 
1901func (m *RegisteredHostnamesRequest) SizeVT() (n int) {
1902	if m == nil {
1903		return 0
1904	}
1905	var l int
1906	_ = l
1907	n += len(m.unknownFields)
1908	return n
1909}
1910 
1911func (m *RegisteredHostnamesResponse) SizeVT() (n int) {
1912	if m == nil {
1913		return 0
1914	}
1915	var l int
1916	_ = l
1917	if len(m.Hostnames) > 0 {
1918		for _, s := range m.Hostnames {
1919			l = len(s)
1920			n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1921		}
1922	}
1923	n += len(m.unknownFields)
1924	return n
1925}
1926 
1927func (m *PublishTunnelRequest) SizeVT() (n int) {
1928	if m == nil {
1929		return 0
1930	}
1931	var l int
1932	_ = l
1933	l = len(m.Hostname)
1934	if l > 0 {
1935		n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1936	}
1937	if len(m.Servers) > 0 {
1938		for _, e := range m.Servers {
1939			l = e.SizeVT()
1940			n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1941		}
1942	}
1943	n += len(m.unknownFields)
1944	return n
1945}
1946 
1947func (m *PublishTunnelResponse) SizeVT() (n int) {
1948	if m == nil {
1949		return 0
1950	}
1951	var l int
1952	_ = l
1953	if len(m.Published) > 0 {
1954		for _, e := range m.Published {
1955			l = e.SizeVT()
1956			n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1957		}
1958	}
1959	n += len(m.unknownFields)
1960	return n
1961}
1962 
1963func (m *UnpublishTunnelRequest) SizeVT() (n int) {
1964	if m == nil {
1965		return 0
1966	}
1967	var l int
1968	_ = l
1969	l = len(m.Hostname)
1970	if l > 0 {
1971		n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1972	}
1973	n += len(m.unknownFields)
1974	return n
1975}
1976 
1977func (m *UnpublishTunnelResponse) SizeVT() (n int) {
1978	if m == nil {
1979		return 0
1980	}
1981	var l int
1982	_ = l
1983	n += len(m.unknownFields)
1984	return n
1985}
1986 
1987func (m *ReleaseTunnelRequest) SizeVT() (n int) {
1988	if m == nil {
1989		return 0
1990	}
1991	var l int
1992	_ = l
1993	l = len(m.Hostname)
1994	if l > 0 {
1995		n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
1996	}
1997	n += len(m.unknownFields)
1998	return n
1999}
2000 
2001func (m *ReleaseTunnelResponse) SizeVT() (n int) {
2002	if m == nil {
2003		return 0
2004	}
2005	var l int
2006	_ = l
2007	n += len(m.unknownFields)
2008	return n
2009}
2010 
2011func (m *InstructionRequest) SizeVT() (n int) {
2012	if m == nil {
2013		return 0
2014	}
2015	var l int
2016	_ = l
2017	if m.Proof != nil {
2018		l = m.Proof.SizeVT()
2019		n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2020	}
2021	l = len(m.Hostname)
2022	if l > 0 {
2023		n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2024	}
2025	n += len(m.unknownFields)
2026	return n
2027}
2028 
2029func (m *InstructionResponse) SizeVT() (n int) {
2030	if m == nil {
2031		return 0
2032	}
2033	var l int
2034	_ = l
2035	l = len(m.Name)
2036	if l > 0 {
2037		n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2038	}
2039	l = len(m.Content)
2040	if l > 0 {
2041		n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2042	}
2043	n += len(m.unknownFields)
2044	return n
2045}
2046 
2047func (m *ValidateRequest) SizeVT() (n int) {
2048	if m == nil {
2049		return 0
2050	}
2051	var l int
2052	_ = l
2053	if m.Proof != nil {
2054		l = m.Proof.SizeVT()
2055		n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2056	}
2057	l = len(m.Hostname)
2058	if l > 0 {
2059		n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2060	}
2061	n += len(m.unknownFields)
2062	return n
2063}
2064 
2065func (m *ValidateResponse) SizeVT() (n int) {
2066	if m == nil {
2067		return 0
2068	}
2069	var l int
2070	_ = l
2071	l = len(m.Apex)
2072	if l > 0 {
2073		n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2074	}
2075	n += len(m.unknownFields)
2076	return n
2077}
2078 
2079func (m *DelegationRecord) SizeVT() (n int) {
2080	if m == nil {
2081		return 0
2082	}
2083	var l int
2084	_ = l
2085	if m.Version != 0 {
2086		n += 1 + protohelpers.SizeOfVarint(uint64(m.Version))
2087	}
2088	l = len(m.Id)
2089	if l > 0 {
2090		n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2091	}
2092	if m.Owner != nil {
2093		l = m.Owner.SizeVT()
2094		n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2095	}
2096	l = len(m.Hostname)
2097	if l > 0 {
2098		n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2099	}
2100	if m.ExpiresAt != 0 {
2101		n += 1 + protohelpers.SizeOfVarint(uint64(m.ExpiresAt))
2102	}
2103	n += len(m.unknownFields)
2104	return n
2105}
2106 
2107func (m *DelegationGrant) SizeVT() (n int) {
2108	if m == nil {
2109		return 0
2110	}
2111	var l int
2112	_ = l
2113	l = len(m.Id)
2114	if l > 0 {
2115		n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2116	}
2117	l = len(m.Hostname)
2118	if l > 0 {
2119		n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2120	}
2121	if m.ExpiresAt != 0 {
2122		n += 1 + protohelpers.SizeOfVarint(uint64(m.ExpiresAt))
2123	}
2124	if m.Incomplete {
2125		n += 2
2126	}
2127	n += len(m.unknownFields)
2128	return n
2129}
2130 
2131func (m *MintDelegationRequest) SizeVT() (n int) {
2132	if m == nil {
2133		return 0
2134	}
2135	var l int
2136	_ = l
2137	l = len(m.Hostname)
2138	if l > 0 {
2139		n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2140	}
2141	if m.ExpiresAt != 0 {
2142		n += 1 + protohelpers.SizeOfVarint(uint64(m.ExpiresAt))
2143	}
2144	n += len(m.unknownFields)
2145	return n
2146}
2147 
2148func (m *MintDelegationResponse) SizeVT() (n int) {
2149	if m == nil {
2150		return 0
2151	}
2152	var l int
2153	_ = l
2154	if m.Grant != nil {
2155		l = m.Grant.SizeVT()
2156		n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2157	}
2158	l = len(m.Token)
2159	if l > 0 {
2160		n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2161	}
2162	n += len(m.unknownFields)
2163	return n
2164}
2165 
2166func (m *ListDelegationsRequest) SizeVT() (n int) {
2167	if m == nil {
2168		return 0
2169	}
2170	var l int
2171	_ = l
2172	n += len(m.unknownFields)
2173	return n
2174}
2175 
2176func (m *ListDelegationsResponse) SizeVT() (n int) {
2177	if m == nil {
2178		return 0
2179	}
2180	var l int
2181	_ = l
2182	if len(m.Grants) > 0 {
2183		for _, e := range m.Grants {
2184			l = e.SizeVT()
2185			n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2186		}
2187	}
2188	n += len(m.unknownFields)
2189	return n
2190}
2191 
2192func (m *RevokeDelegationRequest) SizeVT() (n int) {
2193	if m == nil {
2194		return 0
2195	}
2196	var l int
2197	_ = l
2198	l = len(m.Id)
2199	if l > 0 {
2200		n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2201	}
2202	n += len(m.unknownFields)
2203	return n
2204}
2205 
2206func (m *RevokeDelegationResponse) SizeVT() (n int) {
2207	if m == nil {
2208		return 0
2209	}
2210	var l int
2211	_ = l
2212	if m.Revoked {
2213		n += 2
2214	}
2215	l = len(m.IndexError)
2216	if l > 0 {
2217		n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2218	}
2219	n += len(m.unknownFields)
2220	return n
2221}
2222 
2223func (m *OpenEphemeralSessionRequest) SizeVT() (n int) {
2224	if m == nil {
2225		return 0
2226	}
2227	var l int
2228	_ = l
2229	n += len(m.unknownFields)
2230	return n
2231}
2232 
2233func (m *OpenDelegatedSessionRequest) SizeVT() (n int) {
2234	if m == nil {
2235		return 0
2236	}
2237	var l int
2238	_ = l
2239	l = len(m.Token)
2240	if l > 0 {
2241		n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2242	}
2243	if m.RouteSlot != 0 {
2244		n += 1 + protohelpers.SizeOfVarint(uint64(m.RouteSlot))
2245	}
2246	n += len(m.unknownFields)
2247	return n
2248}
2249 
2250func (m *OpenSessionResponse) SizeVT() (n int) {
2251	if m == nil {
2252		return 0
2253	}
2254	var l int
2255	_ = l
2256	l = len(m.Hostname)
2257	if l > 0 {
2258		n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2259	}
2260	l = len(m.Apex)
2261	if l > 0 {
2262		n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2263	}
2264	l = len(m.GrantId)
2265	if l > 0 {
2266		n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2267	}
2268	if m.ExpiresAt != 0 {
2269		n += 1 + protohelpers.SizeOfVarint(uint64(m.ExpiresAt))
2270	}
2271	if m.Node != nil {
2272		l = m.Node.SizeVT()
2273		n += 1 + l + protohelpers.SizeOfVarint(uint64(l))
2274	}
2275	n += len(m.unknownFields)
2276	return n
2277}
2278 
2279func (m *Link) UnmarshalVT(dAtA []byte) error {
2280	l := len(dAtA)
2281	iNdEx := 0
2282	for iNdEx < l {
2283		preIndex := iNdEx
2284		var wire uint64
2285		for shift := uint(0); ; shift += 7 {
2286			if shift >= 64 {
2287				return protohelpers.ErrIntOverflow
2288			}
2289			if iNdEx >= l {
2290				return io.ErrUnexpectedEOF
2291			}
2292			b := dAtA[iNdEx]
2293			iNdEx++
2294			wire |= uint64(b&0x7F) << shift
2295			if b < 0x80 {
2296				break
2297			}
2298		}
2299		fieldNum := int32(wire >> 3)
2300		wireType := int(wire & 0x7)
2301		if wireType == 4 {
2302			return fmt.Errorf("proto: Link: wiretype end group for non-group")
2303		}
2304		if fieldNum <= 0 {
2305			return fmt.Errorf("proto: Link: illegal tag %d (wire type %d)", fieldNum, wire)
2306		}
2307		switch fieldNum {
2308		case 1:
2309			if wireType != 0 {
2310				return fmt.Errorf("proto: wrong wireType = %d for field Alpn", wireType)
2311			}
2312			m.Alpn = 0
2313			for shift := uint(0); ; shift += 7 {
2314				if shift >= 64 {
2315					return protohelpers.ErrIntOverflow
2316				}
2317				if iNdEx >= l {
2318					return io.ErrUnexpectedEOF
2319				}
2320				b := dAtA[iNdEx]
2321				iNdEx++
2322				m.Alpn |= Link_ALPN(b&0x7F) << shift
2323				if b < 0x80 {
2324					break
2325				}
2326			}
2327		case 2:
2328			if wireType != 2 {
2329				return fmt.Errorf("proto: wrong wireType = %d for field Hostname", wireType)
2330			}
2331			var stringLen uint64
2332			for shift := uint(0); ; shift += 7 {
2333				if shift >= 64 {
2334					return protohelpers.ErrIntOverflow
2335				}
2336				if iNdEx >= l {
2337					return io.ErrUnexpectedEOF
2338				}
2339				b := dAtA[iNdEx]
2340				iNdEx++
2341				stringLen |= uint64(b&0x7F) << shift
2342				if b < 0x80 {
2343					break
2344				}
2345			}
2346			intStringLen := int(stringLen)
2347			if intStringLen < 0 {
2348				return protohelpers.ErrInvalidLength
2349			}
2350			postIndex := iNdEx + intStringLen
2351			if postIndex < 0 {
2352				return protohelpers.ErrInvalidLength
2353			}
2354			if postIndex > l {
2355				return io.ErrUnexpectedEOF
2356			}
2357			m.Hostname = string(dAtA[iNdEx:postIndex])
2358			iNdEx = postIndex
2359		case 3:
2360			if wireType != 2 {
2361				return fmt.Errorf("proto: wrong wireType = %d for field Remote", wireType)
2362			}
2363			var stringLen uint64
2364			for shift := uint(0); ; shift += 7 {
2365				if shift >= 64 {
2366					return protohelpers.ErrIntOverflow
2367				}
2368				if iNdEx >= l {
2369					return io.ErrUnexpectedEOF
2370				}
2371				b := dAtA[iNdEx]
2372				iNdEx++
2373				stringLen |= uint64(b&0x7F) << shift
2374				if b < 0x80 {
2375					break
2376				}
2377			}
2378			intStringLen := int(stringLen)
2379			if intStringLen < 0 {
2380				return protohelpers.ErrInvalidLength
2381			}
2382			postIndex := iNdEx + intStringLen
2383			if postIndex < 0 {
2384				return protohelpers.ErrInvalidLength
2385			}
2386			if postIndex > l {
2387				return io.ErrUnexpectedEOF
2388			}
2389			m.Remote = string(dAtA[iNdEx:postIndex])
2390			iNdEx = postIndex
2391		default:
2392			iNdEx = preIndex
2393			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
2394			if err != nil {
2395				return err
2396			}
2397			if (skippy < 0) || (iNdEx+skippy) < 0 {
2398				return protohelpers.ErrInvalidLength
2399			}
2400			if (iNdEx + skippy) > l {
2401				return io.ErrUnexpectedEOF
2402			}
2403			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
2404			iNdEx += skippy
2405		}
2406	}
2407 
2408	if iNdEx > l {
2409		return io.ErrUnexpectedEOF
2410	}
2411	return nil
2412}
2413func (m *CustomHostname) UnmarshalVT(dAtA []byte) error {
2414	l := len(dAtA)
2415	iNdEx := 0
2416	for iNdEx < l {
2417		preIndex := iNdEx
2418		var wire uint64
2419		for shift := uint(0); ; shift += 7 {
2420			if shift >= 64 {
2421				return protohelpers.ErrIntOverflow
2422			}
2423			if iNdEx >= l {
2424				return io.ErrUnexpectedEOF
2425			}
2426			b := dAtA[iNdEx]
2427			iNdEx++
2428			wire |= uint64(b&0x7F) << shift
2429			if b < 0x80 {
2430				break
2431			}
2432		}
2433		fieldNum := int32(wire >> 3)
2434		wireType := int(wire & 0x7)
2435		if wireType == 4 {
2436			return fmt.Errorf("proto: CustomHostname: wiretype end group for non-group")
2437		}
2438		if fieldNum <= 0 {
2439			return fmt.Errorf("proto: CustomHostname: illegal tag %d (wire type %d)", fieldNum, wire)
2440		}
2441		switch fieldNum {
2442		case 1:
2443			if wireType != 2 {
2444				return fmt.Errorf("proto: wrong wireType = %d for field ClientIdentity", wireType)
2445			}
2446			var msglen int
2447			for shift := uint(0); ; shift += 7 {
2448				if shift >= 64 {
2449					return protohelpers.ErrIntOverflow
2450				}
2451				if iNdEx >= l {
2452					return io.ErrUnexpectedEOF
2453				}
2454				b := dAtA[iNdEx]
2455				iNdEx++
2456				msglen |= int(b&0x7F) << shift
2457				if b < 0x80 {
2458					break
2459				}
2460			}
2461			if msglen < 0 {
2462				return protohelpers.ErrInvalidLength
2463			}
2464			postIndex := iNdEx + msglen
2465			if postIndex < 0 {
2466				return protohelpers.ErrInvalidLength
2467			}
2468			if postIndex > l {
2469				return io.ErrUnexpectedEOF
2470			}
2471			if m.ClientIdentity == nil {
2472				m.ClientIdentity = &Node{}
2473			}
2474			if err := m.ClientIdentity.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
2475				return err
2476			}
2477			iNdEx = postIndex
2478		case 2:
2479			if wireType != 2 {
2480				return fmt.Errorf("proto: wrong wireType = %d for field ClientToken", wireType)
2481			}
2482			var msglen int
2483			for shift := uint(0); ; shift += 7 {
2484				if shift >= 64 {
2485					return protohelpers.ErrIntOverflow
2486				}
2487				if iNdEx >= l {
2488					return io.ErrUnexpectedEOF
2489				}
2490				b := dAtA[iNdEx]
2491				iNdEx++
2492				msglen |= int(b&0x7F) << shift
2493				if b < 0x80 {
2494					break
2495				}
2496			}
2497			if msglen < 0 {
2498				return protohelpers.ErrInvalidLength
2499			}
2500			postIndex := iNdEx + msglen
2501			if postIndex < 0 {
2502				return protohelpers.ErrInvalidLength
2503			}
2504			if postIndex > l {
2505				return io.ErrUnexpectedEOF
2506			}
2507			if m.ClientToken == nil {
2508				m.ClientToken = &ClientToken{}
2509			}
2510			if err := m.ClientToken.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
2511				return err
2512			}
2513			iNdEx = postIndex
2514		default:
2515			iNdEx = preIndex
2516			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
2517			if err != nil {
2518				return err
2519			}
2520			if (skippy < 0) || (iNdEx+skippy) < 0 {
2521				return protohelpers.ErrInvalidLength
2522			}
2523			if (iNdEx + skippy) > l {
2524				return io.ErrUnexpectedEOF
2525			}
2526			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
2527			iNdEx += skippy
2528		}
2529	}
2530 
2531	if iNdEx > l {
2532		return io.ErrUnexpectedEOF
2533	}
2534	return nil
2535}
2536func (m *TunnelRoute) UnmarshalVT(dAtA []byte) error {
2537	l := len(dAtA)
2538	iNdEx := 0
2539	for iNdEx < l {
2540		preIndex := iNdEx
2541		var wire uint64
2542		for shift := uint(0); ; shift += 7 {
2543			if shift >= 64 {
2544				return protohelpers.ErrIntOverflow
2545			}
2546			if iNdEx >= l {
2547				return io.ErrUnexpectedEOF
2548			}
2549			b := dAtA[iNdEx]
2550			iNdEx++
2551			wire |= uint64(b&0x7F) << shift
2552			if b < 0x80 {
2553				break
2554			}
2555		}
2556		fieldNum := int32(wire >> 3)
2557		wireType := int(wire & 0x7)
2558		if wireType == 4 {
2559			return fmt.Errorf("proto: TunnelRoute: wiretype end group for non-group")
2560		}
2561		if fieldNum <= 0 {
2562			return fmt.Errorf("proto: TunnelRoute: illegal tag %d (wire type %d)", fieldNum, wire)
2563		}
2564		switch fieldNum {
2565		case 1:
2566			if wireType != 2 {
2567				return fmt.Errorf("proto: wrong wireType = %d for field ClientDestination", wireType)
2568			}
2569			var msglen int
2570			for shift := uint(0); ; shift += 7 {
2571				if shift >= 64 {
2572					return protohelpers.ErrIntOverflow
2573				}
2574				if iNdEx >= l {
2575					return io.ErrUnexpectedEOF
2576				}
2577				b := dAtA[iNdEx]
2578				iNdEx++
2579				msglen |= int(b&0x7F) << shift
2580				if b < 0x80 {
2581					break
2582				}
2583			}
2584			if msglen < 0 {
2585				return protohelpers.ErrInvalidLength
2586			}
2587			postIndex := iNdEx + msglen
2588			if postIndex < 0 {
2589				return protohelpers.ErrInvalidLength
2590			}
2591			if postIndex > l {
2592				return io.ErrUnexpectedEOF
2593			}
2594			if m.ClientDestination == nil {
2595				m.ClientDestination = &Node{}
2596			}
2597			if err := m.ClientDestination.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
2598				return err
2599			}
2600			iNdEx = postIndex
2601		case 2:
2602			if wireType != 2 {
2603				return fmt.Errorf("proto: wrong wireType = %d for field ChordDestination", wireType)
2604			}
2605			var msglen int
2606			for shift := uint(0); ; shift += 7 {
2607				if shift >= 64 {
2608					return protohelpers.ErrIntOverflow
2609				}
2610				if iNdEx >= l {
2611					return io.ErrUnexpectedEOF
2612				}
2613				b := dAtA[iNdEx]
2614				iNdEx++
2615				msglen |= int(b&0x7F) << shift
2616				if b < 0x80 {
2617					break
2618				}
2619			}
2620			if msglen < 0 {
2621				return protohelpers.ErrInvalidLength
2622			}
2623			postIndex := iNdEx + msglen
2624			if postIndex < 0 {
2625				return protohelpers.ErrInvalidLength
2626			}
2627			if postIndex > l {
2628				return io.ErrUnexpectedEOF
2629			}
2630			if m.ChordDestination == nil {
2631				m.ChordDestination = &Node{}
2632			}
2633			if err := m.ChordDestination.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
2634				return err
2635			}
2636			iNdEx = postIndex
2637		case 3:
2638			if wireType != 2 {
2639				return fmt.Errorf("proto: wrong wireType = %d for field TunnelDestination", wireType)
2640			}
2641			var msglen int
2642			for shift := uint(0); ; shift += 7 {
2643				if shift >= 64 {
2644					return protohelpers.ErrIntOverflow
2645				}
2646				if iNdEx >= l {
2647					return io.ErrUnexpectedEOF
2648				}
2649				b := dAtA[iNdEx]
2650				iNdEx++
2651				msglen |= int(b&0x7F) << shift
2652				if b < 0x80 {
2653					break
2654				}
2655			}
2656			if msglen < 0 {
2657				return protohelpers.ErrInvalidLength
2658			}
2659			postIndex := iNdEx + msglen
2660			if postIndex < 0 {
2661				return protohelpers.ErrInvalidLength
2662			}
2663			if postIndex > l {
2664				return io.ErrUnexpectedEOF
2665			}
2666			if m.TunnelDestination == nil {
2667				m.TunnelDestination = &Node{}
2668			}
2669			if err := m.TunnelDestination.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
2670				return err
2671			}
2672			iNdEx = postIndex
2673		case 10:
2674			if wireType != 2 {
2675				return fmt.Errorf("proto: wrong wireType = %d for field Hostname", wireType)
2676			}
2677			var stringLen uint64
2678			for shift := uint(0); ; shift += 7 {
2679				if shift >= 64 {
2680					return protohelpers.ErrIntOverflow
2681				}
2682				if iNdEx >= l {
2683					return io.ErrUnexpectedEOF
2684				}
2685				b := dAtA[iNdEx]
2686				iNdEx++
2687				stringLen |= uint64(b&0x7F) << shift
2688				if b < 0x80 {
2689					break
2690				}
2691			}
2692			intStringLen := int(stringLen)
2693			if intStringLen < 0 {
2694				return protohelpers.ErrInvalidLength
2695			}
2696			postIndex := iNdEx + intStringLen
2697			if postIndex < 0 {
2698				return protohelpers.ErrInvalidLength
2699			}
2700			if postIndex > l {
2701				return io.ErrUnexpectedEOF
2702			}
2703			m.Hostname = string(dAtA[iNdEx:postIndex])
2704			iNdEx = postIndex
2705		default:
2706			iNdEx = preIndex
2707			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
2708			if err != nil {
2709				return err
2710			}
2711			if (skippy < 0) || (iNdEx+skippy) < 0 {
2712				return protohelpers.ErrInvalidLength
2713			}
2714			if (iNdEx + skippy) > l {
2715				return io.ErrUnexpectedEOF
2716			}
2717			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
2718			iNdEx += skippy
2719		}
2720	}
2721 
2722	if iNdEx > l {
2723		return io.ErrUnexpectedEOF
2724	}
2725	return nil
2726}
2727func (m *TunnelDestination) UnmarshalVT(dAtA []byte) error {
2728	l := len(dAtA)
2729	iNdEx := 0
2730	for iNdEx < l {
2731		preIndex := iNdEx
2732		var wire uint64
2733		for shift := uint(0); ; shift += 7 {
2734			if shift >= 64 {
2735				return protohelpers.ErrIntOverflow
2736			}
2737			if iNdEx >= l {
2738				return io.ErrUnexpectedEOF
2739			}
2740			b := dAtA[iNdEx]
2741			iNdEx++
2742			wire |= uint64(b&0x7F) << shift
2743			if b < 0x80 {
2744				break
2745			}
2746		}
2747		fieldNum := int32(wire >> 3)
2748		wireType := int(wire & 0x7)
2749		if wireType == 4 {
2750			return fmt.Errorf("proto: TunnelDestination: wiretype end group for non-group")
2751		}
2752		if fieldNum <= 0 {
2753			return fmt.Errorf("proto: TunnelDestination: illegal tag %d (wire type %d)", fieldNum, wire)
2754		}
2755		switch fieldNum {
2756		case 1:
2757			if wireType != 2 {
2758				return fmt.Errorf("proto: wrong wireType = %d for field Chord", wireType)
2759			}
2760			var msglen int
2761			for shift := uint(0); ; shift += 7 {
2762				if shift >= 64 {
2763					return protohelpers.ErrIntOverflow
2764				}
2765				if iNdEx >= l {
2766					return io.ErrUnexpectedEOF
2767				}
2768				b := dAtA[iNdEx]
2769				iNdEx++
2770				msglen |= int(b&0x7F) << shift
2771				if b < 0x80 {
2772					break
2773				}
2774			}
2775			if msglen < 0 {
2776				return protohelpers.ErrInvalidLength
2777			}
2778			postIndex := iNdEx + msglen
2779			if postIndex < 0 {
2780				return protohelpers.ErrInvalidLength
2781			}
2782			if postIndex > l {
2783				return io.ErrUnexpectedEOF
2784			}
2785			if m.Chord == nil {
2786				m.Chord = &Node{}
2787			}
2788			if err := m.Chord.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
2789				return err
2790			}
2791			iNdEx = postIndex
2792		case 2:
2793			if wireType != 2 {
2794				return fmt.Errorf("proto: wrong wireType = %d for field Tunnel", wireType)
2795			}
2796			var msglen int
2797			for shift := uint(0); ; shift += 7 {
2798				if shift >= 64 {
2799					return protohelpers.ErrIntOverflow
2800				}
2801				if iNdEx >= l {
2802					return io.ErrUnexpectedEOF
2803				}
2804				b := dAtA[iNdEx]
2805				iNdEx++
2806				msglen |= int(b&0x7F) << shift
2807				if b < 0x80 {
2808					break
2809				}
2810			}
2811			if msglen < 0 {
2812				return protohelpers.ErrInvalidLength
2813			}
2814			postIndex := iNdEx + msglen
2815			if postIndex < 0 {
2816				return protohelpers.ErrInvalidLength
2817			}
2818			if postIndex > l {
2819				return io.ErrUnexpectedEOF
2820			}
2821			if m.Tunnel == nil {
2822				m.Tunnel = &Node{}
2823			}
2824			if err := m.Tunnel.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
2825				return err
2826			}
2827			iNdEx = postIndex
2828		default:
2829			iNdEx = preIndex
2830			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
2831			if err != nil {
2832				return err
2833			}
2834			if (skippy < 0) || (iNdEx+skippy) < 0 {
2835				return protohelpers.ErrInvalidLength
2836			}
2837			if (iNdEx + skippy) > l {
2838				return io.ErrUnexpectedEOF
2839			}
2840			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
2841			iNdEx += skippy
2842		}
2843	}
2844 
2845	if iNdEx > l {
2846		return io.ErrUnexpectedEOF
2847	}
2848	return nil
2849}
2850func (m *TunnelStatus) UnmarshalVT(dAtA []byte) error {
2851	l := len(dAtA)
2852	iNdEx := 0
2853	for iNdEx < l {
2854		preIndex := iNdEx
2855		var wire uint64
2856		for shift := uint(0); ; shift += 7 {
2857			if shift >= 64 {
2858				return protohelpers.ErrIntOverflow
2859			}
2860			if iNdEx >= l {
2861				return io.ErrUnexpectedEOF
2862			}
2863			b := dAtA[iNdEx]
2864			iNdEx++
2865			wire |= uint64(b&0x7F) << shift
2866			if b < 0x80 {
2867				break
2868			}
2869		}
2870		fieldNum := int32(wire >> 3)
2871		wireType := int(wire & 0x7)
2872		if wireType == 4 {
2873			return fmt.Errorf("proto: TunnelStatus: wiretype end group for non-group")
2874		}
2875		if fieldNum <= 0 {
2876			return fmt.Errorf("proto: TunnelStatus: illegal tag %d (wire type %d)", fieldNum, wire)
2877		}
2878		switch fieldNum {
2879		case 2:
2880			if wireType != 0 {
2881				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
2882			}
2883			m.Status = 0
2884			for shift := uint(0); ; shift += 7 {
2885				if shift >= 64 {
2886					return protohelpers.ErrIntOverflow
2887				}
2888				if iNdEx >= l {
2889					return io.ErrUnexpectedEOF
2890				}
2891				b := dAtA[iNdEx]
2892				iNdEx++
2893				m.Status |= TunnelStatusCode(b&0x7F) << shift
2894				if b < 0x80 {
2895					break
2896				}
2897			}
2898		case 3:
2899			if wireType != 2 {
2900				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
2901			}
2902			var stringLen uint64
2903			for shift := uint(0); ; shift += 7 {
2904				if shift >= 64 {
2905					return protohelpers.ErrIntOverflow
2906				}
2907				if iNdEx >= l {
2908					return io.ErrUnexpectedEOF
2909				}
2910				b := dAtA[iNdEx]
2911				iNdEx++
2912				stringLen |= uint64(b&0x7F) << shift
2913				if b < 0x80 {
2914					break
2915				}
2916			}
2917			intStringLen := int(stringLen)
2918			if intStringLen < 0 {
2919				return protohelpers.ErrInvalidLength
2920			}
2921			postIndex := iNdEx + intStringLen
2922			if postIndex < 0 {
2923				return protohelpers.ErrInvalidLength
2924			}
2925			if postIndex > l {
2926				return io.ErrUnexpectedEOF
2927			}
2928			m.Error = string(dAtA[iNdEx:postIndex])
2929			iNdEx = postIndex
2930		default:
2931			iNdEx = preIndex
2932			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
2933			if err != nil {
2934				return err
2935			}
2936			if (skippy < 0) || (iNdEx+skippy) < 0 {
2937				return protohelpers.ErrInvalidLength
2938			}
2939			if (iNdEx + skippy) > l {
2940				return io.ErrUnexpectedEOF
2941			}
2942			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
2943			iNdEx += skippy
2944		}
2945	}
2946 
2947	if iNdEx > l {
2948		return io.ErrUnexpectedEOF
2949	}
2950	return nil
2951}
2952func (m *ClientToken) UnmarshalVT(dAtA []byte) error {
2953	l := len(dAtA)
2954	iNdEx := 0
2955	for iNdEx < l {
2956		preIndex := iNdEx
2957		var wire uint64
2958		for shift := uint(0); ; shift += 7 {
2959			if shift >= 64 {
2960				return protohelpers.ErrIntOverflow
2961			}
2962			if iNdEx >= l {
2963				return io.ErrUnexpectedEOF
2964			}
2965			b := dAtA[iNdEx]
2966			iNdEx++
2967			wire |= uint64(b&0x7F) << shift
2968			if b < 0x80 {
2969				break
2970			}
2971		}
2972		fieldNum := int32(wire >> 3)
2973		wireType := int(wire & 0x7)
2974		if wireType == 4 {
2975			return fmt.Errorf("proto: ClientToken: wiretype end group for non-group")
2976		}
2977		if fieldNum <= 0 {
2978			return fmt.Errorf("proto: ClientToken: illegal tag %d (wire type %d)", fieldNum, wire)
2979		}
2980		switch fieldNum {
2981		case 1:
2982			if wireType != 2 {
2983				return fmt.Errorf("proto: wrong wireType = %d for field Token", wireType)
2984			}
2985			var byteLen int
2986			for shift := uint(0); ; shift += 7 {
2987				if shift >= 64 {
2988					return protohelpers.ErrIntOverflow
2989				}
2990				if iNdEx >= l {
2991					return io.ErrUnexpectedEOF
2992				}
2993				b := dAtA[iNdEx]
2994				iNdEx++
2995				byteLen |= int(b&0x7F) << shift
2996				if b < 0x80 {
2997					break
2998				}
2999			}
3000			if byteLen < 0 {
3001				return protohelpers.ErrInvalidLength
3002			}
3003			postIndex := iNdEx + byteLen
3004			if postIndex < 0 {
3005				return protohelpers.ErrInvalidLength
3006			}
3007			if postIndex > l {
3008				return io.ErrUnexpectedEOF
3009			}
3010			m.Token = append(m.Token[:0], dAtA[iNdEx:postIndex]...)
3011			if m.Token == nil {
3012				m.Token = []byte{}
3013			}
3014			iNdEx = postIndex
3015		default:
3016			iNdEx = preIndex
3017			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
3018			if err != nil {
3019				return err
3020			}
3021			if (skippy < 0) || (iNdEx+skippy) < 0 {
3022				return protohelpers.ErrInvalidLength
3023			}
3024			if (iNdEx + skippy) > l {
3025				return io.ErrUnexpectedEOF
3026			}
3027			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
3028			iNdEx += skippy
3029		}
3030	}
3031 
3032	if iNdEx > l {
3033		return io.ErrUnexpectedEOF
3034	}
3035	return nil
3036}
3037func (m *ClientPingRequest) UnmarshalVT(dAtA []byte) error {
3038	l := len(dAtA)
3039	iNdEx := 0
3040	for iNdEx < l {
3041		preIndex := iNdEx
3042		var wire uint64
3043		for shift := uint(0); ; shift += 7 {
3044			if shift >= 64 {
3045				return protohelpers.ErrIntOverflow
3046			}
3047			if iNdEx >= l {
3048				return io.ErrUnexpectedEOF
3049			}
3050			b := dAtA[iNdEx]
3051			iNdEx++
3052			wire |= uint64(b&0x7F) << shift
3053			if b < 0x80 {
3054				break
3055			}
3056		}
3057		fieldNum := int32(wire >> 3)
3058		wireType := int(wire & 0x7)
3059		if wireType == 4 {
3060			return fmt.Errorf("proto: ClientPingRequest: wiretype end group for non-group")
3061		}
3062		if fieldNum <= 0 {
3063			return fmt.Errorf("proto: ClientPingRequest: illegal tag %d (wire type %d)", fieldNum, wire)
3064		}
3065		switch fieldNum {
3066		default:
3067			iNdEx = preIndex
3068			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
3069			if err != nil {
3070				return err
3071			}
3072			if (skippy < 0) || (iNdEx+skippy) < 0 {
3073				return protohelpers.ErrInvalidLength
3074			}
3075			if (iNdEx + skippy) > l {
3076				return io.ErrUnexpectedEOF
3077			}
3078			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
3079			iNdEx += skippy
3080		}
3081	}
3082 
3083	if iNdEx > l {
3084		return io.ErrUnexpectedEOF
3085	}
3086	return nil
3087}
3088func (m *ClientPingResponse) UnmarshalVT(dAtA []byte) error {
3089	l := len(dAtA)
3090	iNdEx := 0
3091	for iNdEx < l {
3092		preIndex := iNdEx
3093		var wire uint64
3094		for shift := uint(0); ; shift += 7 {
3095			if shift >= 64 {
3096				return protohelpers.ErrIntOverflow
3097			}
3098			if iNdEx >= l {
3099				return io.ErrUnexpectedEOF
3100			}
3101			b := dAtA[iNdEx]
3102			iNdEx++
3103			wire |= uint64(b&0x7F) << shift
3104			if b < 0x80 {
3105				break
3106			}
3107		}
3108		fieldNum := int32(wire >> 3)
3109		wireType := int(wire & 0x7)
3110		if wireType == 4 {
3111			return fmt.Errorf("proto: ClientPingResponse: wiretype end group for non-group")
3112		}
3113		if fieldNum <= 0 {
3114			return fmt.Errorf("proto: ClientPingResponse: illegal tag %d (wire type %d)", fieldNum, wire)
3115		}
3116		switch fieldNum {
3117		case 1:
3118			if wireType != 2 {
3119				return fmt.Errorf("proto: wrong wireType = %d for field Node", wireType)
3120			}
3121			var msglen int
3122			for shift := uint(0); ; shift += 7 {
3123				if shift >= 64 {
3124					return protohelpers.ErrIntOverflow
3125				}
3126				if iNdEx >= l {
3127					return io.ErrUnexpectedEOF
3128				}
3129				b := dAtA[iNdEx]
3130				iNdEx++
3131				msglen |= int(b&0x7F) << shift
3132				if b < 0x80 {
3133					break
3134				}
3135			}
3136			if msglen < 0 {
3137				return protohelpers.ErrInvalidLength
3138			}
3139			postIndex := iNdEx + msglen
3140			if postIndex < 0 {
3141				return protohelpers.ErrInvalidLength
3142			}
3143			if postIndex > l {
3144				return io.ErrUnexpectedEOF
3145			}
3146			if m.Node == nil {
3147				m.Node = &Node{}
3148			}
3149			if err := m.Node.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
3150				return err
3151			}
3152			iNdEx = postIndex
3153		case 2:
3154			if wireType != 2 {
3155				return fmt.Errorf("proto: wrong wireType = %d for field Apex", wireType)
3156			}
3157			var stringLen uint64
3158			for shift := uint(0); ; shift += 7 {
3159				if shift >= 64 {
3160					return protohelpers.ErrIntOverflow
3161				}
3162				if iNdEx >= l {
3163					return io.ErrUnexpectedEOF
3164				}
3165				b := dAtA[iNdEx]
3166				iNdEx++
3167				stringLen |= uint64(b&0x7F) << shift
3168				if b < 0x80 {
3169					break
3170				}
3171			}
3172			intStringLen := int(stringLen)
3173			if intStringLen < 0 {
3174				return protohelpers.ErrInvalidLength
3175			}
3176			postIndex := iNdEx + intStringLen
3177			if postIndex < 0 {
3178				return protohelpers.ErrInvalidLength
3179			}
3180			if postIndex > l {
3181				return io.ErrUnexpectedEOF
3182			}
3183			m.Apex = string(dAtA[iNdEx:postIndex])
3184			iNdEx = postIndex
3185		default:
3186			iNdEx = preIndex
3187			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
3188			if err != nil {
3189				return err
3190			}
3191			if (skippy < 0) || (iNdEx+skippy) < 0 {
3192				return protohelpers.ErrInvalidLength
3193			}
3194			if (iNdEx + skippy) > l {
3195				return io.ErrUnexpectedEOF
3196			}
3197			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
3198			iNdEx += skippy
3199		}
3200	}
3201 
3202	if iNdEx > l {
3203		return io.ErrUnexpectedEOF
3204	}
3205	return nil
3206}
3207func (m *RegisterIdentityRequest) UnmarshalVT(dAtA []byte) error {
3208	l := len(dAtA)
3209	iNdEx := 0
3210	for iNdEx < l {
3211		preIndex := iNdEx
3212		var wire uint64
3213		for shift := uint(0); ; shift += 7 {
3214			if shift >= 64 {
3215				return protohelpers.ErrIntOverflow
3216			}
3217			if iNdEx >= l {
3218				return io.ErrUnexpectedEOF
3219			}
3220			b := dAtA[iNdEx]
3221			iNdEx++
3222			wire |= uint64(b&0x7F) << shift
3223			if b < 0x80 {
3224				break
3225			}
3226		}
3227		fieldNum := int32(wire >> 3)
3228		wireType := int(wire & 0x7)
3229		if wireType == 4 {
3230			return fmt.Errorf("proto: RegisterIdentityRequest: wiretype end group for non-group")
3231		}
3232		if fieldNum <= 0 {
3233			return fmt.Errorf("proto: RegisterIdentityRequest: illegal tag %d (wire type %d)", fieldNum, wire)
3234		}
3235		switch fieldNum {
3236		default:
3237			iNdEx = preIndex
3238			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
3239			if err != nil {
3240				return err
3241			}
3242			if (skippy < 0) || (iNdEx+skippy) < 0 {
3243				return protohelpers.ErrInvalidLength
3244			}
3245			if (iNdEx + skippy) > l {
3246				return io.ErrUnexpectedEOF
3247			}
3248			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
3249			iNdEx += skippy
3250		}
3251	}
3252 
3253	if iNdEx > l {
3254		return io.ErrUnexpectedEOF
3255	}
3256	return nil
3257}
3258func (m *RegisterIdentityResponse) UnmarshalVT(dAtA []byte) error {
3259	l := len(dAtA)
3260	iNdEx := 0
3261	for iNdEx < l {
3262		preIndex := iNdEx
3263		var wire uint64
3264		for shift := uint(0); ; shift += 7 {
3265			if shift >= 64 {
3266				return protohelpers.ErrIntOverflow
3267			}
3268			if iNdEx >= l {
3269				return io.ErrUnexpectedEOF
3270			}
3271			b := dAtA[iNdEx]
3272			iNdEx++
3273			wire |= uint64(b&0x7F) << shift
3274			if b < 0x80 {
3275				break
3276			}
3277		}
3278		fieldNum := int32(wire >> 3)
3279		wireType := int(wire & 0x7)
3280		if wireType == 4 {
3281			return fmt.Errorf("proto: RegisterIdentityResponse: wiretype end group for non-group")
3282		}
3283		if fieldNum <= 0 {
3284			return fmt.Errorf("proto: RegisterIdentityResponse: illegal tag %d (wire type %d)", fieldNum, wire)
3285		}
3286		switch fieldNum {
3287		case 2:
3288			if wireType != 2 {
3289				return fmt.Errorf("proto: wrong wireType = %d for field Apex", wireType)
3290			}
3291			var stringLen uint64
3292			for shift := uint(0); ; shift += 7 {
3293				if shift >= 64 {
3294					return protohelpers.ErrIntOverflow
3295				}
3296				if iNdEx >= l {
3297					return io.ErrUnexpectedEOF
3298				}
3299				b := dAtA[iNdEx]
3300				iNdEx++
3301				stringLen |= uint64(b&0x7F) << shift
3302				if b < 0x80 {
3303					break
3304				}
3305			}
3306			intStringLen := int(stringLen)
3307			if intStringLen < 0 {
3308				return protohelpers.ErrInvalidLength
3309			}
3310			postIndex := iNdEx + intStringLen
3311			if postIndex < 0 {
3312				return protohelpers.ErrInvalidLength
3313			}
3314			if postIndex > l {
3315				return io.ErrUnexpectedEOF
3316			}
3317			m.Apex = string(dAtA[iNdEx:postIndex])
3318			iNdEx = postIndex
3319		default:
3320			iNdEx = preIndex
3321			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
3322			if err != nil {
3323				return err
3324			}
3325			if (skippy < 0) || (iNdEx+skippy) < 0 {
3326				return protohelpers.ErrInvalidLength
3327			}
3328			if (iNdEx + skippy) > l {
3329				return io.ErrUnexpectedEOF
3330			}
3331			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
3332			iNdEx += skippy
3333		}
3334	}
3335 
3336	if iNdEx > l {
3337		return io.ErrUnexpectedEOF
3338	}
3339	return nil
3340}
3341func (m *GetNodesRequest) UnmarshalVT(dAtA []byte) error {
3342	l := len(dAtA)
3343	iNdEx := 0
3344	for iNdEx < l {
3345		preIndex := iNdEx
3346		var wire uint64
3347		for shift := uint(0); ; shift += 7 {
3348			if shift >= 64 {
3349				return protohelpers.ErrIntOverflow
3350			}
3351			if iNdEx >= l {
3352				return io.ErrUnexpectedEOF
3353			}
3354			b := dAtA[iNdEx]
3355			iNdEx++
3356			wire |= uint64(b&0x7F) << shift
3357			if b < 0x80 {
3358				break
3359			}
3360		}
3361		fieldNum := int32(wire >> 3)
3362		wireType := int(wire & 0x7)
3363		if wireType == 4 {
3364			return fmt.Errorf("proto: GetNodesRequest: wiretype end group for non-group")
3365		}
3366		if fieldNum <= 0 {
3367			return fmt.Errorf("proto: GetNodesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
3368		}
3369		switch fieldNum {
3370		default:
3371			iNdEx = preIndex
3372			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
3373			if err != nil {
3374				return err
3375			}
3376			if (skippy < 0) || (iNdEx+skippy) < 0 {
3377				return protohelpers.ErrInvalidLength
3378			}
3379			if (iNdEx + skippy) > l {
3380				return io.ErrUnexpectedEOF
3381			}
3382			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
3383			iNdEx += skippy
3384		}
3385	}
3386 
3387	if iNdEx > l {
3388		return io.ErrUnexpectedEOF
3389	}
3390	return nil
3391}
3392func (m *GetNodesResponse) UnmarshalVT(dAtA []byte) error {
3393	l := len(dAtA)
3394	iNdEx := 0
3395	for iNdEx < l {
3396		preIndex := iNdEx
3397		var wire uint64
3398		for shift := uint(0); ; shift += 7 {
3399			if shift >= 64 {
3400				return protohelpers.ErrIntOverflow
3401			}
3402			if iNdEx >= l {
3403				return io.ErrUnexpectedEOF
3404			}
3405			b := dAtA[iNdEx]
3406			iNdEx++
3407			wire |= uint64(b&0x7F) << shift
3408			if b < 0x80 {
3409				break
3410			}
3411		}
3412		fieldNum := int32(wire >> 3)
3413		wireType := int(wire & 0x7)
3414		if wireType == 4 {
3415			return fmt.Errorf("proto: GetNodesResponse: wiretype end group for non-group")
3416		}
3417		if fieldNum <= 0 {
3418			return fmt.Errorf("proto: GetNodesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
3419		}
3420		switch fieldNum {
3421		case 1:
3422			if wireType != 2 {
3423				return fmt.Errorf("proto: wrong wireType = %d for field Nodes", wireType)
3424			}
3425			var msglen int
3426			for shift := uint(0); ; shift += 7 {
3427				if shift >= 64 {
3428					return protohelpers.ErrIntOverflow
3429				}
3430				if iNdEx >= l {
3431					return io.ErrUnexpectedEOF
3432				}
3433				b := dAtA[iNdEx]
3434				iNdEx++
3435				msglen |= int(b&0x7F) << shift
3436				if b < 0x80 {
3437					break
3438				}
3439			}
3440			if msglen < 0 {
3441				return protohelpers.ErrInvalidLength
3442			}
3443			postIndex := iNdEx + msglen
3444			if postIndex < 0 {
3445				return protohelpers.ErrInvalidLength
3446			}
3447			if postIndex > l {
3448				return io.ErrUnexpectedEOF
3449			}
3450			m.Nodes = append(m.Nodes, &Node{})
3451			if err := m.Nodes[len(m.Nodes)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
3452				return err
3453			}
3454			iNdEx = postIndex
3455		default:
3456			iNdEx = preIndex
3457			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
3458			if err != nil {
3459				return err
3460			}
3461			if (skippy < 0) || (iNdEx+skippy) < 0 {
3462				return protohelpers.ErrInvalidLength
3463			}
3464			if (iNdEx + skippy) > l {
3465				return io.ErrUnexpectedEOF
3466			}
3467			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
3468			iNdEx += skippy
3469		}
3470	}
3471 
3472	if iNdEx > l {
3473		return io.ErrUnexpectedEOF
3474	}
3475	return nil
3476}
3477func (m *GenerateHostnameRequest) UnmarshalVT(dAtA []byte) error {
3478	l := len(dAtA)
3479	iNdEx := 0
3480	for iNdEx < l {
3481		preIndex := iNdEx
3482		var wire uint64
3483		for shift := uint(0); ; shift += 7 {
3484			if shift >= 64 {
3485				return protohelpers.ErrIntOverflow
3486			}
3487			if iNdEx >= l {
3488				return io.ErrUnexpectedEOF
3489			}
3490			b := dAtA[iNdEx]
3491			iNdEx++
3492			wire |= uint64(b&0x7F) << shift
3493			if b < 0x80 {
3494				break
3495			}
3496		}
3497		fieldNum := int32(wire >> 3)
3498		wireType := int(wire & 0x7)
3499		if wireType == 4 {
3500			return fmt.Errorf("proto: GenerateHostnameRequest: wiretype end group for non-group")
3501		}
3502		if fieldNum <= 0 {
3503			return fmt.Errorf("proto: GenerateHostnameRequest: illegal tag %d (wire type %d)", fieldNum, wire)
3504		}
3505		switch fieldNum {
3506		default:
3507			iNdEx = preIndex
3508			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
3509			if err != nil {
3510				return err
3511			}
3512			if (skippy < 0) || (iNdEx+skippy) < 0 {
3513				return protohelpers.ErrInvalidLength
3514			}
3515			if (iNdEx + skippy) > l {
3516				return io.ErrUnexpectedEOF
3517			}
3518			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
3519			iNdEx += skippy
3520		}
3521	}
3522 
3523	if iNdEx > l {
3524		return io.ErrUnexpectedEOF
3525	}
3526	return nil
3527}
3528func (m *GenerateHostnameResponse) UnmarshalVT(dAtA []byte) error {
3529	l := len(dAtA)
3530	iNdEx := 0
3531	for iNdEx < l {
3532		preIndex := iNdEx
3533		var wire uint64
3534		for shift := uint(0); ; shift += 7 {
3535			if shift >= 64 {
3536				return protohelpers.ErrIntOverflow
3537			}
3538			if iNdEx >= l {
3539				return io.ErrUnexpectedEOF
3540			}
3541			b := dAtA[iNdEx]
3542			iNdEx++
3543			wire |= uint64(b&0x7F) << shift
3544			if b < 0x80 {
3545				break
3546			}
3547		}
3548		fieldNum := int32(wire >> 3)
3549		wireType := int(wire & 0x7)
3550		if wireType == 4 {
3551			return fmt.Errorf("proto: GenerateHostnameResponse: wiretype end group for non-group")
3552		}
3553		if fieldNum <= 0 {
3554			return fmt.Errorf("proto: GenerateHostnameResponse: illegal tag %d (wire type %d)", fieldNum, wire)
3555		}
3556		switch fieldNum {
3557		case 1:
3558			if wireType != 2 {
3559				return fmt.Errorf("proto: wrong wireType = %d for field Hostname", wireType)
3560			}
3561			var stringLen uint64
3562			for shift := uint(0); ; shift += 7 {
3563				if shift >= 64 {
3564					return protohelpers.ErrIntOverflow
3565				}
3566				if iNdEx >= l {
3567					return io.ErrUnexpectedEOF
3568				}
3569				b := dAtA[iNdEx]
3570				iNdEx++
3571				stringLen |= uint64(b&0x7F) << shift
3572				if b < 0x80 {
3573					break
3574				}
3575			}
3576			intStringLen := int(stringLen)
3577			if intStringLen < 0 {
3578				return protohelpers.ErrInvalidLength
3579			}
3580			postIndex := iNdEx + intStringLen
3581			if postIndex < 0 {
3582				return protohelpers.ErrInvalidLength
3583			}
3584			if postIndex > l {
3585				return io.ErrUnexpectedEOF
3586			}
3587			m.Hostname = string(dAtA[iNdEx:postIndex])
3588			iNdEx = postIndex
3589		default:
3590			iNdEx = preIndex
3591			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
3592			if err != nil {
3593				return err
3594			}
3595			if (skippy < 0) || (iNdEx+skippy) < 0 {
3596				return protohelpers.ErrInvalidLength
3597			}
3598			if (iNdEx + skippy) > l {
3599				return io.ErrUnexpectedEOF
3600			}
3601			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
3602			iNdEx += skippy
3603		}
3604	}
3605 
3606	if iNdEx > l {
3607		return io.ErrUnexpectedEOF
3608	}
3609	return nil
3610}
3611func (m *RegisteredHostnamesRequest) UnmarshalVT(dAtA []byte) error {
3612	l := len(dAtA)
3613	iNdEx := 0
3614	for iNdEx < l {
3615		preIndex := iNdEx
3616		var wire uint64
3617		for shift := uint(0); ; shift += 7 {
3618			if shift >= 64 {
3619				return protohelpers.ErrIntOverflow
3620			}
3621			if iNdEx >= l {
3622				return io.ErrUnexpectedEOF
3623			}
3624			b := dAtA[iNdEx]
3625			iNdEx++
3626			wire |= uint64(b&0x7F) << shift
3627			if b < 0x80 {
3628				break
3629			}
3630		}
3631		fieldNum := int32(wire >> 3)
3632		wireType := int(wire & 0x7)
3633		if wireType == 4 {
3634			return fmt.Errorf("proto: RegisteredHostnamesRequest: wiretype end group for non-group")
3635		}
3636		if fieldNum <= 0 {
3637			return fmt.Errorf("proto: RegisteredHostnamesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
3638		}
3639		switch fieldNum {
3640		default:
3641			iNdEx = preIndex
3642			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
3643			if err != nil {
3644				return err
3645			}
3646			if (skippy < 0) || (iNdEx+skippy) < 0 {
3647				return protohelpers.ErrInvalidLength
3648			}
3649			if (iNdEx + skippy) > l {
3650				return io.ErrUnexpectedEOF
3651			}
3652			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
3653			iNdEx += skippy
3654		}
3655	}
3656 
3657	if iNdEx > l {
3658		return io.ErrUnexpectedEOF
3659	}
3660	return nil
3661}
3662func (m *RegisteredHostnamesResponse) UnmarshalVT(dAtA []byte) error {
3663	l := len(dAtA)
3664	iNdEx := 0
3665	for iNdEx < l {
3666		preIndex := iNdEx
3667		var wire uint64
3668		for shift := uint(0); ; shift += 7 {
3669			if shift >= 64 {
3670				return protohelpers.ErrIntOverflow
3671			}
3672			if iNdEx >= l {
3673				return io.ErrUnexpectedEOF
3674			}
3675			b := dAtA[iNdEx]
3676			iNdEx++
3677			wire |= uint64(b&0x7F) << shift
3678			if b < 0x80 {
3679				break
3680			}
3681		}
3682		fieldNum := int32(wire >> 3)
3683		wireType := int(wire & 0x7)
3684		if wireType == 4 {
3685			return fmt.Errorf("proto: RegisteredHostnamesResponse: wiretype end group for non-group")
3686		}
3687		if fieldNum <= 0 {
3688			return fmt.Errorf("proto: RegisteredHostnamesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
3689		}
3690		switch fieldNum {
3691		case 1:
3692			if wireType != 2 {
3693				return fmt.Errorf("proto: wrong wireType = %d for field Hostnames", wireType)
3694			}
3695			var stringLen uint64
3696			for shift := uint(0); ; shift += 7 {
3697				if shift >= 64 {
3698					return protohelpers.ErrIntOverflow
3699				}
3700				if iNdEx >= l {
3701					return io.ErrUnexpectedEOF
3702				}
3703				b := dAtA[iNdEx]
3704				iNdEx++
3705				stringLen |= uint64(b&0x7F) << shift
3706				if b < 0x80 {
3707					break
3708				}
3709			}
3710			intStringLen := int(stringLen)
3711			if intStringLen < 0 {
3712				return protohelpers.ErrInvalidLength
3713			}
3714			postIndex := iNdEx + intStringLen
3715			if postIndex < 0 {
3716				return protohelpers.ErrInvalidLength
3717			}
3718			if postIndex > l {
3719				return io.ErrUnexpectedEOF
3720			}
3721			m.Hostnames = append(m.Hostnames, string(dAtA[iNdEx:postIndex]))
3722			iNdEx = postIndex
3723		default:
3724			iNdEx = preIndex
3725			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
3726			if err != nil {
3727				return err
3728			}
3729			if (skippy < 0) || (iNdEx+skippy) < 0 {
3730				return protohelpers.ErrInvalidLength
3731			}
3732			if (iNdEx + skippy) > l {
3733				return io.ErrUnexpectedEOF
3734			}
3735			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
3736			iNdEx += skippy
3737		}
3738	}
3739 
3740	if iNdEx > l {
3741		return io.ErrUnexpectedEOF
3742	}
3743	return nil
3744}
3745func (m *PublishTunnelRequest) UnmarshalVT(dAtA []byte) error {
3746	l := len(dAtA)
3747	iNdEx := 0
3748	for iNdEx < l {
3749		preIndex := iNdEx
3750		var wire uint64
3751		for shift := uint(0); ; shift += 7 {
3752			if shift >= 64 {
3753				return protohelpers.ErrIntOverflow
3754			}
3755			if iNdEx >= l {
3756				return io.ErrUnexpectedEOF
3757			}
3758			b := dAtA[iNdEx]
3759			iNdEx++
3760			wire |= uint64(b&0x7F) << shift
3761			if b < 0x80 {
3762				break
3763			}
3764		}
3765		fieldNum := int32(wire >> 3)
3766		wireType := int(wire & 0x7)
3767		if wireType == 4 {
3768			return fmt.Errorf("proto: PublishTunnelRequest: wiretype end group for non-group")
3769		}
3770		if fieldNum <= 0 {
3771			return fmt.Errorf("proto: PublishTunnelRequest: illegal tag %d (wire type %d)", fieldNum, wire)
3772		}
3773		switch fieldNum {
3774		case 1:
3775			if wireType != 2 {
3776				return fmt.Errorf("proto: wrong wireType = %d for field Hostname", wireType)
3777			}
3778			var stringLen uint64
3779			for shift := uint(0); ; shift += 7 {
3780				if shift >= 64 {
3781					return protohelpers.ErrIntOverflow
3782				}
3783				if iNdEx >= l {
3784					return io.ErrUnexpectedEOF
3785				}
3786				b := dAtA[iNdEx]
3787				iNdEx++
3788				stringLen |= uint64(b&0x7F) << shift
3789				if b < 0x80 {
3790					break
3791				}
3792			}
3793			intStringLen := int(stringLen)
3794			if intStringLen < 0 {
3795				return protohelpers.ErrInvalidLength
3796			}
3797			postIndex := iNdEx + intStringLen
3798			if postIndex < 0 {
3799				return protohelpers.ErrInvalidLength
3800			}
3801			if postIndex > l {
3802				return io.ErrUnexpectedEOF
3803			}
3804			m.Hostname = string(dAtA[iNdEx:postIndex])
3805			iNdEx = postIndex
3806		case 2:
3807			if wireType != 2 {
3808				return fmt.Errorf("proto: wrong wireType = %d for field Servers", wireType)
3809			}
3810			var msglen int
3811			for shift := uint(0); ; shift += 7 {
3812				if shift >= 64 {
3813					return protohelpers.ErrIntOverflow
3814				}
3815				if iNdEx >= l {
3816					return io.ErrUnexpectedEOF
3817				}
3818				b := dAtA[iNdEx]
3819				iNdEx++
3820				msglen |= int(b&0x7F) << shift
3821				if b < 0x80 {
3822					break
3823				}
3824			}
3825			if msglen < 0 {
3826				return protohelpers.ErrInvalidLength
3827			}
3828			postIndex := iNdEx + msglen
3829			if postIndex < 0 {
3830				return protohelpers.ErrInvalidLength
3831			}
3832			if postIndex > l {
3833				return io.ErrUnexpectedEOF
3834			}
3835			m.Servers = append(m.Servers, &Node{})
3836			if err := m.Servers[len(m.Servers)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
3837				return err
3838			}
3839			iNdEx = postIndex
3840		default:
3841			iNdEx = preIndex
3842			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
3843			if err != nil {
3844				return err
3845			}
3846			if (skippy < 0) || (iNdEx+skippy) < 0 {
3847				return protohelpers.ErrInvalidLength
3848			}
3849			if (iNdEx + skippy) > l {
3850				return io.ErrUnexpectedEOF
3851			}
3852			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
3853			iNdEx += skippy
3854		}
3855	}
3856 
3857	if iNdEx > l {
3858		return io.ErrUnexpectedEOF
3859	}
3860	return nil
3861}
3862func (m *PublishTunnelResponse) UnmarshalVT(dAtA []byte) error {
3863	l := len(dAtA)
3864	iNdEx := 0
3865	for iNdEx < l {
3866		preIndex := iNdEx
3867		var wire uint64
3868		for shift := uint(0); ; shift += 7 {
3869			if shift >= 64 {
3870				return protohelpers.ErrIntOverflow
3871			}
3872			if iNdEx >= l {
3873				return io.ErrUnexpectedEOF
3874			}
3875			b := dAtA[iNdEx]
3876			iNdEx++
3877			wire |= uint64(b&0x7F) << shift
3878			if b < 0x80 {
3879				break
3880			}
3881		}
3882		fieldNum := int32(wire >> 3)
3883		wireType := int(wire & 0x7)
3884		if wireType == 4 {
3885			return fmt.Errorf("proto: PublishTunnelResponse: wiretype end group for non-group")
3886		}
3887		if fieldNum <= 0 {
3888			return fmt.Errorf("proto: PublishTunnelResponse: illegal tag %d (wire type %d)", fieldNum, wire)
3889		}
3890		switch fieldNum {
3891		case 1:
3892			if wireType != 2 {
3893				return fmt.Errorf("proto: wrong wireType = %d for field Published", wireType)
3894			}
3895			var msglen int
3896			for shift := uint(0); ; shift += 7 {
3897				if shift >= 64 {
3898					return protohelpers.ErrIntOverflow
3899				}
3900				if iNdEx >= l {
3901					return io.ErrUnexpectedEOF
3902				}
3903				b := dAtA[iNdEx]
3904				iNdEx++
3905				msglen |= int(b&0x7F) << shift
3906				if b < 0x80 {
3907					break
3908				}
3909			}
3910			if msglen < 0 {
3911				return protohelpers.ErrInvalidLength
3912			}
3913			postIndex := iNdEx + msglen
3914			if postIndex < 0 {
3915				return protohelpers.ErrInvalidLength
3916			}
3917			if postIndex > l {
3918				return io.ErrUnexpectedEOF
3919			}
3920			m.Published = append(m.Published, &Node{})
3921			if err := m.Published[len(m.Published)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
3922				return err
3923			}
3924			iNdEx = postIndex
3925		default:
3926			iNdEx = preIndex
3927			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
3928			if err != nil {
3929				return err
3930			}
3931			if (skippy < 0) || (iNdEx+skippy) < 0 {
3932				return protohelpers.ErrInvalidLength
3933			}
3934			if (iNdEx + skippy) > l {
3935				return io.ErrUnexpectedEOF
3936			}
3937			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
3938			iNdEx += skippy
3939		}
3940	}
3941 
3942	if iNdEx > l {
3943		return io.ErrUnexpectedEOF
3944	}
3945	return nil
3946}
3947func (m *UnpublishTunnelRequest) UnmarshalVT(dAtA []byte) error {
3948	l := len(dAtA)
3949	iNdEx := 0
3950	for iNdEx < l {
3951		preIndex := iNdEx
3952		var wire uint64
3953		for shift := uint(0); ; shift += 7 {
3954			if shift >= 64 {
3955				return protohelpers.ErrIntOverflow
3956			}
3957			if iNdEx >= l {
3958				return io.ErrUnexpectedEOF
3959			}
3960			b := dAtA[iNdEx]
3961			iNdEx++
3962			wire |= uint64(b&0x7F) << shift
3963			if b < 0x80 {
3964				break
3965			}
3966		}
3967		fieldNum := int32(wire >> 3)
3968		wireType := int(wire & 0x7)
3969		if wireType == 4 {
3970			return fmt.Errorf("proto: UnpublishTunnelRequest: wiretype end group for non-group")
3971		}
3972		if fieldNum <= 0 {
3973			return fmt.Errorf("proto: UnpublishTunnelRequest: illegal tag %d (wire type %d)", fieldNum, wire)
3974		}
3975		switch fieldNum {
3976		case 1:
3977			if wireType != 2 {
3978				return fmt.Errorf("proto: wrong wireType = %d for field Hostname", wireType)
3979			}
3980			var stringLen uint64
3981			for shift := uint(0); ; shift += 7 {
3982				if shift >= 64 {
3983					return protohelpers.ErrIntOverflow
3984				}
3985				if iNdEx >= l {
3986					return io.ErrUnexpectedEOF
3987				}
3988				b := dAtA[iNdEx]
3989				iNdEx++
3990				stringLen |= uint64(b&0x7F) << shift
3991				if b < 0x80 {
3992					break
3993				}
3994			}
3995			intStringLen := int(stringLen)
3996			if intStringLen < 0 {
3997				return protohelpers.ErrInvalidLength
3998			}
3999			postIndex := iNdEx + intStringLen
4000			if postIndex < 0 {
4001				return protohelpers.ErrInvalidLength
4002			}
4003			if postIndex > l {
4004				return io.ErrUnexpectedEOF
4005			}
4006			m.Hostname = string(dAtA[iNdEx:postIndex])
4007			iNdEx = postIndex
4008		default:
4009			iNdEx = preIndex
4010			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
4011			if err != nil {
4012				return err
4013			}
4014			if (skippy < 0) || (iNdEx+skippy) < 0 {
4015				return protohelpers.ErrInvalidLength
4016			}
4017			if (iNdEx + skippy) > l {
4018				return io.ErrUnexpectedEOF
4019			}
4020			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
4021			iNdEx += skippy
4022		}
4023	}
4024 
4025	if iNdEx > l {
4026		return io.ErrUnexpectedEOF
4027	}
4028	return nil
4029}
4030func (m *UnpublishTunnelResponse) UnmarshalVT(dAtA []byte) error {
4031	l := len(dAtA)
4032	iNdEx := 0
4033	for iNdEx < l {
4034		preIndex := iNdEx
4035		var wire uint64
4036		for shift := uint(0); ; shift += 7 {
4037			if shift >= 64 {
4038				return protohelpers.ErrIntOverflow
4039			}
4040			if iNdEx >= l {
4041				return io.ErrUnexpectedEOF
4042			}
4043			b := dAtA[iNdEx]
4044			iNdEx++
4045			wire |= uint64(b&0x7F) << shift
4046			if b < 0x80 {
4047				break
4048			}
4049		}
4050		fieldNum := int32(wire >> 3)
4051		wireType := int(wire & 0x7)
4052		if wireType == 4 {
4053			return fmt.Errorf("proto: UnpublishTunnelResponse: wiretype end group for non-group")
4054		}
4055		if fieldNum <= 0 {
4056			return fmt.Errorf("proto: UnpublishTunnelResponse: illegal tag %d (wire type %d)", fieldNum, wire)
4057		}
4058		switch fieldNum {
4059		default:
4060			iNdEx = preIndex
4061			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
4062			if err != nil {
4063				return err
4064			}
4065			if (skippy < 0) || (iNdEx+skippy) < 0 {
4066				return protohelpers.ErrInvalidLength
4067			}
4068			if (iNdEx + skippy) > l {
4069				return io.ErrUnexpectedEOF
4070			}
4071			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
4072			iNdEx += skippy
4073		}
4074	}
4075 
4076	if iNdEx > l {
4077		return io.ErrUnexpectedEOF
4078	}
4079	return nil
4080}
4081func (m *ReleaseTunnelRequest) UnmarshalVT(dAtA []byte) error {
4082	l := len(dAtA)
4083	iNdEx := 0
4084	for iNdEx < l {
4085		preIndex := iNdEx
4086		var wire uint64
4087		for shift := uint(0); ; shift += 7 {
4088			if shift >= 64 {
4089				return protohelpers.ErrIntOverflow
4090			}
4091			if iNdEx >= l {
4092				return io.ErrUnexpectedEOF
4093			}
4094			b := dAtA[iNdEx]
4095			iNdEx++
4096			wire |= uint64(b&0x7F) << shift
4097			if b < 0x80 {
4098				break
4099			}
4100		}
4101		fieldNum := int32(wire >> 3)
4102		wireType := int(wire & 0x7)
4103		if wireType == 4 {
4104			return fmt.Errorf("proto: ReleaseTunnelRequest: wiretype end group for non-group")
4105		}
4106		if fieldNum <= 0 {
4107			return fmt.Errorf("proto: ReleaseTunnelRequest: illegal tag %d (wire type %d)", fieldNum, wire)
4108		}
4109		switch fieldNum {
4110		case 1:
4111			if wireType != 2 {
4112				return fmt.Errorf("proto: wrong wireType = %d for field Hostname", wireType)
4113			}
4114			var stringLen uint64
4115			for shift := uint(0); ; shift += 7 {
4116				if shift >= 64 {
4117					return protohelpers.ErrIntOverflow
4118				}
4119				if iNdEx >= l {
4120					return io.ErrUnexpectedEOF
4121				}
4122				b := dAtA[iNdEx]
4123				iNdEx++
4124				stringLen |= uint64(b&0x7F) << shift
4125				if b < 0x80 {
4126					break
4127				}
4128			}
4129			intStringLen := int(stringLen)
4130			if intStringLen < 0 {
4131				return protohelpers.ErrInvalidLength
4132			}
4133			postIndex := iNdEx + intStringLen
4134			if postIndex < 0 {
4135				return protohelpers.ErrInvalidLength
4136			}
4137			if postIndex > l {
4138				return io.ErrUnexpectedEOF
4139			}
4140			m.Hostname = string(dAtA[iNdEx:postIndex])
4141			iNdEx = postIndex
4142		default:
4143			iNdEx = preIndex
4144			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
4145			if err != nil {
4146				return err
4147			}
4148			if (skippy < 0) || (iNdEx+skippy) < 0 {
4149				return protohelpers.ErrInvalidLength
4150			}
4151			if (iNdEx + skippy) > l {
4152				return io.ErrUnexpectedEOF
4153			}
4154			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
4155			iNdEx += skippy
4156		}
4157	}
4158 
4159	if iNdEx > l {
4160		return io.ErrUnexpectedEOF
4161	}
4162	return nil
4163}
4164func (m *ReleaseTunnelResponse) UnmarshalVT(dAtA []byte) error {
4165	l := len(dAtA)
4166	iNdEx := 0
4167	for iNdEx < l {
4168		preIndex := iNdEx
4169		var wire uint64
4170		for shift := uint(0); ; shift += 7 {
4171			if shift >= 64 {
4172				return protohelpers.ErrIntOverflow
4173			}
4174			if iNdEx >= l {
4175				return io.ErrUnexpectedEOF
4176			}
4177			b := dAtA[iNdEx]
4178			iNdEx++
4179			wire |= uint64(b&0x7F) << shift
4180			if b < 0x80 {
4181				break
4182			}
4183		}
4184		fieldNum := int32(wire >> 3)
4185		wireType := int(wire & 0x7)
4186		if wireType == 4 {
4187			return fmt.Errorf("proto: ReleaseTunnelResponse: wiretype end group for non-group")
4188		}
4189		if fieldNum <= 0 {
4190			return fmt.Errorf("proto: ReleaseTunnelResponse: illegal tag %d (wire type %d)", fieldNum, wire)
4191		}
4192		switch fieldNum {
4193		default:
4194			iNdEx = preIndex
4195			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
4196			if err != nil {
4197				return err
4198			}
4199			if (skippy < 0) || (iNdEx+skippy) < 0 {
4200				return protohelpers.ErrInvalidLength
4201			}
4202			if (iNdEx + skippy) > l {
4203				return io.ErrUnexpectedEOF
4204			}
4205			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
4206			iNdEx += skippy
4207		}
4208	}
4209 
4210	if iNdEx > l {
4211		return io.ErrUnexpectedEOF
4212	}
4213	return nil
4214}
4215func (m *InstructionRequest) UnmarshalVT(dAtA []byte) error {
4216	l := len(dAtA)
4217	iNdEx := 0
4218	for iNdEx < l {
4219		preIndex := iNdEx
4220		var wire uint64
4221		for shift := uint(0); ; shift += 7 {
4222			if shift >= 64 {
4223				return protohelpers.ErrIntOverflow
4224			}
4225			if iNdEx >= l {
4226				return io.ErrUnexpectedEOF
4227			}
4228			b := dAtA[iNdEx]
4229			iNdEx++
4230			wire |= uint64(b&0x7F) << shift
4231			if b < 0x80 {
4232				break
4233			}
4234		}
4235		fieldNum := int32(wire >> 3)
4236		wireType := int(wire & 0x7)
4237		if wireType == 4 {
4238			return fmt.Errorf("proto: InstructionRequest: wiretype end group for non-group")
4239		}
4240		if fieldNum <= 0 {
4241			return fmt.Errorf("proto: InstructionRequest: illegal tag %d (wire type %d)", fieldNum, wire)
4242		}
4243		switch fieldNum {
4244		case 1:
4245			if wireType != 2 {
4246				return fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType)
4247			}
4248			var msglen int
4249			for shift := uint(0); ; shift += 7 {
4250				if shift >= 64 {
4251					return protohelpers.ErrIntOverflow
4252				}
4253				if iNdEx >= l {
4254					return io.ErrUnexpectedEOF
4255				}
4256				b := dAtA[iNdEx]
4257				iNdEx++
4258				msglen |= int(b&0x7F) << shift
4259				if b < 0x80 {
4260					break
4261				}
4262			}
4263			if msglen < 0 {
4264				return protohelpers.ErrInvalidLength
4265			}
4266			postIndex := iNdEx + msglen
4267			if postIndex < 0 {
4268				return protohelpers.ErrInvalidLength
4269			}
4270			if postIndex > l {
4271				return io.ErrUnexpectedEOF
4272			}
4273			if m.Proof == nil {
4274				m.Proof = &ProofOfWork{}
4275			}
4276			if err := m.Proof.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
4277				return err
4278			}
4279			iNdEx = postIndex
4280		case 2:
4281			if wireType != 2 {
4282				return fmt.Errorf("proto: wrong wireType = %d for field Hostname", wireType)
4283			}
4284			var stringLen uint64
4285			for shift := uint(0); ; shift += 7 {
4286				if shift >= 64 {
4287					return protohelpers.ErrIntOverflow
4288				}
4289				if iNdEx >= l {
4290					return io.ErrUnexpectedEOF
4291				}
4292				b := dAtA[iNdEx]
4293				iNdEx++
4294				stringLen |= uint64(b&0x7F) << shift
4295				if b < 0x80 {
4296					break
4297				}
4298			}
4299			intStringLen := int(stringLen)
4300			if intStringLen < 0 {
4301				return protohelpers.ErrInvalidLength
4302			}
4303			postIndex := iNdEx + intStringLen
4304			if postIndex < 0 {
4305				return protohelpers.ErrInvalidLength
4306			}
4307			if postIndex > l {
4308				return io.ErrUnexpectedEOF
4309			}
4310			m.Hostname = string(dAtA[iNdEx:postIndex])
4311			iNdEx = postIndex
4312		default:
4313			iNdEx = preIndex
4314			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
4315			if err != nil {
4316				return err
4317			}
4318			if (skippy < 0) || (iNdEx+skippy) < 0 {
4319				return protohelpers.ErrInvalidLength
4320			}
4321			if (iNdEx + skippy) > l {
4322				return io.ErrUnexpectedEOF
4323			}
4324			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
4325			iNdEx += skippy
4326		}
4327	}
4328 
4329	if iNdEx > l {
4330		return io.ErrUnexpectedEOF
4331	}
4332	return nil
4333}
4334func (m *InstructionResponse) UnmarshalVT(dAtA []byte) error {
4335	l := len(dAtA)
4336	iNdEx := 0
4337	for iNdEx < l {
4338		preIndex := iNdEx
4339		var wire uint64
4340		for shift := uint(0); ; shift += 7 {
4341			if shift >= 64 {
4342				return protohelpers.ErrIntOverflow
4343			}
4344			if iNdEx >= l {
4345				return io.ErrUnexpectedEOF
4346			}
4347			b := dAtA[iNdEx]
4348			iNdEx++
4349			wire |= uint64(b&0x7F) << shift
4350			if b < 0x80 {
4351				break
4352			}
4353		}
4354		fieldNum := int32(wire >> 3)
4355		wireType := int(wire & 0x7)
4356		if wireType == 4 {
4357			return fmt.Errorf("proto: InstructionResponse: wiretype end group for non-group")
4358		}
4359		if fieldNum <= 0 {
4360			return fmt.Errorf("proto: InstructionResponse: illegal tag %d (wire type %d)", fieldNum, wire)
4361		}
4362		switch fieldNum {
4363		case 1:
4364			if wireType != 2 {
4365				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
4366			}
4367			var stringLen uint64
4368			for shift := uint(0); ; shift += 7 {
4369				if shift >= 64 {
4370					return protohelpers.ErrIntOverflow
4371				}
4372				if iNdEx >= l {
4373					return io.ErrUnexpectedEOF
4374				}
4375				b := dAtA[iNdEx]
4376				iNdEx++
4377				stringLen |= uint64(b&0x7F) << shift
4378				if b < 0x80 {
4379					break
4380				}
4381			}
4382			intStringLen := int(stringLen)
4383			if intStringLen < 0 {
4384				return protohelpers.ErrInvalidLength
4385			}
4386			postIndex := iNdEx + intStringLen
4387			if postIndex < 0 {
4388				return protohelpers.ErrInvalidLength
4389			}
4390			if postIndex > l {
4391				return io.ErrUnexpectedEOF
4392			}
4393			m.Name = string(dAtA[iNdEx:postIndex])
4394			iNdEx = postIndex
4395		case 2:
4396			if wireType != 2 {
4397				return fmt.Errorf("proto: wrong wireType = %d for field Content", wireType)
4398			}
4399			var stringLen uint64
4400			for shift := uint(0); ; shift += 7 {
4401				if shift >= 64 {
4402					return protohelpers.ErrIntOverflow
4403				}
4404				if iNdEx >= l {
4405					return io.ErrUnexpectedEOF
4406				}
4407				b := dAtA[iNdEx]
4408				iNdEx++
4409				stringLen |= uint64(b&0x7F) << shift
4410				if b < 0x80 {
4411					break
4412				}
4413			}
4414			intStringLen := int(stringLen)
4415			if intStringLen < 0 {
4416				return protohelpers.ErrInvalidLength
4417			}
4418			postIndex := iNdEx + intStringLen
4419			if postIndex < 0 {
4420				return protohelpers.ErrInvalidLength
4421			}
4422			if postIndex > l {
4423				return io.ErrUnexpectedEOF
4424			}
4425			m.Content = string(dAtA[iNdEx:postIndex])
4426			iNdEx = postIndex
4427		default:
4428			iNdEx = preIndex
4429			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
4430			if err != nil {
4431				return err
4432			}
4433			if (skippy < 0) || (iNdEx+skippy) < 0 {
4434				return protohelpers.ErrInvalidLength
4435			}
4436			if (iNdEx + skippy) > l {
4437				return io.ErrUnexpectedEOF
4438			}
4439			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
4440			iNdEx += skippy
4441		}
4442	}
4443 
4444	if iNdEx > l {
4445		return io.ErrUnexpectedEOF
4446	}
4447	return nil
4448}
4449func (m *ValidateRequest) UnmarshalVT(dAtA []byte) error {
4450	l := len(dAtA)
4451	iNdEx := 0
4452	for iNdEx < l {
4453		preIndex := iNdEx
4454		var wire uint64
4455		for shift := uint(0); ; shift += 7 {
4456			if shift >= 64 {
4457				return protohelpers.ErrIntOverflow
4458			}
4459			if iNdEx >= l {
4460				return io.ErrUnexpectedEOF
4461			}
4462			b := dAtA[iNdEx]
4463			iNdEx++
4464			wire |= uint64(b&0x7F) << shift
4465			if b < 0x80 {
4466				break
4467			}
4468		}
4469		fieldNum := int32(wire >> 3)
4470		wireType := int(wire & 0x7)
4471		if wireType == 4 {
4472			return fmt.Errorf("proto: ValidateRequest: wiretype end group for non-group")
4473		}
4474		if fieldNum <= 0 {
4475			return fmt.Errorf("proto: ValidateRequest: illegal tag %d (wire type %d)", fieldNum, wire)
4476		}
4477		switch fieldNum {
4478		case 1:
4479			if wireType != 2 {
4480				return fmt.Errorf("proto: wrong wireType = %d for field Proof", wireType)
4481			}
4482			var msglen int
4483			for shift := uint(0); ; shift += 7 {
4484				if shift >= 64 {
4485					return protohelpers.ErrIntOverflow
4486				}
4487				if iNdEx >= l {
4488					return io.ErrUnexpectedEOF
4489				}
4490				b := dAtA[iNdEx]
4491				iNdEx++
4492				msglen |= int(b&0x7F) << shift
4493				if b < 0x80 {
4494					break
4495				}
4496			}
4497			if msglen < 0 {
4498				return protohelpers.ErrInvalidLength
4499			}
4500			postIndex := iNdEx + msglen
4501			if postIndex < 0 {
4502				return protohelpers.ErrInvalidLength
4503			}
4504			if postIndex > l {
4505				return io.ErrUnexpectedEOF
4506			}
4507			if m.Proof == nil {
4508				m.Proof = &ProofOfWork{}
4509			}
4510			if err := m.Proof.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
4511				return err
4512			}
4513			iNdEx = postIndex
4514		case 2:
4515			if wireType != 2 {
4516				return fmt.Errorf("proto: wrong wireType = %d for field Hostname", wireType)
4517			}
4518			var stringLen uint64
4519			for shift := uint(0); ; shift += 7 {
4520				if shift >= 64 {
4521					return protohelpers.ErrIntOverflow
4522				}
4523				if iNdEx >= l {
4524					return io.ErrUnexpectedEOF
4525				}
4526				b := dAtA[iNdEx]
4527				iNdEx++
4528				stringLen |= uint64(b&0x7F) << shift
4529				if b < 0x80 {
4530					break
4531				}
4532			}
4533			intStringLen := int(stringLen)
4534			if intStringLen < 0 {
4535				return protohelpers.ErrInvalidLength
4536			}
4537			postIndex := iNdEx + intStringLen
4538			if postIndex < 0 {
4539				return protohelpers.ErrInvalidLength
4540			}
4541			if postIndex > l {
4542				return io.ErrUnexpectedEOF
4543			}
4544			m.Hostname = string(dAtA[iNdEx:postIndex])
4545			iNdEx = postIndex
4546		default:
4547			iNdEx = preIndex
4548			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
4549			if err != nil {
4550				return err
4551			}
4552			if (skippy < 0) || (iNdEx+skippy) < 0 {
4553				return protohelpers.ErrInvalidLength
4554			}
4555			if (iNdEx + skippy) > l {
4556				return io.ErrUnexpectedEOF
4557			}
4558			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
4559			iNdEx += skippy
4560		}
4561	}
4562 
4563	if iNdEx > l {
4564		return io.ErrUnexpectedEOF
4565	}
4566	return nil
4567}
4568func (m *ValidateResponse) UnmarshalVT(dAtA []byte) error {
4569	l := len(dAtA)
4570	iNdEx := 0
4571	for iNdEx < l {
4572		preIndex := iNdEx
4573		var wire uint64
4574		for shift := uint(0); ; shift += 7 {
4575			if shift >= 64 {
4576				return protohelpers.ErrIntOverflow
4577			}
4578			if iNdEx >= l {
4579				return io.ErrUnexpectedEOF
4580			}
4581			b := dAtA[iNdEx]
4582			iNdEx++
4583			wire |= uint64(b&0x7F) << shift
4584			if b < 0x80 {
4585				break
4586			}
4587		}
4588		fieldNum := int32(wire >> 3)
4589		wireType := int(wire & 0x7)
4590		if wireType == 4 {
4591			return fmt.Errorf("proto: ValidateResponse: wiretype end group for non-group")
4592		}
4593		if fieldNum <= 0 {
4594			return fmt.Errorf("proto: ValidateResponse: illegal tag %d (wire type %d)", fieldNum, wire)
4595		}
4596		switch fieldNum {
4597		case 1:
4598			if wireType != 2 {
4599				return fmt.Errorf("proto: wrong wireType = %d for field Apex", wireType)
4600			}
4601			var stringLen uint64
4602			for shift := uint(0); ; shift += 7 {
4603				if shift >= 64 {
4604					return protohelpers.ErrIntOverflow
4605				}
4606				if iNdEx >= l {
4607					return io.ErrUnexpectedEOF
4608				}
4609				b := dAtA[iNdEx]
4610				iNdEx++
4611				stringLen |= uint64(b&0x7F) << shift
4612				if b < 0x80 {
4613					break
4614				}
4615			}
4616			intStringLen := int(stringLen)
4617			if intStringLen < 0 {
4618				return protohelpers.ErrInvalidLength
4619			}
4620			postIndex := iNdEx + intStringLen
4621			if postIndex < 0 {
4622				return protohelpers.ErrInvalidLength
4623			}
4624			if postIndex > l {
4625				return io.ErrUnexpectedEOF
4626			}
4627			m.Apex = string(dAtA[iNdEx:postIndex])
4628			iNdEx = postIndex
4629		default:
4630			iNdEx = preIndex
4631			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
4632			if err != nil {
4633				return err
4634			}
4635			if (skippy < 0) || (iNdEx+skippy) < 0 {
4636				return protohelpers.ErrInvalidLength
4637			}
4638			if (iNdEx + skippy) > l {
4639				return io.ErrUnexpectedEOF
4640			}
4641			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
4642			iNdEx += skippy
4643		}
4644	}
4645 
4646	if iNdEx > l {
4647		return io.ErrUnexpectedEOF
4648	}
4649	return nil
4650}
4651func (m *DelegationRecord) UnmarshalVT(dAtA []byte) error {
4652	l := len(dAtA)
4653	iNdEx := 0
4654	for iNdEx < l {
4655		preIndex := iNdEx
4656		var wire uint64
4657		for shift := uint(0); ; shift += 7 {
4658			if shift >= 64 {
4659				return protohelpers.ErrIntOverflow
4660			}
4661			if iNdEx >= l {
4662				return io.ErrUnexpectedEOF
4663			}
4664			b := dAtA[iNdEx]
4665			iNdEx++
4666			wire |= uint64(b&0x7F) << shift
4667			if b < 0x80 {
4668				break
4669			}
4670		}
4671		fieldNum := int32(wire >> 3)
4672		wireType := int(wire & 0x7)
4673		if wireType == 4 {
4674			return fmt.Errorf("proto: DelegationRecord: wiretype end group for non-group")
4675		}
4676		if fieldNum <= 0 {
4677			return fmt.Errorf("proto: DelegationRecord: illegal tag %d (wire type %d)", fieldNum, wire)
4678		}
4679		switch fieldNum {
4680		case 1:
4681			if wireType != 0 {
4682				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
4683			}
4684			m.Version = 0
4685			for shift := uint(0); ; shift += 7 {
4686				if shift >= 64 {
4687					return protohelpers.ErrIntOverflow
4688				}
4689				if iNdEx >= l {
4690					return io.ErrUnexpectedEOF
4691				}
4692				b := dAtA[iNdEx]
4693				iNdEx++
4694				m.Version |= uint32(b&0x7F) << shift
4695				if b < 0x80 {
4696					break
4697				}
4698			}
4699		case 2:
4700			if wireType != 2 {
4701				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
4702			}
4703			var stringLen uint64
4704			for shift := uint(0); ; shift += 7 {
4705				if shift >= 64 {
4706					return protohelpers.ErrIntOverflow
4707				}
4708				if iNdEx >= l {
4709					return io.ErrUnexpectedEOF
4710				}
4711				b := dAtA[iNdEx]
4712				iNdEx++
4713				stringLen |= uint64(b&0x7F) << shift
4714				if b < 0x80 {
4715					break
4716				}
4717			}
4718			intStringLen := int(stringLen)
4719			if intStringLen < 0 {
4720				return protohelpers.ErrInvalidLength
4721			}
4722			postIndex := iNdEx + intStringLen
4723			if postIndex < 0 {
4724				return protohelpers.ErrInvalidLength
4725			}
4726			if postIndex > l {
4727				return io.ErrUnexpectedEOF
4728			}
4729			m.Id = string(dAtA[iNdEx:postIndex])
4730			iNdEx = postIndex
4731		case 3:
4732			if wireType != 2 {
4733				return fmt.Errorf("proto: wrong wireType = %d for field Owner", wireType)
4734			}
4735			var msglen int
4736			for shift := uint(0); ; shift += 7 {
4737				if shift >= 64 {
4738					return protohelpers.ErrIntOverflow
4739				}
4740				if iNdEx >= l {
4741					return io.ErrUnexpectedEOF
4742				}
4743				b := dAtA[iNdEx]
4744				iNdEx++
4745				msglen |= int(b&0x7F) << shift
4746				if b < 0x80 {
4747					break
4748				}
4749			}
4750			if msglen < 0 {
4751				return protohelpers.ErrInvalidLength
4752			}
4753			postIndex := iNdEx + msglen
4754			if postIndex < 0 {
4755				return protohelpers.ErrInvalidLength
4756			}
4757			if postIndex > l {
4758				return io.ErrUnexpectedEOF
4759			}
4760			if m.Owner == nil {
4761				m.Owner = &ClientToken{}
4762			}
4763			if err := m.Owner.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
4764				return err
4765			}
4766			iNdEx = postIndex
4767		case 4:
4768			if wireType != 2 {
4769				return fmt.Errorf("proto: wrong wireType = %d for field Hostname", wireType)
4770			}
4771			var stringLen uint64
4772			for shift := uint(0); ; shift += 7 {
4773				if shift >= 64 {
4774					return protohelpers.ErrIntOverflow
4775				}
4776				if iNdEx >= l {
4777					return io.ErrUnexpectedEOF
4778				}
4779				b := dAtA[iNdEx]
4780				iNdEx++
4781				stringLen |= uint64(b&0x7F) << shift
4782				if b < 0x80 {
4783					break
4784				}
4785			}
4786			intStringLen := int(stringLen)
4787			if intStringLen < 0 {
4788				return protohelpers.ErrInvalidLength
4789			}
4790			postIndex := iNdEx + intStringLen
4791			if postIndex < 0 {
4792				return protohelpers.ErrInvalidLength
4793			}
4794			if postIndex > l {
4795				return io.ErrUnexpectedEOF
4796			}
4797			m.Hostname = string(dAtA[iNdEx:postIndex])
4798			iNdEx = postIndex
4799		case 5:
4800			if wireType != 0 {
4801				return fmt.Errorf("proto: wrong wireType = %d for field ExpiresAt", wireType)
4802			}
4803			m.ExpiresAt = 0
4804			for shift := uint(0); ; shift += 7 {
4805				if shift >= 64 {
4806					return protohelpers.ErrIntOverflow
4807				}
4808				if iNdEx >= l {
4809					return io.ErrUnexpectedEOF
4810				}
4811				b := dAtA[iNdEx]
4812				iNdEx++
4813				m.ExpiresAt |= int64(b&0x7F) << shift
4814				if b < 0x80 {
4815					break
4816				}
4817			}
4818		default:
4819			iNdEx = preIndex
4820			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
4821			if err != nil {
4822				return err
4823			}
4824			if (skippy < 0) || (iNdEx+skippy) < 0 {
4825				return protohelpers.ErrInvalidLength
4826			}
4827			if (iNdEx + skippy) > l {
4828				return io.ErrUnexpectedEOF
4829			}
4830			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
4831			iNdEx += skippy
4832		}
4833	}
4834 
4835	if iNdEx > l {
4836		return io.ErrUnexpectedEOF
4837	}
4838	return nil
4839}
4840func (m *DelegationGrant) UnmarshalVT(dAtA []byte) error {
4841	l := len(dAtA)
4842	iNdEx := 0
4843	for iNdEx < l {
4844		preIndex := iNdEx
4845		var wire uint64
4846		for shift := uint(0); ; shift += 7 {
4847			if shift >= 64 {
4848				return protohelpers.ErrIntOverflow
4849			}
4850			if iNdEx >= l {
4851				return io.ErrUnexpectedEOF
4852			}
4853			b := dAtA[iNdEx]
4854			iNdEx++
4855			wire |= uint64(b&0x7F) << shift
4856			if b < 0x80 {
4857				break
4858			}
4859		}
4860		fieldNum := int32(wire >> 3)
4861		wireType := int(wire & 0x7)
4862		if wireType == 4 {
4863			return fmt.Errorf("proto: DelegationGrant: wiretype end group for non-group")
4864		}
4865		if fieldNum <= 0 {
4866			return fmt.Errorf("proto: DelegationGrant: illegal tag %d (wire type %d)", fieldNum, wire)
4867		}
4868		switch fieldNum {
4869		case 1:
4870			if wireType != 2 {
4871				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
4872			}
4873			var stringLen uint64
4874			for shift := uint(0); ; shift += 7 {
4875				if shift >= 64 {
4876					return protohelpers.ErrIntOverflow
4877				}
4878				if iNdEx >= l {
4879					return io.ErrUnexpectedEOF
4880				}
4881				b := dAtA[iNdEx]
4882				iNdEx++
4883				stringLen |= uint64(b&0x7F) << shift
4884				if b < 0x80 {
4885					break
4886				}
4887			}
4888			intStringLen := int(stringLen)
4889			if intStringLen < 0 {
4890				return protohelpers.ErrInvalidLength
4891			}
4892			postIndex := iNdEx + intStringLen
4893			if postIndex < 0 {
4894				return protohelpers.ErrInvalidLength
4895			}
4896			if postIndex > l {
4897				return io.ErrUnexpectedEOF
4898			}
4899			m.Id = string(dAtA[iNdEx:postIndex])
4900			iNdEx = postIndex
4901		case 2:
4902			if wireType != 2 {
4903				return fmt.Errorf("proto: wrong wireType = %d for field Hostname", wireType)
4904			}
4905			var stringLen uint64
4906			for shift := uint(0); ; shift += 7 {
4907				if shift >= 64 {
4908					return protohelpers.ErrIntOverflow
4909				}
4910				if iNdEx >= l {
4911					return io.ErrUnexpectedEOF
4912				}
4913				b := dAtA[iNdEx]
4914				iNdEx++
4915				stringLen |= uint64(b&0x7F) << shift
4916				if b < 0x80 {
4917					break
4918				}
4919			}
4920			intStringLen := int(stringLen)
4921			if intStringLen < 0 {
4922				return protohelpers.ErrInvalidLength
4923			}
4924			postIndex := iNdEx + intStringLen
4925			if postIndex < 0 {
4926				return protohelpers.ErrInvalidLength
4927			}
4928			if postIndex > l {
4929				return io.ErrUnexpectedEOF
4930			}
4931			m.Hostname = string(dAtA[iNdEx:postIndex])
4932			iNdEx = postIndex
4933		case 3:
4934			if wireType != 0 {
4935				return fmt.Errorf("proto: wrong wireType = %d for field ExpiresAt", wireType)
4936			}
4937			m.ExpiresAt = 0
4938			for shift := uint(0); ; shift += 7 {
4939				if shift >= 64 {
4940					return protohelpers.ErrIntOverflow
4941				}
4942				if iNdEx >= l {
4943					return io.ErrUnexpectedEOF
4944				}
4945				b := dAtA[iNdEx]
4946				iNdEx++
4947				m.ExpiresAt |= int64(b&0x7F) << shift
4948				if b < 0x80 {
4949					break
4950				}
4951			}
4952		case 4:
4953			if wireType != 0 {
4954				return fmt.Errorf("proto: wrong wireType = %d for field Incomplete", wireType)
4955			}
4956			var v int
4957			for shift := uint(0); ; shift += 7 {
4958				if shift >= 64 {
4959					return protohelpers.ErrIntOverflow
4960				}
4961				if iNdEx >= l {
4962					return io.ErrUnexpectedEOF
4963				}
4964				b := dAtA[iNdEx]
4965				iNdEx++
4966				v |= int(b&0x7F) << shift
4967				if b < 0x80 {
4968					break
4969				}
4970			}
4971			m.Incomplete = bool(v != 0)
4972		default:
4973			iNdEx = preIndex
4974			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
4975			if err != nil {
4976				return err
4977			}
4978			if (skippy < 0) || (iNdEx+skippy) < 0 {
4979				return protohelpers.ErrInvalidLength
4980			}
4981			if (iNdEx + skippy) > l {
4982				return io.ErrUnexpectedEOF
4983			}
4984			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
4985			iNdEx += skippy
4986		}
4987	}
4988 
4989	if iNdEx > l {
4990		return io.ErrUnexpectedEOF
4991	}
4992	return nil
4993}
4994func (m *MintDelegationRequest) UnmarshalVT(dAtA []byte) error {
4995	l := len(dAtA)
4996	iNdEx := 0
4997	for iNdEx < l {
4998		preIndex := iNdEx
4999		var wire uint64
5000		for shift := uint(0); ; shift += 7 {
5001			if shift >= 64 {
5002				return protohelpers.ErrIntOverflow
5003			}
5004			if iNdEx >= l {
5005				return io.ErrUnexpectedEOF
5006			}
5007			b := dAtA[iNdEx]
5008			iNdEx++
5009			wire |= uint64(b&0x7F) << shift
5010			if b < 0x80 {
5011				break
5012			}
5013		}
5014		fieldNum := int32(wire >> 3)
5015		wireType := int(wire & 0x7)
5016		if wireType == 4 {
5017			return fmt.Errorf("proto: MintDelegationRequest: wiretype end group for non-group")
5018		}
5019		if fieldNum <= 0 {
5020			return fmt.Errorf("proto: MintDelegationRequest: illegal tag %d (wire type %d)", fieldNum, wire)
5021		}
5022		switch fieldNum {
5023		case 1:
5024			if wireType != 2 {
5025				return fmt.Errorf("proto: wrong wireType = %d for field Hostname", wireType)
5026			}
5027			var stringLen uint64
5028			for shift := uint(0); ; shift += 7 {
5029				if shift >= 64 {
5030					return protohelpers.ErrIntOverflow
5031				}
5032				if iNdEx >= l {
5033					return io.ErrUnexpectedEOF
5034				}
5035				b := dAtA[iNdEx]
5036				iNdEx++
5037				stringLen |= uint64(b&0x7F) << shift
5038				if b < 0x80 {
5039					break
5040				}
5041			}
5042			intStringLen := int(stringLen)
5043			if intStringLen < 0 {
5044				return protohelpers.ErrInvalidLength
5045			}
5046			postIndex := iNdEx + intStringLen
5047			if postIndex < 0 {
5048				return protohelpers.ErrInvalidLength
5049			}
5050			if postIndex > l {
5051				return io.ErrUnexpectedEOF
5052			}
5053			m.Hostname = string(dAtA[iNdEx:postIndex])
5054			iNdEx = postIndex
5055		case 2:
5056			if wireType != 0 {
5057				return fmt.Errorf("proto: wrong wireType = %d for field ExpiresAt", wireType)
5058			}
5059			m.ExpiresAt = 0
5060			for shift := uint(0); ; shift += 7 {
5061				if shift >= 64 {
5062					return protohelpers.ErrIntOverflow
5063				}
5064				if iNdEx >= l {
5065					return io.ErrUnexpectedEOF
5066				}
5067				b := dAtA[iNdEx]
5068				iNdEx++
5069				m.ExpiresAt |= int64(b&0x7F) << shift
5070				if b < 0x80 {
5071					break
5072				}
5073			}
5074		default:
5075			iNdEx = preIndex
5076			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
5077			if err != nil {
5078				return err
5079			}
5080			if (skippy < 0) || (iNdEx+skippy) < 0 {
5081				return protohelpers.ErrInvalidLength
5082			}
5083			if (iNdEx + skippy) > l {
5084				return io.ErrUnexpectedEOF
5085			}
5086			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
5087			iNdEx += skippy
5088		}
5089	}
5090 
5091	if iNdEx > l {
5092		return io.ErrUnexpectedEOF
5093	}
5094	return nil
5095}
5096func (m *MintDelegationResponse) UnmarshalVT(dAtA []byte) error {
5097	l := len(dAtA)
5098	iNdEx := 0
5099	for iNdEx < l {
5100		preIndex := iNdEx
5101		var wire uint64
5102		for shift := uint(0); ; shift += 7 {
5103			if shift >= 64 {
5104				return protohelpers.ErrIntOverflow
5105			}
5106			if iNdEx >= l {
5107				return io.ErrUnexpectedEOF
5108			}
5109			b := dAtA[iNdEx]
5110			iNdEx++
5111			wire |= uint64(b&0x7F) << shift
5112			if b < 0x80 {
5113				break
5114			}
5115		}
5116		fieldNum := int32(wire >> 3)
5117		wireType := int(wire & 0x7)
5118		if wireType == 4 {
5119			return fmt.Errorf("proto: MintDelegationResponse: wiretype end group for non-group")
5120		}
5121		if fieldNum <= 0 {
5122			return fmt.Errorf("proto: MintDelegationResponse: illegal tag %d (wire type %d)", fieldNum, wire)
5123		}
5124		switch fieldNum {
5125		case 1:
5126			if wireType != 2 {
5127				return fmt.Errorf("proto: wrong wireType = %d for field Grant", wireType)
5128			}
5129			var msglen int
5130			for shift := uint(0); ; shift += 7 {
5131				if shift >= 64 {
5132					return protohelpers.ErrIntOverflow
5133				}
5134				if iNdEx >= l {
5135					return io.ErrUnexpectedEOF
5136				}
5137				b := dAtA[iNdEx]
5138				iNdEx++
5139				msglen |= int(b&0x7F) << shift
5140				if b < 0x80 {
5141					break
5142				}
5143			}
5144			if msglen < 0 {
5145				return protohelpers.ErrInvalidLength
5146			}
5147			postIndex := iNdEx + msglen
5148			if postIndex < 0 {
5149				return protohelpers.ErrInvalidLength
5150			}
5151			if postIndex > l {
5152				return io.ErrUnexpectedEOF
5153			}
5154			if m.Grant == nil {
5155				m.Grant = &DelegationGrant{}
5156			}
5157			if err := m.Grant.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
5158				return err
5159			}
5160			iNdEx = postIndex
5161		case 2:
5162			if wireType != 2 {
5163				return fmt.Errorf("proto: wrong wireType = %d for field Token", wireType)
5164			}
5165			var stringLen uint64
5166			for shift := uint(0); ; shift += 7 {
5167				if shift >= 64 {
5168					return protohelpers.ErrIntOverflow
5169				}
5170				if iNdEx >= l {
5171					return io.ErrUnexpectedEOF
5172				}
5173				b := dAtA[iNdEx]
5174				iNdEx++
5175				stringLen |= uint64(b&0x7F) << shift
5176				if b < 0x80 {
5177					break
5178				}
5179			}
5180			intStringLen := int(stringLen)
5181			if intStringLen < 0 {
5182				return protohelpers.ErrInvalidLength
5183			}
5184			postIndex := iNdEx + intStringLen
5185			if postIndex < 0 {
5186				return protohelpers.ErrInvalidLength
5187			}
5188			if postIndex > l {
5189				return io.ErrUnexpectedEOF
5190			}
5191			m.Token = string(dAtA[iNdEx:postIndex])
5192			iNdEx = postIndex
5193		default:
5194			iNdEx = preIndex
5195			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
5196			if err != nil {
5197				return err
5198			}
5199			if (skippy < 0) || (iNdEx+skippy) < 0 {
5200				return protohelpers.ErrInvalidLength
5201			}
5202			if (iNdEx + skippy) > l {
5203				return io.ErrUnexpectedEOF
5204			}
5205			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
5206			iNdEx += skippy
5207		}
5208	}
5209 
5210	if iNdEx > l {
5211		return io.ErrUnexpectedEOF
5212	}
5213	return nil
5214}
5215func (m *ListDelegationsRequest) UnmarshalVT(dAtA []byte) error {
5216	l := len(dAtA)
5217	iNdEx := 0
5218	for iNdEx < l {
5219		preIndex := iNdEx
5220		var wire uint64
5221		for shift := uint(0); ; shift += 7 {
5222			if shift >= 64 {
5223				return protohelpers.ErrIntOverflow
5224			}
5225			if iNdEx >= l {
5226				return io.ErrUnexpectedEOF
5227			}
5228			b := dAtA[iNdEx]
5229			iNdEx++
5230			wire |= uint64(b&0x7F) << shift
5231			if b < 0x80 {
5232				break
5233			}
5234		}
5235		fieldNum := int32(wire >> 3)
5236		wireType := int(wire & 0x7)
5237		if wireType == 4 {
5238			return fmt.Errorf("proto: ListDelegationsRequest: wiretype end group for non-group")
5239		}
5240		if fieldNum <= 0 {
5241			return fmt.Errorf("proto: ListDelegationsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
5242		}
5243		switch fieldNum {
5244		default:
5245			iNdEx = preIndex
5246			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
5247			if err != nil {
5248				return err
5249			}
5250			if (skippy < 0) || (iNdEx+skippy) < 0 {
5251				return protohelpers.ErrInvalidLength
5252			}
5253			if (iNdEx + skippy) > l {
5254				return io.ErrUnexpectedEOF
5255			}
5256			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
5257			iNdEx += skippy
5258		}
5259	}
5260 
5261	if iNdEx > l {
5262		return io.ErrUnexpectedEOF
5263	}
5264	return nil
5265}
5266func (m *ListDelegationsResponse) UnmarshalVT(dAtA []byte) error {
5267	l := len(dAtA)
5268	iNdEx := 0
5269	for iNdEx < l {
5270		preIndex := iNdEx
5271		var wire uint64
5272		for shift := uint(0); ; shift += 7 {
5273			if shift >= 64 {
5274				return protohelpers.ErrIntOverflow
5275			}
5276			if iNdEx >= l {
5277				return io.ErrUnexpectedEOF
5278			}
5279			b := dAtA[iNdEx]
5280			iNdEx++
5281			wire |= uint64(b&0x7F) << shift
5282			if b < 0x80 {
5283				break
5284			}
5285		}
5286		fieldNum := int32(wire >> 3)
5287		wireType := int(wire & 0x7)
5288		if wireType == 4 {
5289			return fmt.Errorf("proto: ListDelegationsResponse: wiretype end group for non-group")
5290		}
5291		if fieldNum <= 0 {
5292			return fmt.Errorf("proto: ListDelegationsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
5293		}
5294		switch fieldNum {
5295		case 1:
5296			if wireType != 2 {
5297				return fmt.Errorf("proto: wrong wireType = %d for field Grants", wireType)
5298			}
5299			var msglen int
5300			for shift := uint(0); ; shift += 7 {
5301				if shift >= 64 {
5302					return protohelpers.ErrIntOverflow
5303				}
5304				if iNdEx >= l {
5305					return io.ErrUnexpectedEOF
5306				}
5307				b := dAtA[iNdEx]
5308				iNdEx++
5309				msglen |= int(b&0x7F) << shift
5310				if b < 0x80 {
5311					break
5312				}
5313			}
5314			if msglen < 0 {
5315				return protohelpers.ErrInvalidLength
5316			}
5317			postIndex := iNdEx + msglen
5318			if postIndex < 0 {
5319				return protohelpers.ErrInvalidLength
5320			}
5321			if postIndex > l {
5322				return io.ErrUnexpectedEOF
5323			}
5324			m.Grants = append(m.Grants, &DelegationGrant{})
5325			if err := m.Grants[len(m.Grants)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
5326				return err
5327			}
5328			iNdEx = postIndex
5329		default:
5330			iNdEx = preIndex
5331			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
5332			if err != nil {
5333				return err
5334			}
5335			if (skippy < 0) || (iNdEx+skippy) < 0 {
5336				return protohelpers.ErrInvalidLength
5337			}
5338			if (iNdEx + skippy) > l {
5339				return io.ErrUnexpectedEOF
5340			}
5341			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
5342			iNdEx += skippy
5343		}
5344	}
5345 
5346	if iNdEx > l {
5347		return io.ErrUnexpectedEOF
5348	}
5349	return nil
5350}
5351func (m *RevokeDelegationRequest) UnmarshalVT(dAtA []byte) error {
5352	l := len(dAtA)
5353	iNdEx := 0
5354	for iNdEx < l {
5355		preIndex := iNdEx
5356		var wire uint64
5357		for shift := uint(0); ; shift += 7 {
5358			if shift >= 64 {
5359				return protohelpers.ErrIntOverflow
5360			}
5361			if iNdEx >= l {
5362				return io.ErrUnexpectedEOF
5363			}
5364			b := dAtA[iNdEx]
5365			iNdEx++
5366			wire |= uint64(b&0x7F) << shift
5367			if b < 0x80 {
5368				break
5369			}
5370		}
5371		fieldNum := int32(wire >> 3)
5372		wireType := int(wire & 0x7)
5373		if wireType == 4 {
5374			return fmt.Errorf("proto: RevokeDelegationRequest: wiretype end group for non-group")
5375		}
5376		if fieldNum <= 0 {
5377			return fmt.Errorf("proto: RevokeDelegationRequest: illegal tag %d (wire type %d)", fieldNum, wire)
5378		}
5379		switch fieldNum {
5380		case 1:
5381			if wireType != 2 {
5382				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
5383			}
5384			var stringLen uint64
5385			for shift := uint(0); ; shift += 7 {
5386				if shift >= 64 {
5387					return protohelpers.ErrIntOverflow
5388				}
5389				if iNdEx >= l {
5390					return io.ErrUnexpectedEOF
5391				}
5392				b := dAtA[iNdEx]
5393				iNdEx++
5394				stringLen |= uint64(b&0x7F) << shift
5395				if b < 0x80 {
5396					break
5397				}
5398			}
5399			intStringLen := int(stringLen)
5400			if intStringLen < 0 {
5401				return protohelpers.ErrInvalidLength
5402			}
5403			postIndex := iNdEx + intStringLen
5404			if postIndex < 0 {
5405				return protohelpers.ErrInvalidLength
5406			}
5407			if postIndex > l {
5408				return io.ErrUnexpectedEOF
5409			}
5410			m.Id = string(dAtA[iNdEx:postIndex])
5411			iNdEx = postIndex
5412		default:
5413			iNdEx = preIndex
5414			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
5415			if err != nil {
5416				return err
5417			}
5418			if (skippy < 0) || (iNdEx+skippy) < 0 {
5419				return protohelpers.ErrInvalidLength
5420			}
5421			if (iNdEx + skippy) > l {
5422				return io.ErrUnexpectedEOF
5423			}
5424			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
5425			iNdEx += skippy
5426		}
5427	}
5428 
5429	if iNdEx > l {
5430		return io.ErrUnexpectedEOF
5431	}
5432	return nil
5433}
5434func (m *RevokeDelegationResponse) UnmarshalVT(dAtA []byte) error {
5435	l := len(dAtA)
5436	iNdEx := 0
5437	for iNdEx < l {
5438		preIndex := iNdEx
5439		var wire uint64
5440		for shift := uint(0); ; shift += 7 {
5441			if shift >= 64 {
5442				return protohelpers.ErrIntOverflow
5443			}
5444			if iNdEx >= l {
5445				return io.ErrUnexpectedEOF
5446			}
5447			b := dAtA[iNdEx]
5448			iNdEx++
5449			wire |= uint64(b&0x7F) << shift
5450			if b < 0x80 {
5451				break
5452			}
5453		}
5454		fieldNum := int32(wire >> 3)
5455		wireType := int(wire & 0x7)
5456		if wireType == 4 {
5457			return fmt.Errorf("proto: RevokeDelegationResponse: wiretype end group for non-group")
5458		}
5459		if fieldNum <= 0 {
5460			return fmt.Errorf("proto: RevokeDelegationResponse: illegal tag %d (wire type %d)", fieldNum, wire)
5461		}
5462		switch fieldNum {
5463		case 1:
5464			if wireType != 0 {
5465				return fmt.Errorf("proto: wrong wireType = %d for field Revoked", wireType)
5466			}
5467			var v int
5468			for shift := uint(0); ; shift += 7 {
5469				if shift >= 64 {
5470					return protohelpers.ErrIntOverflow
5471				}
5472				if iNdEx >= l {
5473					return io.ErrUnexpectedEOF
5474				}
5475				b := dAtA[iNdEx]
5476				iNdEx++
5477				v |= int(b&0x7F) << shift
5478				if b < 0x80 {
5479					break
5480				}
5481			}
5482			m.Revoked = bool(v != 0)
5483		case 2:
5484			if wireType != 2 {
5485				return fmt.Errorf("proto: wrong wireType = %d for field IndexError", wireType)
5486			}
5487			var stringLen uint64
5488			for shift := uint(0); ; shift += 7 {
5489				if shift >= 64 {
5490					return protohelpers.ErrIntOverflow
5491				}
5492				if iNdEx >= l {
5493					return io.ErrUnexpectedEOF
5494				}
5495				b := dAtA[iNdEx]
5496				iNdEx++
5497				stringLen |= uint64(b&0x7F) << shift
5498				if b < 0x80 {
5499					break
5500				}
5501			}
5502			intStringLen := int(stringLen)
5503			if intStringLen < 0 {
5504				return protohelpers.ErrInvalidLength
5505			}
5506			postIndex := iNdEx + intStringLen
5507			if postIndex < 0 {
5508				return protohelpers.ErrInvalidLength
5509			}
5510			if postIndex > l {
5511				return io.ErrUnexpectedEOF
5512			}
5513			m.IndexError = string(dAtA[iNdEx:postIndex])
5514			iNdEx = postIndex
5515		default:
5516			iNdEx = preIndex
5517			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
5518			if err != nil {
5519				return err
5520			}
5521			if (skippy < 0) || (iNdEx+skippy) < 0 {
5522				return protohelpers.ErrInvalidLength
5523			}
5524			if (iNdEx + skippy) > l {
5525				return io.ErrUnexpectedEOF
5526			}
5527			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
5528			iNdEx += skippy
5529		}
5530	}
5531 
5532	if iNdEx > l {
5533		return io.ErrUnexpectedEOF
5534	}
5535	return nil
5536}
5537func (m *OpenEphemeralSessionRequest) UnmarshalVT(dAtA []byte) error {
5538	l := len(dAtA)
5539	iNdEx := 0
5540	for iNdEx < l {
5541		preIndex := iNdEx
5542		var wire uint64
5543		for shift := uint(0); ; shift += 7 {
5544			if shift >= 64 {
5545				return protohelpers.ErrIntOverflow
5546			}
5547			if iNdEx >= l {
5548				return io.ErrUnexpectedEOF
5549			}
5550			b := dAtA[iNdEx]
5551			iNdEx++
5552			wire |= uint64(b&0x7F) << shift
5553			if b < 0x80 {
5554				break
5555			}
5556		}
5557		fieldNum := int32(wire >> 3)
5558		wireType := int(wire & 0x7)
5559		if wireType == 4 {
5560			return fmt.Errorf("proto: OpenEphemeralSessionRequest: wiretype end group for non-group")
5561		}
5562		if fieldNum <= 0 {
5563			return fmt.Errorf("proto: OpenEphemeralSessionRequest: illegal tag %d (wire type %d)", fieldNum, wire)
5564		}
5565		switch fieldNum {
5566		default:
5567			iNdEx = preIndex
5568			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
5569			if err != nil {
5570				return err
5571			}
5572			if (skippy < 0) || (iNdEx+skippy) < 0 {
5573				return protohelpers.ErrInvalidLength
5574			}
5575			if (iNdEx + skippy) > l {
5576				return io.ErrUnexpectedEOF
5577			}
5578			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
5579			iNdEx += skippy
5580		}
5581	}
5582 
5583	if iNdEx > l {
5584		return io.ErrUnexpectedEOF
5585	}
5586	return nil
5587}
5588func (m *OpenDelegatedSessionRequest) UnmarshalVT(dAtA []byte) error {
5589	l := len(dAtA)
5590	iNdEx := 0
5591	for iNdEx < l {
5592		preIndex := iNdEx
5593		var wire uint64
5594		for shift := uint(0); ; shift += 7 {
5595			if shift >= 64 {
5596				return protohelpers.ErrIntOverflow
5597			}
5598			if iNdEx >= l {
5599				return io.ErrUnexpectedEOF
5600			}
5601			b := dAtA[iNdEx]
5602			iNdEx++
5603			wire |= uint64(b&0x7F) << shift
5604			if b < 0x80 {
5605				break
5606			}
5607		}
5608		fieldNum := int32(wire >> 3)
5609		wireType := int(wire & 0x7)
5610		if wireType == 4 {
5611			return fmt.Errorf("proto: OpenDelegatedSessionRequest: wiretype end group for non-group")
5612		}
5613		if fieldNum <= 0 {
5614			return fmt.Errorf("proto: OpenDelegatedSessionRequest: illegal tag %d (wire type %d)", fieldNum, wire)
5615		}
5616		switch fieldNum {
5617		case 1:
5618			if wireType != 2 {
5619				return fmt.Errorf("proto: wrong wireType = %d for field Token", wireType)
5620			}
5621			var stringLen uint64
5622			for shift := uint(0); ; shift += 7 {
5623				if shift >= 64 {
5624					return protohelpers.ErrIntOverflow
5625				}
5626				if iNdEx >= l {
5627					return io.ErrUnexpectedEOF
5628				}
5629				b := dAtA[iNdEx]
5630				iNdEx++
5631				stringLen |= uint64(b&0x7F) << shift
5632				if b < 0x80 {
5633					break
5634				}
5635			}
5636			intStringLen := int(stringLen)
5637			if intStringLen < 0 {
5638				return protohelpers.ErrInvalidLength
5639			}
5640			postIndex := iNdEx + intStringLen
5641			if postIndex < 0 {
5642				return protohelpers.ErrInvalidLength
5643			}
5644			if postIndex > l {
5645				return io.ErrUnexpectedEOF
5646			}
5647			m.Token = string(dAtA[iNdEx:postIndex])
5648			iNdEx = postIndex
5649		case 2:
5650			if wireType != 0 {
5651				return fmt.Errorf("proto: wrong wireType = %d for field RouteSlot", wireType)
5652			}
5653			m.RouteSlot = 0
5654			for shift := uint(0); ; shift += 7 {
5655				if shift >= 64 {
5656					return protohelpers.ErrIntOverflow
5657				}
5658				if iNdEx >= l {
5659					return io.ErrUnexpectedEOF
5660				}
5661				b := dAtA[iNdEx]
5662				iNdEx++
5663				m.RouteSlot |= uint32(b&0x7F) << shift
5664				if b < 0x80 {
5665					break
5666				}
5667			}
5668		default:
5669			iNdEx = preIndex
5670			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
5671			if err != nil {
5672				return err
5673			}
5674			if (skippy < 0) || (iNdEx+skippy) < 0 {
5675				return protohelpers.ErrInvalidLength
5676			}
5677			if (iNdEx + skippy) > l {
5678				return io.ErrUnexpectedEOF
5679			}
5680			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
5681			iNdEx += skippy
5682		}
5683	}
5684 
5685	if iNdEx > l {
5686		return io.ErrUnexpectedEOF
5687	}
5688	return nil
5689}
5690func (m *OpenSessionResponse) UnmarshalVT(dAtA []byte) error {
5691	l := len(dAtA)
5692	iNdEx := 0
5693	for iNdEx < l {
5694		preIndex := iNdEx
5695		var wire uint64
5696		for shift := uint(0); ; shift += 7 {
5697			if shift >= 64 {
5698				return protohelpers.ErrIntOverflow
5699			}
5700			if iNdEx >= l {
5701				return io.ErrUnexpectedEOF
5702			}
5703			b := dAtA[iNdEx]
5704			iNdEx++
5705			wire |= uint64(b&0x7F) << shift
5706			if b < 0x80 {
5707				break
5708			}
5709		}
5710		fieldNum := int32(wire >> 3)
5711		wireType := int(wire & 0x7)
5712		if wireType == 4 {
5713			return fmt.Errorf("proto: OpenSessionResponse: wiretype end group for non-group")
5714		}
5715		if fieldNum <= 0 {
5716			return fmt.Errorf("proto: OpenSessionResponse: illegal tag %d (wire type %d)", fieldNum, wire)
5717		}
5718		switch fieldNum {
5719		case 1:
5720			if wireType != 2 {
5721				return fmt.Errorf("proto: wrong wireType = %d for field Hostname", wireType)
5722			}
5723			var stringLen uint64
5724			for shift := uint(0); ; shift += 7 {
5725				if shift >= 64 {
5726					return protohelpers.ErrIntOverflow
5727				}
5728				if iNdEx >= l {
5729					return io.ErrUnexpectedEOF
5730				}
5731				b := dAtA[iNdEx]
5732				iNdEx++
5733				stringLen |= uint64(b&0x7F) << shift
5734				if b < 0x80 {
5735					break
5736				}
5737			}
5738			intStringLen := int(stringLen)
5739			if intStringLen < 0 {
5740				return protohelpers.ErrInvalidLength
5741			}
5742			postIndex := iNdEx + intStringLen
5743			if postIndex < 0 {
5744				return protohelpers.ErrInvalidLength
5745			}
5746			if postIndex > l {
5747				return io.ErrUnexpectedEOF
5748			}
5749			m.Hostname = string(dAtA[iNdEx:postIndex])
5750			iNdEx = postIndex
5751		case 2:
5752			if wireType != 2 {
5753				return fmt.Errorf("proto: wrong wireType = %d for field Apex", wireType)
5754			}
5755			var stringLen uint64
5756			for shift := uint(0); ; shift += 7 {
5757				if shift >= 64 {
5758					return protohelpers.ErrIntOverflow
5759				}
5760				if iNdEx >= l {
5761					return io.ErrUnexpectedEOF
5762				}
5763				b := dAtA[iNdEx]
5764				iNdEx++
5765				stringLen |= uint64(b&0x7F) << shift
5766				if b < 0x80 {
5767					break
5768				}
5769			}
5770			intStringLen := int(stringLen)
5771			if intStringLen < 0 {
5772				return protohelpers.ErrInvalidLength
5773			}
5774			postIndex := iNdEx + intStringLen
5775			if postIndex < 0 {
5776				return protohelpers.ErrInvalidLength
5777			}
5778			if postIndex > l {
5779				return io.ErrUnexpectedEOF
5780			}
5781			m.Apex = string(dAtA[iNdEx:postIndex])
5782			iNdEx = postIndex
5783		case 3:
5784			if wireType != 2 {
5785				return fmt.Errorf("proto: wrong wireType = %d for field GrantId", wireType)
5786			}
5787			var stringLen uint64
5788			for shift := uint(0); ; shift += 7 {
5789				if shift >= 64 {
5790					return protohelpers.ErrIntOverflow
5791				}
5792				if iNdEx >= l {
5793					return io.ErrUnexpectedEOF
5794				}
5795				b := dAtA[iNdEx]
5796				iNdEx++
5797				stringLen |= uint64(b&0x7F) << shift
5798				if b < 0x80 {
5799					break
5800				}
5801			}
5802			intStringLen := int(stringLen)
5803			if intStringLen < 0 {
5804				return protohelpers.ErrInvalidLength
5805			}
5806			postIndex := iNdEx + intStringLen
5807			if postIndex < 0 {
5808				return protohelpers.ErrInvalidLength
5809			}
5810			if postIndex > l {
5811				return io.ErrUnexpectedEOF
5812			}
5813			m.GrantId = string(dAtA[iNdEx:postIndex])
5814			iNdEx = postIndex
5815		case 4:
5816			if wireType != 0 {
5817				return fmt.Errorf("proto: wrong wireType = %d for field ExpiresAt", wireType)
5818			}
5819			m.ExpiresAt = 0
5820			for shift := uint(0); ; shift += 7 {
5821				if shift >= 64 {
5822					return protohelpers.ErrIntOverflow
5823				}
5824				if iNdEx >= l {
5825					return io.ErrUnexpectedEOF
5826				}
5827				b := dAtA[iNdEx]
5828				iNdEx++
5829				m.ExpiresAt |= int64(b&0x7F) << shift
5830				if b < 0x80 {
5831					break
5832				}
5833			}
5834		case 5:
5835			if wireType != 2 {
5836				return fmt.Errorf("proto: wrong wireType = %d for field Node", wireType)
5837			}
5838			var msglen int
5839			for shift := uint(0); ; shift += 7 {
5840				if shift >= 64 {
5841					return protohelpers.ErrIntOverflow
5842				}
5843				if iNdEx >= l {
5844					return io.ErrUnexpectedEOF
5845				}
5846				b := dAtA[iNdEx]
5847				iNdEx++
5848				msglen |= int(b&0x7F) << shift
5849				if b < 0x80 {
5850					break
5851				}
5852			}
5853			if msglen < 0 {
5854				return protohelpers.ErrInvalidLength
5855			}
5856			postIndex := iNdEx + msglen
5857			if postIndex < 0 {
5858				return protohelpers.ErrInvalidLength
5859			}
5860			if postIndex > l {
5861				return io.ErrUnexpectedEOF
5862			}
5863			if m.Node == nil {
5864				m.Node = &Node{}
5865			}
5866			if err := m.Node.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
5867				return err
5868			}
5869			iNdEx = postIndex
5870		default:
5871			iNdEx = preIndex
5872			skippy, err := protohelpers.Skip(dAtA[iNdEx:])
5873			if err != nil {
5874				return err
5875			}
5876			if (skippy < 0) || (iNdEx+skippy) < 0 {
5877				return protohelpers.ErrInvalidLength
5878			}
5879			if (iNdEx + skippy) > l {
5880				return io.ErrUnexpectedEOF
5881			}
5882			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
5883			iNdEx += skippy
5884		}
5885	}
5886 
5887	if iNdEx > l {
5888		return io.ErrUnexpectedEOF
5889	}
5890	return nil
5891}