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

package grammar

import (
	capnp "capnproto.org/go/capnp/v3"
	text "capnproto.org/go/capnp/v3/encoding/text"
	schemas "capnproto.org/go/capnp/v3/schemas"
	math "math"
	strconv "strconv"
)

const Declaration_builtinParams = uint64(0x94099c3f9eb32d6b)

type LocatedText capnp.Struct

// LocatedText_TypeID is the unique identifier for the type LocatedText.
const LocatedText_TypeID = 0xe75816b56529d464

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

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

func ReadRootLocatedText(msg *capnp.Message) (LocatedText, error) {
	root, err := msg.Root()
	return LocatedText(root.Struct()), err
}

func (s LocatedText) String() string {
	str, _ := text.Marshal(0xe75816b56529d464, capnp.Struct(s))
	return str
}

func (s LocatedText) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr {
	return capnp.Struct(s).EncodeAsPtr(seg)
}

func (LocatedText) DecodeFromPtr(p capnp.Ptr) LocatedText {
	return LocatedText(capnp.Struct{}.DecodeFromPtr(p))
}

func (s LocatedText) ToPtr() capnp.Ptr {
	return capnp.Struct(s).ToPtr()
}
func (s LocatedText) IsValid() bool {
	return capnp.Struct(s).IsValid()
}

func (s LocatedText) Message() *capnp.Message {
	return capnp.Struct(s).Message()
}

func (s LocatedText) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s LocatedText) Value() (string, error) {
	p, err := capnp.Struct(s).Ptr(0)
	return p.Text(), err
}

func (s LocatedText) HasValue() bool {
	return capnp.Struct(s).HasPtr(0)
}

func (s LocatedText) ValueBytes() ([]byte, error) {
	p, err := capnp.Struct(s).Ptr(0)
	return p.TextBytes(), err
}

func (s LocatedText) SetValue(v string) error {
	return capnp.Struct(s).SetText(0, v)
}

func (s LocatedText) StartByte() uint32 {
	return capnp.Struct(s).Uint32(0)
}

func (s LocatedText) SetStartByte(v uint32) {
	capnp.Struct(s).SetUint32(0, v)
}

func (s LocatedText) EndByte() uint32 {
	return capnp.Struct(s).Uint32(4)
}

func (s LocatedText) SetEndByte(v uint32) {
	capnp.Struct(s).SetUint32(4, v)
}

// LocatedText_List is a list of LocatedText.
type LocatedText_List = capnp.StructList[LocatedText]

// NewLocatedText creates a new list of LocatedText.
func NewLocatedText_List(s *capnp.Segment, sz int32) (LocatedText_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 1}, sz)
	return capnp.StructList[LocatedText](l), err
}

// LocatedText_Future is a wrapper for a LocatedText promised by a client call.
type LocatedText_Future struct{ *capnp.Future }

func (f LocatedText_Future) Struct() (LocatedText, error) {
	p, err := f.Future.Ptr()
	return LocatedText(p.Struct()), err
}

type LocatedInteger capnp.Struct

// LocatedInteger_TypeID is the unique identifier for the type LocatedInteger.
const LocatedInteger_TypeID = 0x991c7a3693d62cf2

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

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

func ReadRootLocatedInteger(msg *capnp.Message) (LocatedInteger, error) {
	root, err := msg.Root()
	return LocatedInteger(root.Struct()), err
}

func (s LocatedInteger) String() string {
	str, _ := text.Marshal(0x991c7a3693d62cf2, capnp.Struct(s))
	return str
}

func (s LocatedInteger) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr {
	return capnp.Struct(s).EncodeAsPtr(seg)
}

func (LocatedInteger) DecodeFromPtr(p capnp.Ptr) LocatedInteger {
	return LocatedInteger(capnp.Struct{}.DecodeFromPtr(p))
}

func (s LocatedInteger) ToPtr() capnp.Ptr {
	return capnp.Struct(s).ToPtr()
}
func (s LocatedInteger) IsValid() bool {
	return capnp.Struct(s).IsValid()
}

func (s LocatedInteger) Message() *capnp.Message {
	return capnp.Struct(s).Message()
}

func (s LocatedInteger) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s LocatedInteger) Value() uint64 {
	return capnp.Struct(s).Uint64(0)
}

func (s LocatedInteger) SetValue(v uint64) {
	capnp.Struct(s).SetUint64(0, v)
}

func (s LocatedInteger) StartByte() uint32 {
	return capnp.Struct(s).Uint32(8)
}

func (s LocatedInteger) SetStartByte(v uint32) {
	capnp.Struct(s).SetUint32(8, v)
}

func (s LocatedInteger) EndByte() uint32 {
	return capnp.Struct(s).Uint32(12)
}

func (s LocatedInteger) SetEndByte(v uint32) {
	capnp.Struct(s).SetUint32(12, v)
}

// LocatedInteger_List is a list of LocatedInteger.
type LocatedInteger_List = capnp.StructList[LocatedInteger]

// NewLocatedInteger creates a new list of LocatedInteger.
func NewLocatedInteger_List(s *capnp.Segment, sz int32) (LocatedInteger_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 16, PointerCount: 0}, sz)
	return capnp.StructList[LocatedInteger](l), err
}

// LocatedInteger_Future is a wrapper for a LocatedInteger promised by a client call.
type LocatedInteger_Future struct{ *capnp.Future }

func (f LocatedInteger_Future) Struct() (LocatedInteger, error) {
	p, err := f.Future.Ptr()
	return LocatedInteger(p.Struct()), err
}

type LocatedFloat capnp.Struct

// LocatedFloat_TypeID is the unique identifier for the type LocatedFloat.
const LocatedFloat_TypeID = 0x90f2a60678fd2367

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

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

func ReadRootLocatedFloat(msg *capnp.Message) (LocatedFloat, error) {
	root, err := msg.Root()
	return LocatedFloat(root.Struct()), err
}

func (s LocatedFloat) String() string {
	str, _ := text.Marshal(0x90f2a60678fd2367, capnp.Struct(s))
	return str
}

func (s LocatedFloat) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr {
	return capnp.Struct(s).EncodeAsPtr(seg)
}

func (LocatedFloat) DecodeFromPtr(p capnp.Ptr) LocatedFloat {
	return LocatedFloat(capnp.Struct{}.DecodeFromPtr(p))
}

func (s LocatedFloat) ToPtr() capnp.Ptr {
	return capnp.Struct(s).ToPtr()
}
func (s LocatedFloat) IsValid() bool {
	return capnp.Struct(s).IsValid()
}

func (s LocatedFloat) Message() *capnp.Message {
	return capnp.Struct(s).Message()
}

func (s LocatedFloat) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s LocatedFloat) Value() float64 {
	return math.Float64frombits(capnp.Struct(s).Uint64(0))
}

func (s LocatedFloat) SetValue(v float64) {
	capnp.Struct(s).SetUint64(0, math.Float64bits(v))
}

func (s LocatedFloat) StartByte() uint32 {
	return capnp.Struct(s).Uint32(8)
}

func (s LocatedFloat) SetStartByte(v uint32) {
	capnp.Struct(s).SetUint32(8, v)
}

func (s LocatedFloat) EndByte() uint32 {
	return capnp.Struct(s).Uint32(12)
}

func (s LocatedFloat) SetEndByte(v uint32) {
	capnp.Struct(s).SetUint32(12, v)
}

// LocatedFloat_List is a list of LocatedFloat.
type LocatedFloat_List = capnp.StructList[LocatedFloat]

// NewLocatedFloat creates a new list of LocatedFloat.
func NewLocatedFloat_List(s *capnp.Segment, sz int32) (LocatedFloat_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 16, PointerCount: 0}, sz)
	return capnp.StructList[LocatedFloat](l), err
}

// LocatedFloat_Future is a wrapper for a LocatedFloat promised by a client call.
type LocatedFloat_Future struct{ *capnp.Future }

func (f LocatedFloat_Future) Struct() (LocatedFloat, error) {
	p, err := f.Future.Ptr()
	return LocatedFloat(p.Struct()), err
}

type Expression capnp.Struct
type Expression_application Expression
type Expression_member Expression
type Expression_Which uint16

const (
	Expression_Which_unknown      Expression_Which = 0
	Expression_Which_positiveInt  Expression_Which = 1
	Expression_Which_negativeInt  Expression_Which = 2
	Expression_Which_float        Expression_Which = 3
	Expression_Which_stringValue  Expression_Which = 4
	Expression_Which_binary       Expression_Which = 8
	Expression_Which_relativeName Expression_Which = 5
	Expression_Which_absoluteName Expression_Which = 11
	Expression_Which_import       Expression_Which = 12
	Expression_Which_embed        Expression_Which = 13
	Expression_Which_list         Expression_Which = 6
	Expression_Which_tuple        Expression_Which = 7
	Expression_Which_application  Expression_Which = 9
	Expression_Which_member       Expression_Which = 10
)

func (w Expression_Which) String() string {
	const s = "unknownpositiveIntnegativeIntfloatstringValuebinaryrelativeNameabsoluteNameimportembedlisttupleapplicationmember"
	switch w {
	case Expression_Which_unknown:
		return s[0:7]
	case Expression_Which_positiveInt:
		return s[7:18]
	case Expression_Which_negativeInt:
		return s[18:29]
	case Expression_Which_float:
		return s[29:34]
	case Expression_Which_stringValue:
		return s[34:45]
	case Expression_Which_binary:
		return s[45:51]
	case Expression_Which_relativeName:
		return s[51:63]
	case Expression_Which_absoluteName:
		return s[63:75]
	case Expression_Which_import:
		return s[75:81]
	case Expression_Which_embed:
		return s[81:86]
	case Expression_Which_list:
		return s[86:90]
	case Expression_Which_tuple:
		return s[90:95]
	case Expression_Which_application:
		return s[95:106]
	case Expression_Which_member:
		return s[106:112]

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

// Expression_TypeID is the unique identifier for the type Expression.
const Expression_TypeID = 0x8e207d4dfe54d0de

func NewExpression(s *capnp.Segment) (Expression, error) {
	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 24, PointerCount: 2})
	return Expression(st), err
}

func NewRootExpression(s *capnp.Segment) (Expression, error) {
	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 24, PointerCount: 2})
	return Expression(st), err
}

func ReadRootExpression(msg *capnp.Message) (Expression, error) {
	root, err := msg.Root()
	return Expression(root.Struct()), err
}

func (s Expression) String() string {
	str, _ := text.Marshal(0x8e207d4dfe54d0de, capnp.Struct(s))
	return str
}

func (s Expression) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr {
	return capnp.Struct(s).EncodeAsPtr(seg)
}

func (Expression) DecodeFromPtr(p capnp.Ptr) Expression {
	return Expression(capnp.Struct{}.DecodeFromPtr(p))
}

func (s Expression) ToPtr() capnp.Ptr {
	return capnp.Struct(s).ToPtr()
}

func (s Expression) Which() Expression_Which {
	return Expression_Which(capnp.Struct(s).Uint16(0))
}
func (s Expression) IsValid() bool {
	return capnp.Struct(s).IsValid()
}

func (s Expression) Message() *capnp.Message {
	return capnp.Struct(s).Message()
}

func (s Expression) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Expression) SetUnknown() {
	capnp.Struct(s).SetUint16(0, 0)

}

func (s Expression) PositiveInt() uint64 {
	if capnp.Struct(s).Uint16(0) != 1 {
		panic("Which() != positiveInt")
	}
	return capnp.Struct(s).Uint64(8)
}

func (s Expression) SetPositiveInt(v uint64) {
	capnp.Struct(s).SetUint16(0, 1)
	capnp.Struct(s).SetUint64(8, v)
}

func (s Expression) NegativeInt() uint64 {
	if capnp.Struct(s).Uint16(0) != 2 {
		panic("Which() != negativeInt")
	}
	return capnp.Struct(s).Uint64(8)
}

func (s Expression) SetNegativeInt(v uint64) {
	capnp.Struct(s).SetUint16(0, 2)
	capnp.Struct(s).SetUint64(8, v)
}

func (s Expression) Float() float64 {
	if capnp.Struct(s).Uint16(0) != 3 {
		panic("Which() != float")
	}
	return math.Float64frombits(capnp.Struct(s).Uint64(8))
}

func (s Expression) SetFloat(v float64) {
	capnp.Struct(s).SetUint16(0, 3)
	capnp.Struct(s).SetUint64(8, math.Float64bits(v))
}

func (s Expression) StringValue() (string, error) {
	if capnp.Struct(s).Uint16(0) != 4 {
		panic("Which() != stringValue")
	}
	p, err := capnp.Struct(s).Ptr(0)
	return p.Text(), err
}

func (s Expression) HasStringValue() bool {
	if capnp.Struct(s).Uint16(0) != 4 {
		return false
	}
	return capnp.Struct(s).HasPtr(0)
}

func (s Expression) StringValueBytes() ([]byte, error) {
	p, err := capnp.Struct(s).Ptr(0)
	return p.TextBytes(), err
}

func (s Expression) SetStringValue(v string) error {
	capnp.Struct(s).SetUint16(0, 4)
	return capnp.Struct(s).SetText(0, v)
}

func (s Expression) Binary() ([]byte, error) {
	if capnp.Struct(s).Uint16(0) != 8 {
		panic("Which() != binary")
	}
	p, err := capnp.Struct(s).Ptr(0)
	return []byte(p.Data()), err
}

func (s Expression) HasBinary() bool {
	if capnp.Struct(s).Uint16(0) != 8 {
		return false
	}
	return capnp.Struct(s).HasPtr(0)
}

func (s Expression) SetBinary(v []byte) error {
	capnp.Struct(s).SetUint16(0, 8)
	return capnp.Struct(s).SetData(0, v)
}

func (s Expression) RelativeName() (LocatedText, error) {
	if capnp.Struct(s).Uint16(0) != 5 {
		panic("Which() != relativeName")
	}
	p, err := capnp.Struct(s).Ptr(0)
	return LocatedText(p.Struct()), err
}

func (s Expression) HasRelativeName() bool {
	if capnp.Struct(s).Uint16(0) != 5 {
		return false
	}
	return capnp.Struct(s).HasPtr(0)
}

func (s Expression) SetRelativeName(v LocatedText) error {
	capnp.Struct(s).SetUint16(0, 5)
	return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr())
}

// NewRelativeName sets the relativeName field to a newly
// allocated LocatedText struct, preferring placement in s's segment.
func (s Expression) NewRelativeName() (LocatedText, error) {
	capnp.Struct(s).SetUint16(0, 5)
	ss, err := NewLocatedText(capnp.Struct(s).Segment())
	if err != nil {
		return LocatedText{}, err
	}
	err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr())
	return ss, err
}

func (s Expression) AbsoluteName() (LocatedText, error) {
	if capnp.Struct(s).Uint16(0) != 11 {
		panic("Which() != absoluteName")
	}
	p, err := capnp.Struct(s).Ptr(0)
	return LocatedText(p.Struct()), err
}

func (s Expression) HasAbsoluteName() bool {
	if capnp.Struct(s).Uint16(0) != 11 {
		return false
	}
	return capnp.Struct(s).HasPtr(0)
}

func (s Expression) SetAbsoluteName(v LocatedText) error {
	capnp.Struct(s).SetUint16(0, 11)
	return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr())
}

// NewAbsoluteName sets the absoluteName field to a newly
// allocated LocatedText struct, preferring placement in s's segment.
func (s Expression) NewAbsoluteName() (LocatedText, error) {
	capnp.Struct(s).SetUint16(0, 11)
	ss, err := NewLocatedText(capnp.Struct(s).Segment())
	if err != nil {
		return LocatedText{}, err
	}
	err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr())
	return ss, err
}

