path_mgmt.capnp.go

// Code generated by capnpc-go. DO NOT EDIT.

package proto

import (
	strconv "strconv"
	capnp "zombiezen.com/go/capnproto2"
	text "zombiezen.com/go/capnproto2/encoding/text"
	schemas "zombiezen.com/go/capnproto2/schemas"
)

type SegReq struct{ capnp.Struct }
type SegReq_flags SegReq

// SegReq_TypeID is the unique identifier for the type SegReq.
const SegReq_TypeID = 0x9d0135027d04861e

func NewSegReq(s *capnp.Segment) (SegReq, error) {
	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 24, PointerCount: 0})
	return SegReq{st}, err
}

func NewRootSegReq(s *capnp.Segment) (SegReq, error) {
	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 24, PointerCount: 0})
	return SegReq{st}, err
}

func ReadRootSegReq(msg *capnp.Message) (SegReq, error) {
	root, err := msg.RootPtr()
	return SegReq{root.Struct()}, err
}

func (s SegReq) String() string {
	str, _ := text.Marshal(0x9d0135027d04861e, s.Struct)
	return str
}

func (s SegReq) SrcIA() uint64 {
	return s.Struct.Uint64(0)
}

func (s SegReq) SetSrcIA(v uint64) {
	s.Struct.SetUint64(0, v)
}

func (s SegReq) DstIA() uint64 {
	return s.Struct.Uint64(8)
}

func (s SegReq) SetDstIA(v uint64) {
	s.Struct.SetUint64(8, v)
}

func (s SegReq) Flags() SegReq_flags { return SegReq_flags(s) }

func (s SegReq_flags) Sibra() bool {
	return s.Struct.Bit(128)
}

func (s SegReq_flags) SetSibra(v bool) {
	s.Struct.SetBit(128, v)
}

func (s SegReq_flags) CacheOnly() bool {
	return s.Struct.Bit(129)
}

func (s SegReq_flags) SetCacheOnly(v bool) {
	s.Struct.SetBit(129, v)
}

// SegReq_List is a list of SegReq.
type SegReq_List struct{ capnp.List }

// NewSegReq creates a new list of SegReq.
func NewSegReq_List(s *capnp.Segment, sz int32) (SegReq_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 24, PointerCount: 0}, sz)
	return SegReq_List{l}, err
}

func (s SegReq_List) At(i int) SegReq { return SegReq{s.List.Struct(i)} }

func (s SegReq_List) Set(i int, v SegReq) error { return s.List.SetStruct(i, v.Struct) }

func (s SegReq_List) String() string {
	str, _ := text.MarshalList(0x9d0135027d04861e, s.List)
	return str
}

// SegReq_Promise is a wrapper for a SegReq promised by a client call.
type SegReq_Promise struct{ *capnp.Pipeline }

func (p SegReq_Promise) Struct() (SegReq, error) {
	s, err := p.Pipeline.Struct()
	return SegReq{s}, err
}

func (p SegReq_Promise) Flags() SegReq_flags_Promise { return SegReq_flags_Promise{p.Pipeline} }

// SegReq_flags_Promise is a wrapper for a SegReq_flags promised by a client call.
type SegReq_flags_Promise struct{ *capnp.Pipeline }

func (p SegReq_flags_Promise) Struct() (SegReq_flags, error) {
	s, err := p.Pipeline.Struct()
	return SegReq_flags{s}, err
}

type SegRecs struct{ capnp.Struct }

// SegRecs_TypeID is the unique identifier for the type SegRecs.
const SegRecs_TypeID = 0x934ba70bfd144ebd

func NewSegRecs(s *capnp.Segment) (SegRecs, error) {
	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2})
	return SegRecs{st}, err
}

func NewRootSegRecs(s *capnp.Segment) (SegRecs, error) {
	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2})
	return SegRecs{st}, err
}

func ReadRootSegRecs(msg *capnp.Message) (SegRecs, error) {
	root, err := msg.RootPtr()
	return SegRecs{root.Struct()}, err
}

func (s SegRecs) String() string {
	str, _ := text.Marshal(0x934ba70bfd144ebd, s.Struct)
	return str
}

func (s SegRecs) Recs() (PathSegMeta_List, error) {
	p, err := s.Struct.Ptr(0)
	return PathSegMeta_List{List: p.List()}, err
}

func (s SegRecs) HasRecs() bool {
	p, err := s.Struct.Ptr(0)
	return p.IsValid() || err != nil
}

func (s SegRecs) SetRecs(v PathSegMeta_List) error {
	return s.Struct.SetPtr(0, v.List.ToPtr())
}

// NewRecs sets the recs field to a newly
// allocated PathSegMeta_List, preferring placement in s's segment.
func (s SegRecs) NewRecs(n int32) (PathSegMeta_List, error) {
	l, err := NewPathSegMeta_List(s.Struct.Segment(), n)
	if err != nil {
		return PathSegMeta_List{}, err
	}
	err = s.Struct.SetPtr(0, l.List.ToPtr())
	return l, err
}

func (s SegRecs) SRevInfos() (SignedBlob_List, error) {
	p, err := s.Struct.Ptr(1)
	return SignedBlob_List{List: p.List()}, err
}

func (s SegRecs) HasSRevInfos() bool {
	p, err := s.Struct.Ptr(1)
	return p.IsValid() || err != nil
}

func (s SegRecs) SetSRevInfos(v SignedBlob_List) error {
	return s.Struct.SetPtr(1, v.List.ToPtr())
}

// NewSRevInfos sets the sRevInfos field to a newly
// allocated SignedBlob_List, preferring placement in s's segment.
func (s SegRecs) NewSRevInfos(n int32) (SignedBlob_List, error) {
	l, err := NewSignedBlob_List(s.Struct.Segment(), n)
	if err != nil {
		return SignedBlob_List{}, err
	}
	err = s.Struct.SetPtr(1, l.List.ToPtr())
	return l, err
}

// SegRecs_List is a list of SegRecs.
type SegRecs_List struct{ capnp.List }

// NewSegRecs creates a new list of SegRecs.
func NewSegRecs_List(s *capnp.Segment, sz int32) (SegRecs_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2}, sz)
	return SegRecs_List{l}, err
}

func (s SegRecs_List) At(i int) SegRecs { return SegRecs{s.List.Struct(i)} }

func (s SegRecs_List) Set(i int, v SegRecs) error { return s.List.SetStruct(i, v.Struct) }

func (s SegRecs_List) String() string {
	str, _ := text.MarshalList(0x934ba70bfd144ebd, s.List)
	return str
}

// SegRecs_Promise is a wrapper for a SegRecs promised by a client call.
type SegRecs_Promise struct{ *capnp.Pipeline }

func (p SegRecs_Promise) Struct() (SegRecs, error) {
	s, err := p.Pipeline.Struct()
	return SegRecs{s}, err
}

type SegReply struct{ capnp.Struct }

// SegReply_TypeID is the unique identifier for the type SegReply.
const SegReply_TypeID = 0x9359e1b2db37dbbb

func NewSegReply(s *capnp.Segment) (SegReply, error) {
	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2})
	return SegReply{st}, err
}

func NewRootSegReply(s *capnp.Segment) (SegReply, error) {
	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2})
	return SegReply{st}, err
}

func ReadRootSegReply(msg *capnp.Message) (SegReply, error) {
	root, err := msg.RootPtr()
	return SegReply{root.Struct()}, err
}

func (s SegReply) String() string {
	str, _ := text.Marshal(0x9359e1b2db37dbbb, s.Struct)
	return str
}

func (s SegReply) Req() (SegReq, error) {
	p, err := s.Struct.Ptr(0)
	return SegReq{Struct: p.Struct()}, err
}

func (s SegReply) HasReq() bool {
	p, err := s.Struct.Ptr(0)
	return p.IsValid() || err != nil
}

func (s SegReply) SetReq(v SegReq) error {
	return s.Struct.SetPtr(0, v.Struct.ToPtr())
}

// NewReq sets the req field to a newly
// allocated SegReq struct, preferring placement in s's segment.
func (s SegReply) NewReq() (SegReq, error) {
	ss, err := NewSegReq(s.Struct.Segment())
	if err != nil {
		return SegReq{}, err
	}
	err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
	return ss, err
}

func (s SegReply) Recs() (SegRecs, error) {
	p, err := s.Struct.Ptr(1)
	return SegRecs{Struct: p.Struct()}, err
}

func (s SegReply) HasRecs() bool {
	p, err := s.Struct.Ptr(1)
	return p.IsValid() || err != nil
}

func (s SegReply) SetRecs(v SegRecs) error {
	return s.Struct.SetPtr(1, v.Struct.ToPtr())
}

// NewRecs sets the recs field to a newly
// allocated SegRecs struct, preferring placement in s's segment.
func (s SegReply) NewRecs() (SegRecs, error) {
	ss, err := NewSegRecs(s.Struct.Segment())
	if err != nil {
		return SegRecs{}, err
	}
	err = s.Struct.SetPtr(1, ss.Struct.ToPtr())
	return ss, err
}

// SegReply_List is a list of SegReply.
type SegReply_List struct{ capnp.List }

// NewSegReply creates a new list of SegReply.
func NewSegReply_List(s *capnp.Segment, sz int32) (SegReply_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2}, sz)
	return SegReply_List{l}, err
}

func (s SegReply_List) At(i int) SegReply { return SegReply{s.List.Struct(i)} }

func (s SegReply_List) Set(i int, v SegReply) error { return s.List.SetStruct(i, v.Struct) }

func (s SegReply_List) String() string {
	str, _ := text.MarshalList(0x9359e1b2db37dbbb, s.List)
	return str
}

// SegReply_Promise is a wrapper for a SegReply promised by a client call.
type SegReply_Promise struct{ *capnp.Pipeline }

func (p SegReply_Promise) Struct() (SegReply, error) {
	s, err := p.Pipeline.Struct()
	return SegReply{s}, err
}

func (p SegReply_Promise) Req() SegReq_Promise {
	return SegReq_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
}

