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

package json

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 Name = uint64(0xfa5b1fd61c2e7c3d)
const Flatten = uint64(0x82d3e852af0336bf)
const Discriminator = uint64(0xcfa794e8d19a0162)
const Base64 = uint64(0xd7d879450a253e4b)
const Hex = uint64(0xf061e22f0ae5c7b5)
const Notification = uint64(0xa0a054dea32fd98c)

type Value capnp.Struct
type Value_Which uint16

const (
	Value_Which_null        Value_Which = 0
	Value_Which_boolean     Value_Which = 1
	Value_Which_number      Value_Which = 2
	Value_Which_stringValue Value_Which = 3
	Value_Which_array       Value_Which = 4
	Value_Which_object      Value_Which = 5
	Value_Which_call        Value_Which = 6
	Value_Which_raw         Value_Which = 7
)

func (w Value_Which) String() string {
	const s = "nullbooleannumberstringValuearrayobjectcallraw"
	switch w {
	case Value_Which_null:
		return s[0:4]
	case Value_Which_boolean:
		return s[4:11]
	case Value_Which_number:
		return s[11:17]
	case Value_Which_stringValue:
		return s[17:28]
	case Value_Which_array:
		return s[28:33]
	case Value_Which_object:
		return s[33:39]
	case Value_Which_call:
		return s[39:43]
	case Value_Which_raw:
		return s[43:46]

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

// Value_TypeID is the unique identifier for the type Value.
const Value_TypeID = 0xa3fa7845f919dd83

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

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

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

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

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

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

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

func (s Value) Which() Value_Which {
	return Value_Which(capnp.Struct(s).Uint16(0))
}
func (s Value) IsValid() bool {
	return capnp.Struct(s).IsValid()
}

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

func (s Value) Segment() *capnp.Segment {
	return capnp.Struct(s).Segment()
}
func (s Value) SetNull() {
	capnp.Struct(s).SetUint16(0, 0)

}

func (s Value) Boolean() bool {
	if capnp.Struct(s).Uint16(0) != 1 {
		panic("Which() != boolean")
	}
	return capnp.Struct(s).Bit(16)
}

func (s Value) SetBoolean(v bool) {
	capnp.Struct(s).SetUint16(0, 1)
	capnp.Struct(s).SetBit(16, v)
}

func (s Value) Number() float64 {
	if capnp.Struct(s).Uint16(0) != 2 {
		panic("Which() != number")
	}
	return math.Float64frombits(capnp.Struct(s).Uint64(8))
}

func (s Value) SetNumber(v float64) {
	capnp.Struct(s).SetUint16(0, 2)
	capnp.Struct(s).SetUint64(8, math.Float64bits(v))
}

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

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

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

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

func (s Value) Array() (Value_List, error) {
	if capnp.Struct(s).Uint16(0) != 4 {
		panic("Which() != array")
	}
	p, err := capnp.Struct(s).Ptr(0)
	return Value_List(p.List()), err
}

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

func (s Value) SetArray(v Value_List) error {
	capnp.Struct(s).SetUint16(0, 4)
	return capnp.Struct(s).SetPtr(0, v.ToPtr())
}

// NewArray sets the array field to a newly
// allocated Value_List, preferring placement in s's segment.
func (s Value) NewArray(n int32) (Value_List, error) {
	capnp.Struct(s).SetUint16(0, 4)
	l, err := NewValue_List(capnp.Struct(s).Segment(), n)
	if err != nil {
		return Value_List{}, err
	}
	err = capnp.Struct(s).SetPtr(0, l.ToPtr())
	return l, err
}
func (s Value) Object() (Value_Field_List, error) {
	if capnp.Struct(s).Uint16(0) != 5 {
		panic("Which() != object")
	}
	p, err := capnp.Struct(s).Ptr(0)
	return Value_Field_List(p.List()), err
}

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

func (s Value) SetObject(v Value_Field_List) error {
	capnp.Struct(s).SetUint16(0, 5)
	return capnp.Struct(s).SetPtr(0, v.ToPtr())
}

// NewObject sets the object field to a newly
// allocated Value_Field_List, preferring placement in s's segment.
func (s Value) NewObject(n int32) (Value_Field_List, error) {
	capnp.Struct(s).SetUint16(0, 5)
	l, err := NewValue_Field_List(capnp.Struct(s).Segment(), n)
	if err != nil {
		return Value_Field_List{}, err
	}
	err = capnp.Struct(s).SetPtr(0, l.ToPtr())
	return l, err
}
func (s Value) Call() (Value_Call, error) {
	if capnp.Struct(s).Uint16(0) != 6 {
		panic("Which() != call")
	}
	p, err := capnp.Struct(s).Ptr(0)
	return Value_Call(p.Struct()), err
}

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

func (s Value) SetCall(v Value_Call) error {
	capnp.Struct(s).SetUint16(0, 6)
	return capnp.Struct(s).SetPtr(0, capnp.Struct(v).ToPtr())
}

// NewCall sets the call field to a newly
// allocated Value_Call struct, preferring placement in s's segment.
func (s Value) NewCall() (Value_Call, error) {
	capnp.Struct(s).SetUint16(0, 6)
	ss, err := NewValue_Call(capnp.Struct(s).Segment())
	if err != nil {
		return Value_Call{}, err
	}
	err = capnp.Struct(s).SetPtr(0, capnp.Struct(ss).ToPtr())
	return ss, err
}

func (s Value) Raw() (string, error) {
	if capnp.Struct(s).Uint16(0) != 7 {
		panic("Which() != raw")
	}
	p, err := capnp.Struct(s).Ptr(0)
	return p.Text(), err
}

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

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

func (s Value) SetRaw(v string) error {
	capnp.Struct(s).SetUint16(0, 7)
	return capnp.Struct(s).SetText(0, v)
}

// Value_List is a list of Value.
type Value_List = capnp.StructList[Value]

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

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

func (f Value_Future) Struct() (Value, error) {
	p, err := f.Future.Ptr()
	return Value(p.Struct()), err
}
func (p Value_Future) Call() Value_Call_Future {
	return Value_Call_Future{Future: p.Future.Field(0, nil)}
}

type Value_Field capnp.Struct

// Value_Field_TypeID is the unique identifier for the type Value_Field.
const Value_Field_TypeID = 0xe31026e735d69ddf

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Value_Field_List is a list of Value_Field.
type Value_Field_List = capnp.StructList[Value_Field]

// NewValue_Field creates a new list of Value_Field.
func NewValue_Field_List(s *capnp.Segment, sz int32) (Value_Field_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2}, sz)
	return capnp.StructList[Value_Field](l), err
}

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