func (s Expression) Import() (LocatedText, error) {
	if capnp.Struct(s).Uint16(0) != 12 {
		panic("Which() != import")
	}
	p, err := capnp.Struct(s).Ptr(0)
	return LocatedText(p.Struct()), err
}

func (s Expression) HasImport() bool {
	if capnp.Struct(s).Uint16(0) != 12 {
		return false
	}
	return capnp.Struct(s).HasPtr(0)
}

func (s Expression) SetImport(v LocatedText) error {
	capnp.Struct(s).SetUint16(0, 12)
	return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr())
}

// NewImport sets the import field to a newly
// allocated LocatedText struct, preferring placement in s's segment.
func (s Expression) NewImport() (LocatedText, error) {
	capnp.Struct(s).SetUint16(0, 12)
	ss, err := NewLocatedText(capnp.Struct(s).Segment())
	if err != nil {
		return LocatedText{}, err
	}
	err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr())
	return ss, err
}

func (s Expression) Embed() (LocatedText, error) {
	if capnp.Struct(s).Uint16(0) != 13 {
		panic("Which() != embed")
	}
	p, err := capnp.Struct(s).Ptr(0)
	return LocatedText(p.Struct()), err
}

func (s Expression) HasEmbed() bool {
	if capnp.Struct(s).Uint16(0) != 13 {
		return false
	}
	return capnp.Struct(s).HasPtr(0)
}

func (s Expression) SetEmbed(v LocatedText) error {
	capnp.Struct(s).SetUint16(0, 13)
	return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr())
}

// NewEmbed sets the embed field to a newly
// allocated LocatedText struct, preferring placement in s's segment.
func (s Expression) NewEmbed() (LocatedText, error) {
	capnp.Struct(s).SetUint16(0, 13)
	ss, err := NewLocatedText(capnp.Struct(s).Segment())
	if err != nil {
		return LocatedText{}, err
	}
	err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr())
	return ss, err
}

func (s Expression) List() (Expression_List, error) {
	if capnp.Struct(s).Uint16(0) != 6 {
		panic("Which() != list")
	}
	p, err := capnp.Struct(s).Ptr(0)
	return Expression_List(p.List()), err
}

func (s Expression) HasList() bool {
	if capnp.Struct(s).Uint16(0) != 6 {
		return false
	}
	return capnp.Struct(s).HasPtr(0)
}

func (s Expression) SetList(v Expression_List) error {
	capnp.Struct(s).SetUint16(0, 6)
	return capnp.Struct(s).SetPtr(0, v.ToPtr())
}

// NewList sets the list field to a newly
// allocated Expression_List, preferring placement in s's segment.
func (s Expression) NewList(n int32) (Expression_List, error) {
	capnp.Struct(s).SetUint16(0, 6)
	l, err := NewExpression_List(capnp.Struct(s).Segment(), n)
	if err != nil {
		return Expression_List{}, err
	}
	err = capnp.Struct(s).SetPtr(0, l.ToPtr())
	return l, err
}
func (s Expression) Tuple() (Expression_Param_List, error) {
	if capnp.Struct(s).Uint16(0) != 7 {
		panic("Which() != tuple")
	}
	p, err := capnp.Struct(s).Ptr(0)
	return Expression_Param_List(p.List()), err
}

func (s Expression) HasTuple() bool {
	if capnp.Struct(s).Uint16(0) != 7 {
		return false
	}
	return capnp.Struct(s).HasPtr(0)
}

func (s Expression) SetTuple(v Expression_Param_List) error {
	capnp.Struct(s).SetUint16(0, 7)
	return capnp.Struct(s).SetPtr(0, v.ToPtr())
}

// NewTuple sets the tuple field to a newly
// allocated Expression_Param_List, preferring placement in s's segment.
func (s Expression) NewTuple(n int32) (Expression_Param_List, error) {
	capnp.Struct(s).SetUint16(0, 7)
	l, err := NewExpression_Param_List(capnp.Struct(s).Segment(), n)
	if err != nil {
		return Expression_Param_List{}, err
	}
	err = capnp.Struct(s).SetPtr(0, l.ToPtr())
	return l, err
}
func (s Expression) Application() Expression_application { return Expression_application(s) }

func (s Expression) SetApplication() {
	capnp.Struct(s).SetUint16(0, 9)
}

func (s Expression_application) IsValid() bool {
	return capnp.Struct(s).IsValid()
}

func (s Expression_application) Message() *capnp.Message {
	return capnp.Struct(s).Message()
}

func (s Expression_application) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Expression_application) Function() (Expression, error) {
	p, err := capnp.Struct(s).Ptr(0)
	return Expression(p.Struct()), err
}

func (s Expression_application) HasFunction() bool {
	return capnp.Struct(s).HasPtr(0)
}

func (s Expression_application) SetFunction(v Expression) error {
	return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr())
}

// NewFunction sets the function field to a newly
// allocated Expression struct, preferring placement in s's segment.
func (s Expression_application) NewFunction() (Expression, error) {
	ss, err := NewExpression(capnp.Struct(s).Segment())
	if err != nil {
		return Expression{}, err
	}
	err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr())
	return ss, err
}

func (s Expression_application) Params() (Expression_Param_List, error) {
	p, err := capnp.Struct(s).Ptr(1)
	return Expression_Param_List(p.List()), err
}

func (s Expression_application) HasParams() bool {
	return capnp.Struct(s).HasPtr(1)
}

func (s Expression_application) SetParams(v Expression_Param_List) error {
	return capnp.Struct(s).SetPtr(1, v.ToPtr())
}

// NewParams sets the params field to a newly
// allocated Expression_Param_List, preferring placement in s's segment.
func (s Expression_application) NewParams(n int32) (Expression_Param_List, error) {
	l, err := NewExpression_Param_List(capnp.Struct(s).Segment(), n)
	if err != nil {
		return Expression_Param_List{}, err
	}
	err = capnp.Struct(s).SetPtr(1, l.ToPtr())
	return l, err
}
func (s Expression) Member() Expression_member { return Expression_member(s) }

func (s Expression) SetMember() {
	capnp.Struct(s).SetUint16(0, 10)
}

func (s Expression_member) IsValid() bool {
	return capnp.Struct(s).IsValid()
}

func (s Expression_member) Message() *capnp.Message {
	return capnp.Struct(s).Message()
}

func (s Expression_member) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Expression_member) Parent() (Expression, error) {
	p, err := capnp.Struct(s).Ptr(0)
	return Expression(p.Struct()), err
}

func (s Expression_member) HasParent() bool {
	return capnp.Struct(s).HasPtr(0)
}

func (s Expression_member) SetParent(v Expression) error {
	return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr())
}

// NewParent sets the parent field to a newly
// allocated Expression struct, preferring placement in s's segment.
func (s Expression_member) NewParent() (Expression, error) {
	ss, err := NewExpression(capnp.Struct(s).Segment())
	if err != nil {
		return Expression{}, err
	}
	err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr())
	return ss, err
}

func (s Expression_member) Name() (LocatedText, error) {
	p, err := capnp.Struct(s).Ptr(1)
	return LocatedText(p.Struct()), err
}

func (s Expression_member) HasName() bool {
	return capnp.Struct(s).HasPtr(1)
}

func (s Expression_member) SetName(v LocatedText) error {
	return capnp.Struct(s).SetPtr(1, capnp.Struct(v).ToPtr())
}

// NewName sets the name field to a newly
// allocated LocatedText struct, preferring placement in s's segment.
func (s Expression_member) NewName() (LocatedText, error) {
	ss, err := NewLocatedText(capnp.Struct(s).Segment())
	if err != nil {
		return LocatedText{}, err
	}
	err = capnp.Struct(s).SetPtr(1, capnp.Struct(ss).ToPtr())
	return ss, err
}

func (s Expression) StartByte() uint32 {
	return capnp.Struct(s).Uint32(4)
}

func (s Expression) SetStartByte(v uint32) {
	capnp.Struct(s).SetUint32(4, v)
}

func (s Expression) EndByte() uint32 {
	return capnp.Struct(s).Uint32(16)
}

func (s Expression) SetEndByte(v uint32) {
	capnp.Struct(s).SetUint32(16, v)
}

// Expression_List is a list of Expression.
type Expression_List = capnp.StructList[Expression]

// NewExpression creates a new list of Expression.
func NewExpression_List(s *capnp.Segment, sz int32) (Expression_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 24, PointerCount: 2}, sz)
	return capnp.StructList[Expression](l), err
}

// Expression_Future is a wrapper for a Expression promised by a client call.
type Expression_Future struct{ *capnp.Future }

func (f Expression_Future) Struct() (Expression, error) {
	p, err := f.Future.Ptr()
	return Expression(p.Struct()), err
}
func (p Expression_Future) RelativeName() LocatedText_Future {
	return LocatedText_Future{Future: p.Future.Field(0, nil)}
}
func (p Expression_Future) AbsoluteName() LocatedText_Future {
	return LocatedText_Future{Future: p.Future.Field(0, nil)}
}
func (p Expression_Future) Import() LocatedText_Future {
	return LocatedText_Future{Future: p.Future.Field(0, nil)}
}
func (p Expression_Future) Embed() LocatedText_Future {
	return LocatedText_Future{Future: p.Future.Field(0, nil)}
}
func (p Expression_Future) Application() Expression_application_Future {
	return Expression_application_Future{p.Future}
}

// Expression_application_Future is a wrapper for a Expression_application promised by a client call.
type Expression_application_Future struct{ *capnp.Future }

func (f Expression_application_Future) Struct() (Expression_application, error) {
	p, err := f.Future.Ptr()
	return Expression_application(p.Struct()), err
}
func (p Expression_application_Future) Function() Expression_Future {
	return Expression_Future{Future: p.Future.Field(0, nil)}
}
func (p Expression_Future) Member() Expression_member_Future {
	return Expression_member_Future{p.Future}
}

// Expression_member_Future is a wrapper for a Expression_member promised by a client call.
type Expression_member_Future struct{ *capnp.Future }

func (f Expression_member_Future) Struct() (Expression_member, error) {
	p, err := f.Future.Ptr()
	return Expression_member(p.Struct()), err
}
func (p Expression_member_Future) Parent() Expression_Future {
	return Expression_Future{Future: p.Future.Field(0, nil)}
}
func (p Expression_member_Future) Name() LocatedText_Future {
	return LocatedText_Future{Future: p.Future.Field(1, nil)}
}

type Expression_Param capnp.Struct
type Expression_Param_Which uint16

const (
	Expression_Param_Which_unnamed Expression_Param_Which = 0
	Expression_Param_Which_named   Expression_Param_Which = 1
)

func (w Expression_Param_Which) String() string {
	const s = "unnamednamed"
	switch w {
	case Expression_Param_Which_unnamed:
		return s[0:7]
	case Expression_Param_Which_named:
		return s[7:12]

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

// Expression_Param_TypeID is the unique identifier for the type Expression_Param.
const Expression_Param_TypeID = 0xc90246b71adedbaa

func NewExpression_Param(s *capnp.Segment) (Expression_Param, error) {
	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 2})
	return Expression_Param(st), err
}

func NewRootExpression_Param(s *capnp.Segment) (Expression_Param, error) {
	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 2})
	return Expression_Param(st), err
}

func ReadRootExpression_Param(msg *capnp.Message) (Expression_Param, error) {
	root, err := msg.Root()
	return Expression_Param(root.Struct()), err
}

func (s Expression_Param) String() string {
	str, _ := text.Marshal(0xc90246b71adedbaa, capnp.Struct(s))
	return str
}

func (s Expression_Param) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr {
	return capnp.Struct(s).EncodeAsPtr(seg)
}

func (Expression_Param) DecodeFromPtr(p capnp.Ptr) Expression_Param {
	return Expression_Param(capnp.Struct{}.DecodeFromPtr(p))
}

func (s Expression_Param) ToPtr() capnp.Ptr {
	return capnp.Struct(s).ToPtr()
}

func (s Expression_Param) Which() Expression_Param_Which {
	return Expression_Param_Which(capnp.Struct(s).Uint16(0))
}
func (s Expression_Param) IsValid() bool {
	return capnp.Struct(s).IsValid()
}

func (s Expression_Param) Message() *capnp.Message {
	return capnp.Struct(s).Message()
}

func (s Expression_Param) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Expression_Param) SetUnnamed() {
	capnp.Struct(s).SetUint16(0, 0)

}

func (s Expression_Param) Named() (LocatedText, error) {
	if capnp.Struct(s).Uint16(0) != 1 {
		panic("Which() != named")
	}
	p, err := capnp.Struct(s).Ptr(0)
	return LocatedText(p.Struct()), err
}

func (s Expression_Param) HasNamed() bool {
	if capnp.Struct(s).Uint16(0) != 1 {
		return false
	}
	return capnp.Struct(s).HasPtr(0)
}

func (s Expression_Param) SetNamed(v LocatedText) error {
	capnp.Struct(s).SetUint16(0, 1)
	return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr())
}

// NewNamed sets the named field to a newly
// allocated LocatedText struct, preferring placement in s's segment.
func (s Expression_Param) NewNamed() (LocatedText, error) {
	capnp.Struct(s).SetUint16(0, 1)
	ss, err := NewLocatedText(capnp.Struct(s).Segment())
	if err != nil {
		return LocatedText{}, err
	}
	err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr())
	return ss, err
}

func (s Expression_Param) Value() (Expression, error) {
	p, err := capnp.Struct(s).Ptr(1)
	return Expression(p.Struct()), err
}

func (s Expression_Param) HasValue() bool {
	return capnp.Struct(s).HasPtr(1)
}

func (s Expression_Param) SetValue(v Expression) error {
	return capnp.Struct(s).SetPtr(1, capnp.Struct(v).ToPtr())
}

// NewValue sets the value field to a newly
// allocated Expression struct, preferring placement in s's segment.
func (s Expression_Param) NewValue() (Expression, error) {
	ss, err := NewExpression(capnp.Struct(s).Segment())
	if err != nil {
		return Expression{}, err
	}
	err = capnp.Struct(s).SetPtr(1, capnp.Struct(ss).ToPtr())
	return ss, err
}

// Expression_Param_List is a list of Expression_Param.
type Expression_Param_List = capnp.StructList[Expression_Param]

// NewExpression_Param creates a new list of Expression_Param.
func NewExpression_Param_List(s *capnp.Segment, sz int32) (Expression_Param_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 2}, sz)
	return capnp.StructList[Expression_Param](l), err
}

// Expression_Param_Future is a wrapper for a Expression_Param promised by a client call.
type Expression_Param_Future struct{ *capnp.Future }

func (f Expression_Param_Future) Struct() (Expression_Param, error) {
	p, err := f.Future.Ptr()
	return Expression_Param(p.Struct()), err
}
func (p Expression_Param_Future) Named() LocatedText_Future {
	return LocatedText_Future{Future: p.Future.Field(0, nil)}
}
func (p Expression_Param_Future) Value() Expression_Future {
	return Expression_Future{Future: p.Future.Field(1, nil)}
}

type Declaration capnp.Struct
type Declaration_id Declaration
type Declaration_using Declaration
type Declaration_const Declaration
type Declaration_field Declaration
type Declaration_field_defaultValue Declaration
type Declaration_interface Declaration
type Declaration_method Declaration
type Declaration_method_results Declaration
type Declaration_annotation Declaration
type Declaration_Which uint16