func (p SegReply_Promise) Recs() SegRecs_Promise {
	return SegRecs_Promise{Pipeline: p.Pipeline.GetPipeline(1)}
}

type SegChangesIdReq struct{ capnp.Struct }

// SegChangesIdReq_TypeID is the unique identifier for the type SegChangesIdReq.
const SegChangesIdReq_TypeID = 0xc88dfa6be7a1d091

func NewSegChangesIdReq(s *capnp.Segment) (SegChangesIdReq, error) {
	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 0})
	return SegChangesIdReq{st}, err
}

func NewRootSegChangesIdReq(s *capnp.Segment) (SegChangesIdReq, error) {
	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 0})
	return SegChangesIdReq{st}, err
}

func ReadRootSegChangesIdReq(msg *capnp.Message) (SegChangesIdReq, error) {
	root, err := msg.RootPtr()
	return SegChangesIdReq{root.Struct()}, err
}

func (s SegChangesIdReq) String() string {
	str, _ := text.Marshal(0xc88dfa6be7a1d091, s.Struct)
	return str
}

func (s SegChangesIdReq) LastCheck() uint32 {
	return s.Struct.Uint32(0)
}

func (s SegChangesIdReq) SetLastCheck(v uint32) {
	s.Struct.SetUint32(0, v)
}

// SegChangesIdReq_List is a list of SegChangesIdReq.
type SegChangesIdReq_List struct{ capnp.List }

// NewSegChangesIdReq creates a new list of SegChangesIdReq.
func NewSegChangesIdReq_List(s *capnp.Segment, sz int32) (SegChangesIdReq_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 0}, sz)
	return SegChangesIdReq_List{l}, err
}

func (s SegChangesIdReq_List) At(i int) SegChangesIdReq { return SegChangesIdReq{s.List.Struct(i)} }

func (s SegChangesIdReq_List) Set(i int, v SegChangesIdReq) error {
	return s.List.SetStruct(i, v.Struct)
}

func (s SegChangesIdReq_List) String() string {
	str, _ := text.MarshalList(0xc88dfa6be7a1d091, s.List)
	return str
}

// SegChangesIdReq_Promise is a wrapper for a SegChangesIdReq promised by a client call.
type SegChangesIdReq_Promise struct{ *capnp.Pipeline }

func (p SegChangesIdReq_Promise) Struct() (SegChangesIdReq, error) {
	s, err := p.Pipeline.Struct()
	return SegChangesIdReq{s}, err
}

type SegIds struct{ capnp.Struct }

// SegIds_TypeID is the unique identifier for the type SegIds.
const SegIds_TypeID = 0xabf979c3f68dae4b

func NewSegIds(s *capnp.Segment) (SegIds, error) {
	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2})
	return SegIds{st}, err
}

func NewRootSegIds(s *capnp.Segment) (SegIds, error) {
	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2})
	return SegIds{st}, err
}

func ReadRootSegIds(msg *capnp.Message) (SegIds, error) {
	root, err := msg.RootPtr()
	return SegIds{root.Struct()}, err
}

func (s SegIds) String() string {
	str, _ := text.Marshal(0xabf979c3f68dae4b, s.Struct)
	return str
}

func (s SegIds) SegId() ([]byte, error) {
	p, err := s.Struct.Ptr(0)
	return []byte(p.Data()), err
}

func (s SegIds) HasSegId() bool {
	p, err := s.Struct.Ptr(0)
	return p.IsValid() || err != nil
}

func (s SegIds) SetSegId(v []byte) error {
	return s.Struct.SetData(0, v)
}

func (s SegIds) FullId() ([]byte, error) {
	p, err := s.Struct.Ptr(1)
	return []byte(p.Data()), err
}

func (s SegIds) HasFullId() bool {
	p, err := s.Struct.Ptr(1)
	return p.IsValid() || err != nil
}

func (s SegIds) SetFullId(v []byte) error {
	return s.Struct.SetData(1, v)
}

// SegIds_List is a list of SegIds.
type SegIds_List struct{ capnp.List }

// NewSegIds creates a new list of SegIds.
func NewSegIds_List(s *capnp.Segment, sz int32) (SegIds_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2}, sz)
	return SegIds_List{l}, err
}

func (s SegIds_List) At(i int) SegIds { return SegIds{s.List.Struct(i)} }

func (s SegIds_List) Set(i int, v SegIds) error { return s.List.SetStruct(i, v.Struct) }

func (s SegIds_List) String() string {
	str, _ := text.MarshalList(0xabf979c3f68dae4b, s.List)
	return str
}

// SegIds_Promise is a wrapper for a SegIds promised by a client call.
type SegIds_Promise struct{ *capnp.Pipeline }

func (p SegIds_Promise) Struct() (SegIds, error) {
	s, err := p.Pipeline.Struct()
	return SegIds{s}, err
}

type SegChangesIdReply struct{ capnp.Struct }

// SegChangesIdReply_TypeID is the unique identifier for the type SegChangesIdReply.
const SegChangesIdReply_TypeID = 0xbd56ceeaf8c65140

func NewSegChangesIdReply(s *capnp.Segment) (SegChangesIdReply, error) {
	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
	return SegChangesIdReply{st}, err
}

func NewRootSegChangesIdReply(s *capnp.Segment) (SegChangesIdReply, error) {
	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
	return SegChangesIdReply{st}, err
}

func ReadRootSegChangesIdReply(msg *capnp.Message) (SegChangesIdReply, error) {
	root, err := msg.RootPtr()
	return SegChangesIdReply{root.Struct()}, err
}

func (s SegChangesIdReply) String() string {
	str, _ := text.Marshal(0xbd56ceeaf8c65140, s.Struct)
	return str
}

func (s SegChangesIdReply) Ids() (SegIds_List, error) {
	p, err := s.Struct.Ptr(0)
	return SegIds_List{List: p.List()}, err
}

func (s SegChangesIdReply) HasIds() bool {
	p, err := s.Struct.Ptr(0)
	return p.IsValid() || err != nil
}

func (s SegChangesIdReply) SetIds(v SegIds_List) error {
	return s.Struct.SetPtr(0, v.List.ToPtr())
}

// NewIds sets the ids field to a newly
// allocated SegIds_List, preferring placement in s's segment.
func (s SegChangesIdReply) NewIds(n int32) (SegIds_List, error) {
	l, err := NewSegIds_List(s.Struct.Segment(), n)
	if err != nil {
		return SegIds_List{}, err
	}
	err = s.Struct.SetPtr(0, l.List.ToPtr())
	return l, err
}

// SegChangesIdReply_List is a list of SegChangesIdReply.
type SegChangesIdReply_List struct{ capnp.List }

// NewSegChangesIdReply creates a new list of SegChangesIdReply.
func NewSegChangesIdReply_List(s *capnp.Segment, sz int32) (SegChangesIdReply_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
	return SegChangesIdReply_List{l}, err
}

func (s SegChangesIdReply_List) At(i int) SegChangesIdReply {
	return SegChangesIdReply{s.List.Struct(i)}
}

func (s SegChangesIdReply_List) Set(i int, v SegChangesIdReply) error {
	return s.List.SetStruct(i, v.Struct)
}

func (s SegChangesIdReply_List) String() string {
	str, _ := text.MarshalList(0xbd56ceeaf8c65140, s.List)
	return str
}

// SegChangesIdReply_Promise is a wrapper for a SegChangesIdReply promised by a client call.
type SegChangesIdReply_Promise struct{ *capnp.Pipeline }

func (p SegChangesIdReply_Promise) Struct() (SegChangesIdReply, error) {
	s, err := p.Pipeline.Struct()
	return SegChangesIdReply{s}, err
}

type SegChangesReq struct{ capnp.Struct }

// SegChangesReq_TypeID is the unique identifier for the type SegChangesReq.
const SegChangesReq_TypeID = 0xa7ad0c62a234c68b

func NewSegChangesReq(s *capnp.Segment) (SegChangesReq, error) {
	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
	return SegChangesReq{st}, err
}

func NewRootSegChangesReq(s *capnp.Segment) (SegChangesReq, error) {
	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
	return SegChangesReq{st}, err
}

func ReadRootSegChangesReq(msg *capnp.Message) (SegChangesReq, error) {
	root, err := msg.RootPtr()
	return SegChangesReq{root.Struct()}, err
}

func (s SegChangesReq) String() string {
	str, _ := text.Marshal(0xa7ad0c62a234c68b, s.Struct)
	return str
}

func (s SegChangesReq) SegIds() (capnp.DataList, error) {
	p, err := s.Struct.Ptr(0)
	return capnp.DataList{List: p.List()}, err
}

func (s SegChangesReq) HasSegIds() bool {
	p, err := s.Struct.Ptr(0)
	return p.IsValid() || err != nil
}

func (s SegChangesReq) SetSegIds(v capnp.DataList) error {
	return s.Struct.SetPtr(0, v.List.ToPtr())
}

// NewSegIds sets the segIds field to a newly
// allocated capnp.DataList, preferring placement in s's segment.
func (s SegChangesReq) NewSegIds(n int32) (capnp.DataList, error) {
	l, err := capnp.NewDataList(s.Struct.Segment(), n)
	if err != nil {
		return capnp.DataList{}, err
	}
	err = s.Struct.SetPtr(0, l.List.ToPtr())
	return l, err
}

// SegChangesReq_List is a list of SegChangesReq.
type SegChangesReq_List struct{ capnp.List }

// NewSegChangesReq creates a new list of SegChangesReq.
func NewSegChangesReq_List(s *capnp.Segment, sz int32) (SegChangesReq_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
	return SegChangesReq_List{l}, err
}

func (s SegChangesReq_List) At(i int) SegChangesReq { return SegChangesReq{s.List.Struct(i)} }

func (s SegChangesReq_List) Set(i int, v SegChangesReq) error { return s.List.SetStruct(i, v.Struct) }

func (s SegChangesReq_List) String() string {
	str, _ := text.MarshalList(0xa7ad0c62a234c68b, s.List)
	return str
}