func (f Value_Field_Future) Struct() (Value_Field, error) {
	p, err := f.Future.Ptr()
	return Value_Field(p.Struct()), err
}
func (p Value_Field_Future) Value() Value_Future {
	return Value_Future{Future: p.Future.Field(1, nil)}
}

type Value_Call capnp.Struct

// Value_Call_TypeID is the unique identifier for the type Value_Call.
const Value_Call_TypeID = 0xa0d9f6eca1c93d48

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// Value_Call_List is a list of Value_Call.
type Value_Call_List = capnp.StructList[Value_Call]

// NewValue_Call creates a new list of Value_Call.
func NewValue_Call_List(s *capnp.Segment, sz int32) (Value_Call_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2}, sz)
	return capnp.StructList[Value_Call](l), err
}

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

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

type FlattenOptions capnp.Struct

// FlattenOptions_TypeID is the unique identifier for the type FlattenOptions.
const FlattenOptions_TypeID = 0xc4df13257bc2ea61

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

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

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

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

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

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

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

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

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

func (s FlattenOptions) HasPrefix() bool {
	return capnp.Struct(s).HasPtr(0)
}

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

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

// FlattenOptions_List is a list of FlattenOptions.
type FlattenOptions_List = capnp.StructList[FlattenOptions]

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

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

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

type DiscriminatorOptions capnp.Struct

// DiscriminatorOptions_TypeID is the unique identifier for the type DiscriminatorOptions.
const DiscriminatorOptions_TypeID = 0xc2f8c20c293e5319

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

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

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

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

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

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

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

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

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

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

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

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

func (s DiscriminatorOptions) ValueName() (string, error) {
	p, err := capnp.Struct(s).Ptr(1)
	return p.Text(), err
}