const (
	Declaration_Which_file              Declaration_Which = 0
	Declaration_Which_using             Declaration_Which = 1
	Declaration_Which_const             Declaration_Which = 2
	Declaration_Which_enum              Declaration_Which = 3
	Declaration_Which_enumerant         Declaration_Which = 4
	Declaration_Which_struct            Declaration_Which = 5
	Declaration_Which_field             Declaration_Which = 6
	Declaration_Which_union             Declaration_Which = 7
	Declaration_Which_group             Declaration_Which = 8
	Declaration_Which_interface         Declaration_Which = 9
	Declaration_Which_method            Declaration_Which = 10
	Declaration_Which_annotation        Declaration_Which = 11
	Declaration_Which_nakedId           Declaration_Which = 12
	Declaration_Which_nakedAnnotation   Declaration_Which = 13
	Declaration_Which_builtinVoid       Declaration_Which = 14
	Declaration_Which_builtinBool       Declaration_Which = 15
	Declaration_Which_builtinInt8       Declaration_Which = 16
	Declaration_Which_builtinInt16      Declaration_Which = 17
	Declaration_Which_builtinInt32      Declaration_Which = 18
	Declaration_Which_builtinInt64      Declaration_Which = 19
	Declaration_Which_builtinUInt8      Declaration_Which = 20
	Declaration_Which_builtinUInt16     Declaration_Which = 21
	Declaration_Which_builtinUInt32     Declaration_Which = 22
	Declaration_Which_builtinUInt64     Declaration_Which = 23
	Declaration_Which_builtinFloat32    Declaration_Which = 24
	Declaration_Which_builtinFloat64    Declaration_Which = 25
	Declaration_Which_builtinText       Declaration_Which = 26
	Declaration_Which_builtinData       Declaration_Which = 27
	Declaration_Which_builtinList       Declaration_Which = 28
	Declaration_Which_builtinObject     Declaration_Which = 29
	Declaration_Which_builtinAnyPointer Declaration_Which = 30
	Declaration_Which_builtinAnyStruct  Declaration_Which = 31
	Declaration_Which_builtinAnyList    Declaration_Which = 32
	Declaration_Which_builtinCapability Declaration_Which = 33
)

func (w Declaration_Which) String() string {
	const s = "fileusingconstenumenumerantstructfielduniongroupinterfacemethodannotationnakedIdnakedAnnotationbuiltinVoidbuiltinBoolbuiltinInt8builtinInt16builtinInt32builtinInt64builtinUInt8builtinUInt16builtinUInt32builtinUInt64builtinFloat32builtinFloat64builtinTextbuiltinDatabuiltinListbuiltinObjectbuiltinAnyPointerbuiltinAnyStructbuiltinAnyListbuiltinCapability"
	switch w {
	case Declaration_Which_file:
		return s[0:4]
	case Declaration_Which_using:
		return s[4:9]
	case Declaration_Which_const:
		return s[9:14]
	case Declaration_Which_enum:
		return s[14:18]
	case Declaration_Which_enumerant:
		return s[18:27]
	case Declaration_Which_struct:
		return s[27:33]
	case Declaration_Which_field:
		return s[33:38]
	case Declaration_Which_union:
		return s[38:43]
	case Declaration_Which_group:
		return s[43:48]
	case Declaration_Which_interface:
		return s[48:57]
	case Declaration_Which_method:
		return s[57:63]
	case Declaration_Which_annotation:
		return s[63:73]
	case Declaration_Which_nakedId:
		return s[73:80]
	case Declaration_Which_nakedAnnotation:
		return s[80:95]
	case Declaration_Which_builtinVoid:
		return s[95:106]
	case Declaration_Which_builtinBool:
		return s[106:117]
	case Declaration_Which_builtinInt8:
		return s[117:128]
	case Declaration_Which_builtinInt16:
		return s[128:140]
	case Declaration_Which_builtinInt32:
		return s[140:152]
	case Declaration_Which_builtinInt64:
		return s[152:164]
	case Declaration_Which_builtinUInt8:
		return s[164:176]
	case Declaration_Which_builtinUInt16:
		return s[176:189]
	case Declaration_Which_builtinUInt32:
		return s[189:202]
	case Declaration_Which_builtinUInt64:
		return s[202:215]
	case Declaration_Which_builtinFloat32:
		return s[215:229]
	case Declaration_Which_builtinFloat64:
		return s[229:243]
	case Declaration_Which_builtinText:
		return s[243:254]
	case Declaration_Which_builtinData:
		return s[254:265]
	case Declaration_Which_builtinList:
		return s[265:276]
	case Declaration_Which_builtinObject:
		return s[276:289]
	case Declaration_Which_builtinAnyPointer:
		return s[289:306]
	case Declaration_Which_builtinAnyStruct:
		return s[306:322]
	case Declaration_Which_builtinAnyList:
		return s[322:336]
	case Declaration_Which_builtinCapability:
		return s[336:353]

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

type Declaration_id_Which uint16

const (
	Declaration_id_Which_unspecified Declaration_id_Which = 0
	Declaration_id_Which_uid         Declaration_id_Which = 1
	Declaration_id_Which_ordinal     Declaration_id_Which = 2
)

func (w Declaration_id_Which) String() string {
	const s = "unspecifieduidordinal"
	switch w {
	case Declaration_id_Which_unspecified:
		return s[0:11]
	case Declaration_id_Which_uid:
		return s[11:14]
	case Declaration_id_Which_ordinal:
		return s[14:21]

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

type Declaration_field_defaultValue_Which uint16

const (
	Declaration_field_defaultValue_Which_none  Declaration_field_defaultValue_Which = 0
	Declaration_field_defaultValue_Which_value Declaration_field_defaultValue_Which = 1
)

func (w Declaration_field_defaultValue_Which) String() string {
	const s = "nonevalue"
	switch w {
	case Declaration_field_defaultValue_Which_none:
		return s[0:4]
	case Declaration_field_defaultValue_Which_value:
		return s[4:9]

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

type Declaration_method_results_Which uint16

const (
	Declaration_method_results_Which_none     Declaration_method_results_Which = 0
	Declaration_method_results_Which_explicit Declaration_method_results_Which = 1
)

func (w Declaration_method_results_Which) String() string {
	const s = "noneexplicit"
	switch w {
	case Declaration_method_results_Which_none:
		return s[0:4]
	case Declaration_method_results_Which_explicit:
		return s[4:12]

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

// Declaration_TypeID is the unique identifier for the type Declaration.
const Declaration_TypeID = 0x96efe787c17e83bb

func NewDeclaration(s *capnp.Segment) (Declaration, error) {
	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 16, PointerCount: 8})
	return Declaration(st), err
}

func NewRootDeclaration(s *capnp.Segment) (Declaration, error) {
	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 16, PointerCount: 8})
	return Declaration(st), err
}

func ReadRootDeclaration(msg *capnp.Message) (Declaration, error) {
	root, err := msg.Root()
	return Declaration(root.Struct()), err
}

func (s Declaration) String() string {
	str, _ := text.Marshal(0x96efe787c17e83bb, capnp.Struct(s))
	return str
}

func (s Declaration) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr {
	return capnp.Struct(s).EncodeAsPtr(seg)
}

func (Declaration) DecodeFromPtr(p capnp.Ptr) Declaration {
	return Declaration(capnp.Struct{}.DecodeFromPtr(p))
}

func (s Declaration) ToPtr() capnp.Ptr {
	return capnp.Struct(s).ToPtr()
}

func (s Declaration) Which() Declaration_Which {
	return Declaration_Which(capnp.Struct(s).Uint16(2))
}
func (s Declaration) IsValid() bool {
	return capnp.Struct(s).IsValid()
}

func (s Declaration) Message() *capnp.Message {
	return capnp.Struct(s).Message()
}

func (s Declaration) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Declaration) Name() (LocatedText, error) {
	p, err := capnp.Struct(s).Ptr(0)
	return LocatedText(p.Struct()), err
}

func (s Declaration) HasName() bool {
	return capnp.Struct(s).HasPtr(0)
}

func (s Declaration) SetName(v LocatedText) error {
	return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr())
}

// NewName sets the name field to a newly
// allocated LocatedText struct, preferring placement in s's segment.
func (s Declaration) NewName() (LocatedText, error) {
	ss, err := NewLocatedText(capnp.Struct(s).Segment())
	if err != nil {
		return LocatedText{}, err
	}
	err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr())
	return ss, err
}

func (s Declaration) Id() Declaration_id { return Declaration_id(s) }

func (s Declaration_id) Which() Declaration_id_Which {
	return Declaration_id_Which(capnp.Struct(s).Uint16(0))
}
func (s Declaration_id) IsValid() bool {
	return capnp.Struct(s).IsValid()
}

func (s Declaration_id) Message() *capnp.Message {
	return capnp.Struct(s).Message()
}

func (s Declaration_id) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Declaration_id) SetUnspecified() {
	capnp.Struct(s).SetUint16(0, 0)

}

func (s Declaration_id) Uid() (LocatedInteger, error) {
	if capnp.Struct(s).Uint16(0) != 1 {
		panic("Which() != uid")
	}
	p, err := capnp.Struct(s).Ptr(1)
	return LocatedInteger(p.Struct()), err
}

func (s Declaration_id) HasUid() bool {
	if capnp.Struct(s).Uint16(0) != 1 {
		return false
	}
	return capnp.Struct(s).HasPtr(1)
}

func (s Declaration_id) SetUid(v LocatedInteger) error {
	capnp.Struct(s).SetUint16(0, 1)
	return capnp.Struct(s).SetPtr(1, capnp.Struct(v).ToPtr())
}

// NewUid sets the uid field to a newly
// allocated LocatedInteger struct, preferring placement in s's segment.
func (s Declaration_id) NewUid() (LocatedInteger, error) {
	capnp.Struct(s).SetUint16(0, 1)
	ss, err := NewLocatedInteger(capnp.Struct(s).Segment())
	if err != nil {
		return LocatedInteger{}, err
	}
	err = capnp.Struct(s).SetPtr(1, capnp.Struct(ss).ToPtr())
	return ss, err
}

func (s Declaration_id) Ordinal() (LocatedInteger, error) {
	if capnp.Struct(s).Uint16(0) != 2 {
		panic("Which() != ordinal")
	}
	p, err := capnp.Struct(s).Ptr(1)
	return LocatedInteger(p.Struct()), err
}

func (s Declaration_id) HasOrdinal() bool {
	if capnp.Struct(s).Uint16(0) != 2 {
		return false
	}
	return capnp.Struct(s).HasPtr(1)
}

func (s Declaration_id) SetOrdinal(v LocatedInteger) error {
	capnp.Struct(s).SetUint16(0, 2)
	return capnp.Struct(s).SetPtr(1, capnp.Struct(v).ToPtr())
}

// NewOrdinal sets the ordinal field to a newly
// allocated LocatedInteger struct, preferring placement in s's segment.
func (s Declaration_id) NewOrdinal() (LocatedInteger, error) {
	capnp.Struct(s).SetUint16(0, 2)
	ss, err := NewLocatedInteger(capnp.Struct(s).Segment())
	if err != nil {
		return LocatedInteger{}, err
	}
	err = capnp.Struct(s).SetPtr(1, capnp.Struct(ss).ToPtr())
	return ss, err
}

func (s Declaration) Parameters() (Declaration_BrandParameter_List, error) {
	p, err := capnp.Struct(s).Ptr(7)
	return Declaration_BrandParameter_List(p.List()), err
}

func (s Declaration) HasParameters() bool {
	return capnp.Struct(s).HasPtr(7)
}

func (s Declaration) SetParameters(v Declaration_BrandParameter_List) error {
	return capnp.Struct(s).SetPtr(7, v.ToPtr())
}

// NewParameters sets the parameters field to a newly
// allocated Declaration_BrandParameter_List, preferring placement in s's segment.
func (s Declaration) NewParameters(n int32) (Declaration_BrandParameter_List, error) {
	l, err := NewDeclaration_BrandParameter_List(capnp.Struct(s).Segment(), n)
	if err != nil {
		return Declaration_BrandParameter_List{}, err
	}
	err = capnp.Struct(s).SetPtr(7, l.ToPtr())
	return l, err
}
func (s Declaration) NestedDecls() (Declaration_List, error) {
	p, err := capnp.Struct(s).Ptr(2)
	return Declaration_List(p.List()), err
}

func (s Declaration) HasNestedDecls() bool {
	return capnp.Struct(s).HasPtr(2)
}

func (s Declaration) SetNestedDecls(v Declaration_List) error {
	return capnp.Struct(s).SetPtr(2, v.ToPtr())
}

// NewNestedDecls sets the nestedDecls field to a newly
// allocated Declaration_List, preferring placement in s's segment.
func (s Declaration) NewNestedDecls(n int32) (Declaration_List, error) {
	l, err := NewDeclaration_List(capnp.Struct(s).Segment(), n)
	if err != nil {
		return Declaration_List{}, err
	}
	err = capnp.Struct(s).SetPtr(2, l.ToPtr())
	return l, err
}
func (s Declaration) Annotations() (Declaration_AnnotationApplication_List, error) {
	p, err := capnp.Struct(s).Ptr(3)
	return Declaration_AnnotationApplication_List(p.List()), err
}

func (s Declaration) HasAnnotations() bool {
	return capnp.Struct(s).HasPtr(3)
}

func (s Declaration) SetAnnotations(v Declaration_AnnotationApplication_List) error {
	return capnp.Struct(s).SetPtr(3, v.ToPtr())
}

// NewAnnotations sets the annotations field to a newly
// allocated Declaration_AnnotationApplication_List, preferring placement in s's segment.
func (s Declaration) NewAnnotations(n int32) (Declaration_AnnotationApplication_List, error) {
	l, err := NewDeclaration_AnnotationApplication_List(capnp.Struct(s).Segment(), n)
	if err != nil {
		return Declaration_AnnotationApplication_List{}, err
	}
	err = capnp.Struct(s).SetPtr(3, l.ToPtr())
	return l, err
}
func (s Declaration) StartByte() uint32 {
	return capnp.Struct(s).Uint32(4)
}

func (s Declaration) SetStartByte(v uint32) {
	capnp.Struct(s).SetUint32(4, v)
}

func (s Declaration) EndByte() uint32 {
	return capnp.Struct(s).Uint32(8)
}

func (s Declaration) SetEndByte(v uint32) {
	capnp.Struct(s).SetUint32(8, v)
}

func (s Declaration) DocComment() (string, error) {
	p, err := capnp.Struct(s).Ptr(4)
	return p.Text(), err
}

func (s Declaration) HasDocComment() bool {
	return capnp.Struct(s).HasPtr(4)
}

func (s Declaration) DocCommentBytes() ([]byte, error) {
	p, err := capnp.Struct(s).Ptr(4)
	return p.TextBytes(), err
}

func (s Declaration) SetDocComment(v string) error {
	return capnp.Struct(s).SetText(4, v)
}

func (s Declaration) SetFile() {
	capnp.Struct(s).SetUint16(2, 0)

}

func (s Declaration) Using() Declaration_using { return Declaration_using(s) }

func (s Declaration) SetUsing() {
	capnp.Struct(s).SetUint16(2, 1)
}

func (s Declaration_using) IsValid() bool {
	return capnp.Struct(s).IsValid()
}

func (s Declaration_using) Message() *capnp.Message {
	return capnp.Struct(s).Message()
}

func (s Declaration_using) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Declaration_using) Target() (Expression, error) {
	p, err := capnp.Struct(s).Ptr(5)
	return Expression(p.Struct()), err
}

func (s Declaration_using) HasTarget() bool {
	return capnp.Struct(s).HasPtr(5)
}

func (s Declaration_using) SetTarget(v Expression) error {
	return capnp.Struct(s).SetPtr(5, capnp.Struct(v).ToPtr())
}

// NewTarget sets the target field to a newly
// allocated Expression struct, preferring placement in s's segment.
func (s Declaration_using) NewTarget() (Expression, error) {
	ss, err := NewExpression(capnp.Struct(s).Segment())
	if err != nil {
		return Expression{}, err
	}
	err = capnp.Struct(s).SetPtr(5, capnp.Struct(ss).ToPtr())
	return ss, err
}