// SegChangesReq_Promise is a wrapper for a SegChangesReq promised by a client call.
type SegChangesReq_Promise struct{ *capnp.Pipeline }

func (p SegChangesReq_Promise) Struct() (SegChangesReq, error) {
	s, err := p.Pipeline.Struct()
	return SegChangesReq{s}, err
}

type HPGroupId struct{ capnp.Struct }

// HPGroupId_TypeID is the unique identifier for the type HPGroupId.
const HPGroupId_TypeID = 0xba21c7133ee44518

func NewHPGroupId(s *capnp.Segment) (HPGroupId, error) {
	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 16, PointerCount: 0})
	return HPGroupId{st}, err
}

func NewRootHPGroupId(s *capnp.Segment) (HPGroupId, error) {
	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 16, PointerCount: 0})
	return HPGroupId{st}, err
}

func ReadRootHPGroupId(msg *capnp.Message) (HPGroupId, error) {
	root, err := msg.RootPtr()
	return HPGroupId{root.Struct()}, err
}

func (s HPGroupId) String() string {
	str, _ := text.Marshal(0xba21c7133ee44518, s.Struct)
	return str
}

func (s HPGroupId) OwnerAS() uint64 {
	return s.Struct.Uint64(0)
}

func (s HPGroupId) SetOwnerAS(v uint64) {
	s.Struct.SetUint64(0, v)
}

func (s HPGroupId) GroupId() uint16 {
	return s.Struct.Uint16(8)
}

func (s HPGroupId) SetGroupId(v uint16) {
	s.Struct.SetUint16(8, v)
}

// HPGroupId_List is a list of HPGroupId.
type HPGroupId_List struct{ capnp.List }

// NewHPGroupId creates a new list of HPGroupId.
func NewHPGroupId_List(s *capnp.Segment, sz int32) (HPGroupId_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 16, PointerCount: 0}, sz)
	return HPGroupId_List{l}, err
}

func (s HPGroupId_List) At(i int) HPGroupId { return HPGroupId{s.List.Struct(i)} }

func (s HPGroupId_List) Set(i int, v HPGroupId) error { return s.List.SetStruct(i, v.Struct) }

func (s HPGroupId_List) String() string {
	str, _ := text.MarshalList(0xba21c7133ee44518, s.List)
	return str
}

// HPGroupId_Promise is a wrapper for a HPGroupId promised by a client call.
type HPGroupId_Promise struct{ *capnp.Pipeline }

func (p HPGroupId_Promise) Struct() (HPGroupId, error) {
	s, err := p.Pipeline.Struct()
	return HPGroupId{s}, err
}

type HPSegReq struct{ capnp.Struct }

// HPSegReq_TypeID is the unique identifier for the type HPSegReq.
const HPSegReq_TypeID = 0x8f51e8717b3fbe1c

func NewHPSegReq(s *capnp.Segment) (HPSegReq, error) {
	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 1})
	return HPSegReq{st}, err
}

func NewRootHPSegReq(s *capnp.Segment) (HPSegReq, error) {
	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 1})
	return HPSegReq{st}, err
}

func ReadRootHPSegReq(msg *capnp.Message) (HPSegReq, error) {
	root, err := msg.RootPtr()
	return HPSegReq{root.Struct()}, err
}

func (s HPSegReq) String() string {
	str, _ := text.Marshal(0x8f51e8717b3fbe1c, s.Struct)
	return str
}

func (s HPSegReq) DstIA() uint64 {
	return s.Struct.Uint64(0)
}

func (s HPSegReq) SetDstIA(v uint64) {
	s.Struct.SetUint64(0, v)
}

func (s HPSegReq) GroupIds() (HPGroupId_List, error) {
	p, err := s.Struct.Ptr(0)
	return HPGroupId_List{List: p.List()}, err
}

func (s HPSegReq) HasGroupIds() bool {
	p, err := s.Struct.Ptr(0)
	return p.IsValid() || err != nil
}

func (s HPSegReq) SetGroupIds(v HPGroupId_List) error {
	return s.Struct.SetPtr(0, v.List.ToPtr())
}

// NewGroupIds sets the groupIds field to a newly
// allocated HPGroupId_List, preferring placement in s's segment.
func (s HPSegReq) NewGroupIds(n int32) (HPGroupId_List, error) {
	l, err := NewHPGroupId_List(s.Struct.Segment(), n)
	if err != nil {
		return HPGroupId_List{}, err
	}
	err = s.Struct.SetPtr(0, l.List.ToPtr())
	return l, err
}

// HPSegReq_List is a list of HPSegReq.
type HPSegReq_List struct{ capnp.List }

// NewHPSegReq creates a new list of HPSegReq.
func NewHPSegReq_List(s *capnp.Segment, sz int32) (HPSegReq_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 1}, sz)
	return HPSegReq_List{l}, err
}

func (s HPSegReq_List) At(i int) HPSegReq { return HPSegReq{s.List.Struct(i)} }

func (s HPSegReq_List) Set(i int, v HPSegReq) error { return s.List.SetStruct(i, v.Struct) }

func (s HPSegReq_List) String() string {
	str, _ := text.MarshalList(0x8f51e8717b3fbe1c, s.List)
	return str
}

// HPSegReq_Promise is a wrapper for a HPSegReq promised by a client call.
type HPSegReq_Promise struct{ *capnp.Pipeline }

func (p HPSegReq_Promise) Struct() (HPSegReq, error) {
	s, err := p.Pipeline.Struct()
	return HPSegReq{s}, err
}

type HPSegRecs struct{ capnp.Struct }

// HPSegRecs_TypeID is the unique identifier for the type HPSegRecs.
const HPSegRecs_TypeID = 0xa56b96c8b25ce2e1

func NewHPSegRecs(s *capnp.Segment) (HPSegRecs, error) {
	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3})
	return HPSegRecs{st}, err
}

func NewRootHPSegRecs(s *capnp.Segment) (HPSegRecs, error) {
	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3})
	return HPSegRecs{st}, err
}

func ReadRootHPSegRecs(msg *capnp.Message) (HPSegRecs, error) {
	root, err := msg.RootPtr()
	return HPSegRecs{root.Struct()}, err
}

func (s HPSegRecs) String() string {
	str, _ := text.Marshal(0xa56b96c8b25ce2e1, s.Struct)
	return str
}

func (s HPSegRecs) GroupId() (HPGroupId, error) {
	p, err := s.Struct.Ptr(0)
	return HPGroupId{Struct: p.Struct()}, err
}

func (s HPSegRecs) HasGroupId() bool {
	p, err := s.Struct.Ptr(0)
	return p.IsValid() || err != nil
}

func (s HPSegRecs) SetGroupId(v HPGroupId) error {
	return s.Struct.SetPtr(0, v.Struct.ToPtr())
}

// NewGroupId sets the groupId field to a newly
// allocated HPGroupId struct, preferring placement in s's segment.
func (s HPSegRecs) NewGroupId() (HPGroupId, error) {
	ss, err := NewHPGroupId(s.Struct.Segment())
	if err != nil {
		return HPGroupId{}, err
	}
	err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
	return ss, err
}

func (s HPSegRecs) Recs() (PathSegMeta_List, error) {
	p, err := s.Struct.Ptr(1)
	return PathSegMeta_List{List: p.List()}, err
}

func (s HPSegRecs) HasRecs() bool {
	p, err := s.Struct.Ptr(1)
	return p.IsValid() || err != nil
}

func (s HPSegRecs) SetRecs(v PathSegMeta_List) error {
	return s.Struct.SetPtr(1, v.List.ToPtr())
}

// NewRecs sets the recs field to a newly
// allocated PathSegMeta_List, preferring placement in s's segment.
func (s HPSegRecs) NewRecs(n int32) (PathSegMeta_List, error) {
	l, err := NewPathSegMeta_List(s.Struct.Segment(), n)
	if err != nil {
		return PathSegMeta_List{}, err
	}
	err = s.Struct.SetPtr(1, l.List.ToPtr())
	return l, err
}

func (s HPSegRecs) Err() (string, error) {
	p, err := s.Struct.Ptr(2)
	return p.Text(), err
}

func (s HPSegRecs) HasErr() bool {
	p, err := s.Struct.Ptr(2)
	return p.IsValid() || err != nil
}

func (s HPSegRecs) ErrBytes() ([]byte, error) {
	p, err := s.Struct.Ptr(2)
	return p.TextBytes(), err
}

func (s HPSegRecs) SetErr(v string) error {
	return s.Struct.SetText(2, v)
}

// HPSegRecs_List is a list of HPSegRecs.
type HPSegRecs_List struct{ capnp.List }

// NewHPSegRecs creates a new list of HPSegRecs.
func NewHPSegRecs_List(s *capnp.Segment, sz int32) (HPSegRecs_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 3}, sz)
	return HPSegRecs_List{l}, err
}

func (s HPSegRecs_List) At(i int) HPSegRecs { return HPSegRecs{s.List.Struct(i)} }

func (s HPSegRecs_List) Set(i int, v HPSegRecs) error { return s.List.SetStruct(i, v.Struct) }

func (s HPSegRecs_List) String() string {
	str, _ := text.MarshalList(0xa56b96c8b25ce2e1, s.List)
	return str
}

// HPSegRecs_Promise is a wrapper for a HPSegRecs promised by a client call.
type HPSegRecs_Promise struct{ *capnp.Pipeline }

func (p HPSegRecs_Promise) Struct() (HPSegRecs, error) {
	s, err := p.Pipeline.Struct()
	return HPSegRecs{s}, err
}

func (p HPSegRecs_Promise) GroupId() HPGroupId_Promise {
	return HPGroupId_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
}

type HPSegReply struct{ capnp.Struct }

// HPSegReply_TypeID is the unique identifier for the type HPSegReply.
const HPSegReply_TypeID = 0xaaf7fd9241668ed6

func NewHPSegReply(s *capnp.Segment) (HPSegReply, error) {
	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
	return HPSegReply{st}, err
}