func (s DiscriminatorOptions) HasValueName() bool {
	return capnp.Struct(s).HasPtr(1)
}

func (s DiscriminatorOptions) ValueNameBytes() ([]byte, error) {
	p, err := capnp.Struct(s).Ptr(1)
	return p.TextBytes(), err
}

func (s DiscriminatorOptions) SetValueName(v string) error {
	return capnp.Struct(s).SetText(1, v)
}

// DiscriminatorOptions_List is a list of DiscriminatorOptions.
type DiscriminatorOptions_List = capnp.StructList[DiscriminatorOptions]

// NewDiscriminatorOptions creates a new list of DiscriminatorOptions.
func NewDiscriminatorOptions_List(s *capnp.Segment, sz int32) (DiscriminatorOptions_List, error) {
	l, err := capnp.NewCompositeList(s, capnp.ObjectSize{DataSize: 0, PointerCount: 2}, sz)
	return capnp.StructList[DiscriminatorOptions](l), err
}

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

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

const schema_8ef99297a43a5e34 = "x\xda\x8cT]h\x1cU\x18\xfd\xce\xbd3\x93\x9f\xdd" +
	"5;\xce\xa0\x06\x0c\x1b\xc4\xa8\x0d5\x7fMkYl" +
	"\xd7\xbf\x94\xa0P\xf7fkAD\xf1\xeef\xa2Sf" +
	"g\x97\xdd\x8dMT\x10*\xbe\x88\x15Z\x04\xa1 D" +
	"*\xf8(\x08>\xe8\x8b\xb0\x08E\x114\xfe\xd4\x06\x8c" +
	"-\x8a\x18E\xc1>T\x92h\xbdrg\xdb\xfdI," +
	"\xf4m\x99s8\xdf\xf9\xcew\xee\x8e\xdd\xc4\xee3\xc6" +
	"\x13\xf7X\xc4\xc4\xb4i\xa9\x8f\xf7\xf0\xf7f\xd6\xbe>" +
	"F\"f^P\x93O\xa5\xdfy\xf3\xe4\xc6\xebDp" +
	"\xc0O9=\xbc\x8b(gp\x0e\x82zme\xf4\xf4" +
	"\x0f\x87\x96\x96\xe8D\xccd\x1d\xd4K\xac\xee\\f\x9a" +
	"\xba\xce\"\xea\xf4\xbeO\xdf\xfe\xfd\xaf\x95%\xb2m\xa8" +
	"\x97W\xfb7\xa6\x166O\x93\xa9)\xce\xaf\xec}\xe7" +
	"b\xf4\xeb\x0fv\x94\xda`\x11C\x9b\xec\x14\xba\xba\x89" +
	"\x9c'\xf9\xab\x8e\xc7\xef$\xda\xb5\xc8\xcfh\xe9\xfe\xdc" +
	"\xfe\x1d\xf1\xfaz\x9d\xec\x18Z\xecHz\xd7+&\x83" +
	"s\xc2\xd4\xda\xc7M\xad-\x7f\xab\xbf0\xe4\x9c\xffd" +
	"\x0b\x19\xd1t\xf3+g#\xe2^23\x04\x95\xc7\xa9" +
	"\xe5\xb57\xde\xfdB'\x91\xedX\xaf\xdf\xfa\xcc\x19\xb2" +
	"\xf4z\x83V\xb4\xde#\xfb\x87z\xa7\x16\xcf}\xa7\xa9" +
	"\x83\x1dT\xdb:\xe9\xf4GT\xb7A=\xff\xd6\xd9\xdd" +
	"\xbf\xdc\x91\xfc\xe9\xff\x920\xad\x8f\x9c\x84&;=\x96" +
	"v\xfb\xc1\x99\x9f{G\x7f\x94\x7fn\x97\xf5\xac\xe7\x1d" +
	"?\x92\x9dm\xc8\xee{q\xe4\xd6\xb3\xa9'6i9" +
	"f\xaeu\x1e\xe31\xeb\x98\xf3x\xc4=\xa4\xb9\x07\xd5" +
	"\x91j)\x1c)\xc82\xc2rz.\x90\xb5\x1a\xf7\xc2" +
	",\x80d+\x1eB\x93\xc5\xc2r:,\xd5\xfc9\xbf" +
	" k~)\xa4,@\xbcC\xe4\xb0\x0c\xe6\xbd\xd4\xc8" +
	"\x832\x08\xb2\x80\xe8\xe6\x06\x91\x01\"{\xc7\xc3D\xe2" +
	".\x0e1\xc9`\x03.\xf4\xc7\xf14\x91\xd8\xc9!\xa6" +
	"\x19\xd4\xdc|X\x88T\x89\x10'\x868!S\x96\x15" +
	"Y\xac\xe2\x06B\x96kW\xcd\x94\x08\xfa\xe3\xf6\xd1D" +
	"\xa2\x1b\xed\xd1\xf6L\xb45\xce\x1cN\x1d\xf0\xbd`\xb6" +
	"O\xfb\x13\x83\xdc\x88+\x15\xb9[\x1e&\x12\x9fs\x88" +
	"s\x0c\x03\xf8W%\x1b\xfe\xbe}\x80H|\xc9!\xbe" +
	"g\x18`\x97\x15\\0\"{E\xdb\xfe\x86C\\`" +
	"H\xf0\x7f\x94\x0bNd\xaf\xa6\xed\xd5\xd4\x0c8rq" +
	"0$\x8c\xbf\x95\x0bC\x1f\x10\x13\xfa\xa1h`P\x03" +
	"\xe6\xa6ra\x129\x03H\x13\xe5n\xd1\xc0\xa4\x06\xac" +
	"\x0d\xe5\xc2\"r\xc61L\x94\xdb\xa9\x81\xbd\x1a\xe8Z" +
	"Wn\xd4\xcb\xdd\xb8\x8d(7\xa6\x81{\xc1\xd0\x17\xce" +
	"\x07\x01Y/\xe5K\xa5\xc0\x93!@\x0c d\xc2\xf9" +
	"b\xde\xab F\x0c1B\xa6Z\xab\xf8\xe13\xc2\x00" +
	"S\x17\x8f\x8f\xde|\xe3\xd3\x1f\xd6I\x18\x0c\xf7\xbb@" +
	"\x9c\xc8F^5(\x87%uE\x19^\xcd?%+" +
	"\x15\xb9x\xcd\xf83\xa5\xfc\x11\xafPk\xe1\xcd\xd8\x1b" +
	"x_A\x06\x01\x92\xad\x03\x10\x90$tU\xe4\xd1\xab" +
	"\x13\x9a\x17\xe4a9\xfd\x90_-T\xfc\xa2\x1f\xcaZ" +
	"\xa9\xf2hY\x97\xa1J[j\xa4\x0fu;\x87\x18k" +
	"\xab\xd1\xdd3Wj\xb4Wg\"\x8b^S\xfd9\xdd" +
	"\x89\x83\xb2H\xf0\xb6M\xd4m>\xa0;\xef\x85\x8dY" +
	"\xa8\xeaYFc\x16`'\xf4\x99\xbb9\x84\xcb\x90)" +
	"W\xbc9\x7f\xe1\x8a\x08\xd9\xe8%\xeaP\x9am\xf7N" +
	"\xd4xD\xcd?\xa4-U\xcd\xcb\xaa\xb7\x07\x93\xd7x" +
	">\x99\x91\xa8\xa4\xd7\xb3\xf8D\xebQu,\x9e\x8a\x16" +
	"\xdfr\xb1d\x9b\x0b\xca\x84\xe5\xf4\xb3\xde\xc2v\x0bZ" +
	"&\xb2\x1f'\xf6_\x00\x00\x00\xff\xff\x15\\\x9e3"

func RegisterSchema(reg *schemas.Registry) {
	reg.Register(&schemas.Schema{
		String: schema_8ef99297a43a5e34,
		Nodes: []uint64{
			0x82d3e852af0336bf,
			0xa0a054dea32fd98c,
			0xa0d9f6eca1c93d48,
			0xa3fa7845f919dd83,
			0xc2f8c20c293e5319,
			0xc4df13257bc2ea61,
			0xcfa794e8d19a0162,
			0xd7d879450a253e4b,
			0xe31026e735d69ddf,
			0xf061e22f0ae5c7b5,
			0xfa5b1fd61c2e7c3d,
		},
		Compressed: true,
	})
}