func (s Declaration) Const() Declaration_const { return Declaration_const(s) }

func (s Declaration) SetConst() {
	capnp.Struct(s).SetUint16(2, 2)
}

func (s Declaration_const) IsValid() bool {
	return capnp.Struct(s).IsValid()
}

func (s Declaration_const) Message() *capnp.Message {
	return capnp.Struct(s).Message()
}

func (s Declaration_const) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Declaration_const) Type() (Expression, error) {
	p, err := capnp.Struct(s).Ptr(5)
	return Expression(p.Struct()), err
}

func (s Declaration_const) HasType() bool {
	return capnp.Struct(s).HasPtr(5)
}

func (s Declaration_const) SetType(v Expression) error {
	return capnp.Struct(s).SetPtr(5, capnp.Struct(v).ToPtr())
}

// NewType sets the type field to a newly
// allocated Expression struct, preferring placement in s's segment.
func (s Declaration_const) NewType() (Expression, error) {
	ss, err := NewExpression(capnp.Struct(s).Segment())
	if err != nil {
		return Expression{}, err
	}
	err = capnp.Struct(s).SetPtr(5, capnp.Struct(ss).ToPtr())
	return ss, err
}

func (s Declaration_const) Value() (Expression, error) {
	p, err := capnp.Struct(s).Ptr(6)
	return Expression(p.Struct()), err
}

func (s Declaration_const) HasValue() bool {
	return capnp.Struct(s).HasPtr(6)
}

func (s Declaration_const) SetValue(v Expression) error {
	return capnp.Struct(s).SetPtr(6, capnp.Struct(v).ToPtr())
}

// NewValue sets the value field to a newly
// allocated Expression struct, preferring placement in s's segment.
func (s Declaration_const) NewValue() (Expression, error) {
	ss, err := NewExpression(capnp.Struct(s).Segment())
	if err != nil {
		return Expression{}, err
	}
	err = capnp.Struct(s).SetPtr(6, capnp.Struct(ss).ToPtr())
	return ss, err
}

func (s Declaration) SetEnum() {
	capnp.Struct(s).SetUint16(2, 3)

}

func (s Declaration) SetEnumerant() {
	capnp.Struct(s).SetUint16(2, 4)

}

func (s Declaration) SetStruct() {
	capnp.Struct(s).SetUint16(2, 5)

}

func (s Declaration) Field() Declaration_field { return Declaration_field(s) }

func (s Declaration) SetField() {
	capnp.Struct(s).SetUint16(2, 6)
}

func (s Declaration_field) IsValid() bool {
	return capnp.Struct(s).IsValid()
}

func (s Declaration_field) Message() *capnp.Message {
	return capnp.Struct(s).Message()
}

func (s Declaration_field) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Declaration_field) Type() (Expression, error) {
	p, err := capnp.Struct(s).Ptr(5)
	return Expression(p.Struct()), err
}

func (s Declaration_field) HasType() bool {
	return capnp.Struct(s).HasPtr(5)
}

func (s Declaration_field) SetType(v Expression) error {
	return capnp.Struct(s).SetPtr(5, capnp.Struct(v).ToPtr())
}

// NewType sets the type field to a newly
// allocated Expression struct, preferring placement in s's segment.
func (s Declaration_field) NewType() (Expression, error) {
	ss, err := NewExpression(capnp.Struct(s).Segment())
	if err != nil {
		return Expression{}, err
	}
	err = capnp.Struct(s).SetPtr(5, capnp.Struct(ss).ToPtr())
	return ss, err
}

func (s Declaration_field) DefaultValue() Declaration_field_defaultValue {
	return Declaration_field_defaultValue(s)
}

func (s Declaration_field_defaultValue) Which() Declaration_field_defaultValue_Which {
	return Declaration_field_defaultValue_Which(capnp.Struct(s).Uint16(12))
}
func (s Declaration_field_defaultValue) IsValid() bool {
	return capnp.Struct(s).IsValid()
}

func (s Declaration_field_defaultValue) Message() *capnp.Message {
	return capnp.Struct(s).Message()
}

func (s Declaration_field_defaultValue) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Declaration_field_defaultValue) SetNone() {
	capnp.Struct(s).SetUint16(12, 0)

}

func (s Declaration_field_defaultValue) Value() (Expression, error) {
	if capnp.Struct(s).Uint16(12) != 1 {
		panic("Which() != value")
	}
	p, err := capnp.Struct(s).Ptr(6)
	return Expression(p.Struct()), err
}

func (s Declaration_field_defaultValue) HasValue() bool {
	if capnp.Struct(s).Uint16(12) != 1 {
		return false
	}
	return capnp.Struct(s).HasPtr(6)
}

func (s Declaration_field_defaultValue) SetValue(v Expression) error {
	capnp.Struct(s).SetUint16(12, 1)
	return capnp.Struct(s).SetPtr(6, capnp.Struct(v).ToPtr())
}

// NewValue sets the value field to a newly
// allocated Expression struct, preferring placement in s's segment.
func (s Declaration_field_defaultValue) NewValue() (Expression, error) {
	capnp.Struct(s).SetUint16(12, 1)
	ss, err := NewExpression(capnp.Struct(s).Segment())
	if err != nil {
		return Expression{}, err
	}
	err = capnp.Struct(s).SetPtr(6, capnp.Struct(ss).ToPtr())
	return ss, err
}

func (s Declaration) SetUnion() {
	capnp.Struct(s).SetUint16(2, 7)

}

func (s Declaration) SetGroup() {
	capnp.Struct(s).SetUint16(2, 8)

}

func (s Declaration) Interface() Declaration_interface { return Declaration_interface(s) }

func (s Declaration) SetInterface() {
	capnp.Struct(s).SetUint16(2, 9)
}

func (s Declaration_interface) IsValid() bool {
	return capnp.Struct(s).IsValid()
}

func (s Declaration_interface) Message() *capnp.Message {
	return capnp.Struct(s).Message()
}

func (s Declaration_interface) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Declaration_interface) Superclasses() (Expression_List, error) {
	p, err := capnp.Struct(s).Ptr(5)
	return Expression_List(p.List()), err
}

func (s Declaration_interface) HasSuperclasses() bool {
	return capnp.Struct(s).HasPtr(5)
}

func (s Declaration_interface) SetSuperclasses(v Expression_List) error {
	return capnp.Struct(s).SetPtr(5, v.ToPtr())
}

// NewSuperclasses sets the superclasses field to a newly
// allocated Expression_List, preferring placement in s's segment.
func (s Declaration_interface) NewSuperclasses(n int32) (Expression_List, error) {
	l, err := NewExpression_List(capnp.Struct(s).Segment(), n)
	if err != nil {
		return Expression_List{}, err
	}
	err = capnp.Struct(s).SetPtr(5, l.ToPtr())
	return l, err
}
func (s Declaration) Method() Declaration_method { return Declaration_method(s) }

func (s Declaration) SetMethod() {
	capnp.Struct(s).SetUint16(2, 10)
}

func (s Declaration_method) IsValid() bool {
	return capnp.Struct(s).IsValid()
}

func (s Declaration_method) Message() *capnp.Message {
	return capnp.Struct(s).Message()
}

func (s Declaration_method) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Declaration_method) Params() (Declaration_ParamList, error) {
	p, err := capnp.Struct(s).Ptr(5)
	return Declaration_ParamList(p.Struct()), err
}

func (s Declaration_method) HasParams() bool {
	return capnp.Struct(s).HasPtr(5)
}

func (s Declaration_method) SetParams(v Declaration_ParamList) error {
	return capnp.Struct(s).SetPtr(5, capnp.Struct(v).ToPtr())
}

// NewParams sets the params field to a newly
// allocated Declaration_ParamList struct, preferring placement in s's segment.
func (s Declaration_method) NewParams() (Declaration_ParamList, error) {
	ss, err := NewDeclaration_ParamList(capnp.Struct(s).Segment())
	if err != nil {
		return Declaration_ParamList{}, err
	}
	err = capnp.Struct(s).SetPtr(5, capnp.Struct(ss).ToPtr())
	return ss, err
}

func (s Declaration_method) Results() Declaration_method_results {
	return Declaration_method_results(s)
}

func (s Declaration_method_results) Which() Declaration_method_results_Which {
	return Declaration_method_results_Which(capnp.Struct(s).Uint16(12))
}
func (s Declaration_method_results) IsValid() bool {
	return capnp.Struct(s).IsValid()
}

func (s Declaration_method_results) Message() *capnp.Message {
	return capnp.Struct(s).Message()
}

func (s Declaration_method_results) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Declaration_method_results) SetNone() {
	capnp.Struct(s).SetUint16(12, 0)

}

func (s Declaration_method_results) Explicit() (Declaration_ParamList, error) {
	if capnp.Struct(s).Uint16(12) != 1 {
		panic("Which() != explicit")
	}
	p, err := capnp.Struct(s).Ptr(6)
	return Declaration_ParamList(p.Struct()), err
}

func (s Declaration_method_results) HasExplicit() bool {
	if capnp.Struct(s).Uint16(12) != 1 {
		return false
	}
	return capnp.Struct(s).HasPtr(6)
}

func (s Declaration_method_results) SetExplicit(v Declaration_ParamList) error {
	capnp.Struct(s).SetUint16(12, 1)
	return capnp.Struct(s).SetPtr(6, capnp.Struct(v).ToPtr())
}

// NewExplicit sets the explicit field to a newly
// allocated Declaration_ParamList struct, preferring placement in s's segment.
func (s Declaration_method_results) NewExplicit() (Declaration_ParamList, error) {
	capnp.Struct(s).SetUint16(12, 1)
	ss, err := NewDeclaration_ParamList(capnp.Struct(s).Segment())
	if err != nil {
		return Declaration_ParamList{}, err
	}
	err = capnp.Struct(s).SetPtr(6, capnp.Struct(ss).ToPtr())
	return ss, err
}

func (s Declaration) Annotation() Declaration_annotation { return Declaration_annotation(s) }

func (s Declaration) SetAnnotation() {
	capnp.Struct(s).SetUint16(2, 11)
}

func (s Declaration_annotation) IsValid() bool {
	return capnp.Struct(s).IsValid()
}

func (s Declaration_annotation) Message() *capnp.Message {
	return capnp.Struct(s).Message()
}

func (s Declaration_annotation) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Declaration_annotation) Type() (Expression, error) {
	p, err := capnp.Struct(s).Ptr(5)
	return Expression(p.Struct()), err
}

func (s Declaration_annotation) HasType() bool {
	return capnp.Struct(s).HasPtr(5)
}

func (s Declaration_annotation) SetType(v Expression) error {
	return capnp.Struct(s).SetPtr(5, capnp.Struct(v).ToPtr())
}

// NewType sets the type field to a newly
// allocated Expression struct, preferring placement in s's segment.
func (s Declaration_annotation) NewType() (Expression, error) {
	ss, err := NewExpression(capnp.Struct(s).Segment())
	if err != nil {
		return Expression{}, err
	}
	err = capnp.Struct(s).SetPtr(5, capnp.Struct(ss).ToPtr())
	return ss, err
}

func (s Declaration_annotation) TargetsFile() bool {
	return capnp.Struct(s).Bit(96)
}

func (s Declaration_annotation) SetTargetsFile(v bool) {
	capnp.Struct(s).SetBit(96, v)
}

func (s Declaration_annotation) TargetsConst() bool {
	return capnp.Struct(s).Bit(97)
}

func (s Declaration_annotation) SetTargetsConst(v bool) {
	capnp.Struct(s).SetBit(97, v)
}

func (s Declaration_annotation) TargetsEnum() bool {
	return capnp.Struct(s).Bit(98)
}

func (s Declaration_annotation) SetTargetsEnum(v bool) {
	capnp.Struct(s).SetBit(98, v)
}

func (s Declaration_annotation) TargetsEnumerant() bool {
	return capnp.Struct(s).Bit(99)
}

func (s Declaration_annotation) SetTargetsEnumerant(v bool) {
	capnp.Struct(s).SetBit(99, v)
}

func (s Declaration_annotation) TargetsStruct() bool {
	return capnp.Struct(s).Bit(100)
}

func (s Declaration_annotation) SetTargetsStruct(v bool) {
	capnp.Struct(s).SetBit(100, v)
}

func (s Declaration_annotation) TargetsField() bool {
	return capnp.Struct(s).Bit(101)
}

func (s Declaration_annotation) SetTargetsField(v bool) {
	capnp.Struct(s).SetBit(101, v)
}

func (s Declaration_annotation) TargetsUnion() bool {
	return capnp.Struct(s).Bit(102)
}

func (s Declaration_annotation) SetTargetsUnion(v bool) {
	capnp.Struct(s).SetBit(102, v)
}

func (s Declaration_annotation) TargetsGroup() bool {
	return capnp.Struct(s).Bit(103)
}

func (s Declaration_annotation) SetTargetsGroup(v bool) {
	capnp.Struct(s).SetBit(103, v)
}

func (s Declaration_annotation) TargetsInterface() bool {
	return capnp.Struct(s).Bit(104)
}

func (s Declaration_annotation) SetTargetsInterface(v bool) {
	capnp.Struct(s).SetBit(104, v)
}

func (s Declaration_annotation) TargetsMethod() bool {
	return capnp.Struct(s).Bit(105)
}

func (s Declaration_annotation) SetTargetsMethod(v bool) {
	capnp.Struct(s).SetBit(105, v)
}

func (s Declaration_annotation) TargetsParam() bool {
	return capnp.Struct(s).Bit(106)
}

func (s Declaration_annotation) SetTargetsParam(v bool) {
	capnp.Struct(s).SetBit(106, v)
}

func (s Declaration_annotation) TargetsAnnotation() bool {
	return capnp.Struct(s).Bit(107)
}

func (s Declaration_annotation) SetTargetsAnnotation(v bool) {
	capnp.Struct(s).SetBit(107, v)
}

func (s Declaration) NakedId() (LocatedInteger, error) {
	if capnp.Struct(s).Uint16(2) != 12 {
		panic("Which() != nakedId")
	}
	p, err := capnp.Struct(s).Ptr(5)
	return LocatedInteger(p.Struct()), err
}

func (s Declaration) HasNakedId() bool {
	if capnp.Struct(s).Uint16(2) != 12 {
		return false
	}
	return capnp.Struct(s).HasPtr(5)
}

func (s Declaration) SetNakedId(v LocatedInteger) error {
	capnp.Struct(s).SetUint16(2, 12)
	return capnp.Struct(s).SetPtr(5, capnp.Struct(v).ToPtr())
}

// NewNakedId sets the nakedId field to a newly
// allocated LocatedInteger struct, preferring placement in s's segment.
func (s Declaration) NewNakedId() (LocatedInteger, error) {
	capnp.Struct(s).SetUint16(2, 12)
	ss, err := NewLocatedInteger(capnp.Struct(s).Segment())
	if err != nil {
		return LocatedInteger{}, err
	}
	err = capnp.Struct(s).SetPtr(5, capnp.Struct(ss).ToPtr())
	return ss, err
}

func (s Declaration) NakedAnnotation() (Declaration_AnnotationApplication, error) {
	if capnp.Struct(s).Uint16(2) != 13 {
		panic("Which() != nakedAnnotation")
	}
	p, err := capnp.Struct(s).Ptr(5)
	return Declaration_AnnotationApplication(p.Struct()), err
}

func (s Declaration) HasNakedAnnotation() bool {
	if capnp.Struct(s).Uint16(2) != 13 {
		return false
	}
	return capnp.Struct(s).HasPtr(5)
}