func NewRootHPSegReply(s *capnp.Segment) (HPSegReply, error) {
	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
	return HPSegReply{st}, err
}

func ReadRootHPSegReply(msg *capnp.Message) (HPSegReply, error) {
	root, err := msg.RootPtr()
	return HPSegReply{root.Struct()}, err
}

func (s HPSegReply) String() string {
	str, _ := text.Marshal(0xaaf7fd9241668ed6, s.Struct)
	return str
}

func (s HPSegReply) Recs() (HPSegRecs_List, error) {
	p, err := s.Struct.Ptr(0)
	return HPSegRecs_List{List: p.List()}, err
}

func (s HPSegReply) HasRecs() bool {
	p, err := s.Struct.Ptr(0)
	return p.IsValid() || err != nil
}

func (s HPSegReply) SetRecs(v HPSegRecs_List) error {
	return s.Struct.SetPtr(0, v.List.ToPtr())
}

// NewRecs sets the recs field to a newly
// allocated HPSegRecs_List, preferring placement in s's segment.
func (s HPSegReply) NewRecs(n int32) (HPSegRecs_List, error) {
	l, err := NewHPSegRecs_List(s.Struct.Segment(), n)
	if err != nil {
		return HPSegRecs_List{}, err
	}
	err = s.Struct.SetPtr(0, l.List.ToPtr())
	return l, err
}

// HPSegReply_List is a list of HPSegReply.
type HPSegReply_List struct{ capnp.List }

// NewHPSegReply creates a new list of HPSegReply.
func NewHPSegReply_List(s *capnp.Segment, sz int32) (HPSegReply_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
	return HPSegReply_List{l}, err
}

func (s HPSegReply_List) At(i int) HPSegReply { return HPSegReply{s.List.Struct(i)} }

func (s HPSegReply_List) Set(i int, v HPSegReply) error { return s.List.SetStruct(i, v.Struct) }

func (s HPSegReply_List) String() string {
	str, _ := text.MarshalList(0xaaf7fd9241668ed6, s.List)
	return str
}

// HPSegReply_Promise is a wrapper for a HPSegReply promised by a client call.
type HPSegReply_Promise struct{ *capnp.Pipeline }

func (p HPSegReply_Promise) Struct() (HPSegReply, error) {
	s, err := p.Pipeline.Struct()
	return HPSegReply{s}, err
}

type HPCfg struct{ capnp.Struct }

// HPCfg_TypeID is the unique identifier for the type HPCfg.
const HPCfg_TypeID = 0xf307100ab87a1963

func NewHPCfg(s *capnp.Segment) (HPCfg, error) {
	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 4})
	return HPCfg{st}, err
}

func NewRootHPCfg(s *capnp.Segment) (HPCfg, error) {
	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 4})
	return HPCfg{st}, err
}

func ReadRootHPCfg(msg *capnp.Message) (HPCfg, error) {
	root, err := msg.RootPtr()
	return HPCfg{root.Struct()}, err
}

func (s HPCfg) String() string {
	str, _ := text.Marshal(0xf307100ab87a1963, s.Struct)
	return str
}

func (s HPCfg) GroupId() (HPGroupId, error) {
	p, err := s.Struct.Ptr(0)
	return HPGroupId{Struct: p.Struct()}, err
}

func (s HPCfg) HasGroupId() bool {
	p, err := s.Struct.Ptr(0)
	return p.IsValid() || err != nil
}

func (s HPCfg) SetGroupId(v HPGroupId) error {
	return s.Struct.SetPtr(0, v.Struct.ToPtr())
}

// NewGroupId sets the groupId field to a newly
// allocated HPGroupId struct, preferring placement in s's segment.
func (s HPCfg) NewGroupId() (HPGroupId, error) {
	ss, err := NewHPGroupId(s.Struct.Segment())
	if err != nil {
		return HPGroupId{}, err
	}
	err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
	return ss, err
}

func (s HPCfg) Version() uint32 {
	return s.Struct.Uint32(0)
}

func (s HPCfg) SetVersion(v uint32) {
	s.Struct.SetUint32(0, v)
}

func (s HPCfg) OwnerISD() uint16 {
	return s.Struct.Uint16(4)
}

func (s HPCfg) SetOwnerISD(v uint16) {
	s.Struct.SetUint16(4, v)
}

func (s HPCfg) Writers() (capnp.UInt64List, error) {
	p, err := s.Struct.Ptr(1)
	return capnp.UInt64List{List: p.List()}, err
}

func (s HPCfg) HasWriters() bool {
	p, err := s.Struct.Ptr(1)
	return p.IsValid() || err != nil
}

func (s HPCfg) SetWriters(v capnp.UInt64List) error {
	return s.Struct.SetPtr(1, v.List.ToPtr())
}

// NewWriters sets the writers field to a newly
// allocated capnp.UInt64List, preferring placement in s's segment.
func (s HPCfg) NewWriters(n int32) (capnp.UInt64List, error) {
	l, err := capnp.NewUInt64List(s.Struct.Segment(), n)
	if err != nil {
		return capnp.UInt64List{}, err
	}
	err = s.Struct.SetPtr(1, l.List.ToPtr())
	return l, err
}

func (s HPCfg) Readers() (capnp.UInt64List, error) {
	p, err := s.Struct.Ptr(2)
	return capnp.UInt64List{List: p.List()}, err
}

func (s HPCfg) HasReaders() bool {
	p, err := s.Struct.Ptr(2)
	return p.IsValid() || err != nil
}

func (s HPCfg) SetReaders(v capnp.UInt64List) error {
	return s.Struct.SetPtr(2, v.List.ToPtr())
}

// NewReaders sets the readers field to a newly
// allocated capnp.UInt64List, preferring placement in s's segment.
func (s HPCfg) NewReaders(n int32) (capnp.UInt64List, error) {
	l, err := capnp.NewUInt64List(s.Struct.Segment(), n)
	if err != nil {
		return capnp.UInt64List{}, err
	}
	err = s.Struct.SetPtr(2, l.List.ToPtr())
	return l, err
}

func (s HPCfg) Registries() (capnp.UInt64List, error) {
	p, err := s.Struct.Ptr(3)
	return capnp.UInt64List{List: p.List()}, err
}

func (s HPCfg) HasRegistries() bool {
	p, err := s.Struct.Ptr(3)
	return p.IsValid() || err != nil
}

func (s HPCfg) SetRegistries(v capnp.UInt64List) error {
	return s.Struct.SetPtr(3, v.List.ToPtr())
}

// NewRegistries sets the registries field to a newly
// allocated capnp.UInt64List, preferring placement in s's segment.
func (s HPCfg) NewRegistries(n int32) (capnp.UInt64List, error) {
	l, err := capnp.NewUInt64List(s.Struct.Segment(), n)
	if err != nil {
		return capnp.UInt64List{}, err
	}
	err = s.Struct.SetPtr(3, l.List.ToPtr())
	return l, err
}

// HPCfg_List is a list of HPCfg.
type HPCfg_List struct{ capnp.List }

// NewHPCfg creates a new list of HPCfg.
func NewHPCfg_List(s *capnp.Segment, sz int32) (HPCfg_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 4}, sz)
	return HPCfg_List{l}, err
}

func (s HPCfg_List) At(i int) HPCfg { return HPCfg{s.List.Struct(i)} }

func (s HPCfg_List) Set(i int, v HPCfg) error { return s.List.SetStruct(i, v.Struct) }

func (s HPCfg_List) String() string {
	str, _ := text.MarshalList(0xf307100ab87a1963, s.List)
	return str
}

// HPCfg_Promise is a wrapper for a HPCfg promised by a client call.
type HPCfg_Promise struct{ *capnp.Pipeline }

func (p HPCfg_Promise) Struct() (HPCfg, error) {
	s, err := p.Pipeline.Struct()
	return HPCfg{s}, err
}

func (p HPCfg_Promise) GroupId() HPGroupId_Promise {
	return HPGroupId_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
}

type HPCfgReq struct{ capnp.Struct }

// HPCfgReq_TypeID is the unique identifier for the type HPCfgReq.
const HPCfgReq_TypeID = 0xd24bad15bb2bab5e

func NewHPCfgReq(s *capnp.Segment) (HPCfgReq, error) {
	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 0})
	return HPCfgReq{st}, err
}

func NewRootHPCfgReq(s *capnp.Segment) (HPCfgReq, error) {
	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 0})
	return HPCfgReq{st}, err
}

func ReadRootHPCfgReq(msg *capnp.Message) (HPCfgReq, error) {
	root, err := msg.RootPtr()
	return HPCfgReq{root.Struct()}, err
}

func (s HPCfgReq) String() string {
	str, _ := text.Marshal(0xd24bad15bb2bab5e, s.Struct)
	return str
}

func (s HPCfgReq) ChangedSince() uint32 {
	return s.Struct.Uint32(0)
}

func (s HPCfgReq) SetChangedSince(v uint32) {
	s.Struct.SetUint32(0, v)
}

// HPCfgReq_List is a list of HPCfgReq.
type HPCfgReq_List struct{ capnp.List }

// NewHPCfgReq creates a new list of HPCfgReq.
func NewHPCfgReq_List(s *capnp.Segment, sz int32) (HPCfgReq_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 0}, sz)
	return HPCfgReq_List{l}, err
}

func (s HPCfgReq_List) At(i int) HPCfgReq { return HPCfgReq{s.List.Struct(i)} }

func (s HPCfgReq_List) Set(i int, v HPCfgReq) error { return s.List.SetStruct(i, v.Struct) }

func (s HPCfgReq_List) String() string {
	str, _ := text.MarshalList(0xd24bad15bb2bab5e, s.List)
	return str
}

// HPCfgReq_Promise is a wrapper for a HPCfgReq promised by a client call.
type HPCfgReq_Promise struct{ *capnp.Pipeline }

func (p HPCfgReq_Promise) Struct() (HPCfgReq, error) {
	s, err := p.Pipeline.Struct()
	return HPCfgReq{s}, err
}

