GitVita
New repositoryImport repositoryNew issue
Your repositories Your dashboard Sign in

cloudflare/cloudflared

Public

mirrored from https://github.com/cloudflare/cloudflaredAvailable

Watch0Fork0Star0
CodeCommitsIssuesPull requestsActionsInsightsSecurity
2018.12.0

Branches

Tags

  • No tags available.
0Branches0Tags
Go to file
Add file
Code

Clone

HTTPS

Download ZIP

cloudflared/tunnelrpc

tunnelrpc/tunnelrpc.capnp.go

1434lines · modecode

RawDownload
Latest commit unavailable.
1// Code generated by capnpc-go. DO NOT EDIT.
2
3package tunnelrpc
4
5import (
6 context "golang.org/x/net/context"
7 capnp "zombiezen.com/go/capnproto2"
8 text "zombiezen.com/go/capnproto2/encoding/text"
9 schemas "zombiezen.com/go/capnproto2/schemas"
10 server "zombiezen.com/go/capnproto2/server"
11)
12
13type Authentication struct{ capnp.Struct }
14
15// Authentication_TypeID is the unique identifier for the type Authentication.
16const Authentication_TypeID = 0xc082ef6e0d42ed1d
17
18func NewAuthentication(s *capnp.Segment) (Authentication, error) {
19 st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3})
20 return Authentication{st}, err
21}
22
23func NewRootAuthentication(s *capnp.Segment) (Authentication, error) {
24 st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3})
25 return Authentication{st}, err
26}
27
28func ReadRootAuthentication(msg *capnp.Message) (Authentication, error) {
29 root, err := msg.RootPtr()
30 return Authentication{root.Struct()}, err
31}
32
33func (s Authentication) String() string {
34 str, _ := text.Marshal(0xc082ef6e0d42ed1d, s.Struct)
35 return str
36}
37
38func (s Authentication) Key() (string, error) {
39 p, err := s.Struct.Ptr(0)
40 return p.Text(), err
41}
42
43func (s Authentication) HasKey() bool {
44 p, err := s.Struct.Ptr(0)
45 return p.IsValid() || err != nil
46}
47
48func (s Authentication) KeyBytes() ([]byte, error) {
49 p, err := s.Struct.Ptr(0)
50 return p.TextBytes(), err
51}
52
53func (s Authentication) SetKey(v string) error {
54 return s.Struct.SetText(0, v)
55}
56
57func (s Authentication) Email() (string, error) {
58 p, err := s.Struct.Ptr(1)
59 return p.Text(), err
60}
61
62func (s Authentication) HasEmail() bool {
63 p, err := s.Struct.Ptr(1)
64 return p.IsValid() || err != nil
65}
66
67func (s Authentication) EmailBytes() ([]byte, error) {
68 p, err := s.Struct.Ptr(1)
69 return p.TextBytes(), err
70}
71
72func (s Authentication) SetEmail(v string) error {
73 return s.Struct.SetText(1, v)
74}
75
76func (s Authentication) OriginCAKey() (string, error) {
77 p, err := s.Struct.Ptr(2)
78 return p.Text(), err
79}
80
81func (s Authentication) HasOriginCAKey() bool {
82 p, err := s.Struct.Ptr(2)
83 return p.IsValid() || err != nil
84}
85
86func (s Authentication) OriginCAKeyBytes() ([]byte, error) {
87 p, err := s.Struct.Ptr(2)
88 return p.TextBytes(), err
89}
90
91func (s Authentication) SetOriginCAKey(v string) error {
92 return s.Struct.SetText(2, v)
93}
94
95// Authentication_List is a list of Authentication.
96type Authentication_List struct{ capnp.List }
97
98// NewAuthentication creates a new list of Authentication.
99func NewAuthentication_List(s *capnp.Segment, sz int32) (Authentication_List, error) {
100 l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3}, sz)
101 return Authentication_List{l}, err
102}
103
104func (s Authentication_List) At(i int) Authentication { return Authentication{s.List.Struct(i)} }
105
106func (s Authentication_List) Set(i int, v Authentication) error { return s.List.SetStruct(i, v.Struct) }
107
108func (s Authentication_List) String() string {
109 str, _ := text.MarshalList(0xc082ef6e0d42ed1d, s.List)
110 return str
111}
112
113// Authentication_Promise is a wrapper for a Authentication promised by a client call.
114type Authentication_Promise struct{ *capnp.Pipeline }
115
116func (p Authentication_Promise) Struct() (Authentication, error) {
117 s, err := p.Pipeline.Struct()
118 return Authentication{s}, err
119}
120
121type TunnelRegistration struct{ capnp.Struct }
122
123// TunnelRegistration_TypeID is the unique identifier for the type TunnelRegistration.
124const TunnelRegistration_TypeID = 0xf41a0f001ad49e46
125
126func NewTunnelRegistration(s *capnp.Segment) (TunnelRegistration, error) {
127 st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 4})
128 return TunnelRegistration{st}, err
129}
130
131func NewRootTunnelRegistration(s *capnp.Segment) (TunnelRegistration, error) {
132 st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 4})
133 return TunnelRegistration{st}, err
134}
135
136func ReadRootTunnelRegistration(msg *capnp.Message) (TunnelRegistration, error) {
137 root, err := msg.RootPtr()
138 return TunnelRegistration{root.Struct()}, err
139}
140
141func (s TunnelRegistration) String() string {
142 str, _ := text.Marshal(0xf41a0f001ad49e46, s.Struct)
143 return str
144}
145
146func (s TunnelRegistration) Err() (string, error) {
147 p, err := s.Struct.Ptr(0)
148 return p.Text(), err
149}
150
151func (s TunnelRegistration) HasErr() bool {
152 p, err := s.Struct.Ptr(0)
153 return p.IsValid() || err != nil
154}
155
156func (s TunnelRegistration) ErrBytes() ([]byte, error) {
157 p, err := s.Struct.Ptr(0)
158 return p.TextBytes(), err
159}
160
161func (s TunnelRegistration) SetErr(v string) error {
162 return s.Struct.SetText(0, v)
163}
164
165func (s TunnelRegistration) Url() (string, error) {
166 p, err := s.Struct.Ptr(1)
167 return p.Text(), err
168}
169
170func (s TunnelRegistration) HasUrl() bool {
171 p, err := s.Struct.Ptr(1)
172 return p.IsValid() || err != nil
173}
174
175func (s TunnelRegistration) UrlBytes() ([]byte, error) {
176 p, err := s.Struct.Ptr(1)
177 return p.TextBytes(), err
178}
179
180func (s TunnelRegistration) SetUrl(v string) error {
181 return s.Struct.SetText(1, v)
182}
183
184func (s TunnelRegistration) LogLines() (capnp.TextList, error) {
185 p, err := s.Struct.Ptr(2)
186 return capnp.TextList{List: p.List()}, err
187}
188
189func (s TunnelRegistration) HasLogLines() bool {
190 p, err := s.Struct.Ptr(2)
191 return p.IsValid() || err != nil
192}
193
194func (s TunnelRegistration) SetLogLines(v capnp.TextList) error {
195 return s.Struct.SetPtr(2, v.List.ToPtr())
196}
197
198// NewLogLines sets the logLines field to a newly
199// allocated capnp.TextList, preferring placement in s's segment.
200func (s TunnelRegistration) NewLogLines(n int32) (capnp.TextList, error) {
201 l, err := capnp.NewTextList(s.Struct.Segment(), n)
202 if err != nil {
203 return capnp.TextList{}, err
204 }
205 err = s.Struct.SetPtr(2, l.List.ToPtr())
206 return l, err
207}
208
209func (s TunnelRegistration) PermanentFailure() bool {
210 return s.Struct.Bit(0)
211}
212
213func (s TunnelRegistration) SetPermanentFailure(v bool) {
214 s.Struct.SetBit(0, v)
215}
216
217func (s TunnelRegistration) TunnelID() (string, error) {
218 p, err := s.Struct.Ptr(3)
219 return p.Text(), err
220}
221
222func (s TunnelRegistration) HasTunnelID() bool {
223 p, err := s.Struct.Ptr(3)
224 return p.IsValid() || err != nil
225}
226
227func (s TunnelRegistration) TunnelIDBytes() ([]byte, error) {
228 p, err := s.Struct.Ptr(3)
229 return p.TextBytes(), err
230}
231
232func (s TunnelRegistration) SetTunnelID(v string) error {
233 return s.Struct.SetText(3, v)
234}
235
236// TunnelRegistration_List is a list of TunnelRegistration.
237type TunnelRegistration_List struct{ capnp.List }
238
239// NewTunnelRegistration creates a new list of TunnelRegistration.
240func NewTunnelRegistration_List(s *capnp.Segment, sz int32) (TunnelRegistration_List, error) {
241 l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 4}, sz)
242 return TunnelRegistration_List{l}, err
243}
244
245func (s TunnelRegistration_List) At(i int) TunnelRegistration {
246 return TunnelRegistration{s.List.Struct(i)}
247}
248
249func (s TunnelRegistration_List) Set(i int, v TunnelRegistration) error {
250 return s.List.SetStruct(i, v.Struct)
251}
252
253func (s TunnelRegistration_List) String() string {
254 str, _ := text.MarshalList(0xf41a0f001ad49e46, s.List)
255 return str
256}
257
258// TunnelRegistration_Promise is a wrapper for a TunnelRegistration promised by a client call.
259type TunnelRegistration_Promise struct{ *capnp.Pipeline }
260
261func (p TunnelRegistration_Promise) Struct() (TunnelRegistration, error) {
262 s, err := p.Pipeline.Struct()
263 return TunnelRegistration{s}, err
264}
265
266type RegistrationOptions struct{ capnp.Struct }
267
268// RegistrationOptions_TypeID is the unique identifier for the type RegistrationOptions.
269const RegistrationOptions_TypeID = 0xc793e50592935b4a
270
271func NewRegistrationOptions(s *capnp.Segment) (RegistrationOptions, error) {
272 st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 16, PointerCount: 7})
273 return RegistrationOptions{st}, err
274}
275
276func NewRootRegistrationOptions(s *capnp.Segment) (RegistrationOptions, error) {
277 st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 16, PointerCount: 7})
278 return RegistrationOptions{st}, err
279}
280
281func ReadRootRegistrationOptions(msg *capnp.Message) (RegistrationOptions, error) {
282 root, err := msg.RootPtr()
283 return RegistrationOptions{root.Struct()}, err
284}
285
286func (s RegistrationOptions) String() string {
287 str, _ := text.Marshal(0xc793e50592935b4a, s.Struct)
288 return str
289}
290
291func (s RegistrationOptions) ClientId() (string, error) {
292 p, err := s.Struct.Ptr(0)
293 return p.Text(), err
294}
295
296func (s RegistrationOptions) HasClientId() bool {
297 p, err := s.Struct.Ptr(0)
298 return p.IsValid() || err != nil
299}
300
301func (s RegistrationOptions) ClientIdBytes() ([]byte, error) {
302 p, err := s.Struct.Ptr(0)
303 return p.TextBytes(), err
304}
305
306func (s RegistrationOptions) SetClientId(v string) error {
307 return s.Struct.SetText(0, v)
308}
309
310func (s RegistrationOptions) Version() (string, error) {
311 p, err := s.Struct.Ptr(1)
312 return p.Text(), err
313}
314
315func (s RegistrationOptions) HasVersion() bool {
316 p, err := s.Struct.Ptr(1)
317 return p.IsValid() || err != nil
318}
319
320func (s RegistrationOptions) VersionBytes() ([]byte, error) {
321 p, err := s.Struct.Ptr(1)
322 return p.TextBytes(), err
323}
324
325func (s RegistrationOptions) SetVersion(v string) error {
326 return s.Struct.SetText(1, v)
327}
328
329func (s RegistrationOptions) Os() (string, error) {
330 p, err := s.Struct.Ptr(2)
331 return p.Text(), err
332}
333
334func (s RegistrationOptions) HasOs() bool {
335 p, err := s.Struct.Ptr(2)
336 return p.IsValid() || err != nil
337}
338
339func (s RegistrationOptions) OsBytes() ([]byte, error) {
340 p, err := s.Struct.Ptr(2)
341 return p.TextBytes(), err
342}
343
344func (s RegistrationOptions) SetOs(v string) error {
345 return s.Struct.SetText(2, v)
346}
347
348func (s RegistrationOptions) ExistingTunnelPolicy() ExistingTunnelPolicy {
349 return ExistingTunnelPolicy(s.Struct.Uint16(0))
350}
351
352func (s RegistrationOptions) SetExistingTunnelPolicy(v ExistingTunnelPolicy) {
353 s.Struct.SetUint16(0, uint16(v))
354}
355
356func (s RegistrationOptions) PoolName() (string, error) {
357 p, err := s.Struct.Ptr(3)
358 return p.Text(), err
359}
360
361func (s RegistrationOptions) HasPoolName() bool {
362 p, err := s.Struct.Ptr(3)
363 return p.IsValid() || err != nil
364}
365
366func (s RegistrationOptions) PoolNameBytes() ([]byte, error) {
367 p, err := s.Struct.Ptr(3)
368 return p.TextBytes(), err
369}
370
371func (s RegistrationOptions) SetPoolName(v string) error {
372 return s.Struct.SetText(3, v)
373}
374
375func (s RegistrationOptions) Tags() (Tag_List, error) {
376 p, err := s.Struct.Ptr(4)
377 return Tag_List{List: p.List()}, err
378}
379
380func (s RegistrationOptions) HasTags() bool {
381 p, err := s.Struct.Ptr(4)
382 return p.IsValid() || err != nil
383}
384
385func (s RegistrationOptions) SetTags(v Tag_List) error {
386 return s.Struct.SetPtr(4, v.List.ToPtr())
387}
388
389// NewTags sets the tags field to a newly
390// allocated Tag_List, preferring placement in s's segment.
391func (s RegistrationOptions) NewTags(n int32) (Tag_List, error) {
392 l, err := NewTag_List(s.Struct.Segment(), n)
393 if err != nil {
394 return Tag_List{}, err
395 }
396 err = s.Struct.SetPtr(4, l.List.ToPtr())
397 return l, err
398}
399
400func (s RegistrationOptions) ConnectionId() uint8 {
401 return s.Struct.Uint8(2)
402}
403
404func (s RegistrationOptions) SetConnectionId(v uint8) {
405 s.Struct.SetUint8(2, v)
406}
407
408func (s RegistrationOptions) OriginLocalIp() (string, error) {
409 p, err := s.Struct.Ptr(5)
410 return p.Text(), err
411}
412
413func (s RegistrationOptions) HasOriginLocalIp() bool {
414 p, err := s.Struct.Ptr(5)
415 return p.IsValid() || err != nil
416}
417
418func (s RegistrationOptions) OriginLocalIpBytes() ([]byte, error) {
419 p, err := s.Struct.Ptr(5)
420 return p.TextBytes(), err
421}
422
423func (s RegistrationOptions) SetOriginLocalIp(v string) error {
424 return s.Struct.SetText(5, v)
425}
426
427func (s RegistrationOptions) IsAutoupdated() bool {
428 return s.Struct.Bit(24)
429}
430
431func (s RegistrationOptions) SetIsAutoupdated(v bool) {
432 s.Struct.SetBit(24, v)
433}
434
435func (s RegistrationOptions) RunFromTerminal() bool {
436 return s.Struct.Bit(25)
437}
438
439func (s RegistrationOptions) SetRunFromTerminal(v bool) {
440 s.Struct.SetBit(25, v)
441}
442
443func (s RegistrationOptions) CompressionQuality() uint64 {
444 return s.Struct.Uint64(8)
445}
446
447func (s RegistrationOptions) SetCompressionQuality(v uint64) {
448 s.Struct.SetUint64(8, v)
449}
450
451func (s RegistrationOptions) Uuid() (string, error) {
452 p, err := s.Struct.Ptr(6)
453 return p.Text(), err
454}
455
456func (s RegistrationOptions) HasUuid() bool {
457 p, err := s.Struct.Ptr(6)
458 return p.IsValid() || err != nil
459}
460
461func (s RegistrationOptions) UuidBytes() ([]byte, error) {
462 p, err := s.Struct.Ptr(6)
463 return p.TextBytes(), err
464}
465
466func (s RegistrationOptions) SetUuid(v string) error {
467 return s.Struct.SetText(6, v)
468}
469
470// RegistrationOptions_List is a list of RegistrationOptions.
471type RegistrationOptions_List struct{ capnp.List }
472
473// NewRegistrationOptions creates a new list of RegistrationOptions.
474func NewRegistrationOptions_List(s *capnp.Segment, sz int32) (RegistrationOptions_List, error) {
475 l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 16, PointerCount: 7}, sz)
476 return RegistrationOptions_List{l}, err
477}
478
479func (s RegistrationOptions_List) At(i int) RegistrationOptions {
480 return RegistrationOptions{s.List.Struct(i)}
481}
482
483func (s RegistrationOptions_List) Set(i int, v RegistrationOptions) error {
484 return s.List.SetStruct(i, v.Struct)
485}
486
487func (s RegistrationOptions_List) String() string {
488 str, _ := text.MarshalList(0xc793e50592935b4a, s.List)
489 return str
490}
491
492// RegistrationOptions_Promise is a wrapper for a RegistrationOptions promised by a client call.
493type RegistrationOptions_Promise struct{ *capnp.Pipeline }
494
495func (p RegistrationOptions_Promise) Struct() (RegistrationOptions, error) {
496 s, err := p.Pipeline.Struct()
497 return RegistrationOptions{s}, err
498}
499
500type Tag struct{ capnp.Struct }
501
502// Tag_TypeID is the unique identifier for the type Tag.
503const Tag_TypeID = 0xcbd96442ae3bb01a
504
505func NewTag(s *capnp.Segment) (Tag, error) {
506 st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2})
507 return Tag{st}, err
508}
509
510func NewRootTag(s *capnp.Segment) (Tag, error) {
511 st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2})
512 return Tag{st}, err
513}
514
515func ReadRootTag(msg *capnp.Message) (Tag, error) {
516 root, err := msg.RootPtr()
517 return Tag{root.Struct()}, err
518}
519
520func (s Tag) String() string {
521 str, _ := text.Marshal(0xcbd96442ae3bb01a, s.Struct)
522 return str
523}
524
525func (s Tag) Name() (string, error) {
526 p, err := s.Struct.Ptr(0)
527 return p.Text(), err
528}
529
530func (s Tag) HasName() bool {
531 p, err := s.Struct.Ptr(0)
532 return p.IsValid() || err != nil
533}
534
535func (s Tag) NameBytes() ([]byte, error) {
536 p, err := s.Struct.Ptr(0)
537 return p.TextBytes(), err
538}
539
540func (s Tag) SetName(v string) error {
541 return s.Struct.SetText(0, v)
542}
543
544func (s Tag) Value() (string, error) {
545 p, err := s.Struct.Ptr(1)
546 return p.Text(), err
547}
548
549func (s Tag) HasValue() bool {
550 p, err := s.Struct.Ptr(1)
551 return p.IsValid() || err != nil
552}
553
554func (s Tag) ValueBytes() ([]byte, error) {
555 p, err := s.Struct.Ptr(1)
556 return p.TextBytes(), err
557}
558
559func (s Tag) SetValue(v string) error {
560 return s.Struct.SetText(1, v)
561}
562
563// Tag_List is a list of Tag.
564type Tag_List struct{ capnp.List }
565
566// NewTag creates a new list of Tag.
567func NewTag_List(s *capnp.Segment, sz int32) (Tag_List, error) {
568 l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2}, sz)
569 return Tag_List{l}, err
570}
571
572func (s Tag_List) At(i int) Tag { return Tag{s.List.Struct(i)} }
573
574func (s Tag_List) Set(i int, v Tag) error { return s.List.SetStruct(i, v.Struct) }
575
576func (s Tag_List) String() string {
577 str, _ := text.MarshalList(0xcbd96442ae3bb01a, s.List)
578 return str
579}
580
581// Tag_Promise is a wrapper for a Tag promised by a client call.
582type Tag_Promise struct{ *capnp.Pipeline }
583
584func (p Tag_Promise) Struct() (Tag, error) {
585 s, err := p.Pipeline.Struct()
586 return Tag{s}, err
587}
588
589type ExistingTunnelPolicy uint16
590
591// ExistingTunnelPolicy_TypeID is the unique identifier for the type ExistingTunnelPolicy.
592const ExistingTunnelPolicy_TypeID = 0x84cb9536a2cf6d3c
593
594// Values of ExistingTunnelPolicy.
595const (
596 ExistingTunnelPolicy_ignore ExistingTunnelPolicy = 0
597 ExistingTunnelPolicy_disconnect ExistingTunnelPolicy = 1
598 ExistingTunnelPolicy_balance ExistingTunnelPolicy = 2
599)
600
601// String returns the enum's constant name.
602func (c ExistingTunnelPolicy) String() string {
603 switch c {
604 case ExistingTunnelPolicy_ignore:
605 return "ignore"
606 case ExistingTunnelPolicy_disconnect:
607 return "disconnect"
608 case ExistingTunnelPolicy_balance:
609 return "balance"
610
611 default:
612 return ""
613 }
614}
615
616// ExistingTunnelPolicyFromString returns the enum value with a name,
617// or the zero value if there's no such value.
618func ExistingTunnelPolicyFromString(c string) ExistingTunnelPolicy {
619 switch c {
620 case "ignore":
621 return ExistingTunnelPolicy_ignore
622 case "disconnect":
623 return ExistingTunnelPolicy_disconnect
624 case "balance":
625 return ExistingTunnelPolicy_balance
626
627 default:
628 return 0
629 }
630}
631
632type ExistingTunnelPolicy_List struct{ capnp.List }
633
634func NewExistingTunnelPolicy_List(s *capnp.Segment, sz int32) (ExistingTunnelPolicy_List, error) {
635 l, err := capnp.NewUInt16List(s, sz)
636 return ExistingTunnelPolicy_List{l.List}, err
637}
638
639func (l ExistingTunnelPolicy_List) At(i int) ExistingTunnelPolicy {
640 ul := capnp.UInt16List{List: l.List}
641 return ExistingTunnelPolicy(ul.At(i))
642}
643
644func (l ExistingTunnelPolicy_List) Set(i int, v ExistingTunnelPolicy) {
645 ul := capnp.UInt16List{List: l.List}
646 ul.Set(i, uint16(v))
647}
648
649type ServerInfo struct{ capnp.Struct }
650
651// ServerInfo_TypeID is the unique identifier for the type ServerInfo.
652const ServerInfo_TypeID = 0xf2c68e2547ec3866
653
654func NewServerInfo(s *capnp.Segment) (ServerInfo, error) {
655 st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
656 return ServerInfo{st}, err
657}
658
659func NewRootServerInfo(s *capnp.Segment) (ServerInfo, error) {
660 st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
661 return ServerInfo{st}, err
662}
663
664func ReadRootServerInfo(msg *capnp.Message) (ServerInfo, error) {
665 root, err := msg.RootPtr()
666 return ServerInfo{root.Struct()}, err
667}
668
669func (s ServerInfo) String() string {
670 str, _ := text.Marshal(0xf2c68e2547ec3866, s.Struct)
671 return str
672}
673
674func (s ServerInfo) LocationName() (string, error) {
675 p, err := s.Struct.Ptr(0)
676 return p.Text(), err
677}
678
679func (s ServerInfo) HasLocationName() bool {
680 p, err := s.Struct.Ptr(0)
681 return p.IsValid() || err != nil
682}
683
684func (s ServerInfo) LocationNameBytes() ([]byte, error) {
685 p, err := s.Struct.Ptr(0)
686 return p.TextBytes(), err
687}
688
689func (s ServerInfo) SetLocationName(v string) error {
690 return s.Struct.SetText(0, v)
691}
692
693// ServerInfo_List is a list of ServerInfo.
694type ServerInfo_List struct{ capnp.List }
695
696// NewServerInfo creates a new list of ServerInfo.
697func NewServerInfo_List(s *capnp.Segment, sz int32) (ServerInfo_List, error) {
698 l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
699 return ServerInfo_List{l}, err
700}
701
702func (s ServerInfo_List) At(i int) ServerInfo { return ServerInfo{s.List.Struct(i)} }
703
704func (s ServerInfo_List) Set(i int, v ServerInfo) error { return s.List.SetStruct(i, v.Struct) }
705
706func (s ServerInfo_List) String() string {
707 str, _ := text.MarshalList(0xf2c68e2547ec3866, s.List)
708 return str
709}
710
711// ServerInfo_Promise is a wrapper for a ServerInfo promised by a client call.
712type ServerInfo_Promise struct{ *capnp.Pipeline }
713
714func (p ServerInfo_Promise) Struct() (ServerInfo, error) {
715 s, err := p.Pipeline.Struct()
716 return ServerInfo{s}, err
717}
718
719type TunnelServer struct{ Client capnp.Client }
720
721// TunnelServer_TypeID is the unique identifier for the type TunnelServer.
722const TunnelServer_TypeID = 0xea58385c65416035
723
724func (c TunnelServer) RegisterTunnel(ctx context.Context, params func(TunnelServer_registerTunnel_Params) error, opts ...capnp.CallOption) TunnelServer_registerTunnel_Results_Promise {
725 if c.Client == nil {
726 return TunnelServer_registerTunnel_Results_Promise{Pipeline: capnp.NewPipeline(capnp.ErrorAnswer(capnp.ErrNullClient))}
727 }
728 call := &capnp.Call{
729 Ctx: ctx,
730 Method: capnp.Method{
731 InterfaceID: 0xea58385c65416035,
732 MethodID: 0,
733 InterfaceName: "tunnelrpc/tunnelrpc.capnp:TunnelServer",
734 MethodName: "registerTunnel",
735 },
736 Options: capnp.NewCallOptions(opts),
737 }
738 if params != nil {
739 call.ParamsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 3}
740 call.ParamsFunc = func(s capnp.Struct) error { return params(TunnelServer_registerTunnel_Params{Struct: s}) }
741 }
742 return TunnelServer_registerTunnel_Results_Promise{Pipeline: capnp.NewPipeline(c.Client.Call(call))}
743}
744func (c TunnelServer) GetServerInfo(ctx context.Context, params func(TunnelServer_getServerInfo_Params) error, opts ...capnp.CallOption) TunnelServer_getServerInfo_Results_Promise {
745 if c.Client == nil {
746 return TunnelServer_getServerInfo_Results_Promise{Pipeline: capnp.NewPipeline(capnp.ErrorAnswer(capnp.ErrNullClient))}
747 }
748 call := &capnp.Call{
749 Ctx: ctx,
750 Method: capnp.Method{
751 InterfaceID: 0xea58385c65416035,
752 MethodID: 1,
753 InterfaceName: "tunnelrpc/tunnelrpc.capnp:TunnelServer",
754 MethodName: "getServerInfo",
755 },
756 Options: capnp.NewCallOptions(opts),
757 }
758 if params != nil {
759 call.ParamsSize = capnp.ObjectSize{DataSize: 0, PointerCount: 0}
760 call.ParamsFunc = func(s capnp.Struct) error { return params(TunnelServer_getServerInfo_Params{Struct: s}) }
761 }
762 return TunnelServer_getServerInfo_Results_Promise{Pipeline: capnp.NewPipeline(c.Client.Call(call))}
763}
764func (c TunnelServer) UnregisterTunnel(ctx context.Context, params func(TunnelServer_unregisterTunnel_Params) error, opts ...capnp.CallOption) TunnelServer_unregisterTunnel_Results_Promise {
765 if c.Client == nil {
766 return TunnelServer_unregisterTunnel_Results_Promise{Pipeline: capnp.NewPipeline(capnp.ErrorAnswer(capnp.ErrNullClient))}
767 }
768 call := &capnp.Call{
769 Ctx: ctx,
770 Method: capnp.Method{
771 InterfaceID: 0xea58385c65416035,
772 MethodID: 2,
773 InterfaceName: "tunnelrpc/tunnelrpc.capnp:TunnelServer",
774 MethodName: "unregisterTunnel",
775 },
776 Options: capnp.NewCallOptions(opts),
777 }
778 if params != nil {
779 call.ParamsSize = capnp.ObjectSize{DataSize: 8, PointerCount: 0}
780 call.ParamsFunc = func(s capnp.Struct) error { return params(TunnelServer_unregisterTunnel_Params{Struct: s}) }
781 }
782 return TunnelServer_unregisterTunnel_Results_Promise{Pipeline: capnp.NewPipeline(c.Client.Call(call))}
783}
784
785type TunnelServer_Server interface {
786 RegisterTunnel(TunnelServer_registerTunnel) error
787
788 GetServerInfo(TunnelServer_getServerInfo) error
789
790 UnregisterTunnel(TunnelServer_unregisterTunnel) error
791}
792
793func TunnelServer_ServerToClient(s TunnelServer_Server) TunnelServer {
794 c, _ := s.(server.Closer)
795 return TunnelServer{Client: server.New(TunnelServer_Methods(nil, s), c)}
796}
797
798func TunnelServer_Methods(methods []server.Method, s TunnelServer_Server) []server.Method {
799 if cap(methods) == 0 {
800 methods = make([]server.Method, 0, 3)
801 }
802
803 methods = append(methods, server.Method{
804 Method: capnp.Method{
805 InterfaceID: 0xea58385c65416035,
806 MethodID: 0,
807 InterfaceName: "tunnelrpc/tunnelrpc.capnp:TunnelServer",
808 MethodName: "registerTunnel",
809 },
810 Impl: func(c context.Context, opts capnp.CallOptions, p, r capnp.Struct) error {
811 call := TunnelServer_registerTunnel{c, opts, TunnelServer_registerTunnel_Params{Struct: p}, TunnelServer_registerTunnel_Results{Struct: r}}
812 return s.RegisterTunnel(call)
813 },
814 ResultsSize: capnp.ObjectSize{DataSize: 0, PointerCount: 1},
815 })
816
817 methods = append(methods, server.Method{
818 Method: capnp.Method{
819 InterfaceID: 0xea58385c65416035,
820 MethodID: 1,
821 InterfaceName: "tunnelrpc/tunnelrpc.capnp:TunnelServer",
822 MethodName: "getServerInfo",
823 },
824 Impl: func(c context.Context, opts capnp.CallOptions, p, r capnp.Struct) error {
825 call := TunnelServer_getServerInfo{c, opts, TunnelServer_getServerInfo_Params{Struct: p}, TunnelServer_getServerInfo_Results{Struct: r}}
826 return s.GetServerInfo(call)
827 },
828 ResultsSize: capnp.ObjectSize{DataSize: 0, PointerCount: 1},
829 })
830
831 methods = append(methods, server.Method{
832 Method: capnp.Method{
833 InterfaceID: 0xea58385c65416035,
834 MethodID: 2,
835 InterfaceName: "tunnelrpc/tunnelrpc.capnp:TunnelServer",
836 MethodName: "unregisterTunnel",
837 },
838 Impl: func(c context.Context, opts capnp.CallOptions, p, r capnp.Struct) error {
839 call := TunnelServer_unregisterTunnel{c, opts, TunnelServer_unregisterTunnel_Params{Struct: p}, TunnelServer_unregisterTunnel_Results{Struct: r}}
840 return s.UnregisterTunnel(call)
841 },
842 ResultsSize: capnp.ObjectSize{DataSize: 0, PointerCount: 0},
843 })
844
845 return methods
846}
847
848// TunnelServer_registerTunnel holds the arguments for a server call to TunnelServer.registerTunnel.
849type TunnelServer_registerTunnel struct {
850 Ctx context.Context
851 Options capnp.CallOptions
852 Params TunnelServer_registerTunnel_Params
853 Results TunnelServer_registerTunnel_Results
854}
855
856// TunnelServer_getServerInfo holds the arguments for a server call to TunnelServer.getServerInfo.
857type TunnelServer_getServerInfo struct {
858 Ctx context.Context
859 Options capnp.CallOptions
860 Params TunnelServer_getServerInfo_Params
861 Results TunnelServer_getServerInfo_Results
862}
863
864// TunnelServer_unregisterTunnel holds the arguments for a server call to TunnelServer.unregisterTunnel.
865type TunnelServer_unregisterTunnel struct {
866 Ctx context.Context
867 Options capnp.CallOptions
868 Params TunnelServer_unregisterTunnel_Params
869 Results TunnelServer_unregisterTunnel_Results
870}
871
872type TunnelServer_registerTunnel_Params struct{ capnp.Struct }
873
874// TunnelServer_registerTunnel_Params_TypeID is the unique identifier for the type TunnelServer_registerTunnel_Params.
875const TunnelServer_registerTunnel_Params_TypeID = 0xb70431c0dc014915
876
877func NewTunnelServer_registerTunnel_Params(s *capnp.Segment) (TunnelServer_registerTunnel_Params, error) {
878 st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3})
879 return TunnelServer_registerTunnel_Params{st}, err
880}
881
882func NewRootTunnelServer_registerTunnel_Params(s *capnp.Segment) (TunnelServer_registerTunnel_Params, error) {
883 st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3})
884 return TunnelServer_registerTunnel_Params{st}, err
885}
886
887func ReadRootTunnelServer_registerTunnel_Params(msg *capnp.Message) (TunnelServer_registerTunnel_Params, error) {
888 root, err := msg.RootPtr()
889 return TunnelServer_registerTunnel_Params{root.Struct()}, err
890}
891
892func (s TunnelServer_registerTunnel_Params) String() string {
893 str, _ := text.Marshal(0xb70431c0dc014915, s.Struct)
894 return str
895}
896
897func (s TunnelServer_registerTunnel_Params) OriginCert() ([]byte, error) {
898 p, err := s.Struct.Ptr(0)
899 return []byte(p.Data()), err
900}
901
902func (s TunnelServer_registerTunnel_Params) HasOriginCert() bool {
903 p, err := s.Struct.Ptr(0)
904 return p.IsValid() || err != nil
905}
906
907func (s TunnelServer_registerTunnel_Params) SetOriginCert(v []byte) error {
908 return s.Struct.SetData(0, v)
909}
910
911func (s TunnelServer_registerTunnel_Params) Hostname() (string, error) {
912 p, err := s.Struct.Ptr(1)
913 return p.Text(), err
914}
915
916func (s TunnelServer_registerTunnel_Params) HasHostname() bool {
917 p, err := s.Struct.Ptr(1)
918 return p.IsValid() || err != nil
919}
920
921func (s TunnelServer_registerTunnel_Params) HostnameBytes() ([]byte, error) {
922 p, err := s.Struct.Ptr(1)
923 return p.TextBytes(), err
924}
925
926func (s TunnelServer_registerTunnel_Params) SetHostname(v string) error {
927 return s.Struct.SetText(1, v)
928}
929
930func (s TunnelServer_registerTunnel_Params) Options() (RegistrationOptions, error) {
931 p, err := s.Struct.Ptr(2)
932 return RegistrationOptions{Struct: p.Struct()}, err
933}
934
935func (s TunnelServer_registerTunnel_Params) HasOptions() bool {
936 p, err := s.Struct.Ptr(2)
937 return p.IsValid() || err != nil
938}
939
940func (s TunnelServer_registerTunnel_Params) SetOptions(v RegistrationOptions) error {
941 return s.Struct.SetPtr(2, v.Struct.ToPtr())
942}
943
944// NewOptions sets the options field to a newly
945// allocated RegistrationOptions struct, preferring placement in s's segment.
946func (s TunnelServer_registerTunnel_Params) NewOptions() (RegistrationOptions, error) {
947 ss, err := NewRegistrationOptions(s.Struct.Segment())
948 if err != nil {
949 return RegistrationOptions{}, err
950 }
951 err = s.Struct.SetPtr(2, ss.Struct.ToPtr())
952 return ss, err
953}
954
955// TunnelServer_registerTunnel_Params_List is a list of TunnelServer_registerTunnel_Params.
956type TunnelServer_registerTunnel_Params_List struct{ capnp.List }
957
958// NewTunnelServer_registerTunnel_Params creates a new list of TunnelServer_registerTunnel_Params.
959func NewTunnelServer_registerTunnel_Params_List(s *capnp.Segment, sz int32) (TunnelServer_registerTunnel_Params_List, error) {
960 l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3}, sz)
961 return TunnelServer_registerTunnel_Params_List{l}, err
962}
963
964func (s TunnelServer_registerTunnel_Params_List) At(i int) TunnelServer_registerTunnel_Params {
965 return TunnelServer_registerTunnel_Params{s.List.Struct(i)}
966}
967
968func (s TunnelServer_registerTunnel_Params_List) Set(i int, v TunnelServer_registerTunnel_Params) error {
969 return s.List.SetStruct(i, v.Struct)
970}
971
972func (s TunnelServer_registerTunnel_Params_List) String() string {
973 str, _ := text.MarshalList(0xb70431c0dc014915, s.List)
974 return str
975}
976
977// TunnelServer_registerTunnel_Params_Promise is a wrapper for a TunnelServer_registerTunnel_Params promised by a client call.
978type TunnelServer_registerTunnel_Params_Promise struct{ *capnp.Pipeline }
979
980func (p TunnelServer_registerTunnel_Params_Promise) Struct() (TunnelServer_registerTunnel_Params, error) {
981 s, err := p.Pipeline.Struct()
982 return TunnelServer_registerTunnel_Params{s}, err
983}
984
985func (p TunnelServer_registerTunnel_Params_Promise) Options() RegistrationOptions_Promise {
986 return RegistrationOptions_Promise{Pipeline: p.Pipeline.GetPipeline(2)}
987}
988
989type TunnelServer_registerTunnel_Results struct{ capnp.Struct }
990
991// TunnelServer_registerTunnel_Results_TypeID is the unique identifier for the type TunnelServer_registerTunnel_Results.
992const TunnelServer_registerTunnel_Results_TypeID = 0xf2c122394f447e8e
993
994func NewTunnelServer_registerTunnel_Results(s *capnp.Segment) (TunnelServer_registerTunnel_Results, error) {
995 st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
996 return TunnelServer_registerTunnel_Results{st}, err
997}
998
999func NewRootTunnelServer_registerTunnel_Results(s *capnp.Segment) (TunnelServer_registerTunnel_Results, error) {
1000 st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
1001 return TunnelServer_registerTunnel_Results{st}, err
1002}
1003
1004func ReadRootTunnelServer_registerTunnel_Results(msg *capnp.Message) (TunnelServer_registerTunnel_Results, error) {
1005 root, err := msg.RootPtr()
1006 return TunnelServer_registerTunnel_Results{root.Struct()}, err
1007}
1008
1009func (s TunnelServer_registerTunnel_Results) String() string {
1010 str, _ := text.Marshal(0xf2c122394f447e8e, s.Struct)
1011 return str
1012}
1013
1014func (s TunnelServer_registerTunnel_Results) Result() (TunnelRegistration, error) {
1015 p, err := s.Struct.Ptr(0)
1016 return TunnelRegistration{Struct: p.Struct()}, err
1017}
1018
1019func (s TunnelServer_registerTunnel_Results) HasResult() bool {
1020 p, err := s.Struct.Ptr(0)
1021 return p.IsValid() || err != nil
1022}
1023
1024func (s TunnelServer_registerTunnel_Results) SetResult(v TunnelRegistration) error {
1025 return s.Struct.SetPtr(0, v.Struct.ToPtr())
1026}
1027
1028// NewResult sets the result field to a newly
1029// allocated TunnelRegistration struct, preferring placement in s's segment.
1030func (s TunnelServer_registerTunnel_Results) NewResult() (TunnelRegistration, error) {
1031 ss, err := NewTunnelRegistration(s.Struct.Segment())
1032 if err != nil {
1033 return TunnelRegistration{}, err
1034 }
1035 err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
1036 return ss, err
1037}
1038
1039// TunnelServer_registerTunnel_Results_List is a list of TunnelServer_registerTunnel_Results.
1040type TunnelServer_registerTunnel_Results_List struct{ capnp.List }
1041
1042// NewTunnelServer_registerTunnel_Results creates a new list of TunnelServer_registerTunnel_Results.
1043func NewTunnelServer_registerTunnel_Results_List(s *capnp.Segment, sz int32) (TunnelServer_registerTunnel_Results_List, error) {
1044 l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
1045 return TunnelServer_registerTunnel_Results_List{l}, err
1046}
1047
1048func (s TunnelServer_registerTunnel_Results_List) At(i int) TunnelServer_registerTunnel_Results {
1049 return TunnelServer_registerTunnel_Results{s.List.Struct(i)}
1050}
1051
1052func (s TunnelServer_registerTunnel_Results_List) Set(i int, v TunnelServer_registerTunnel_Results) error {
1053 return s.List.SetStruct(i, v.Struct)
1054}
1055
1056func (s TunnelServer_registerTunnel_Results_List) String() string {
1057 str, _ := text.MarshalList(0xf2c122394f447e8e, s.List)
1058 return str
1059}
1060
1061// TunnelServer_registerTunnel_Results_Promise is a wrapper for a TunnelServer_registerTunnel_Results promised by a client call.
1062type TunnelServer_registerTunnel_Results_Promise struct{ *capnp.Pipeline }
1063
1064func (p TunnelServer_registerTunnel_Results_Promise) Struct() (TunnelServer_registerTunnel_Results, error) {
1065 s, err := p.Pipeline.Struct()
1066 return TunnelServer_registerTunnel_Results{s}, err
1067}
1068
1069func (p TunnelServer_registerTunnel_Results_Promise) Result() TunnelRegistration_Promise {
1070 return TunnelRegistration_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
1071}
1072
1073type TunnelServer_getServerInfo_Params struct{ capnp.Struct }
1074
1075// TunnelServer_getServerInfo_Params_TypeID is the unique identifier for the type TunnelServer_getServerInfo_Params.
1076const TunnelServer_getServerInfo_Params_TypeID = 0xdc3ed6801961e502
1077
1078func NewTunnelServer_getServerInfo_Params(s *capnp.Segment) (TunnelServer_getServerInfo_Params, error) {
1079 st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0})
1080 return TunnelServer_getServerInfo_Params{st}, err
1081}
1082
1083func NewRootTunnelServer_getServerInfo_Params(s *capnp.Segment) (TunnelServer_getServerInfo_Params, error) {
1084 st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0})
1085 return TunnelServer_getServerInfo_Params{st}, err
1086}
1087
1088func ReadRootTunnelServer_getServerInfo_Params(msg *capnp.Message) (TunnelServer_getServerInfo_Params, error) {
1089 root, err := msg.RootPtr()
1090 return TunnelServer_getServerInfo_Params{root.Struct()}, err
1091}
1092
1093func (s TunnelServer_getServerInfo_Params) String() string {
1094 str, _ := text.Marshal(0xdc3ed6801961e502, s.Struct)
1095 return str
1096}
1097
1098// TunnelServer_getServerInfo_Params_List is a list of TunnelServer_getServerInfo_Params.
1099type TunnelServer_getServerInfo_Params_List struct{ capnp.List }
1100
1101// NewTunnelServer_getServerInfo_Params creates a new list of TunnelServer_getServerInfo_Params.
1102func NewTunnelServer_getServerInfo_Params_List(s *capnp.Segment, sz int32) (TunnelServer_getServerInfo_Params_List, error) {
1103 l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0}, sz)
1104 return TunnelServer_getServerInfo_Params_List{l}, err
1105}
1106
1107func (s TunnelServer_getServerInfo_Params_List) At(i int) TunnelServer_getServerInfo_Params {
1108 return TunnelServer_getServerInfo_Params{s.List.Struct(i)}
1109}
1110
1111func (s TunnelServer_getServerInfo_Params_List) Set(i int, v TunnelServer_getServerInfo_Params) error {
1112 return s.List.SetStruct(i, v.Struct)
1113}
1114
1115func (s TunnelServer_getServerInfo_Params_List) String() string {
1116 str, _ := text.MarshalList(0xdc3ed6801961e502, s.List)
1117 return str
1118}
1119
1120// TunnelServer_getServerInfo_Params_Promise is a wrapper for a TunnelServer_getServerInfo_Params promised by a client call.
1121type TunnelServer_getServerInfo_Params_Promise struct{ *capnp.Pipeline }
1122
1123func (p TunnelServer_getServerInfo_Params_Promise) Struct() (TunnelServer_getServerInfo_Params, error) {
1124 s, err := p.Pipeline.Struct()
1125 return TunnelServer_getServerInfo_Params{s}, err
1126}
1127
1128type TunnelServer_getServerInfo_Results struct{ capnp.Struct }
1129
1130// TunnelServer_getServerInfo_Results_TypeID is the unique identifier for the type TunnelServer_getServerInfo_Results.
1131const TunnelServer_getServerInfo_Results_TypeID = 0xe3e37d096a5b564e
1132
1133func NewTunnelServer_getServerInfo_Results(s *capnp.Segment) (TunnelServer_getServerInfo_Results, error) {
1134 st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
1135 return TunnelServer_getServerInfo_Results{st}, err
1136}
1137
1138func NewRootTunnelServer_getServerInfo_Results(s *capnp.Segment) (TunnelServer_getServerInfo_Results, error) {
1139 st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
1140 return TunnelServer_getServerInfo_Results{st}, err
1141}
1142
1143func ReadRootTunnelServer_getServerInfo_Results(msg *capnp.Message) (TunnelServer_getServerInfo_Results, error) {
1144 root, err := msg.RootPtr()
1145 return TunnelServer_getServerInfo_Results{root.Struct()}, err
1146}
1147
1148func (s TunnelServer_getServerInfo_Results) String() string {
1149 str, _ := text.Marshal(0xe3e37d096a5b564e, s.Struct)
1150 return str
1151}
1152
1153func (s TunnelServer_getServerInfo_Results) Result() (ServerInfo, error) {
1154 p, err := s.Struct.Ptr(0)
1155 return ServerInfo{Struct: p.Struct()}, err
1156}
1157
1158func (s TunnelServer_getServerInfo_Results) HasResult() bool {
1159 p, err := s.Struct.Ptr(0)
1160 return p.IsValid() || err != nil
1161}
1162
1163func (s TunnelServer_getServerInfo_Results) SetResult(v ServerInfo) error {
1164 return s.Struct.SetPtr(0, v.Struct.ToPtr())
1165}
1166
1167// NewResult sets the result field to a newly
1168// allocated ServerInfo struct, preferring placement in s's segment.
1169func (s TunnelServer_getServerInfo_Results) NewResult() (ServerInfo, error) {
1170 ss, err := NewServerInfo(s.Struct.Segment())
1171 if err != nil {
1172 return ServerInfo{}, err
1173 }
1174 err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
1175 return ss, err
1176}
1177
1178// TunnelServer_getServerInfo_Results_List is a list of TunnelServer_getServerInfo_Results.
1179type TunnelServer_getServerInfo_Results_List struct{ capnp.List }
1180
1181// NewTunnelServer_getServerInfo_Results creates a new list of TunnelServer_getServerInfo_Results.
1182func NewTunnelServer_getServerInfo_Results_List(s *capnp.Segment, sz int32) (TunnelServer_getServerInfo_Results_List, error) {
1183 l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
1184 return TunnelServer_getServerInfo_Results_List{l}, err
1185}
1186
1187func (s TunnelServer_getServerInfo_Results_List) At(i int) TunnelServer_getServerInfo_Results {
1188 return TunnelServer_getServerInfo_Results{s.List.Struct(i)}
1189}
1190
1191func (s TunnelServer_getServerInfo_Results_List) Set(i int, v TunnelServer_getServerInfo_Results) error {
1192 return s.List.SetStruct(i, v.Struct)
1193}
1194
1195func (s TunnelServer_getServerInfo_Results_List) String() string {
1196 str, _ := text.MarshalList(0xe3e37d096a5b564e, s.List)
1197 return str
1198}
1199
1200// TunnelServer_getServerInfo_Results_Promise is a wrapper for a TunnelServer_getServerInfo_Results promised by a client call.
1201type TunnelServer_getServerInfo_Results_Promise struct{ *capnp.Pipeline }
1202
1203func (p TunnelServer_getServerInfo_Results_Promise) Struct() (TunnelServer_getServerInfo_Results, error) {
1204 s, err := p.Pipeline.Struct()
1205 return TunnelServer_getServerInfo_Results{s}, err
1206}
1207
1208func (p TunnelServer_getServerInfo_Results_Promise) Result() ServerInfo_Promise {
1209 return ServerInfo_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
1210}
1211
1212type TunnelServer_unregisterTunnel_Params struct{ capnp.Struct }
1213
1214// TunnelServer_unregisterTunnel_Params_TypeID is the unique identifier for the type TunnelServer_unregisterTunnel_Params.
1215const TunnelServer_unregisterTunnel_Params_TypeID = 0x9b87b390babc2ccf
1216
1217func NewTunnelServer_unregisterTunnel_Params(s *capnp.Segment) (TunnelServer_unregisterTunnel_Params, error) {
1218 st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 0})
1219 return TunnelServer_unregisterTunnel_Params{st}, err
1220}
1221
1222func NewRootTunnelServer_unregisterTunnel_Params(s *capnp.Segment) (TunnelServer_unregisterTunnel_Params, error) {
1223 st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 0})
1224 return TunnelServer_unregisterTunnel_Params{st}, err
1225}
1226
1227func ReadRootTunnelServer_unregisterTunnel_Params(msg *capnp.Message) (TunnelServer_unregisterTunnel_Params, error) {
1228 root, err := msg.RootPtr()
1229 return TunnelServer_unregisterTunnel_Params{root.Struct()}, err
1230}
1231
1232func (s TunnelServer_unregisterTunnel_Params) String() string {
1233 str, _ := text.Marshal(0x9b87b390babc2ccf, s.Struct)
1234 return str
1235}
1236
1237func (s TunnelServer_unregisterTunnel_Params) GracePeriodNanoSec() int64 {
1238 return int64(s.Struct.Uint64(0))
1239}
1240
1241func (s TunnelServer_unregisterTunnel_Params) SetGracePeriodNanoSec(v int64) {
1242 s.Struct.SetUint64(0, uint64(v))
1243}
1244
1245// TunnelServer_unregisterTunnel_Params_List is a list of TunnelServer_unregisterTunnel_Params.
1246type TunnelServer_unregisterTunnel_Params_List struct{ capnp.List }
1247
1248// NewTunnelServer_unregisterTunnel_Params creates a new list of TunnelServer_unregisterTunnel_Params.
1249func NewTunnelServer_unregisterTunnel_Params_List(s *capnp.Segment, sz int32) (TunnelServer_unregisterTunnel_Params_List, error) {
1250 l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 0}, sz)
1251 return TunnelServer_unregisterTunnel_Params_List{l}, err
1252}
1253
1254func (s TunnelServer_unregisterTunnel_Params_List) At(i int) TunnelServer_unregisterTunnel_Params {
1255 return TunnelServer_unregisterTunnel_Params{s.List.Struct(i)}
1256}
1257
1258func (s TunnelServer_unregisterTunnel_Params_List) Set(i int, v TunnelServer_unregisterTunnel_Params) error {
1259 return s.List.SetStruct(i, v.Struct)
1260}
1261
1262func (s TunnelServer_unregisterTunnel_Params_List) String() string {
1263 str, _ := text.MarshalList(0x9b87b390babc2ccf, s.List)
1264 return str
1265}
1266
1267// TunnelServer_unregisterTunnel_Params_Promise is a wrapper for a TunnelServer_unregisterTunnel_Params promised by a client call.
1268type TunnelServer_unregisterTunnel_Params_Promise struct{ *capnp.Pipeline }
1269
1270func (p TunnelServer_unregisterTunnel_Params_Promise) Struct() (TunnelServer_unregisterTunnel_Params, error) {
1271 s, err := p.Pipeline.Struct()
1272 return TunnelServer_unregisterTunnel_Params{s}, err
1273}
1274
1275type TunnelServer_unregisterTunnel_Results struct{ capnp.Struct }
1276
1277// TunnelServer_unregisterTunnel_Results_TypeID is the unique identifier for the type TunnelServer_unregisterTunnel_Results.
1278const TunnelServer_unregisterTunnel_Results_TypeID = 0xa29a916d4ebdd894
1279
1280func NewTunnelServer_unregisterTunnel_Results(s *capnp.Segment) (TunnelServer_unregisterTunnel_Results, error) {
1281 st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0})
1282 return TunnelServer_unregisterTunnel_Results{st}, err
1283}
1284
1285func NewRootTunnelServer_unregisterTunnel_Results(s *capnp.Segment) (TunnelServer_unregisterTunnel_Results, error) {
1286 st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0})
1287 return TunnelServer_unregisterTunnel_Results{st}, err
1288}
1289
1290func ReadRootTunnelServer_unregisterTunnel_Results(msg *capnp.Message) (TunnelServer_unregisterTunnel_Results, error) {
1291 root, err := msg.RootPtr()
1292 return TunnelServer_unregisterTunnel_Results{root.Struct()}, err
1293}
1294
1295func (s TunnelServer_unregisterTunnel_Results) String() string {
1296 str, _ := text.Marshal(0xa29a916d4ebdd894, s.Struct)
1297 return str
1298}
1299
1300// TunnelServer_unregisterTunnel_Results_List is a list of TunnelServer_unregisterTunnel_Results.
1301type TunnelServer_unregisterTunnel_Results_List struct{ capnp.List }
1302
1303// NewTunnelServer_unregisterTunnel_Results creates a new list of TunnelServer_unregisterTunnel_Results.
1304func NewTunnelServer_unregisterTunnel_Results_List(s *capnp.Segment, sz int32) (TunnelServer_unregisterTunnel_Results_List, error) {
1305 l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 0}, sz)
1306 return TunnelServer_unregisterTunnel_Results_List{l}, err
1307}
1308
1309func (s TunnelServer_unregisterTunnel_Results_List) At(i int) TunnelServer_unregisterTunnel_Results {
1310 return TunnelServer_unregisterTunnel_Results{s.List.Struct(i)}
1311}
1312
1313func (s TunnelServer_unregisterTunnel_Results_List) Set(i int, v TunnelServer_unregisterTunnel_Results) error {
1314 return s.List.SetStruct(i, v.Struct)
1315}
1316
1317func (s TunnelServer_unregisterTunnel_Results_List) String() string {
1318 str, _ := text.MarshalList(0xa29a916d4ebdd894, s.List)
1319 return str
1320}
1321
1322// TunnelServer_unregisterTunnel_Results_Promise is a wrapper for a TunnelServer_unregisterTunnel_Results promised by a client call.
1323type TunnelServer_unregisterTunnel_Results_Promise struct{ *capnp.Pipeline }
1324
1325func (p TunnelServer_unregisterTunnel_Results_Promise) Struct() (TunnelServer_unregisterTunnel_Results, error) {
1326 s, err := p.Pipeline.Struct()
1327 return TunnelServer_unregisterTunnel_Results{s}, err
1328}
1329
1330const schema_db8274f9144abc7e = "x\xda\x9cV_\x8c\x13U\x17?\xbf{\xdb\x9d\x16v" +
1331 "\xe9N\xa6$\xd0|\xa4\xf9\x08||\x10A\x101\xb0" +
1332 "\xfe\xd9?.h\xd7e\xe9\xd0\xd5\x10\xc0\x84\xa1\xbd\x94" +
1333 "Y\xdb\x99ff\x8a,\xe1\x7f\xd6\x88D\x09\x08<\x88" +
1334 "`\x90\x84\x08\x86\xa8\x89&&\x06\x13|P\x1ex " +
1335 "&b4\x92\x18%<H$\xc4\x8d<hb\xc6\xdc" +
1336 "\xe9N[v\x15\xd0\xb7\xdb\xdf=\xf7\x9c\xdf9s\xce" +
1337 "\xeft\xe1\xffx\x17[\x14\xfd>J\xa4\xf7F[\xfc" +
1338 "\xc7\xca\x97O=r\xf4\xd2\x08\xa9)\xe6\xef<\xdf\x97" +
1339 "\xfc\xcd\xdb\xfb\x1d\x11\x16_a\xdb\xa0\xfd\xc4\x14\"\xed" +
1340 ":[E\xf0/?p\xfe\x93\x83\x1f\xbe\xfc&\xe9s" +
1341 "\x00\xa2\x88B\xb4\xf8\x0f\xf6;\x08\x9a\xca;\x09\xfe\x91" +
1342 "o>\x1d(\x1f:v\x8a\xd49\xe1\xfd2\xce\x18E" +
1343 "\xfc\xa9\x19\\\xbd\xb0(\xf2q\xed&\xca\xe5\xd5|~" +
1344 "C>\xed\xe6\xef\x13\xfc\x197{\xda\xac[{/\x90" +
1345 "\x9aB\x83E\xcd\xf0\x07\xde\x07\xed\xb6<j\xbf\x04\xc6" +
1346 "}\xeb\x0e\xbf\x1e\xbd~\xf8\"\xe9)4q\x8e*\xd2" +
1347 "\xfa\xb5\x88\x03\xed\xed \xf8\x89\xc8;\x8c\xe0\xa7>x" +
1348 "\xf4\xbd\x9e\xc2\xb7\x97\xc6\xf9\x0e2{E\x19\xd5\x8e\xca" +
1349 "w\xda!\xe5E\x82\xcf\xae\x1b\xd3w\x7f\xfd\xc4\xd5\xa6" +
1350 "\x14n*?\x82\"\xfe\xc0s\xeb\x86\xe2;\xae]\x1b" +
1351 "K\x01\x013%H\xe1\xb6\"\xb3_\xb2\xa1[\xac_" +
1352 "\xba\xe6\x06\xa9)~G!\xa7\xc6:\xa0\xcd\x8e\xc9 " +
1353 "\xff\x8d]\xd4\xce\xca\x93\x7f`g\xef\xaae3?\x1b" +
1354 "mvw(6*\xdd\x9d\x8eIw\x9b\x96\xfe\xfc\xd4" +
1355 "\xec\x03_\x8c\x8ec\x1d\x18~\x1e\x9b\x07\xedJ\xe0\xf1" +
1356 "Ki|k\xc5[_\xa5\x12\xa9_\xf5\x14\x9am\x03" +
1357 "\xfa\xb7cC\xd0\xe2qy\x8c\xc6\xd3\xa0\xf9\xbeW\xb5" +
1358 ",Qr*\x91\xfc\x83\xe11\xbf oT\xacJ\xc7" +
1359 "\xf2\xad\xa6\xeb\x99Vq0\xc0;\xb3v\xc9\xcc\x0fg" +
1360 "\x01\xbd\x15\x8cH\x9d\xd1A\x04\xa8S\xd7\x12\x81\xa9j" +
1361 "\x0fQ\xa7Y\xb4lG\xf8\x05\xd3\xcd\xdb\x96%\x88\xe7" +
1362 "\xbd]\x1b\x8d\x92a\xe5E=P\xcb\xc4@\xb5\x009" +
1363 "\xe1l\x11\xce\x82\xaa\xe5\x88\xa2\xe9z\xc2\xa9\xc1\xb3:" +
1364 "\xb3\x86c\x94]=\xc2#D\x11\x10\xa9m\xc7\x88\xf4" +
1365 "v\x0e\xfd?\x0c~\xd11\xf2\"+\x1c\x98va\xc0" +
1366 "\xb0\xec\x1c\x17yD\x89!J\xa8\x07\x9d\xf2O\x83\xae" +
1367 "\x16n\xb5\xe4\xb9T\x7fu\xf7\xf7\xe3^g\x8dD@" +
1368 "\xb9\xb5Ny\xf9Z9a\x1cz\x96A\x05\x92rf" +
1369 "\xd4\x95}Dz?\x87\xbe\x86Ae,\x19\x94\xf5\xd9" +
1370 "\x1e\"=\xcb\xa1\xafg\xf0m\xc7,\x9a\xd6\x93\x82\xb8" +
1371 "\xe3\xa1\x8d\x18\xda\x08\xfef\xdb\xf5,\xa3,\x88\x08\xad" +
1372 "\xc4\xd0J\xd8eW<\xd3\xb6\\\xb47\xe6\x81\x80\xf6" +
1373 "\xa6\x12\xfc\xc5\x07\xee\xaez\x9b\x85\xe5\x99yC>&" +
1374 "\x0a\xbem\x83\xf2L\"\xbd\x8bC\xefo\xa2\x9cy\xa8" +
1375 ")\x8f\x90\xf2\xca\x8d\x8d<\x94\x17\xc4p\xc8*-\xca" +
1376 "\x86Y\x0a\x7f\x85\xc9t\x93\xf2L\xc3\xe6n\xfcV\x07" +
1377 "Uu\x02v\xab*\xe9 C\xc9qa\xc8Q\xebF" +
1378 "\x1fQ\xae\x0b\x1c\xb9~4hj\x19\xf4\x10\xe5z%" +
1379 "\x9eE\x83\xa9\xb6\x12)\xa2\xdc\xd3\x12\x1f\x04\x03x\x12" +
1380 "\x9cH\xd3\xf1.QnP\xc2\x1b\xa4y\x84'\x11!" +
1381 "\xd2\x9e\x0f\xdc\xaf\x97\xf8f\x89G#ID\x894\x81" +
1382 "yD\xb9\x0d\x12\xdf.\xf1\x16\x96D\x0b\x916\x8c!" +
1383 "\xa2\xdcV\x89\x8fH\\\x89&\xe5\x88j{\xe0\x10\xe5" +
1384 "vK\xfcU\x89\xc7\xa6%\x11\x93\x82\x13\xe0\xfb$~" +
1385 "D\xe2\xf1\xe9I\xc4\xa5\xfc`/Q\xee\xa0\xc4\x8fK" +
1386 "|\x12\x92\x98D\xa4\xbd\x81cD\xb9\xe3\x12?#\xf1" +
1387 "\xc9-IL&\xd2N\x07|NJ\xfc\x1c\x18\xfc|" +
1388 "\xc9\x14\x96\x97)4w\xc8\x16\xe1\xb8\xa6m\x85\xbf\xb9" +
1389 "\xed\xd6?\x81\x18\x1bt\xd4\xda7k'\xe4\xa4#\xd1" +
1390 "X\x07\x04$\x08~\xc5\xb6K\x03wv^\xc23\x8a" +
1391 ".\xa6\x10\xb2\x1cho\xc8+A\x82~\xa0\x03y\xcf" +
1392 "\xa4\x84me\x0ah!\x86\x96z+\xf4\xdb\x94\xce\x1b" +
1393 "\xa5L\xa5\xce\xc4t\xbb\xab\x9e]\xadP\xba`x\xa2" +
1394 "\x00\x10\x03\x08\xbeS\xb5V8vy\x10\xc2)\x9b\x96" +
1395 "Q\xa2\xfaM\xde.W\x1c\xe1\xba0mK\xaf\x1a%" +
1396 "\x93{\xc3\x88\x13C\x9c\x90\xa8V\xcd\xc2\x84Fc\xe3" +
1397 "\x1b-]\xe9\x184\x8a\xb2\xb1b\xf5\xe6\x9f;\x8fH" +
1398 "\x9f\xc5\xa1/lj\xfe\xf9\xb2\xf9\xff\xcf\xa1?\xcc\x90" +
1399 "\x90\x13Xo\xf4-F\xa9*&D\xba\x97\xd4\x15\x85" +
1400 "W;e\xacM\xf6\xac\xac\xe1(F\xd9\xfd\x97\xafW" +
1401 "\x0b7!\x15\xabY&;\x88\xf4\x18\x87\x9ed\xe8t" +
1402 "\x02AC{c\x95\x8c\xd3\x07\xfew\xe1:kQj" +
1403 "\xe2\x10%\xaa\xefo\x84kK\xd5\xb7\x11S3\x0a\x1a" +
1404 "+\x13\xe1\x86T\x1fw\x88\xa9K\x14\xb0\xfa_\x06\x84" +
1405 "\x7f\x0d\xd4\xb9\xfb\x89\xa9\xb3\x15?\x94O\xea\xac\x85\xec" +
1406 "\x82\x1ffG\xe9 \xbf.\xf8\xa1F#\x94Y\xa2." +
1407 "dq\xff\xe5\x9e \xf1i\xf7~*\x16\xee\xd3{\xd7" +
1408 "\xab\x16'!\xf9\xcaj5\xf9\x1d\"\xd2[9\xf4i" +
1409 "\x0c~\xc9\x1e\xd3\xdb\xc4@S\x0b\xddM\x07k\x84C" +
1410 "5L\xc8\xc7\xd2\x7f\xb2\xee\x7f\x87\x94\xea\xad\x1c\xfaH" +
1411 "S\xb7\xee\x91\xe0v\x0e}_\x93T\xbf$W\xce\x08" +
1412 "\x87~\xb2\xae~\xea\x89\xfdD\xfaI\x0e\xfd\\C\xfa" +
1413 "\xd4\xb3\xd2\xf0\x0c\x87\xfe\x11\x83\"\x1c'\xe4\xa9T\x9d" +
1414 "\x86\xa2\x97\xecb\xbfi\x09W\xea\xc1\x98\x04\xc8+9" +
1415 "\xf8\x15\xe1\x94\x0dKX\xf0V\x18f\xa9\xea\x08j\xcc" +
1416 "l-\xbfLo\x93\x8c\xfc\x19\x00\x00\xff\xff@V\xc0" +
1417 "\xb7"
1418
1419func init() {
1420 schemas.Register(schema_db8274f9144abc7e,
1421 0x84cb9536a2cf6d3c,
1422 0x9b87b390babc2ccf,
1423 0xa29a916d4ebdd894,
1424 0xb70431c0dc014915,
1425 0xc082ef6e0d42ed1d,
1426 0xc793e50592935b4a,
1427 0xcbd96442ae3bb01a,
1428 0xdc3ed6801961e502,
1429 0xe3e37d096a5b564e,
1430 0xea58385c65416035,
1431 0xf2c122394f447e8e,
1432 0xf2c68e2547ec3866,
1433 0xf41a0f001ad49e46)
1434}