func (s Declaration) SetNakedAnnotation(v Declaration_AnnotationApplication) error {
	capnp.Struct(s).SetUint16(2, 13)
	return capnp.Struct(s).SetPtr(5, capnp.Struct(v).ToPtr())
}

// NewNakedAnnotation sets the nakedAnnotation field to a newly
// allocated Declaration_AnnotationApplication struct, preferring placement in s's segment.
func (s Declaration) NewNakedAnnotation() (Declaration_AnnotationApplication, error) {
	capnp.Struct(s).SetUint16(2, 13)
	ss, err := NewDeclaration_AnnotationApplication(capnp.Struct(s).Segment())
	if err != nil {
		return Declaration_AnnotationApplication{}, err
	}
	err = capnp.Struct(s).SetPtr(5, capnp.Struct(ss).ToPtr())
	return ss, err
}

func (s Declaration) SetBuiltinVoid() {
	capnp.Struct(s).SetUint16(2, 14)

}

func (s Declaration) SetBuiltinBool() {
	capnp.Struct(s).SetUint16(2, 15)

}

func (s Declaration) SetBuiltinInt8() {
	capnp.Struct(s).SetUint16(2, 16)

}

func (s Declaration) SetBuiltinInt16() {
	capnp.Struct(s).SetUint16(2, 17)

}

func (s Declaration) SetBuiltinInt32() {
	capnp.Struct(s).SetUint16(2, 18)

}

func (s Declaration) SetBuiltinInt64() {
	capnp.Struct(s).SetUint16(2, 19)

}

func (s Declaration) SetBuiltinUInt8() {
	capnp.Struct(s).SetUint16(2, 20)

}

func (s Declaration) SetBuiltinUInt16() {
	capnp.Struct(s).SetUint16(2, 21)

}

func (s Declaration) SetBuiltinUInt32() {
	capnp.Struct(s).SetUint16(2, 22)

}

func (s Declaration) SetBuiltinUInt64() {
	capnp.Struct(s).SetUint16(2, 23)

}

func (s Declaration) SetBuiltinFloat32() {
	capnp.Struct(s).SetUint16(2, 24)

}

func (s Declaration) SetBuiltinFloat64() {
	capnp.Struct(s).SetUint16(2, 25)

}

func (s Declaration) SetBuiltinText() {
	capnp.Struct(s).SetUint16(2, 26)

}

func (s Declaration) SetBuiltinData() {
	capnp.Struct(s).SetUint16(2, 27)

}

func (s Declaration) SetBuiltinList() {
	capnp.Struct(s).SetUint16(2, 28)

}

func (s Declaration) SetBuiltinObject() {
	capnp.Struct(s).SetUint16(2, 29)

}

func (s Declaration) SetBuiltinAnyPointer() {
	capnp.Struct(s).SetUint16(2, 30)

}

func (s Declaration) SetBuiltinAnyStruct() {
	capnp.Struct(s).SetUint16(2, 31)

}

func (s Declaration) SetBuiltinAnyList() {
	capnp.Struct(s).SetUint16(2, 32)

}

func (s Declaration) SetBuiltinCapability() {
	capnp.Struct(s).SetUint16(2, 33)

}

// Declaration_List is a list of Declaration.
type Declaration_List = capnp.StructList[Declaration]

// NewDeclaration creates a new list of Declaration.
func NewDeclaration_List(s *capnp.Segment, sz int32) (Declaration_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 16, PointerCount: 8}, sz)
	return capnp.StructList[Declaration](l), err
}

// Declaration_Future is a wrapper for a Declaration promised by a client call.
type Declaration_Future struct{ *capnp.Future }

func (f Declaration_Future) Struct() (Declaration, error) {
	p, err := f.Future.Ptr()
	return Declaration(p.Struct()), err
}
func (p Declaration_Future) Name() LocatedText_Future {
	return LocatedText_Future{Future: p.Future.Field(0, nil)}
}
func (p Declaration_Future) Id() Declaration_id_Future { return Declaration_id_Future{p.Future} }

// Declaration_id_Future is a wrapper for a Declaration_id promised by a client call.
type Declaration_id_Future struct{ *capnp.Future }

func (f Declaration_id_Future) Struct() (Declaration_id, error) {
	p, err := f.Future.Ptr()
	return Declaration_id(p.Struct()), err
}
func (p Declaration_id_Future) Uid() LocatedInteger_Future {
	return LocatedInteger_Future{Future: p.Future.Field(1, nil)}
}
func (p Declaration_id_Future) Ordinal() LocatedInteger_Future {
	return LocatedInteger_Future{Future: p.Future.Field(1, nil)}
}
func (p Declaration_Future) Using() Declaration_using_Future {
	return Declaration_using_Future{p.Future}
}

// Declaration_using_Future is a wrapper for a Declaration_using promised by a client call.
type Declaration_using_Future struct{ *capnp.Future }

func (f Declaration_using_Future) Struct() (Declaration_using, error) {
	p, err := f.Future.Ptr()
	return Declaration_using(p.Struct()), err
}
func (p Declaration_using_Future) Target() Expression_Future {
	return Expression_Future{Future: p.Future.Field(5, nil)}
}
func (p Declaration_Future) Const() Declaration_const_Future {
	return Declaration_const_Future{p.Future}
}

// Declaration_const_Future is a wrapper for a Declaration_const promised by a client call.
type Declaration_const_Future struct{ *capnp.Future }

func (f Declaration_const_Future) Struct() (Declaration_const, error) {
	p, err := f.Future.Ptr()
	return Declaration_const(p.Struct()), err
}
func (p Declaration_const_Future) Type() Expression_Future {
	return Expression_Future{Future: p.Future.Field(5, nil)}
}
func (p Declaration_const_Future) Value() Expression_Future {
	return Expression_Future{Future: p.Future.Field(6, nil)}
}
func (p Declaration_Future) Field() Declaration_field_Future {
	return Declaration_field_Future{p.Future}
}

// Declaration_field_Future is a wrapper for a Declaration_field promised by a client call.
type Declaration_field_Future struct{ *capnp.Future }

func (f Declaration_field_Future) Struct() (Declaration_field, error) {
	p, err := f.Future.Ptr()
	return Declaration_field(p.Struct()), err
}
func (p Declaration_field_Future) Type() Expression_Future {
	return Expression_Future{Future: p.Future.Field(5, nil)}
}
func (p Declaration_field_Future) DefaultValue() Declaration_field_defaultValue_Future {
	return Declaration_field_defaultValue_Future{p.Future}
}

// Declaration_field_defaultValue_Future is a wrapper for a Declaration_field_defaultValue promised by a client call.
type Declaration_field_defaultValue_Future struct{ *capnp.Future }

func (f Declaration_field_defaultValue_Future) Struct() (Declaration_field_defaultValue, error) {
	p, err := f.Future.Ptr()
	return Declaration_field_defaultValue(p.Struct()), err
}
func (p Declaration_field_defaultValue_Future) Value() Expression_Future {
	return Expression_Future{Future: p.Future.Field(6, nil)}
}
func (p Declaration_Future) Interface() Declaration_interface_Future {
	return Declaration_interface_Future{p.Future}
}

// Declaration_interface_Future is a wrapper for a Declaration_interface promised by a client call.
type Declaration_interface_Future struct{ *capnp.Future }

func (f Declaration_interface_Future) Struct() (Declaration_interface, error) {
	p, err := f.Future.Ptr()
	return Declaration_interface(p.Struct()), err
}
func (p Declaration_Future) Method() Declaration_method_Future {
	return Declaration_method_Future{p.Future}
}

// Declaration_method_Future is a wrapper for a Declaration_method promised by a client call.
type Declaration_method_Future struct{ *capnp.Future }

func (f Declaration_method_Future) Struct() (Declaration_method, error) {
	p, err := f.Future.Ptr()
	return Declaration_method(p.Struct()), err
}
func (p Declaration_method_Future) Params() Declaration_ParamList_Future {
	return Declaration_ParamList_Future{Future: p.Future.Field(5, nil)}
}
func (p Declaration_method_Future) Results() Declaration_method_results_Future {
	return Declaration_method_results_Future{p.Future}
}

// Declaration_method_results_Future is a wrapper for a Declaration_method_results promised by a client call.
type Declaration_method_results_Future struct{ *capnp.Future }

func (f Declaration_method_results_Future) Struct() (Declaration_method_results, error) {
	p, err := f.Future.Ptr()
	return Declaration_method_results(p.Struct()), err
}
func (p Declaration_method_results_Future) Explicit() Declaration_ParamList_Future {
	return Declaration_ParamList_Future{Future: p.Future.Field(6, nil)}
}
func (p Declaration_Future) Annotation() Declaration_annotation_Future {
	return Declaration_annotation_Future{p.Future}
}

// Declaration_annotation_Future is a wrapper for a Declaration_annotation promised by a client call.
type Declaration_annotation_Future struct{ *capnp.Future }

func (f Declaration_annotation_Future) Struct() (Declaration_annotation, error) {
	p, err := f.Future.Ptr()
	return Declaration_annotation(p.Struct()), err
}
func (p Declaration_annotation_Future) Type() Expression_Future {
	return Expression_Future{Future: p.Future.Field(5, nil)}
}
func (p Declaration_Future) NakedId() LocatedInteger_Future {
	return LocatedInteger_Future{Future: p.Future.Field(5, nil)}
}
func (p Declaration_Future) NakedAnnotation() Declaration_AnnotationApplication_Future {
	return Declaration_AnnotationApplication_Future{Future: p.Future.Field(5, nil)}
}

type Declaration_BrandParameter capnp.Struct

// Declaration_BrandParameter_TypeID is the unique identifier for the type Declaration_BrandParameter.
const Declaration_BrandParameter_TypeID = 0xd5e71144af1ce175

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

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

func ReadRootDeclaration_BrandParameter(msg *capnp.Message) (Declaration_BrandParameter, error) {
	root, err := msg.Root()
	return Declaration_BrandParameter(root.Struct()), err
}

func (s Declaration_BrandParameter) String() string {
	str, _ := text.Marshal(0xd5e71144af1ce175, capnp.Struct(s))
	return str
}

func (s Declaration_BrandParameter) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr {
	return capnp.Struct(s).EncodeAsPtr(seg)
}

func (Declaration_BrandParameter) DecodeFromPtr(p capnp.Ptr) Declaration_BrandParameter {
	return Declaration_BrandParameter(capnp.Struct{}.DecodeFromPtr(p))
}

func (s Declaration_BrandParameter) ToPtr() capnp.Ptr {
	return capnp.Struct(s).ToPtr()
}
func (s Declaration_BrandParameter) IsValid() bool {
	return capnp.Struct(s).IsValid()
}

func (s Declaration_BrandParameter) Message() *capnp.Message {
	return capnp.Struct(s).Message()
}

func (s Declaration_BrandParameter) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Declaration_BrandParameter) Name() (string, error) {
	p, err := capnp.Struct(s).Ptr(0)
	return p.Text(), err
}

func (s Declaration_BrandParameter) HasName() bool {
	return capnp.Struct(s).HasPtr(0)
}

func (s Declaration_BrandParameter) NameBytes() ([]byte, error) {
	p, err := capnp.Struct(s).Ptr(0)
	return p.TextBytes(), err
}

func (s Declaration_BrandParameter) SetName(v string) error {
	return capnp.Struct(s).SetText(0, v)
}

func (s Declaration_BrandParameter) StartByte() uint32 {
	return capnp.Struct(s).Uint32(0)
}

func (s Declaration_BrandParameter) SetStartByte(v uint32) {
	capnp.Struct(s).SetUint32(0, v)
}

func (s Declaration_BrandParameter) EndByte() uint32 {
	return capnp.Struct(s).Uint32(4)
}

func (s Declaration_BrandParameter) SetEndByte(v uint32) {
	capnp.Struct(s).SetUint32(4, v)
}

// Declaration_BrandParameter_List is a list of Declaration_BrandParameter.
type Declaration_BrandParameter_List = capnp.StructList[Declaration_BrandParameter]

// NewDeclaration_BrandParameter creates a new list of Declaration_BrandParameter.
func NewDeclaration_BrandParameter_List(s *capnp.Segment, sz int32) (Declaration_BrandParameter_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 1}, sz)
	return capnp.StructList[Declaration_BrandParameter](l), err
}

// Declaration_BrandParameter_Future is a wrapper for a Declaration_BrandParameter promised by a client call.
type Declaration_BrandParameter_Future struct{ *capnp.Future }

func (f Declaration_BrandParameter_Future) Struct() (Declaration_BrandParameter, error) {
	p, err := f.Future.Ptr()
	return Declaration_BrandParameter(p.Struct()), err
}

type Declaration_AnnotationApplication capnp.Struct
type Declaration_AnnotationApplication_value Declaration_AnnotationApplication
type Declaration_AnnotationApplication_value_Which uint16

const (
	Declaration_AnnotationApplication_value_Which_none       Declaration_AnnotationApplication_value_Which = 0
	Declaration_AnnotationApplication_value_Which_expression Declaration_AnnotationApplication_value_Which = 1
)

func (w Declaration_AnnotationApplication_value_Which) String() string {
	const s = "noneexpression"
	switch w {
	case Declaration_AnnotationApplication_value_Which_none:
		return s[0:4]
	case Declaration_AnnotationApplication_value_Which_expression:
		return s[4:14]

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

// Declaration_AnnotationApplication_TypeID is the unique identifier for the type Declaration_AnnotationApplication.
const Declaration_AnnotationApplication_TypeID = 0xd00489d473826290

func NewDeclaration_AnnotationApplication(s *capnp.Segment) (Declaration_AnnotationApplication, error) {
	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 2})
	return Declaration_AnnotationApplication(st), err
}

func NewRootDeclaration_AnnotationApplication(s *capnp.Segment) (Declaration_AnnotationApplication, error) {
	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 8, PointerCount: 2})
	return Declaration_AnnotationApplication(st), err
}

func ReadRootDeclaration_AnnotationApplication(msg *capnp.Message) (Declaration_AnnotationApplication, error) {
	root, err := msg.Root()
	return Declaration_AnnotationApplication(root.Struct()), err
}

func (s Declaration_AnnotationApplication) String() string {
	str, _ := text.Marshal(0xd00489d473826290, capnp.Struct(s))
	return str
}

func (s Declaration_AnnotationApplication) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr {
	return capnp.Struct(s).EncodeAsPtr(seg)
}

func (Declaration_AnnotationApplication) DecodeFromPtr(p capnp.Ptr) Declaration_AnnotationApplication {
	return Declaration_AnnotationApplication(capnp.Struct{}.DecodeFromPtr(p))
}

func (s Declaration_AnnotationApplication) ToPtr() capnp.Ptr {
	return capnp.Struct(s).ToPtr()
}
func (s Declaration_AnnotationApplication) IsValid() bool {
	return capnp.Struct(s).IsValid()
}

func (s Declaration_AnnotationApplication) Message() *capnp.Message {
	return capnp.Struct(s).Message()
}

func (s Declaration_AnnotationApplication) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Declaration_AnnotationApplication) Name() (Expression, error) {
	p, err := capnp.Struct(s).Ptr(0)
	return Expression(p.Struct()), err
}

func (s Declaration_AnnotationApplication) HasName() bool {
	return capnp.Struct(s).HasPtr(0)
}

func (s Declaration_AnnotationApplication) SetName(v Expression) error {
	return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr())
}

// NewName sets the name field to a newly
// allocated Expression struct, preferring placement in s's segment.
func (s Declaration_AnnotationApplication) NewName() (Expression, error) {
	ss, err := NewExpression(capnp.Struct(s).Segment())
	if err != nil {
		return Expression{}, err
	}
	err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr())
	return ss, err
}