type HPCfgReply struct{ capnp.Struct }

// HPCfgReply_TypeID is the unique identifier for the type HPCfgReply.
const HPCfgReply_TypeID = 0xb27bf6e10de2aa8c

func NewHPCfgReply(s *capnp.Segment) (HPCfgReply, error) {
	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
	return HPCfgReply{st}, err
}

func NewRootHPCfgReply(s *capnp.Segment) (HPCfgReply, error) {
	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1})
	return HPCfgReply{st}, err
}

func ReadRootHPCfgReply(msg *capnp.Message) (HPCfgReply, error) {
	root, err := msg.RootPtr()
	return HPCfgReply{root.Struct()}, err
}

func (s HPCfgReply) String() string {
	str, _ := text.Marshal(0xb27bf6e10de2aa8c, s.Struct)
	return str
}

func (s HPCfgReply) Cfgs() (HPCfg_List, error) {
	p, err := s.Struct.Ptr(0)
	return HPCfg_List{List: p.List()}, err
}

func (s HPCfgReply) HasCfgs() bool {
	p, err := s.Struct.Ptr(0)
	return p.IsValid() || err != nil
}

func (s HPCfgReply) SetCfgs(v HPCfg_List) error {
	return s.Struct.SetPtr(0, v.List.ToPtr())
}

// NewCfgs sets the cfgs field to a newly
// allocated HPCfg_List, preferring placement in s's segment.
func (s HPCfgReply) NewCfgs(n int32) (HPCfg_List, error) {
	l, err := NewHPCfg_List(s.Struct.Segment(), n)
	if err != nil {
		return HPCfg_List{}, err
	}
	err = s.Struct.SetPtr(0, l.List.ToPtr())
	return l, err
}

// HPCfgReply_List is a list of HPCfgReply.
type HPCfgReply_List struct{ capnp.List }

// NewHPCfgReply creates a new list of HPCfgReply.
func NewHPCfgReply_List(s *capnp.Segment, sz int32) (HPCfgReply_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
	return HPCfgReply_List{l}, err
}

func (s HPCfgReply_List) At(i int) HPCfgReply { return HPCfgReply{s.List.Struct(i)} }

func (s HPCfgReply_List) Set(i int, v HPCfgReply) error { return s.List.SetStruct(i, v.Struct) }

func (s HPCfgReply_List) String() string {
	str, _ := text.MarshalList(0xb27bf6e10de2aa8c, s.List)
	return str
}

// HPCfgReply_Promise is a wrapper for a HPCfgReply promised by a client call.
type HPCfgReply_Promise struct{ *capnp.Pipeline }

func (p HPCfgReply_Promise) Struct() (HPCfgReply, error) {
	s, err := p.Pipeline.Struct()
	return HPCfgReply{s}, err
}

type PathMgmt struct{ capnp.Struct }
type PathMgmt_Which uint16

const (
	PathMgmt_Which_unset             PathMgmt_Which = 0
	PathMgmt_Which_segReq            PathMgmt_Which = 1
	PathMgmt_Which_segReply          PathMgmt_Which = 2
	PathMgmt_Which_segReg            PathMgmt_Which = 3
	PathMgmt_Which_segSync           PathMgmt_Which = 4
	PathMgmt_Which_sRevInfo          PathMgmt_Which = 5
	PathMgmt_Which_ifStateReq        PathMgmt_Which = 6
	PathMgmt_Which_ifStateInfos      PathMgmt_Which = 7
	PathMgmt_Which_segChangesIdReq   PathMgmt_Which = 8
	PathMgmt_Which_segChangesIdReply PathMgmt_Which = 9
	PathMgmt_Which_segChangesReq     PathMgmt_Which = 10
	PathMgmt_Which_segChangesReply   PathMgmt_Which = 11
	PathMgmt_Which_hpSegReq          PathMgmt_Which = 12
	PathMgmt_Which_hpSegReply        PathMgmt_Which = 13
	PathMgmt_Which_hpSegReg          PathMgmt_Which = 14
	PathMgmt_Which_hpCfgReq          PathMgmt_Which = 15
	PathMgmt_Which_hpCfgReply        PathMgmt_Which = 16
)

func (w PathMgmt_Which) String() string {
	const s = "unsetsegReqsegReplysegRegsegSyncsRevInfoifStateReqifStateInfossegChangesIdReqsegChangesIdReplysegChangesReqsegChangesReplyhpSegReqhpSegReplyhpSegReghpCfgReqhpCfgReply"
	switch w {
	case PathMgmt_Which_unset:
		return s[0:5]
	case PathMgmt_Which_segReq:
		return s[5:11]
	case PathMgmt_Which_segReply:
		return s[11:19]
	case PathMgmt_Which_segReg:
		return s[19:25]
	case PathMgmt_Which_segSync:
		return s[25:32]
	case PathMgmt_Which_sRevInfo:
		return s[32:40]
	case PathMgmt_Which_ifStateReq:
		return s[40:50]
	case PathMgmt_Which_ifStateInfos:
		return s[50:62]
	case PathMgmt_Which_segChangesIdReq:
		return s[62:77]
	case PathMgmt_Which_segChangesIdReply:
		return s[77:94]
	case PathMgmt_Which_segChangesReq:
		return s[94:107]
	case PathMgmt_Which_segChangesReply:
		return s[107:122]
	case PathMgmt_Which_hpSegReq:
		return s[122:130]
	case PathMgmt_Which_hpSegReply:
		return s[130:140]
	case PathMgmt_Which_hpSegReg:
		return s[140:148]
	case PathMgmt_Which_hpCfgReq:
		return s[148:156]
	case PathMgmt_Which_hpCfgReply:
		return s[156:166]

	}
	return "PathMgmt_Which(" + strconv.FormatUint(uint64(w), 10) + ")"
}

// PathMgmt_TypeID is the unique identifier for the type PathMgmt.
const PathMgmt_TypeID = 0xa12cfa420c9ad0ca

func NewPathMgmt(s *capnp.Segment) (PathMgmt, error) {
	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 1})
	return PathMgmt{st}, err
}

func NewRootPathMgmt(s *capnp.Segment) (PathMgmt, error) {
	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 1})
	return PathMgmt{st}, err
}

func ReadRootPathMgmt(msg *capnp.Message) (PathMgmt, error) {
	root, err := msg.RootPtr()
	return PathMgmt{root.Struct()}, err
}

func (s PathMgmt) String() string {
	str, _ := text.Marshal(0xa12cfa420c9ad0ca, s.Struct)
	return str
}

func (s PathMgmt) Which() PathMgmt_Which {
	return PathMgmt_Which(s.Struct.Uint16(0))
}
func (s PathMgmt) SetUnset() {
	s.Struct.SetUint16(0, 0)

}

func (s PathMgmt) SegReq() (SegReq, error) {
	if s.Struct.Uint16(0) != 1 {
		panic("Which() != segReq")
	}
	p, err := s.Struct.Ptr(0)
	return SegReq{Struct: p.Struct()}, err
}

func (s PathMgmt) HasSegReq() bool {
	if s.Struct.Uint16(0) != 1 {
		return false
	}
	p, err := s.Struct.Ptr(0)
	return p.IsValid() || err != nil
}

func (s PathMgmt) SetSegReq(v SegReq) error {
	s.Struct.SetUint16(0, 1)
	return s.Struct.SetPtr(0, v.Struct.ToPtr())
}

// NewSegReq sets the segReq field to a newly
// allocated SegReq struct, preferring placement in s's segment.
func (s PathMgmt) NewSegReq() (SegReq, error) {
	s.Struct.SetUint16(0, 1)
	ss, err := NewSegReq(s.Struct.Segment())
	if err != nil {
		return SegReq{}, err
	}
	err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
	return ss, err
}

func (s PathMgmt) SegReply() (SegReply, error) {
	if s.Struct.Uint16(0) != 2 {
		panic("Which() != segReply")
	}
	p, err := s.Struct.Ptr(0)
	return SegReply{Struct: p.Struct()}, err
}

func (s PathMgmt) HasSegReply() bool {
	if s.Struct.Uint16(0) != 2 {
		return false
	}
	p, err := s.Struct.Ptr(0)
	return p.IsValid() || err != nil
}

func (s PathMgmt) SetSegReply(v SegReply) error {
	s.Struct.SetUint16(0, 2)
	return s.Struct.SetPtr(0, v.Struct.ToPtr())
}

// NewSegReply sets the segReply field to a newly
// allocated SegReply struct, preferring placement in s's segment.
func (s PathMgmt) NewSegReply() (SegReply, error) {
	s.Struct.SetUint16(0, 2)
	ss, err := NewSegReply(s.Struct.Segment())
	if err != nil {
		return SegReply{}, err
	}
	err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
	return ss, err
}

func (s PathMgmt) SegReg() (SegRecs, error) {
	if s.Struct.Uint16(0) != 3 {
		panic("Which() != segReg")
	}
	p, err := s.Struct.Ptr(0)
	return SegRecs{Struct: p.Struct()}, err
}

func (s PathMgmt) HasSegReg() bool {
	if s.Struct.Uint16(0) != 3 {
		return false
	}
	p, err := s.Struct.Ptr(0)
	return p.IsValid() || err != nil
}

func (s PathMgmt) SetSegReg(v SegRecs) error {
	s.Struct.SetUint16(0, 3)
	return s.Struct.SetPtr(0, v.Struct.ToPtr())
}

// NewSegReg sets the segReg field to a newly
// allocated SegRecs struct, preferring placement in s's segment.
func (s PathMgmt) NewSegReg() (SegRecs, error) {
	s.Struct.SetUint16(0, 3)
	ss, err := NewSegRecs(s.Struct.Segment())
	if err != nil {
		return SegRecs{}, err
	}
	err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
	return ss, err
}

func (s PathMgmt) SegSync() (SegRecs, error) {
	if s.Struct.Uint16(0) != 4 {
		panic("Which() != segSync")
	}
	p, err := s.Struct.Ptr(0)
	return SegRecs{Struct: p.Struct()}, err
}

