func (m *BoolValue) MarshalToWriter(writer jspb.Writer) {
	if m == nil {
		return
	}
	if m.Value {
		writer.WriteBool(1, m.Value)
	}
	return
}
MarshalToWriter marshals BoolValue to the provided writer.
package wrappers
import jspb "github.com/johanbrandhorst/protobuf/jspb"
const _ = jspb.JspbPackageIsVersion2
type DoubleValue struct {
	Value float64
}
func (m *DoubleValue) GetValue() (x float64) {
	if m == nil {
		return x
	}
	return m.Value
}
func (m *DoubleValue) MarshalToWriter(writer jspb.Writer) {
	if m == nil {
		return
	}
	if m.Value != 0 {
		writer.WriteFloat64(1, m.Value)
	}
	return
}
func (m *DoubleValue) Marshal() []byte {
	writer := jspb.NewWriter()
	m.MarshalToWriter(writer)
	return writer.GetResult()
}
func (m *DoubleValue) UnmarshalFromReader(reader jspb.Reader) *DoubleValue {
	for reader.Next() {
		if m == nil {
			m = &DoubleValue{}
		}
		switch reader.GetFieldNumber() {
		case 1:
			m.Value = reader.ReadFloat64()
		default:
			reader.SkipField()
		}
	}
	return m
}
func (m *DoubleValue) Unmarshal(rawBytes []byte) (*DoubleValue, error) {
	reader := jspb.NewReader(rawBytes)
	m = m.UnmarshalFromReader(reader)
	if err := reader.Err(); err != nil {
		return nil, err
	}
	return m, nil
}
type FloatValue struct {
	Value float32
}
func (m *FloatValue) GetValue() (x float32) {
	if m == nil {
		return x
	}
	return m.Value
}
func (m *FloatValue) MarshalToWriter(writer jspb.Writer) {
	if m == nil {
		return
	}
	if m.Value != 0 {
		writer.WriteFloat32(1, m.Value)
	}
	return
}
func (m *FloatValue) Marshal() []byte {
	writer := jspb.NewWriter()
	m.MarshalToWriter(writer)
	return writer.GetResult()
}
func (m *FloatValue) UnmarshalFromReader(reader jspb.Reader) *FloatValue {
	for reader.Next() {
		if m == nil {
			m = &FloatValue{}
		}
		switch reader.GetFieldNumber() {
		case 1:
			m.Value = reader.ReadFloat32()
		default:
			reader.SkipField()
		}
	}
	return m
}
func (m *FloatValue) Unmarshal(rawBytes []byte) (*FloatValue, error) {
	reader := jspb.NewReader(rawBytes)
	m = m.UnmarshalFromReader(reader)
	if err := reader.Err(); err != nil {
		return nil, err
	}
	return m, nil
}
type Int64Value struct {
	Value int64
}
func (m *Int64Value) GetValue() (x int64) {
	if m == nil {
		return x
	}
	return m.Value
}
func (m *Int64Value) MarshalToWriter(writer jspb.Writer) {
	if m == nil {
		return
	}
	if m.Value != 0 {
		writer.WriteInt64(1, m.Value)
	}
	return
}
func (m *Int64Value) Marshal() []byte {
	writer := jspb.NewWriter()
	m.MarshalToWriter(writer)
	return writer.GetResult()
}
func (m *Int64Value) UnmarshalFromReader(reader jspb.Reader) *Int64Value {
	for reader.Next() {
		if m == nil {
			m = &Int64Value{}
		}
		switch reader.GetFieldNumber() {
		case 1:
			m.Value = reader.ReadInt64()
		default:
			reader.SkipField()
		}
	}
	return m
}
func (m *Int64Value) Unmarshal(rawBytes []byte) (*Int64Value, error) {
	reader := jspb.NewReader(rawBytes)
	m = m.UnmarshalFromReader(reader)
	if err := reader.Err(); err != nil {
		return nil, err
	}
	return m, nil
}
type UInt64Value struct {
	Value uint64
}
func (m *UInt64Value) GetValue() (x uint64) {
	if m == nil {
		return x
	}
	return m.Value
}
func (m *UInt64Value) MarshalToWriter(writer jspb.Writer) {
	if m == nil {
		return
	}
	if m.Value != 0 {
		writer.WriteUint64(1, m.Value)
	}
	return
}
func (m *UInt64Value) Marshal() []byte {
	writer := jspb.NewWriter()
	m.MarshalToWriter(writer)
	return writer.GetResult()
}
func (m *UInt64Value) UnmarshalFromReader(reader jspb.Reader) *UInt64Value {
	for reader.Next() {
		if m == nil {
			m = &UInt64Value{}
		}
		switch reader.GetFieldNumber() {
		case 1:
			m.Value = reader.ReadUint64()
		default:
			reader.SkipField()
		}
	}
	return m
}
func (m *UInt64Value) Unmarshal(rawBytes []byte) (*UInt64Value, error) {
	reader := jspb.NewReader(rawBytes)
	m = m.UnmarshalFromReader(reader)
	if err := reader.Err(); err != nil {
		return nil, err
	}
	return m, nil
}
type Int32Value struct {
	Value int32
}
func (m *Int32Value) GetValue() (x int32) {
	if m == nil {
		return x
	}
	return m.Value
}
func (m *Int32Value) MarshalToWriter(writer jspb.Writer) {
	if m == nil {
		return
	}
	if m.Value != 0 {
		writer.WriteInt32(1, m.Value)
	}
	return
}
func (m *Int32Value) Marshal() []byte {
	writer := jspb.NewWriter()
	m.MarshalToWriter(writer)
	return writer.GetResult()
}
func (m *Int32Value) UnmarshalFromReader(reader jspb.Reader) *Int32Value {
	for reader.Next() {
		if m == nil {
			m = &Int32Value{}
		}
		switch reader.GetFieldNumber() {
		case 1:
			m.Value = reader.ReadInt32()
		default:
			reader.SkipField()
		}
	}
	return m
}
func (m *Int32Value) Unmarshal(rawBytes []byte) (*Int32Value, error) {
	reader := jspb.NewReader(rawBytes)
	m = m.UnmarshalFromReader(reader)
	if err := reader.Err(); err != nil {
		return nil, err
	}
	return m, nil
}
type UInt32Value struct {
	Value uint32
}
func (m *UInt32Value) GetValue() (x uint32) {
	if m == nil {
		return x
	}
	return m.Value
}
func (m *UInt32Value) MarshalToWriter(writer jspb.Writer) {
	if m == nil {
		return
	}
	if m.Value != 0 {
		writer.WriteUint32(1, m.Value)
	}
	return
}
func (m *UInt32Value) Marshal() []byte {
	writer := jspb.NewWriter()
	m.MarshalToWriter(writer)
	return writer.GetResult()
}
func (m *UInt32Value) UnmarshalFromReader(reader jspb.Reader) *UInt32Value {
	for reader.Next() {
		if m == nil {
			m = &UInt32Value{}
		}
		switch reader.GetFieldNumber() {
		case 1:
			m.Value = reader.ReadUint32()
		default:
			reader.SkipField()
		}
	}
	return m
}
func (m *UInt32Value) Unmarshal(rawBytes []byte) (*UInt32Value, error) {
	reader := jspb.NewReader(rawBytes)
	m = m.UnmarshalFromReader(reader)
	if err := reader.Err(); err != nil {
		return nil, err
	}
	return m, nil
}
type BoolValue struct {
	Value bool
}
func (m *BoolValue) GetValue() (x bool) {
	if m == nil {
		return x
	}
	return m.Value
}