func (s Declaration_AnnotationApplication) Value() Declaration_AnnotationApplication_value {
	return Declaration_AnnotationApplication_value(s)
}

func (s Declaration_AnnotationApplication_value) Which() Declaration_AnnotationApplication_value_Which {
	return Declaration_AnnotationApplication_value_Which(capnp.Struct(s).Uint16(0))
}
func (s Declaration_AnnotationApplication_value) IsValid() bool {
	return capnp.Struct(s).IsValid()
}

func (s Declaration_AnnotationApplication_value) Message() *capnp.Message {
	return capnp.Struct(s).Message()
}

func (s Declaration_AnnotationApplication_value) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Declaration_AnnotationApplication_value) SetNone() {
	capnp.Struct(s).SetUint16(0, 0)

}

func (s Declaration_AnnotationApplication_value) Expression() (Expression, error) {
	if capnp.Struct(s).Uint16(0) != 1 {
		panic("Which() != expression")
	}
	p, err := capnp.Struct(s).Ptr(1)
	return Expression(p.Struct()), err
}

func (s Declaration_AnnotationApplication_value) HasExpression() bool {
	if capnp.Struct(s).Uint16(0) != 1 {
		return false
	}
	return capnp.Struct(s).HasPtr(1)
}

func (s Declaration_AnnotationApplication_value) SetExpression(v Expression) error {
	capnp.Struct(s).SetUint16(0, 1)
	return capnp.Struct(s).SetPtr(1, capnp.Struct(v).ToPtr())
}

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

// Declaration_AnnotationApplication_List is a list of Declaration_AnnotationApplication.
type Declaration_AnnotationApplication_List = capnp.StructList[Declaration_AnnotationApplication]

// NewDeclaration_AnnotationApplication creates a new list of Declaration_AnnotationApplication.
func NewDeclaration_AnnotationApplication_List(s *capnp.Segment, sz int32) (Declaration_AnnotationApplication_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 8, PointerCount: 2}, sz)
	return capnp.StructList[Declaration_AnnotationApplication](l), err
}

// Declaration_AnnotationApplication_Future is a wrapper for a Declaration_AnnotationApplication promised by a client call.
type Declaration_AnnotationApplication_Future struct{ *capnp.Future }

func (f Declaration_AnnotationApplication_Future) Struct() (Declaration_AnnotationApplication, error) {
	p, err := f.Future.Ptr()
	return Declaration_AnnotationApplication(p.Struct()), err
}
func (p Declaration_AnnotationApplication_Future) Name() Expression_Future {
	return Expression_Future{Future: p.Future.Field(0, nil)}
}
func (p Declaration_AnnotationApplication_Future) Value() Declaration_AnnotationApplication_value_Future {
	return Declaration_AnnotationApplication_value_Future{p.Future}
}

// Declaration_AnnotationApplication_value_Future is a wrapper for a Declaration_AnnotationApplication_value promised by a client call.
type Declaration_AnnotationApplication_value_Future struct{ *capnp.Future }

func (f Declaration_AnnotationApplication_value_Future) Struct() (Declaration_AnnotationApplication_value, error) {
	p, err := f.Future.Ptr()
	return Declaration_AnnotationApplication_value(p.Struct()), err
}
func (p Declaration_AnnotationApplication_value_Future) Expression() Expression_Future {
	return Expression_Future{Future: p.Future.Field(1, nil)}
}

type Declaration_ParamList capnp.Struct
type Declaration_ParamList_Which uint16

const (
	Declaration_ParamList_Which_namedList Declaration_ParamList_Which = 0
	Declaration_ParamList_Which_type      Declaration_ParamList_Which = 1
	Declaration_ParamList_Which_stream    Declaration_ParamList_Which = 2
)

func (w Declaration_ParamList_Which) String() string {
	const s = "namedListtypestream"
	switch w {
	case Declaration_ParamList_Which_namedList:
		return s[0:9]
	case Declaration_ParamList_Which_type:
		return s[9:13]
	case Declaration_ParamList_Which_stream:
		return s[13:19]

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

// Declaration_ParamList_TypeID is the unique identifier for the type Declaration_ParamList.
const Declaration_ParamList_TypeID = 0xb3f66e7a79d81bcd

func NewDeclaration_ParamList(s *capnp.Segment) (Declaration_ParamList, error) {
	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 16, PointerCount: 1})
	return Declaration_ParamList(st), err
}

func NewRootDeclaration_ParamList(s *capnp.Segment) (Declaration_ParamList, error) {
	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 16, PointerCount: 1})
	return Declaration_ParamList(st), err
}

func ReadRootDeclaration_ParamList(msg *capnp.Message) (Declaration_ParamList, error) {
	root, err := msg.Root()
	return Declaration_ParamList(root.Struct()), err
}

func (s Declaration_ParamList) String() string {
	str, _ := text.Marshal(0xb3f66e7a79d81bcd, capnp.Struct(s))
	return str
}

func (s Declaration_ParamList) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr {
	return capnp.Struct(s).EncodeAsPtr(seg)
}

func (Declaration_ParamList) DecodeFromPtr(p capnp.Ptr) Declaration_ParamList {
	return Declaration_ParamList(capnp.Struct{}.DecodeFromPtr(p))
}

func (s Declaration_ParamList) ToPtr() capnp.Ptr {
	return capnp.Struct(s).ToPtr()
}

func (s Declaration_ParamList) Which() Declaration_ParamList_Which {
	return Declaration_ParamList_Which(capnp.Struct(s).Uint16(0))
}
func (s Declaration_ParamList) IsValid() bool {
	return capnp.Struct(s).IsValid()
}

func (s Declaration_ParamList) Message() *capnp.Message {
	return capnp.Struct(s).Message()
}

func (s Declaration_ParamList) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Declaration_ParamList) NamedList() (Declaration_Param_List, error) {
	if capnp.Struct(s).Uint16(0) != 0 {
		panic("Which() != namedList")
	}
	p, err := capnp.Struct(s).Ptr(0)
	return Declaration_Param_List(p.List()), err
}

func (s Declaration_ParamList) HasNamedList() bool {
	if capnp.Struct(s).Uint16(0) != 0 {
		return false
	}
	return capnp.Struct(s).HasPtr(0)
}

func (s Declaration_ParamList) SetNamedList(v Declaration_Param_List) error {
	capnp.Struct(s).SetUint16(0, 0)
	return capnp.Struct(s).SetPtr(0, v.ToPtr())
}

// NewNamedList sets the namedList field to a newly
// allocated Declaration_Param_List, preferring placement in s's segment.
func (s Declaration_ParamList) NewNamedList(n int32) (Declaration_Param_List, error) {
	capnp.Struct(s).SetUint16(0, 0)
	l, err := NewDeclaration_Param_List(capnp.Struct(s).Segment(), n)
	if err != nil {
		return Declaration_Param_List{}, err
	}
	err = capnp.Struct(s).SetPtr(0, l.ToPtr())
	return l, err
}
func (s Declaration_ParamList) Type() (Expression, error) {
	if capnp.Struct(s).Uint16(0) != 1 {
		panic("Which() != type")
	}
	p, err := capnp.Struct(s).Ptr(0)
	return Expression(p.Struct()), err
}

func (s Declaration_ParamList) HasType() bool {
	if capnp.Struct(s).Uint16(0) != 1 {
		return false
	}
	return capnp.Struct(s).HasPtr(0)
}

func (s Declaration_ParamList) SetType(v Expression) error {
	capnp.Struct(s).SetUint16(0, 1)
	return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr())
}

// NewType sets the type field to a newly
// allocated Expression struct, preferring placement in s's segment.
func (s Declaration_ParamList) NewType() (Expression, error) {
	capnp.Struct(s).SetUint16(0, 1)
	ss, err := NewExpression(capnp.Struct(s).Segment())
	if err != nil {
		return Expression{}, err
	}
	err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr())
	return ss, err
}

func (s Declaration_ParamList) SetStream() {
	capnp.Struct(s).SetUint16(0, 2)

}

func (s Declaration_ParamList) StartByte() uint32 {
	return capnp.Struct(s).Uint32(4)
}

func (s Declaration_ParamList) SetStartByte(v uint32) {
	capnp.Struct(s).SetUint32(4, v)
}

func (s Declaration_ParamList) EndByte() uint32 {
	return capnp.Struct(s).Uint32(8)
}

func (s Declaration_ParamList) SetEndByte(v uint32) {
	capnp.Struct(s).SetUint32(8, v)
}

// Declaration_ParamList_List is a list of Declaration_ParamList.
type Declaration_ParamList_List = capnp.StructList[Declaration_ParamList]

// NewDeclaration_ParamList creates a new list of Declaration_ParamList.
func NewDeclaration_ParamList_List(s *capnp.Segment, sz int32) (Declaration_ParamList_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 16, PointerCount: 1}, sz)
	return capnp.StructList[Declaration_ParamList](l), err
}

// Declaration_ParamList_Future is a wrapper for a Declaration_ParamList promised by a client call.
type Declaration_ParamList_Future struct{ *capnp.Future }

func (f Declaration_ParamList_Future) Struct() (Declaration_ParamList, error) {
	p, err := f.Future.Ptr()
	return Declaration_ParamList(p.Struct()), err
}
func (p Declaration_ParamList_Future) Type() Expression_Future {
	return Expression_Future{Future: p.Future.Field(0, nil)}
}

type Declaration_Param capnp.Struct
type Declaration_Param_defaultValue Declaration_Param
type Declaration_Param_defaultValue_Which uint16

const (
	Declaration_Param_defaultValue_Which_none  Declaration_Param_defaultValue_Which = 0
	Declaration_Param_defaultValue_Which_value Declaration_Param_defaultValue_Which = 1
)

func (w Declaration_Param_defaultValue_Which) String() string {
	const s = "nonevalue"
	switch w {
	case Declaration_Param_defaultValue_Which_none:
		return s[0:4]
	case Declaration_Param_defaultValue_Which_value:
		return s[4:9]

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

// Declaration_Param_TypeID is the unique identifier for the type Declaration_Param.
const Declaration_Param_TypeID = 0xfffe08a9a697d2a5

func NewDeclaration_Param(s *capnp.Segment) (Declaration_Param, error) {
	st, err := capnp.NewStruct(s, capnp.ObjectSize{DataSize: 16, PointerCount: 4})
	return Declaration_Param(st), err
}

func NewRootDeclaration_Param(s *capnp.Segment) (Declaration_Param, error) {
	st, err := capnp.NewRootStruct(s, capnp.ObjectSize{DataSize: 16, PointerCount: 4})
	return Declaration_Param(st), err
}

func ReadRootDeclaration_Param(msg *capnp.Message) (Declaration_Param, error) {
	root, err := msg.Root()
	return Declaration_Param(root.Struct()), err
}

func (s Declaration_Param) String() string {
	str, _ := text.Marshal(0xfffe08a9a697d2a5, capnp.Struct(s))
	return str
}

func (s Declaration_Param) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr {
	return capnp.Struct(s).EncodeAsPtr(seg)
}

func (Declaration_Param) DecodeFromPtr(p capnp.Ptr) Declaration_Param {
	return Declaration_Param(capnp.Struct{}.DecodeFromPtr(p))
}

func (s Declaration_Param) ToPtr() capnp.Ptr {
	return capnp.Struct(s).ToPtr()
}
func (s Declaration_Param) IsValid() bool {
	return capnp.Struct(s).IsValid()
}

func (s Declaration_Param) Message() *capnp.Message {
	return capnp.Struct(s).Message()
}

func (s Declaration_Param) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Declaration_Param) Name() (LocatedText, error) {
	p, err := capnp.Struct(s).Ptr(0)
	return LocatedText(p.Struct()), err
}

func (s Declaration_Param) HasName() bool {
	return capnp.Struct(s).HasPtr(0)
}

func (s Declaration_Param) SetName(v LocatedText) error {
	return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr())
}

// NewName sets the name field to a newly
// allocated LocatedText struct, preferring placement in s's segment.
func (s Declaration_Param) NewName() (LocatedText, error) {
	ss, err := NewLocatedText(capnp.Struct(s).Segment())
	if err != nil {
		return LocatedText{}, err
	}
	err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr())
	return ss, err
}

func (s Declaration_Param) Type() (Expression, error) {
	p, err := capnp.Struct(s).Ptr(1)
	return Expression(p.Struct()), err
}

func (s Declaration_Param) HasType() bool {
	return capnp.Struct(s).HasPtr(1)
}

func (s Declaration_Param) SetType(v Expression) error {
	return capnp.Struct(s).SetPtr(1, capnp.Struct(v).ToPtr())
}

// NewType sets the type field to a newly
// allocated Expression struct, preferring placement in s's segment.
func (s Declaration_Param) NewType() (Expression, error) {
	ss, err := NewExpression(capnp.Struct(s).Segment())
	if err != nil {
		return Expression{}, err
	}
	err = capnp.Struct(s).SetPtr(1, capnp.Struct(ss).ToPtr())
	return ss, err
}

func (s Declaration_Param) Annotations() (Declaration_AnnotationApplication_List, error) {
	p, err := capnp.Struct(s).Ptr(2)
	return Declaration_AnnotationApplication_List(p.List()), err
}

func (s Declaration_Param) HasAnnotations() bool {
	return capnp.Struct(s).HasPtr(2)
}

func (s Declaration_Param) SetAnnotations(v Declaration_AnnotationApplication_List) error {
	return capnp.Struct(s).SetPtr(2, v.ToPtr())
}

// NewAnnotations sets the annotations field to a newly
// allocated Declaration_AnnotationApplication_List, preferring placement in s's segment.
func (s Declaration_Param) NewAnnotations(n int32) (Declaration_AnnotationApplication_List, error) {
	l, err := NewDeclaration_AnnotationApplication_List(capnp.Struct(s).Segment(), n)
	if err != nil {
		return Declaration_AnnotationApplication_List{}, err
	}
	err = capnp.Struct(s).SetPtr(2, l.ToPtr())
	return l, err
}
func (s Declaration_Param) DefaultValue() Declaration_Param_defaultValue {
	return Declaration_Param_defaultValue(s)
}

func (s Declaration_Param_defaultValue) Which() Declaration_Param_defaultValue_Which {
	return Declaration_Param_defaultValue_Which(capnp.Struct(s).Uint16(0))
}
func (s Declaration_Param_defaultValue) IsValid() bool {
	return capnp.Struct(s).IsValid()
}

func (s Declaration_Param_defaultValue) Message() *capnp.Message {
	return capnp.Struct(s).Message()
}

func (s Declaration_Param_defaultValue) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Declaration_Param_defaultValue) SetNone() {
	capnp.Struct(s).SetUint16(0, 0)

}

func (s Declaration_Param_defaultValue) Value() (Expression, error) {
	if capnp.Struct(s).Uint16(0) != 1 {
		panic("Which() != value")
	}
	p, err := capnp.Struct(s).Ptr(3)
	return Expression(p.Struct()), err
}

func (s Declaration_Param_defaultValue) HasValue() bool {
	if capnp.Struct(s).Uint16(0) != 1 {
		return false
	}
	return capnp.Struct(s).HasPtr(3)
}

func (s Declaration_Param_defaultValue) SetValue(v Expression) error {
	capnp.Struct(s).SetUint16(0, 1)
	return capnp.Struct(s).SetPtr(3, capnp.Struct(v).ToPtr())
}

// NewValue sets the value field to a newly
// allocated Expression struct, preferring placement in s's segment.
func (s Declaration_Param_defaultValue) NewValue() (Expression, error) {
	capnp.Struct(s).SetUint16(0, 1)
	ss, err := NewExpression(capnp.Struct(s).Segment())
	if err != nil {
		return Expression{}, err
	}
	err = capnp.Struct(s).SetPtr(3, capnp.Struct(ss).ToPtr())
	return ss, err
}