func (s PathMgmt) HasSegSync() bool {
	if s.Struct.Uint16(0) != 4 {
		return false
	}
	p, err := s.Struct.Ptr(0)
	return p.IsValid() || err != nil
}

func (s PathMgmt) SetSegSync(v SegRecs) error {
	s.Struct.SetUint16(0, 4)
	return s.Struct.SetPtr(0, v.Struct.ToPtr())
}

// NewSegSync sets the segSync field to a newly
// allocated SegRecs struct, preferring placement in s's segment.
func (s PathMgmt) NewSegSync() (SegRecs, error) {
	s.Struct.SetUint16(0, 4)
	ss, err := NewSegRecs(s.Struct.Segment())
	if err != nil {
		return SegRecs{}, err
	}
	err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
	return ss, err
}

func (s PathMgmt) SRevInfo() (SignedBlob, error) {
	if s.Struct.Uint16(0) != 5 {
		panic("Which() != sRevInfo")
	}
	p, err := s.Struct.Ptr(0)
	return SignedBlob{Struct: p.Struct()}, err
}

func (s PathMgmt) HasSRevInfo() bool {
	if s.Struct.Uint16(0) != 5 {
		return false
	}
	p, err := s.Struct.Ptr(0)
	return p.IsValid() || err != nil
}

func (s PathMgmt) SetSRevInfo(v SignedBlob) error {
	s.Struct.SetUint16(0, 5)
	return s.Struct.SetPtr(0, v.Struct.ToPtr())
}

// NewSRevInfo sets the sRevInfo field to a newly
// allocated SignedBlob struct, preferring placement in s's segment.
func (s PathMgmt) NewSRevInfo() (SignedBlob, error) {
	s.Struct.SetUint16(0, 5)
	ss, err := NewSignedBlob(s.Struct.Segment())
	if err != nil {
		return SignedBlob{}, err
	}
	err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
	return ss, err
}

func (s PathMgmt) IfStateReq() (IFStateReq, error) {
	if s.Struct.Uint16(0) != 6 {
		panic("Which() != ifStateReq")
	}
	p, err := s.Struct.Ptr(0)
	return IFStateReq{Struct: p.Struct()}, err
}

func (s PathMgmt) HasIfStateReq() bool {
	if s.Struct.Uint16(0) != 6 {
		return false
	}
	p, err := s.Struct.Ptr(0)
	return p.IsValid() || err != nil
}

func (s PathMgmt) SetIfStateReq(v IFStateReq) error {
	s.Struct.SetUint16(0, 6)
	return s.Struct.SetPtr(0, v.Struct.ToPtr())
}

// NewIfStateReq sets the ifStateReq field to a newly
// allocated IFStateReq struct, preferring placement in s's segment.
func (s PathMgmt) NewIfStateReq() (IFStateReq, error) {
	s.Struct.SetUint16(0, 6)
	ss, err := NewIFStateReq(s.Struct.Segment())
	if err != nil {
		return IFStateReq{}, err
	}
	err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
	return ss, err
}

func (s PathMgmt) IfStateInfos() (IFStateInfos, error) {
	if s.Struct.Uint16(0) != 7 {
		panic("Which() != ifStateInfos")
	}
	p, err := s.Struct.Ptr(0)
	return IFStateInfos{Struct: p.Struct()}, err
}

func (s PathMgmt) HasIfStateInfos() bool {
	if s.Struct.Uint16(0) != 7 {
		return false
	}
	p, err := s.Struct.Ptr(0)
	return p.IsValid() || err != nil
}

func (s PathMgmt) SetIfStateInfos(v IFStateInfos) error {
	s.Struct.SetUint16(0, 7)
	return s.Struct.SetPtr(0, v.Struct.ToPtr())
}

// NewIfStateInfos sets the ifStateInfos field to a newly
// allocated IFStateInfos struct, preferring placement in s's segment.
func (s PathMgmt) NewIfStateInfos() (IFStateInfos, error) {
	s.Struct.SetUint16(0, 7)
	ss, err := NewIFStateInfos(s.Struct.Segment())
	if err != nil {
		return IFStateInfos{}, err
	}
	err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
	return ss, err
}

func (s PathMgmt) SegChangesIdReq() (SegChangesIdReq, error) {
	if s.Struct.Uint16(0) != 8 {
		panic("Which() != segChangesIdReq")
	}
	p, err := s.Struct.Ptr(0)
	return SegChangesIdReq{Struct: p.Struct()}, err
}

func (s PathMgmt) HasSegChangesIdReq() bool {
	if s.Struct.Uint16(0) != 8 {
		return false
	}
	p, err := s.Struct.Ptr(0)
	return p.IsValid() || err != nil
}

func (s PathMgmt) SetSegChangesIdReq(v SegChangesIdReq) error {
	s.Struct.SetUint16(0, 8)
	return s.Struct.SetPtr(0, v.Struct.ToPtr())
}

// NewSegChangesIdReq sets the segChangesIdReq field to a newly
// allocated SegChangesIdReq struct, preferring placement in s's segment.
func (s PathMgmt) NewSegChangesIdReq() (SegChangesIdReq, error) {
	s.Struct.SetUint16(0, 8)
	ss, err := NewSegChangesIdReq(s.Struct.Segment())
	if err != nil {
		return SegChangesIdReq{}, err
	}
	err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
	return ss, err
}

func (s PathMgmt) SegChangesIdReply() (SegChangesIdReply, error) {
	if s.Struct.Uint16(0) != 9 {
		panic("Which() != segChangesIdReply")
	}
	p, err := s.Struct.Ptr(0)
	return SegChangesIdReply{Struct: p.Struct()}, err
}

func (s PathMgmt) HasSegChangesIdReply() bool {
	if s.Struct.Uint16(0) != 9 {
		return false
	}
	p, err := s.Struct.Ptr(0)
	return p.IsValid() || err != nil
}

func (s PathMgmt) SetSegChangesIdReply(v SegChangesIdReply) error {
	s.Struct.SetUint16(0, 9)
	return s.Struct.SetPtr(0, v.Struct.ToPtr())
}

// NewSegChangesIdReply sets the segChangesIdReply field to a newly
// allocated SegChangesIdReply struct, preferring placement in s's segment.
func (s PathMgmt) NewSegChangesIdReply() (SegChangesIdReply, error) {
	s.Struct.SetUint16(0, 9)
	ss, err := NewSegChangesIdReply(s.Struct.Segment())
	if err != nil {
		return SegChangesIdReply{}, err
	}
	err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
	return ss, err
}

func (s PathMgmt) SegChangesReq() (SegChangesReq, error) {
	if s.Struct.Uint16(0) != 10 {
		panic("Which() != segChangesReq")
	}
	p, err := s.Struct.Ptr(0)
	return SegChangesReq{Struct: p.Struct()}, err
}

func (s PathMgmt) HasSegChangesReq() bool {
	if s.Struct.Uint16(0) != 10 {
		return false
	}
	p, err := s.Struct.Ptr(0)
	return p.IsValid() || err != nil
}

func (s PathMgmt) SetSegChangesReq(v SegChangesReq) error {
	s.Struct.SetUint16(0, 10)
	return s.Struct.SetPtr(0, v.Struct.ToPtr())
}

// NewSegChangesReq sets the segChangesReq field to a newly
// allocated SegChangesReq struct, preferring placement in s's segment.
func (s PathMgmt) NewSegChangesReq() (SegChangesReq, error) {
	s.Struct.SetUint16(0, 10)
	ss, err := NewSegChangesReq(s.Struct.Segment())
	if err != nil {
		return SegChangesReq{}, err
	}
	err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
	return ss, err
}

func (s PathMgmt) SegChangesReply() (SegRecs, error) {
	if s.Struct.Uint16(0) != 11 {
		panic("Which() != segChangesReply")
	}
	p, err := s.Struct.Ptr(0)
	return SegRecs{Struct: p.Struct()}, err
}

func (s PathMgmt) HasSegChangesReply() bool {
	if s.Struct.Uint16(0) != 11 {
		return false
	}
	p, err := s.Struct.Ptr(0)
	return p.IsValid() || err != nil
}

func (s PathMgmt) SetSegChangesReply(v SegRecs) error {
	s.Struct.SetUint16(0, 11)
	return s.Struct.SetPtr(0, v.Struct.ToPtr())
}

// NewSegChangesReply sets the segChangesReply field to a newly
// allocated SegRecs struct, preferring placement in s's segment.
func (s PathMgmt) NewSegChangesReply() (SegRecs, error) {
	s.Struct.SetUint16(0, 11)
	ss, err := NewSegRecs(s.Struct.Segment())
	if err != nil {
		return SegRecs{}, err
	}
	err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
	return ss, err
}

func (s PathMgmt) HpSegReq() (HPSegReq, error) {
	if s.Struct.Uint16(0) != 12 {
		panic("Which() != hpSegReq")
	}
	p, err := s.Struct.Ptr(0)
	return HPSegReq{Struct: p.Struct()}, err
}

func (s PathMgmt) HasHpSegReq() bool {
	if s.Struct.Uint16(0) != 12 {
		return false
	}
	p, err := s.Struct.Ptr(0)
	return p.IsValid() || err != nil
}

func (s PathMgmt) SetHpSegReq(v HPSegReq) error {
	s.Struct.SetUint16(0, 12)
	return s.Struct.SetPtr(0, v.Struct.ToPtr())
}

// NewHpSegReq sets the hpSegReq field to a newly
// allocated HPSegReq struct, preferring placement in s's segment.
func (s PathMgmt) NewHpSegReq() (HPSegReq, error) {
	s.Struct.SetUint16(0, 12)
	ss, err := NewHPSegReq(s.Struct.Segment())
	if err != nil {
		return HPSegReq{}, err
	}
	err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
	return ss, err
}

func (s PathMgmt) HpSegReply() (HPSegReply, error) {
	if s.Struct.Uint16(0) != 13 {
		panic("Which() != hpSegReply")
	}
	p, err := s.Struct.Ptr(0)
	return HPSegReply{Struct: p.Struct()}, err
}