func (s Declaration_Param) StartByte() uint32 {
	return capnp.Struct(s).Uint32(4)
}

func (s Declaration_Param) SetStartByte(v uint32) {
	capnp.Struct(s).SetUint32(4, v)
}

func (s Declaration_Param) EndByte() uint32 {
	return capnp.Struct(s).Uint32(8)
}

func (s Declaration_Param) SetEndByte(v uint32) {
	capnp.Struct(s).SetUint32(8, v)
}

// Declaration_Param_List is a list of Declaration_Param.
type Declaration_Param_List = capnp.StructList[Declaration_Param]

// NewDeclaration_Param creates a new list of Declaration_Param.
func NewDeclaration_Param_List(s *capnp.Segment, sz int32) (Declaration_Param_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 16, PointerCount: 4}, sz)
	return capnp.StructList[Declaration_Param](l), err
}

// Declaration_Param_Future is a wrapper for a Declaration_Param promised by a client call.
type Declaration_Param_Future struct{ *capnp.Future }

func (f Declaration_Param_Future) Struct() (Declaration_Param, error) {
	p, err := f.Future.Ptr()
	return Declaration_Param(p.Struct()), err
}
func (p Declaration_Param_Future) Name() LocatedText_Future {
	return LocatedText_Future{Future: p.Future.Field(0, nil)}
}
func (p Declaration_Param_Future) Type() Expression_Future {
	return Expression_Future{Future: p.Future.Field(1, nil)}
}
func (p Declaration_Param_Future) DefaultValue() Declaration_Param_defaultValue_Future {
	return Declaration_Param_defaultValue_Future{p.Future}
}

// Declaration_Param_defaultValue_Future is a wrapper for a Declaration_Param_defaultValue promised by a client call.
type Declaration_Param_defaultValue_Future struct{ *capnp.Future }

func (f Declaration_Param_defaultValue_Future) Struct() (Declaration_Param_defaultValue, error) {
	p, err := f.Future.Ptr()
	return Declaration_Param_defaultValue(p.Struct()), err
}
func (p Declaration_Param_defaultValue_Future) Value() Expression_Future {
	return Expression_Future{Future: p.Future.Field(3, nil)}
}

type ParsedFile capnp.Struct

// ParsedFile_TypeID is the unique identifier for the type ParsedFile.
const ParsedFile_TypeID = 0x84e4f3f5a807605c

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

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

func ReadRootParsedFile(msg *capnp.Message) (ParsedFile, error) {
	root, err := msg.Root()
	return ParsedFile(root.Struct()), err
}

func (s ParsedFile) String() string {
	str, _ := text.Marshal(0x84e4f3f5a807605c, capnp.Struct(s))
	return str
}

func (s ParsedFile) EncodeAsPtr(seg *capnp.Segment) capnp.Ptr {
	return capnp.Struct(s).EncodeAsPtr(seg)
}

func (ParsedFile) DecodeFromPtr(p capnp.Ptr) ParsedFile {
	return ParsedFile(capnp.Struct{}.DecodeFromPtr(p))
}

func (s ParsedFile) ToPtr() capnp.Ptr {
	return capnp.Struct(s).ToPtr()
}
func (s ParsedFile) IsValid() bool {
	return capnp.Struct(s).IsValid()
}

func (s ParsedFile) Message() *capnp.Message {
	return capnp.Struct(s).Message()
}

func (s ParsedFile) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s ParsedFile) Root() (Declaration, error) {
	p, err := capnp.Struct(s).Ptr(0)
	return Declaration(p.Struct()), err
}

func (s ParsedFile) HasRoot() bool {
	return capnp.Struct(s).HasPtr(0)
}

func (s ParsedFile) SetRoot(v Declaration) error {
	return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr())
}

// NewRoot sets the root field to a newly
// allocated Declaration struct, preferring placement in s's segment.
func (s ParsedFile) NewRoot() (Declaration, error) {
	ss, err := NewDeclaration(capnp.Struct(s).Segment())
	if err != nil {
		return Declaration{}, err
	}
	err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr())
	return ss, err
}

// ParsedFile_List is a list of ParsedFile.
type ParsedFile_List = capnp.StructList[ParsedFile]

// NewParsedFile creates a new list of ParsedFile.
func NewParsedFile_List(s *capnp.Segment, sz int32) (ParsedFile_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 1}, sz)
	return capnp.StructList[ParsedFile](l), err
}

// ParsedFile_Future is a wrapper for a ParsedFile promised by a client call.
type ParsedFile_Future struct{ *capnp.Future }

func (f ParsedFile_Future) Struct() (ParsedFile, error) {
	p, err := f.Future.Ptr()
	return ParsedFile(p.Struct()), err
}
func (p ParsedFile_Future) Root() Declaration_Future {
	return Declaration_Future{Future: p.Future.Field(0, nil)}
}