func (s PathMgmt) HasHpSegReply() bool {
	if s.Struct.Uint16(0) != 13 {
		return false
	}
	p, err := s.Struct.Ptr(0)
	return p.IsValid() || err != nil
}

func (s PathMgmt) SetHpSegReply(v HPSegReply) error {
	s.Struct.SetUint16(0, 13)
	return s.Struct.SetPtr(0, v.Struct.ToPtr())
}

// NewHpSegReply sets the hpSegReply field to a newly
// allocated HPSegReply struct, preferring placement in s's segment.
func (s PathMgmt) NewHpSegReply() (HPSegReply, error) {
	s.Struct.SetUint16(0, 13)
	ss, err := NewHPSegReply(s.Struct.Segment())
	if err != nil {
		return HPSegReply{}, err
	}
	err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
	return ss, err
}

func (s PathMgmt) HpSegReg() (HPSegRecs, error) {
	if s.Struct.Uint16(0) != 14 {
		panic("Which() != hpSegReg")
	}
	p, err := s.Struct.Ptr(0)
	return HPSegRecs{Struct: p.Struct()}, err
}

func (s PathMgmt) HasHpSegReg() bool {
	if s.Struct.Uint16(0) != 14 {
		return false
	}
	p, err := s.Struct.Ptr(0)
	return p.IsValid() || err != nil
}

func (s PathMgmt) SetHpSegReg(v HPSegRecs) error {
	s.Struct.SetUint16(0, 14)
	return s.Struct.SetPtr(0, v.Struct.ToPtr())
}

// NewHpSegReg sets the hpSegReg field to a newly
// allocated HPSegRecs struct, preferring placement in s's segment.
func (s PathMgmt) NewHpSegReg() (HPSegRecs, error) {
	s.Struct.SetUint16(0, 14)
	ss, err := NewHPSegRecs(s.Struct.Segment())
	if err != nil {
		return HPSegRecs{}, err
	}
	err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
	return ss, err
}

func (s PathMgmt) HpCfgReq() (HPCfgReq, error) {
	if s.Struct.Uint16(0) != 15 {
		panic("Which() != hpCfgReq")
	}
	p, err := s.Struct.Ptr(0)
	return HPCfgReq{Struct: p.Struct()}, err
}

func (s PathMgmt) HasHpCfgReq() bool {
	if s.Struct.Uint16(0) != 15 {
		return false
	}
	p, err := s.Struct.Ptr(0)
	return p.IsValid() || err != nil
}

func (s PathMgmt) SetHpCfgReq(v HPCfgReq) error {
	s.Struct.SetUint16(0, 15)
	return s.Struct.SetPtr(0, v.Struct.ToPtr())
}

// NewHpCfgReq sets the hpCfgReq field to a newly
// allocated HPCfgReq struct, preferring placement in s's segment.
func (s PathMgmt) NewHpCfgReq() (HPCfgReq, error) {
	s.Struct.SetUint16(0, 15)
	ss, err := NewHPCfgReq(s.Struct.Segment())
	if err != nil {
		return HPCfgReq{}, err
	}
	err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
	return ss, err
}

func (s PathMgmt) HpCfgReply() (HPCfgReply, error) {
	if s.Struct.Uint16(0) != 16 {
		panic("Which() != hpCfgReply")
	}
	p, err := s.Struct.Ptr(0)
	return HPCfgReply{Struct: p.Struct()}, err
}

func (s PathMgmt) HasHpCfgReply() bool {
	if s.Struct.Uint16(0) != 16 {
		return false
	}
	p, err := s.Struct.Ptr(0)
	return p.IsValid() || err != nil
}

func (s PathMgmt) SetHpCfgReply(v HPCfgReply) error {
	s.Struct.SetUint16(0, 16)
	return s.Struct.SetPtr(0, v.Struct.ToPtr())
}

// NewHpCfgReply sets the hpCfgReply field to a newly
// allocated HPCfgReply struct, preferring placement in s's segment.
func (s PathMgmt) NewHpCfgReply() (HPCfgReply, error) {
	s.Struct.SetUint16(0, 16)
	ss, err := NewHPCfgReply(s.Struct.Segment())
	if err != nil {
		return HPCfgReply{}, err
	}
	err = s.Struct.SetPtr(0, ss.Struct.ToPtr())
	return ss, err
}

// PathMgmt_List is a list of PathMgmt.
type PathMgmt_List struct{ capnp.List }

// NewPathMgmt creates a new list of PathMgmt.
func NewPathMgmt_List(s *capnp.Segment, sz int32) (PathMgmt_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 1}, sz)
	return PathMgmt_List{l}, err
}

func (s PathMgmt_List) At(i int) PathMgmt { return PathMgmt{s.List.Struct(i)} }

func (s PathMgmt_List) Set(i int, v PathMgmt) error { return s.List.SetStruct(i, v.Struct) }

func (s PathMgmt_List) String() string {
	str, _ := text.MarshalList(0xa12cfa420c9ad0ca, s.List)
	return str
}

// PathMgmt_Promise is a wrapper for a PathMgmt promised by a client call.
type PathMgmt_Promise struct{ *capnp.Pipeline }

func (p PathMgmt_Promise) Struct() (PathMgmt, error) {
	s, err := p.Pipeline.Struct()
	return PathMgmt{s}, err
}

func (p PathMgmt_Promise) SegReq() SegReq_Promise {
	return SegReq_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
}

func (p PathMgmt_Promise) SegReply() SegReply_Promise {
	return SegReply_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
}

func (p PathMgmt_Promise) SegReg() SegRecs_Promise {
	return SegRecs_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
}

func (p PathMgmt_Promise) SegSync() SegRecs_Promise {
	return SegRecs_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
}

func (p PathMgmt_Promise) SRevInfo() SignedBlob_Promise {
	return SignedBlob_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
}

func (p PathMgmt_Promise) IfStateReq() IFStateReq_Promise {
	return IFStateReq_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
}

func (p PathMgmt_Promise) IfStateInfos() IFStateInfos_Promise {
	return IFStateInfos_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
}

func (p PathMgmt_Promise) SegChangesIdReq() SegChangesIdReq_Promise {
	return SegChangesIdReq_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
}

func (p PathMgmt_Promise) SegChangesIdReply() SegChangesIdReply_Promise {
	return SegChangesIdReply_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
}

func (p PathMgmt_Promise) SegChangesReq() SegChangesReq_Promise {
	return SegChangesReq_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
}

func (p PathMgmt_Promise) SegChangesReply() SegRecs_Promise {
	return SegRecs_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
}

func (p PathMgmt_Promise) HpSegReq() HPSegReq_Promise {
	return HPSegReq_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
}

func (p PathMgmt_Promise) HpSegReply() HPSegReply_Promise {
	return HPSegReply_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
}

func (p PathMgmt_Promise) HpSegReg() HPSegRecs_Promise {
	return HPSegRecs_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
}

func (p PathMgmt_Promise) HpCfgReq() HPCfgReq_Promise {
	return HPCfgReq_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
}

func (p PathMgmt_Promise) HpCfgReply() HPCfgReply_Promise {
	return HPCfgReply_Promise{Pipeline: p.Pipeline.GetPipeline(0)}
}

const schema_8fcd13516850d142 = "x\xda|V\x7flTY\x15>\xe7\xde\x99\xce\xefv" +
	"\xc6\xfb\x8c\xdd\xb8\xb1\xbb\x1bL\xb6H7l\x81\xecn" +
	"\x83\xf6\x07%\xcb,\x8b\xf6\xf5%\xeb\xee\xc6U\x87\x99" +
	"7\xd3\xa1\xd3\xe9t\xde@S\x89\xa9\x9a\xa81\x8a\x04" +
	"D\x03F\x02\x18\x08)\x88\x86&$\xa4\xa4(\x1a\x10" +
	"\x1b!\x14\xc1\x10Pc\x11#!\x10\x91\xdf\x14\xea\xdb" +
	"\x9c;\xd3\xf7\xa6o\xa6\xfdo\xe6~\xdf;\xe7\xbb\xe7" +
	"\x9e\xfb\x9d\xbb4\xe0jc\xaf\xbb\xbf\xef\x06P\xdb\xdc" +
	"5\xe6\x8b'[7\x0f\xdcT\xb7\x82\x1aF4;&" +
	"\xbbzTqn+\xb8\xd1\x03 F\xd8\x848\xc6\xe8" +
	"\xd7Q6\x08h\x8e\x7fQ\x99\x09\x1c\\\xfb\x13\x88\x84" +
	"\xcb\xb9\x92\xf12\xff\xbdh\xe4\xf4\xeb\xb3\x9c\xb8'\xae" +
	"\xbdqmt\xea\x83\xaa\xdc\x03|B\x1c\x95\xdc#\x92" +
	"\xfb\x99\xef\xb9\xbe\xc9V\xe0n\x12\xc1m\xb2\x8b\x18>" +
	"\xd7\x98\x88\xc8_!\xd7o\x00\xcd\x89\x0b?\x0fvL" +
	"/\xd9\xe7\x10\xbc\x1a=\x11\x00\xf1\x03\xd7\x84\xf8)\xb1" +
	"\x97ms\xfd\x96\x03\x9aS\xd7\xbf2z\xf6g\xbd\x07" +
	"\x1c2d\xf2\x11\xefEq\xcc+\xb7\xe7\xa5\xd0?<" +
	"\xb3\xfc\x97\xeb\x83G\x0e:\xb8\xb2\x14\x1f\xf8\xee\x09\xdd" +
	"G\xbfb\xbeV@\xf3\xaf?N\xb6o\x9fy|\xa8" +
	"\x1aw\x9b\xef\xaa\xd8-\xb9\xbb$w\xed\xaf\xb7<\xfa" +
	"\xc3\xd0\xd3\xc3\xd5J\xf1'\xdf\x98\x98\x94\xdcs>*" +
	"\xc5\x8f\x0e]\x0fM=\xda<Z-n\xa3\xff\xaaX" +
	"\xe1\xa7_\xaf\xfb)n\xfd\xea\x1b_\x10\x7f|y\x8c" +
	"J\xc1\x1ce\x8b\xf9/\x8a>\xc9M\xfb)n\x9bz" +
	"\xe6\xc9\xad\xf3\xef\x8dW\x89\xbb\xec\xb4\xff\x13(.K" +
	"\xf2\xa4\x0c\xbc\xed\xc2\xbe\xff\xf4No9\xeb\xa8\xb1\xac" +
	"+\x06\x18\x8aP@\x1eM\x80\xc8_=\xfc\xb9\x13\x9f" +
	"<\xb2\xf6b\x15\xb2h\x0aL\x88\xb7$w\x85\xe4n" +
	"\xfat\xe7\xb3u\x8d;\xfe\x01\xea\xa7\x90\xdb\xc7\xaex" +
	"\x90J\x1c\xb8\x05(>\x0a\x90\xdc\xf8\x0b\xdf8\xee\x0f" +
	"{\xee;\xdbRF\x1d\x0f\x8c\x8a\xd3\x14u\xd9\xa9\xc0" +
	"\x97\x11\xd0\xcc\xc5\x0a=_\xebK\xf5\xb1\xc2k\xf1X" +
	".\x9bkY\xd3\xa5\xe9\xa9n}\x00\xa0\x0bQ\xf5r" +
	"\x17\x80\x0b\x01\"\x8d\xcd\x00\xea\"\x8e\xeaR\x86\x88\x0a" +
	"\xd2Z\xd3;\x00\xea\x12\x8e\xea\x1a\x86\x0d\x09\xa3\x10m" +
	"G\x1f0\xf4\x01\x9a\xa9|\xff\xc6\\4a\x00\x00\xd6" +
	"\x02vq\xc4\xb0]u@Z\xacL.S\xc7\x0dg" +
	"\xea\xc5\xa5\xd4m\x0c#\xb3\xb9?\xdf\x0d\xa0\xae\xe4\xa8" +
	"\xbe\xcf\xb0.\xaf\xc7\x0d;M\xdd\x98\x7f\xe5\xe6\xf7v" +
	"\xee\x99Mct\xeb\x9b\xa2\xd9d?`\x19\xa9\xfb_" +
	"\xd3o|\xf7\xed\xe6=\x0bk\xc9e\x86*\x0a\xf1\x8a" +
	"]\x08KM\x13I|\x95\xa3\xba\x9c\xa1'\xaf\x0f`" +
	"\xd8>\"@\x0cCIc\xd86\x82\xe2\xb2\x95\x17g" +
	"\xf3\xb6\x16\xebOI\x83V\xd2\xd5T\xfd6\x8e\xea\xbb" +
	"eI\xa3\xb4\xd8\xc9Q\xedb\x88\x0c\xcbz$\xb2\xae" +
	"\x19X\x83\x91\x8f\xdb'2\xf7|\x1a\x92\x99X\xca\xa8" +
	"\xdctW\xac\xd0\xb3.\xd5W(n\xba\x93\xbb\x82\xa6" +
	"I\x02\xc49l\x06\xd0\xce\"G\xed\x122\x0c\xe1\xff" +
	"M)BLb\x0b\x80\xf6g\x02\xae\x10\xc0fL\x05" +
	"\x19\x80\xb8\x8c\xef\x00h\x97\x08\xf8'\x01\xfc\xb9\xa9 " +
	"\x07\x10\x7f\x97_\\!\xe0\x06\x01\xaeg\xa6\x82.\x00" +
	"1\x85\x1d\x00\xda\xdf\x08\xb8I\x80{\xdaT\xd0\x0d " +
	"\xfe-C\xdd \xe0.\x015OM\x05k\x00\xc4\x1d" +
	"\xfc\x10@\xbbM\xc0\x13\x02<OLE\xde\xf7\x87\xb8" +
	"\x01@{\x80\x1c\xbb\x19\xc3\x90\xf7\xb1\xa9\xa0\x17@\xcc" +
	"\xe0w\x00\xb4\xe7\xf4\x81\x97\x00\xdf#SA\x1f\x80p" +
	"\xb3\xed\x00\x9a\x97q\xd4\x14\x02\xfc\x0fM\x05\xfd\x00\"" +
	"\xc2\xf2\x00Z\x98\x80\x17\x09\x08<0\x15\x0c\x00\x88\x17" +
	"\x18\x85\xaa'`\x11\x01\xc1\xfb\xa6\x82A\xb2sFj" +
	"_\"`\x09\x01\xa1{\xa6\x82!2!Fj_%" +
	"`9\x01\xb5\xff3\x15\xac%O\x92_,%`%" +
	"\x01uwM\x05\xeb\x00\xc4[\x12x\x93\x80N\x02\xc2" +
	"\xff5\x15\x0c\x03\x88v\x19\xaa\x8d\x80w\x19\xc3\x86\x8d" +
	"YC/@M\xab!{\xa7\xb2\xfbL\xc3\xeaf\xc0" +
	"\xb0=a\x8ah\xf1\xb3Tew\x0e\x1bzJ\x1b\xca" +
	"\xc6\xab\xf4\xadu\xa9d\xc0\xf2\xdbDh:\xa9\x15b" +
	"\x05\xbd\x1b\xb8T3\x92\xfc\xc5\xa9\xde\xc1;7\x1dp" +
	"\x14\xea\xb2\xc9~\xba\x15'\x03\xcf\x1f6\x9f\x7f\xe9/" +
	"erW\xf5\xc4\xb2)\xd4\x8dh\x82\xdc\x08\xc3\xb6\xb5" +
	"V\xe7\xe428\x84a\xdb\xad\x1d,h\xd0\x8dbi" +
	"\xacYU\x19\xa7X\xa2*\xbb\xed\xc9\xcd\xba\"\xa1\xd6" +
	"\xe4\x9f\x8b\xe6\x80gH\x825\xe0\xe6\xc2\xa9\xe2\xc7\xd6" +
	"X\xb5\xd0UI;\xb45\x12\xe6\xa2\xb3\xa1\xad\x19\xe7" +
	"p\x0f\xa7}\xc7\xd1p\x18HG5\x03Y\\2\x90" +
	"\xaf3\x8c0&\xefm\xe4#\xf2\xb7\xf79\xaa\x09\x86" +
	"\xc3%\x1bwx\xb7eg\xf3Y\xaeG\xcf\xe71\x08" +
	"\x0c\x83\xf38\xab,x\xf1DH\xa7\xcb\xd2\x19j\x01" +
	"P\xbd\x1c\xd5EL\xb6e4ae\x09\x01\xab\xee\xd4" +
	"\xa5=\xe7xf\xc8\x11l\xb1\x1d\xcc!\xb8\xfc\x14j" +
	"\xe7\xb3\xe1h\xc2\x98\x7f\x08\xda\xde\xdfb{\x7f\x83\x94" +
	",\xa5\x86\x00[\x93\x1b3\x19\xfbo5\xe5\xc5\xd3]" +
	"Xy<\x99*Sn\xcd\xf7\xf9\x06\xd7\x9a\xae\xb7\xe5" +
	"\xa9a\xc2!\xbe\xa3\\\xbc\xab$\xbe\xc3\x16?\xdc?" +
	"\x98\xd5\xf3\xed\xda\xec\x90\xb0N\xdf\x03\x0c=e\xa9\xb8" +
	"\xf3$\xed\x1b\xe8\xd8\xc6+\xf66<\xe9D\xd9.\xac" +
	"\x87\x9dc\x17\xf3\x84\x1e\x00G`\x9a\xfeA\x8ej=" +
	"C3\x133\x0a\xabz\xf48`/z\x81\xa1w\x81" +
	"R\x97\xde5e\x916\x94E\x8a\xcb\x8c\x09\x0d\xea\xd2" +
	"\xd9\xb8>\x7f\xb0\xa2\x19\xbc\x96\xac\xa3)J%\x0e\x7f" +
	"\xabxy\xe66\xc8\xb7\xe5\xc0\x8b4u\x97\x9eIo" +
	"R\x83\xa4\xd7\xe7c\x88\xc0\x90\x9e_\xf1X\xbcG\xff" +
	"R6\x038d\xadU\xb4b\x83\xd4N\xb2\xeb-\xd9" +
	"\xbb\xe8\xdcvpT\xf7\xda\xcf\xb1\xdd\xb4\xb6\x93\xa3\xba" +
	"\xbf\xec:\xef\xa37\xda^\x8e\xea\xaf\x18F8\x16\x15" +
	"\x8d\x10s?G\xf5w\x0c#.&\xc7od\x9c\x16" +
	"\x8fsT/1\x8c\xb8\xb9\x1c\xbd\x91\xc9\x0f\x01\xd4\x0b" +
	"\x1c\xd5\xdb\x0b\xb9\xc1\xf0&=o\xa4\xfb\xb3V\xc5d" +
	"'E\xb5N2\xb5R\xf7\x0c\x0f\xe6\xd3\x05=o\xf5" +
	"\x80\xafx\x9d\x87\xf3z,Q\xb9l\xe6\xf5T\xda(" +
	"\xe4\xd3\xc0u'\xf6q\x00\x00\x00\xff\xff4\x06O\xa2"

func init() {
	schemas.Register(schema_8fcd13516850d142,
		0x8f51e8717b3fbe1c,
		0x934ba70bfd144ebd,
		0x9359e1b2db37dbbb,
		0x9d0135027d04861e,
		0xa12cfa420c9ad0ca,
		0xa56b96c8b25ce2e1,
		0xa7ad0c62a234c68b,
		0xaaf7fd9241668ed6,
		0xabf979c3f68dae4b,
		0xb27bf6e10de2aa8c,
		0xba21c7133ee44518,
		0xbd56ceeaf8c65140,
		0xc88dfa6be7a1d091,
		0xd24bad15bb2bab5e,
		0xde94294dfb441b76,
		0xf307100ab87a1963)
}