const schema_c56be168dcbbc3c6 = "x\xda\xacY}pT\xd7u?\xe7\xbe\xb7\xfb\xf4\xb5" +
	"\xac\x9e\xdf\x13 !\xb1\x12\x1f\x0eP\xa4 \x09\x08\xa8" +
	"\xe9\x08\xc9\x08#\x06R=\x16\x1c\xcc\xb83<i\x9f" +
	"\xc4\x13\xbbo\xb7\xbbo\x13\xc4@\x95\xbadbw\xa0" +
	"\x81\x16\x12\x98\x81\x0et \xa3d\xec\x04\xc7xj&" +
	"d\x06\xb7&\x132\xc9\x84\xba\x89\xa7\xe9\x87)m\x1c" +
	"\x1c\x92&1\xd8.\xfe\x80\xdb9\xf7\xed\xee[\xadV" +
	"\x18\xbb\xf1?\xde\xfd\xfd\xae\xce={\xee\xb9\xbfs\xce" +
	"e\xd9\xee\xca5r{H\xa9\x06f|!\x10\xe4O" +
	"\xecP&\xde\xbe\xfd\xf3\xfd\xa0\xce@\xfe\xbd\x7f\xfc\xce" +
	"\xbf\xef\xbc\xbe\xeb2\x04P\x01\xd0\xec\xc0\x0f\xb4l\x80" +
	">\xfdi\xa0\x1b\x90\x7f\xe5\x9b\xd2K\x99+\xbf{\x1a" +
	"\x8c\x06d\xfc;\x7f\xf1g/}\xe9\xc6o\xbf\x02[" +
	"+\x14\x94\x00\xb4\xc3\x81\x9b\x80\xda\xd1\xc0\xb7\x00\xf9k" +
	"W\xb7\xdc\xdb\xb4\xaf\xf9\xaf\xc0\x98\x81\x92o\xb7\x8f)" +
	"3\x00\xb4\xf6\xe0\x0f\xb4?\x0a\xce\x02\xe8\xec\x0b~I" +
	"\x02\xe4\xdf\xdf\xf6\xfc\x97\x9b\xe7=\xfc\xe5\x12\xcbu\x15" +
	"\x0a\x02t\xaaU\x0c\x01\xb5\xba\xaa\xcf\x03\xf2\x91\xf9w" +
	"w\x07\xbfv\xeb\x10Yf\xbee\x99\xdc|\xbc\xea_" +
	"5\xab\x8a>\x99U\xe4\xc5\xae\xd6\xe7\xff\xb6\xfbD\xe5" +
	"\x110\x1a\x02\xcd\xbeY\xc0\xce\xbbU\xbd\xa8\x85\xaa\x15" +
	"\x80hE\xb5\x84\x80>;\xd9n_\x852\x0fQ\xab" +
	"\xac~E\xab\xab\xfe,@\xa7Y\xfd\xa9J@~k" +
	"\xe9\xab\x7f\xb3rO\xe3\xf1rn\xac\xae\xbb\xa9\xf5\xd5" +
	"\xd1\xa7\x9e:r\xe3\x9fW\xb0\xdb7\x0f-9^\xfe" +
	"\xd7\xfdG\xdd<\xfau\xaf\xd7Q\x88\xc7\xa5c\xed\xce" +
	"\x1b\x17N\x94_Z?s\x09\x02v\xb6\xcc\xbc\xc6\x00" +
	"\xf9\xe3\x9dc\xa15\xd7\x17}\x03\x8cz\x94\xfc\x88\xd7" +
	"1\xb1vS\xbd\x08\x9aQOA\xdbs\xed\xdc\x9a\xd4" +
	"\xea7\xbeY~\xe9\xb3\xf5dV{A,\xad\x09\xfd" +
	"\xf8\xe0\x92\x8e\xf5\xcf\x97\xf7`a\x83\xb0\xba\xb8\x81\x96" +
	"\xfeh\xce\xbf\x8c\xedq\xde)]\xda\x87\x8a\x04\xd0\xf9" +
	"\xc5\x86y\xa8\x1dmP\x00:\x0f7D(\xc4\x19\xe3" +
	"\xd5\xc1}\x07\xe6\x7f\x0f\x8c\x16d\xfc\xc2\xa5Y\xaf>" +
	":\xfb\xab\xbf\x12\xf9\xc30\xd8ya\xce\x06\xb2}y" +
	"\x0e\xd9\xfe\xc6\xbf\xbd\xd6\xf0\xf7\xeb\xd8\x15\xf2\xb8(\x9d" +
	"\xfa\x98\xc2\x00\xb4\x85\x8d\xefi\xed\x8d\x14\xe1\xd6F\x8a" +
	"\xf0\xa1\xc1'3?yZ\xbeJ\x9e\x14\x1de\x80\xd1" +
	"\xee\x97\x1b\x9fD\xedgb\xf5O\x1b\xc9v\xe4\xe8\xac" +
	"_4\xfd\xdd?]\x05\xa3\x19\x99\x9f{y?\xea\x9a" +
	"F\xc9\x8f\x96&Z\x9b\xbd\xde\xf8\xad\xb5\xea\x8d\x9f\x96" +
	"Z\xa6\x0b\xd2\xb9\xafi\x03j\x87\x9b\xc8\xf2\xc1&\xf2" +
	"\xe3\xd1\x9bO\xdd\xad\xeb\xab}\xdd\xb3|\xf6\x95\xaf~" +
	"\xed\xeb\x15\xf78l\x95\x15d\x00\x9d\x8b\xe7\x0a\xcb+" +
	"\xe6\x92\xe5\xd8O\x16[/\xcc\xdcv\x832h\xca\xd5" +
	";<\xf7\x15\xed\xe4\\\xfat|.\x19\xfe\xf1\xd2{" +
	"\xd5\x13\xb1\xf6_\x96?\x95\x15\x11q*\xab#\x94B" +
	"\x85\xb8\x96]\xfax\xa4\x8a\x96\x9a\x11r\xe1\xdd\xd1k" +
	"O\xfc\xec7\xdb\xdf\x07c\x19\x16\x05q+\xf3\xdc=" +
	"\x1d\xf96\xad}N\xac-\xfc\x98\xc9f\x03\x94\xf1\x9d" +
	"j3C\xad\xa9\x99>\xd67\x7f\x16\xe13|$m" +
	"&\x12f\xba\x8d\x0d\x99)'\xd55`\xa63Vl" +
	"\x9d\x1d\xb7\x00\x06\x10\x0dY\x92\x01d\x04PCK\x00" +
	"\x8c\x0a\x09\x0d\x9da8\x9dL\xbaX[|S\xb1\x96" +
	"\xee\xfcdck\xad\xa1\xb8\x996];\x19v\xda\xec" +
	"\x98Q#\xc95\x9c\xebH\xe6\xfa\x06\x01\x8c\xb5\x12\x1a" +
	"\x03\x0c\x9b\xf0\x1eG\x9d~\x8a\xbai\x1e\x80\xb1^B" +
	"c\x0b\xc3&v\x97`\x09@5z\x01\x8c\x8d\x12\x1a" +
	"\xdb\x18\xf2\xac\x93IYC\xf60(\xb6\x15\x83\xa0\x92" +
	"\xb5cX\xeb_t\xcf\x97\xf1d:f;f|*" +
	"S\xeae\xdf\xeeT\xda\xcad\xec\xa4\x03`\xc8X\x94" +
	"\xd2*vD\x06\xcc\xb4\x990\xd6\x08\xcf)\x0e\xdas" +
	"\xd8\x0b\x10}\x06%\x8c\xbe\x88\x05\xdf\x89y\x01\x07\x01" +
	"\xa2\xe7\x89\xb9\x84\x05\xf7\xe9\x1a|W0\x17\x89\xf9>" +
	"1\xd2\x07\xb9\x1f\xa6]\xc6\x0e\x80\xe8%b~\x88\x0c" +
	"C\xf2\xfb\\G\x19@\xbb\x82]\xda\x15\x8cD\x7fM" +
	"\xd4\x1d\xa2\x82\xefq\x1d\x03\x00\xda\xdb8\x0a\x10}\x0b" +
	"%\xdc\xcc\x18\x86\xaa\xde\xe5:\x06\x01\xb4\xbb\xb8\x04 " +
	"z\x87\xfe@'\xa2\xfa\x0e\xd7E\x92\xaa\x8c6\xa9a" +
	"\x12F\x171\x86\xea\x0c\xd4\xb1\x82n'\xdb\x0c\x10]" +
	"@\xf82\xc2\xc3\xb2\x8e\x95tW\x19\xfd\xc4E\x84/" +
	"'C\x81\xff\xe5:VQ=`]\x00\xd1\xa5D\xac" +
	"\"\xa2\xe6\x1d\x8eE\xa2\xa5\xad`\x83\xc0B\xa1\xb7\x09" +
	"-\xa8\x9e\xd6\xc2\xba\x80\x85\x94\xb7\xb8\x8ea\x00\xad\x92" +
	"\x91\xfb\x15,\xeff\xc5m\xaec\xadp\xb3+\xef\xe6" +
	"l\"*oq\x1dU\x00\xadN\xf8_KD#c" +
	"8\x9euv9\xc9\xcf;\x10\xe4\xa9d\xc6v\xed\xcf" +
	"Y\xa0\xf4;.V\x02C\xd2|\xc7\x1a1\xa7\xa0\x91" +
	"\xe1x\xd2t\xb1\x1a\x18V\x03vg\xdc\xb4\xed\x8c\x18" +
	"22\xfe\xe6\xc1O\xcezh\xc7\x85\x7f\x00Cf\xd8" +
	"\xa3#\xd6\x00\xa88\xc8\xbd%\x8f\x99\xa0\xc4\xb3\x16\x00" +
	"\xd6\x00\xc3\x1a@\x9e\xb6\xe2\x9e\xf9\xf0g\xcc\x84\x85\xb5" +
	"\xbeBx\x09\x16\x8e\xdb\x19\x17g\x00\x0eH\x88\xb5\xbe" +
	"&\x02\x12\x18q\xb3\xa9\xb8\xe5\xd3\x85l\xf3h\x9eq" +
	"\xcd\xb4\xdb;\xe6\x02ZX\x01\x0c+\x00\xc7-'\xd6" +
	";\xe6\x16\xbew\x0f\xda\x8e\x99\x1e\xc3\x100\x0c\x01r" +
	"3\x95\x8a\xdbC\xa6\x0b\x8a\x9dt\xba\x13Vb\xd0J" +
	"ss0\x93\x8cg\xddi\xbd\xec\xb6\x13\xa9d\xda\x9d" +
	"JD\xe8\xefcS\xf1\xc2\xbd\x91Jo\xb7\xd36l" +
	"[\xf1\x18\xc9\x83\\\x1b\x10\x87\xa9.&\xb9X \xa1" +
	"\xb1\x8c!\xfd\xe7\x8b\xb9\xda:\x0a,\xec\x8e\xa5\xac\x92" +
	"\xe0\xd0\x1e1k\xd8\xcc\xc6\xdd\xc7 l\xc6\xb3V\xe9" +
	"U\xdd\x98\x1c2]+\xb6.\x9e\x94L\x97\xe4\xa9\xa6" +
	" O}\x1d\x00\xc6\x1a\x09\x8d\x8d\x0cUd\x9e\xc8\xf4" +
	"o\xf6\xd5De\x92'1\xc5Z\x12\xf9\x1cm\x93O" +
	"\x8a\x07\x89}\xc1%yj\x14\x06\xb3v\xdc\xb5\x1d!" +
	"\x19\x19\x92O\xff\x94\x0b\xe5\xe9~*\x89\x8e\xa1cQ" +
	")S[\xf6\xf8b\xaf\xb6|\xdb\xef\x93\xd4\x85i\xbf" +
	"\xaa\xab\x0b7\xfb\xaa\xaf.\xec\xe0\xbdi\xd3\x89\x0d\x98" +
	"i\xe86\x13\x96k\xa5y\x8f\xe3$]\xd3\xb51\xe9" +
	"\xf4\x88\\\x89\x08\x87y\xdea\x88\x08\x97\xb9\xf0|\xa3" +
	"\x9d\x01ts\xc27\x91\x0f\xb0\xf6\xb4L\xea\xb2_\x96" +
	"0zH\xce\x9di\xa1\xd1\xd4\x0e\xca\x0d\xc0T\x89y" +
	"\xe2\x95\x95I\xef\xdc\xfcZU\x96<\xe5:(\xf0\x03" +
	"\x84O\x10\x1e@O\xb9\xce\xca$Dg\x08?Gx" +
	"\x90y\xc2\xf5\xacLB4A\xf8y\xc2\x15\xd9\x13\xae" +
	"\xe7\xe4\xed\x00\xd1s\x84_\x94IB\xa8\xaa\x90r]" +
	"\x10N\x9e'\xe2\x12\x11\x95\xf7H\x8a\x0aEY\xfb\xae" +
	"\xdc\x01,Tu\x97\xd0B\x03\xa5\x9d\x15h\xf5\x07\\" +
	"\xc7\x90\xf0\x92\x8c<EF\x8e\x90\x91\x1a\xd2dj\x87" +
	"\x0f\x0b7\x0f\x11q\x82\x88\xd0{9I;.\x93r" +
	"\x1d!\xe2\x14\x113\xde\xa5\x0d\x0a\x0d\x8bvRl\x10" +
	"&=\xd6\x00\xb4/\xca\xa4g_\xa0\xe5\x07hy-" +
	"\xe9\xab.b\xdcQ\x1c\xe3\x90*\xf4\xb5\xd0\x96j\x07" +
	"\xe5\xcd\xc0B\x0f\x09}-\xb4\x0f\xda\x98L\xfa\xaa\xbd" +
	"Eh\xa1/\xd5Ly;\xb0&\xfd6\x0f\xe8\xf80" +
	"\x80\xb6I\xc4r=\xd9\xde\"3l\xaa\xbbE\xcc'" +
	"\x004C~\x12 :@\xcc\x13\xb4\xeb\xcc7\xb9\x8e" +
	"\x8b\xa8M\x17\xc7\xb5\x8d\x88\x18\x11\xb3~\xc7u\\L" +
	"]\xbb v\x10\x11'b\xf6o\xb9N\xc5G\xb3\x05" +
	"\xb1\x93\x08\x97\x88\xfa\xdfp\x1d\xff\x80\x06\x13\x99D?" +
	"E\xc4^\"\x1a\xfe\x87\xeb\xb8\x14\xc8y\"v\x13\xb1" +
	"\x9f\x889\xbf\xe6:\xb6\x02h\x7f.\x08?H\x8d\xbf" +
	"\xe2:\xb6\x89 \x8dN:\x9e\xa6\x9b\\\xc7O\x8a\xe3" +
	"IO:\x9e\xb9\xbf\xe4:.\x13\xc7C\xc41\"\xce" +
	"\x10\x11y\x83\xeb\xd8\x0e\xa0\x9d\x16\xc4)\"\x9e!\xa2" +
	"\xf9\x06\xd7\xa9 k_\x97\xf7\x14'^\xa8\xe5\x17\\" +
	"\xc7N\x91y{&e\xde\xbc\xd7\xb9\x8e\xcbE\xe6\xd1" +
	"/\x7f\x91\x88\x97\x89\x98\xffs\xae\xe3\x0a\x00\xed%A" +
	"\\\"\xe2\x87D,\xf8o\xae\xe3J\xaa\xf0\xf2\xa0\xf6" +
	"#9\x12\xbdC\x94\x1c`\x18Z\xf8_\\\xc7O\x01" +
	"h\x18H\x03l\x0eH\x18\xad!\xfc\xe1\xeb\\\xc7U" +
	"T:\x03\x7fM\x15\x92\x88\xd9\x01\x924E\xc7\xd5T" +
	" \x03t\x1ft\xc2\x97\xd1\x1f|\xe2?\xb9\x8e]T" +
	"\xc9\x03\x7f\x09\x10]F\xc4\xa7\x89Xt\x8d\xeb\xf8\x87" +
	"4\xfa\x04\xe8w\xac\"b-\x11\x8b_\xe3:~\x9a" +
	"&!\xb1\xc5Z\"\x06\x02\x0c\xc3N\xd9\xe2!\xd91" +
	"\xeeX\x19\xd7\x8a\xad\xb5@\x19\x8ag|\xa5+\xee\x09" +
	"\xa9\x9e\x999\xed\x01%\xe9\x14-+\xe8\xda\x83\x97=" +
	"\x1eK\x0e=\x92L$,\x90\x1c7_\x8d\xc3\xc3\xd4" +
	"\xab\x06#\xd9\x8c\xed\x8cD\x86\x92N\xc6\x0d[N6" +
	"\x01AN\xff\xb3\xd2\xa6\x03\xe8B\x90\x0a~v\xc8\x85" +
	"`D\xd4\xaaH\xd6\xa1\x86/\x18\x19I'\xb3)\x08" +
	"r\xdbq\xad\xf4\xb09\x04hu',wg2\xe6" +
	"{.%\x9dq\xc7\xdce\xc5\xfa\xcb4\x9a\\0=" +
	"\x8e\x83bq\xd2\x81\x92_GkrB\xfb\x18(I" +
	";\x06\xc1\xfc\xf7^P\x92\xc9\xb8\xff\xbd\x1f\x14\xc7]" +
	"U\xfc=\xec\xb8\xed+K\x80\xce\x8e\x12`\xe5r\x1f" +
	"\xd8\x0a\xe1\xfeI6\xb6B\xa4\x7f\xb2\x11\x0f)\xb6\xe2" +
	"!\xc5f\xd6A7\xb5K\xc5\x8brP\xf1\xaa-\xa0" +
	"X\xbb]\xff\xfbZPL\xd7\xf4\xbfo\x04\xc5\xce\xb8" +
	"\xa2\xc9\xf2G|j\xb2\x1a\xe9\xd0A\xc5Y\xd4p\xd3" +
	"\x87\xde\xf1\xbe\xb8\x95\xb0\x1c\x17\x94\xfc\x1f\xff1D\x06" +
	"G\xad\xa1\"\xf3=\xe8\x8c\x0d$\xe9\xa40M\xcd\x1f" +
	"U(\xcb\xb5@Jg\xcaVZ\x91XE\x7f\x1b\xf5" +
	"R\xa0\xb0C\x0ft;c\x1b\xedL\xd1\x16\x8f\xa0\x99" +
	"2\x07\xed\xb8\xed\xe2\x18\x04\xa7\xe9?\xfa\x1d7l\x8d" +
	"X\xe9\xdfc\x07\x92o]?J\x07R\xa6\x0f\xf3\xb2" +
	"X1\x87,\x9a\xdc\xa8\x17\xab\xa3\xd1m\x14\xc0\xa8\x91" +
	"\xd0X\xc4\x90g\xb2)+=\x147!\x9c\xc9X\x99" +
	"i\xdb\xd4\xfb\xed\xe2]\x8c0}6\x96{\xdb\xd4\x03" +
	"h\x7f\"\xe6\x8fm4\x7f\xc4\x90b\xb0C\xc7\x06\xaa" +
	"\x16b\xfa\xd9Ax\x9cpf\xea8\x87\x8a\x85\x98c" +
	"v\x12\xee\x12.\x0d\xea\xd8H\xb5B\xacO\x11\xbe\x97" +
	"pyH\xc7&*\x15Hb\xb6\x97\xf0\xa7\x08\x0f\xc4" +
	"t\x9cK\xe5\x14I\xc5\xf7\x13~\x88\xf0\xa0\xa5c\x84" +
	"\xea\xb8\xb0\x7f\x80\xf0c\x84+\xc3:6\x03hG\x05" +
	"~\x84\xf0S\x84W\x8c\xe8\xd8\x02\xa0\x9d\x14\xf8\x09\xc2" +
	"'\x08\xaf\xdc\xa9\xe3<\xeaN\xc4\xbe\x13\x84\x9f'\xbc" +
	"\xca\xd6q\xbe\x98\x04i\xdfs\x84_$\xbczT\xc7" +
	"\x05T\x0a\x84\x9d\x17\x09\x7f\x99\xf0\x9a]:.\xa4J" +
	"\x80$\xad/\x13~\x15\x19N\xd7\x02\xbbfz\xc4r" +
	"3\xeb@\xb1\xe3\x16\"0D\x1f}\x04\xc2$q\xa5" +
	"p\x1f(N61\x05\xc5\x9c\x02\xbad{2\x17\x85" +
	"\x88\xb8\x0d\xa5\xf8:\x08\x93>\x96\xc2[!L\x82Y" +
	"\x0a?\x0aa\xd2\xcfR\xb8\x1fsjjM\xddx\x13" +
	"D\x84\xbc\x96\xe2\x03\x10\xa6\xfb\\\x0a\xf7`N\x85\x93" +
	"\xe8\xef^\x92\x9b\xfe\x04\xdf\xe6\x0d?b\x12\x01\x10\xed" +
	"\x9c\xba\xb8\xcb\x9fDTD\xd1\xca\xa9\xad4\x9e,\x92" +
	"\xd0X\xce\xb0;e\xa6-\xc7\x9dz\x14\xd3\x14\xbf\xfb" +
	"l\x9f\x9b\xc4\xbc\xab\x91\xf3\xa1\x9a|\xd8\xe0o'|" +
	"\xa0\x11\xb3\x9d\x1c[*\xa1\xb1\x9e!\x1f\xce:C\xa2" +
	"z\x00Lu\xa4[H]f\xfa\xa1\xf1>\x97U\x94" +
	"\xc4\xc2hV]2\x9a\xa9\x18\xf4\x9ci\xed\xf0=\x9c" +
	"&3sR55c\xef\xb3\xbb7QP\x15 \xb1" +
	"\xd4\x0b\xcf(\xea>\x12\xc6\xbd\x12\x1a\xc7\x18\x86\xf0^" +
	"\xeeU\xe8(\xb9vHB\xe3\x04\xe9A\xeeM\xe88" +
	"-=&\xa1q\x86\xc4\x80y/B\xa7ICOH" +
	"hL0\x0c\xb1\xbb\xde\xab\x89z\x96BzJB\xe3" +
	"\x19F\x859a\xc5\xbci\xc6\x8f\\aP\xf2\"7" +
	"\xdd%|\x90)<\xe3\xa6-3QT%\xca\x8c\x84" +
	"^+\xd1\x96\xb62\xd9\xb8\x9b\x11/h\xde\x1b\xd8\xac" +
	"\x92\x83h\xc2{<\xa8\xe3l:\x8a\x0d\xb9\xbcXE" +
	"\xfdW\xd2\xb1\xa8\x97\xd9M\x89e\xbb^z\x14F\xbf" +
	"\x0f{\xd1\xea\xf6\x0e W\xa8\xf2\xb1\xef\xeb\xf5+\x95" +
	"\x1f\xfb\xfe\x0e\xffENe\xf9\xf7\xb8\x0e\xbf~\x8dg" +
	"\x1d\x11R\x08F\xc4\xff\xcb<\x1d|X\x86\x04\xa6F" +
	"(?\x9b\xe6GS\xaf\x87\"\x8f+\x0a\xa5u\xcac" +
	"B\xe1A\x94\xf2\x96\xe5\xefi\xd9|\xbd\xdf\xe9\x88V" +
	"\xb0-\xff\xe6 \x9e\x1c\x0a\x07\xa4\x96?\xa0\x87J\xef" +
	"\x8aw@\x1f\xfa\xcb\xcb\xec\x9e\x1f\xd3\xbd!\xdd{o" +
	"-j'\x96\xf8\x87\x84X\xae\x9b\xc0\xa9\xdd\x84\x17\x89" +
	"\xfcC\xd5\xff\xf39C\xb86Mt\xa42\xd1\x91\xbc" +
	";\xf8q\xa23\xb9\xbf\xdab\xed\xc6\xfb<\xef<p" +
	"4r\xdb~\x9cp\x94\x9121a@\xbe\xaf\xaa\xa2" +
	"\xbe\xaa\xcb\x7f\x12\xef\xf6\xea\xd5GSGO\x1d\xa0\xa0" +
	"\xce3K\xca\x95\xc8\xf5\xc2\xbf\xc6\xa8\xad\xbd\xc0\xf2\xa5" +
	"`\x8a\x08\x8c\xe74\xe6#\xdf\xb56/L\x85\xa3\xc5" +
	"2G\x9b\x0bn\xeb\xf6\xb2\xca$\xc4\x86\xa6\xa4\x8fQ" +
	"\x1bD\xd6\xcf.\x9c\xf3q\xda\xf8\x88\x84\xc6\xa9\\\xa1" +
	"$\xf0\xe4\x92\xa2\x02\xc0\x98\xe7\xcb\xe9\xc1\x9c\xd4_d" +
	"\x88\x12\x16\xfd\x9b\x8eza\x14\x98*\xa3xsR\xcf" +
	"R\x96\x9c\x91\xd08G-#\x13\x0fN\xea\xb3\x94%" +
	"\x13\x12\x1a\xe7\xa7\x1dq\xa7\xab\x0c\x0f8\xcf\x96<d" +
	">@\xee\xfd_\x00\x00\x00\xff\xff`\xa7\xf2\xef"

func RegisterSchema(reg *schemas.Registry) {
	reg.Register(&schemas.Schema{
		String: schema_c56be168dcbbc3c6,
		Nodes: []uint64{
			0x84e4f3f5a807605c,
			0x89f0c973c103ae96,
			0x8e207d4dfe54d0de,
			0x8f2622208fb358c8,
			0x90f2a60678fd2367,
			0x94099c3f9eb32d6b,
			0x96efe787c17e83bb,
			0x991c7a3693d62cf2,
			0x992a90eaf30235d3,
			0x9cb9e86e3198037f,
			0xaa28e1400d793359,
			0xaee8397040b0df7a,
			0xb348322a8dcf0d0c,
			0xb3f66e7a79d81bcd,
			0xc6238c7d62d65173,
			0xc90246b71adedbaa,
			0xd00489d473826290,
			0xd0d1a21de617951f,
			0xd5e71144af1ce175,
			0xe5104515fd88ea47,
			0xe75816b56529d464,
			0xe93164a80bfe2ccf,
			0xeb971847d617c0b9,
			0xfb5aeed95cdf6af9,
			0xfffe08a9a697d2a5,
		},
		Compressed: true,
	})
}
