rgraphql.pb.go

// Code generated by protoc-gen-go-lite. DO NOT EDIT.
// protoc-gen-go-lite version: v0.6.1
// source: github.com/rgraphql/rgraphql/rgraphql.proto

package rgraphql

import (
	base64 "encoding/base64"
	binary "encoding/binary"
	fmt "fmt"
	io "io"
	math "math"
	strconv "strconv"
	strings "strings"

	protobuf_go_lite "github.com/aperturerobotics/protobuf-go-lite"
	json "github.com/aperturerobotics/protobuf-go-lite/json"
)

type RGQLPrimitive_Kind int32

const (
	RGQLPrimitive_PRIMITIVE_KIND_NULL   RGQLPrimitive_Kind = 0
	RGQLPrimitive_PRIMITIVE_KIND_INT    RGQLPrimitive_Kind = 1
	RGQLPrimitive_PRIMITIVE_KIND_FLOAT  RGQLPrimitive_Kind = 2
	RGQLPrimitive_PRIMITIVE_KIND_STRING RGQLPrimitive_Kind = 3
	RGQLPrimitive_PRIMITIVE_KIND_BOOL   RGQLPrimitive_Kind = 4
	RGQLPrimitive_PRIMITIVE_KIND_OBJECT RGQLPrimitive_Kind = 5
	// A marker for an empty array.
	RGQLPrimitive_PRIMITIVE_KIND_ARRAY RGQLPrimitive_Kind = 6
)

// Enum value maps for RGQLPrimitive_Kind.
var (
	RGQLPrimitive_Kind_name = map[int32]string{
		0: "PRIMITIVE_KIND_NULL",
		1: "PRIMITIVE_KIND_INT",
		2: "PRIMITIVE_KIND_FLOAT",
		3: "PRIMITIVE_KIND_STRING",
		4: "PRIMITIVE_KIND_BOOL",
		5: "PRIMITIVE_KIND_OBJECT",
		6: "PRIMITIVE_KIND_ARRAY",
	}
	RGQLPrimitive_Kind_value = map[string]int32{
		"PRIMITIVE_KIND_NULL":   0,
		"PRIMITIVE_KIND_INT":    1,
		"PRIMITIVE_KIND_FLOAT":  2,
		"PRIMITIVE_KIND_STRING": 3,
		"PRIMITIVE_KIND_BOOL":   4,
		"PRIMITIVE_KIND_OBJECT": 5,
		"PRIMITIVE_KIND_ARRAY":  6,
	}
)

func (x RGQLPrimitive_Kind) Enum() *RGQLPrimitive_Kind {
	p := new(RGQLPrimitive_Kind)
	*p = x
	return p
}

func (x RGQLPrimitive_Kind) String() string {
	name, valid := RGQLPrimitive_Kind_name[int32(x)]
	if valid {
		return name
	}
	return strconv.Itoa(int(x))
}

type RGQLQueryTreeMutation_SubtreeOperation int32

const (
	// Add a child tree to the subtree.
	RGQLQueryTreeMutation_SUBTREE_ADD_CHILD RGQLQueryTreeMutation_SubtreeOperation = 0
	// Delete a tree node and all children.
	RGQLQueryTreeMutation_SUBTREE_DELETE RGQLQueryTreeMutation_SubtreeOperation = 1
)

// Enum value maps for RGQLQueryTreeMutation_SubtreeOperation.
var (
	RGQLQueryTreeMutation_SubtreeOperation_name = map[int32]string{
		0: "SUBTREE_ADD_CHILD",
		1: "SUBTREE_DELETE",
	}
	RGQLQueryTreeMutation_SubtreeOperation_value = map[string]int32{
		"SUBTREE_ADD_CHILD": 0,
		"SUBTREE_DELETE":    1,
	}
)

func (x RGQLQueryTreeMutation_SubtreeOperation) Enum() *RGQLQueryTreeMutation_SubtreeOperation {
	p := new(RGQLQueryTreeMutation_SubtreeOperation)
	*p = x
	return p
}

func (x RGQLQueryTreeMutation_SubtreeOperation) String() string {
	name, valid := RGQLQueryTreeMutation_SubtreeOperation_name[int32(x)]
	if valid {
		return name
	}
	return strconv.Itoa(int(x))
}

type RGQLValueInit_CacheStrategy int32

const (
	RGQLValueInit_CACHE_LRU RGQLValueInit_CacheStrategy = 0
)

// Enum value maps for RGQLValueInit_CacheStrategy.
var (
	RGQLValueInit_CacheStrategy_name = map[int32]string{
		0: "CACHE_LRU",
	}
	RGQLValueInit_CacheStrategy_value = map[string]int32{
		"CACHE_LRU": 0,
	}
)

func (x RGQLValueInit_CacheStrategy) Enum() *RGQLValueInit_CacheStrategy {
	p := new(RGQLValueInit_CacheStrategy)
	*p = x
	return p
}

func (x RGQLValueInit_CacheStrategy) String() string {
	name, valid := RGQLValueInit_CacheStrategy_name[int32(x)]
	if valid {
		return name
	}
	return strconv.Itoa(int(x))
}

type RGQLQueryFieldDirective struct {
	unknownFields []byte
	// Directive name
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// Optional arguments.
	Args []*FieldArgument `protobuf:"bytes,2,rep,name=args,proto3" json:"args,omitempty"`
}

func (x *RGQLQueryFieldDirective) Reset() {
	*x = RGQLQueryFieldDirective{}
}

func (*RGQLQueryFieldDirective) ProtoMessage() {}

func (x *RGQLQueryFieldDirective) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

func (x *RGQLQueryFieldDirective) GetArgs() []*FieldArgument {
	if x != nil {
		return x.Args
	}
	return nil
}

type RGQLQueryTreeNode struct {
	unknownFields []byte
	// Integer ID of the node.
	Id uint32 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	// Name of the field this node represents.
	FieldName string `protobuf:"bytes,2,opt,name=field_name,json=fieldName,proto3" json:"fieldName,omitempty"`
	// Arguments.
	Args []*FieldArgument `protobuf:"bytes,3,rep,name=args,proto3" json:"args,omitempty"`
	// Directives
	Directive []*RGQLQueryFieldDirective `protobuf:"bytes,4,rep,name=directive,proto3" json:"directive,omitempty"`
	// Children
	Children []*RGQLQueryTreeNode `protobuf:"bytes,5,rep,name=children,proto3" json:"children,omitempty"`
}

func (x *RGQLQueryTreeNode) Reset() {
	*x = RGQLQueryTreeNode{}
}

func (*RGQLQueryTreeNode) ProtoMessage() {}

func (x *RGQLQueryTreeNode) GetId() uint32 {
	if x != nil {
		return x.Id
	}
	return 0
}

func (x *RGQLQueryTreeNode) GetFieldName() string {
	if x != nil {
		return x.FieldName
	}
	return ""
}

func (x *RGQLQueryTreeNode) GetArgs() []*FieldArgument {
	if x != nil {
		return x.Args
	}
	return nil
}

func (x *RGQLQueryTreeNode) GetDirective() []*RGQLQueryFieldDirective {
	if x != nil {
		return x.Directive
	}
	return nil
}

func (x *RGQLQueryTreeNode) GetChildren() []*RGQLQueryTreeNode {
	if x != nil {
		return x.Children
	}
	return nil
}

type FieldArgument struct {
	unknownFields []byte
	Name          string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	VariableId    uint32 `protobuf:"varint,2,opt,name=variable_id,json=variableId,proto3" json:"variableId,omitempty"`
}

func (x *FieldArgument) Reset() {
	*x = FieldArgument{}
}

func (*FieldArgument) ProtoMessage() {}

func (x *FieldArgument) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

func (x *FieldArgument) GetVariableId() uint32 {
	if x != nil {
		return x.VariableId
	}
	return 0
}

type ASTVariable struct {
	unknownFields []byte
	Id            uint32         `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	Value         *RGQLPrimitive `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
}

func (x *ASTVariable) Reset() {
	*x = ASTVariable{}
}

func (*ASTVariable) ProtoMessage() {}

func (x *ASTVariable) GetId() uint32 {
	if x != nil {
		return x.Id
	}
	return 0
}

func (x *ASTVariable) GetValue() *RGQLPrimitive {
	if x != nil {
		return x.Value
	}
	return nil
}

type RGQLPrimitive struct {
	unknownFields []byte
	Kind          RGQLPrimitive_Kind `protobuf:"varint,1,opt,name=kind,proto3" json:"kind,omitempty"`
	IntValue      int32              `protobuf:"varint,2,opt,name=int_value,json=intValue,proto3" json:"intValue,omitempty"`
	FloatValue    float64            `protobuf:"fixed64,3,opt,name=float_value,json=floatValue,proto3" json:"floatValue,omitempty"`
	StringValue   string             `protobuf:"bytes,4,opt,name=string_value,json=stringValue,proto3" json:"stringValue,omitempty"`
	BoolValue     bool               `protobuf:"varint,5,opt,name=bool_value,json=boolValue,proto3" json:"boolValue,omitempty"`
}

func (x *RGQLPrimitive) Reset() {
	*x = RGQLPrimitive{}
}

func (*RGQLPrimitive) ProtoMessage() {}

func (x *RGQLPrimitive) GetKind() RGQLPrimitive_Kind {
	if x != nil {
		return x.Kind
	}
	return RGQLPrimitive_PRIMITIVE_KIND_NULL
}

func (x *RGQLPrimitive) GetIntValue() int32 {
	if x != nil {
		return x.IntValue
	}
	return 0
}

func (x *RGQLPrimitive) GetFloatValue() float64 {
	if x != nil {
		return x.FloatValue
	}
	return 0
}

func (x *RGQLPrimitive) GetStringValue() string {
	if x != nil {
		return x.StringValue
	}
	return ""
}

func (x *RGQLPrimitive) GetBoolValue() bool {
	if x != nil {
		return x.BoolValue
	}
	return false
}

// Messages
type RGQLClientMessage struct {
	unknownFields []byte
	InitQuery     *RGQLQueryInit         `protobuf:"bytes,1,opt,name=init_query,json=initQuery,proto3" json:"initQuery,omitempty"`
	MutateTree    *RGQLQueryTreeMutation `protobuf:"bytes,2,opt,name=mutate_tree,json=mutateTree,proto3" json:"mutateTree,omitempty"`
	FinishQuery   *RGQLQueryFinish       `protobuf:"bytes,3,opt,name=finish_query,json=finishQuery,proto3" json:"finishQuery,omitempty"`
}

func (x *RGQLClientMessage) Reset() {
	*x = RGQLClientMessage{}
}

func (*RGQLClientMessage) ProtoMessage() {}

func (x *RGQLClientMessage) GetInitQuery() *RGQLQueryInit {
	if x != nil {
		return x.InitQuery
	}
	return nil
}

func (x *RGQLClientMessage) GetMutateTree() *RGQLQueryTreeMutation {
	if x != nil {
		return x.MutateTree
	}
	return nil
}

func (x *RGQLClientMessage) GetFinishQuery() *RGQLQueryFinish {
	if x != nil {
		return x.FinishQuery
	}
	return nil
}

type RGQLQueryInit struct {
	unknownFields []byte
	// The ID of this query.
	QueryId uint32 `protobuf:"varint,1,opt,name=query_id,json=queryId,proto3" json:"queryId,omitempty"`
	// Force serial for this query?
	// Note: serial queries execute as soon as the first mutation arrives, and cannot be updated.
	ForceSerial bool `protobuf:"varint,2,opt,name=force_serial,json=forceSerial,proto3" json:"forceSerial,omitempty"`
	// Operation type, i.e. query, mutation, etc.
	OperationType string `protobuf:"bytes,3,opt,name=operation_type,json=operationType,proto3" json:"operationType,omitempty"`
}

func (x *RGQLQueryInit) Reset() {
	*x = RGQLQueryInit{}
}

func (*RGQLQueryInit) ProtoMessage() {}

func (x *RGQLQueryInit) GetQueryId() uint32 {
	if x != nil {
		return x.QueryId
	}
	return 0
}

func (x *RGQLQueryInit) GetForceSerial() bool {
	if x != nil {
		return x.ForceSerial
	}
	return false
}

func (x *RGQLQueryInit) GetOperationType() string {
	if x != nil {
		return x.OperationType
	}
	return ""
}

type RGQLQueryTreeMutation struct {
	unknownFields []byte
	// The ID of this query.
	QueryId uint32 `protobuf:"varint,1,opt,name=query_id,json=queryId,proto3" json:"queryId,omitempty"`
	// All node mutations in this step.
	NodeMutation []*RGQLQueryTreeMutation_NodeMutation `protobuf:"bytes,2,rep,name=node_mutation,json=nodeMutation,proto3" json:"nodeMutation,omitempty"`
	// Any new variables.
	Variables []*ASTVariable `protobuf:"bytes,3,rep,name=variables,proto3" json:"variables,omitempty"`
}

func (x *RGQLQueryTreeMutation) Reset() {
	*x = RGQLQueryTreeMutation{}
}

func (*RGQLQueryTreeMutation) ProtoMessage() {}

func (x *RGQLQueryTreeMutation) GetQueryId() uint32 {
	if x != nil {
		return x.QueryId
	}
	return 0
}

func (x *RGQLQueryTreeMutation) GetNodeMutation() []*RGQLQueryTreeMutation_NodeMutation {
	if x != nil {
		return x.NodeMutation
	}
	return nil
}

func (x *RGQLQueryTreeMutation) GetVariables() []*ASTVariable {
	if x != nil {
		return x.Variables
	}
	return nil
}

type RGQLQueryFinish struct {
	unknownFields []byte
	// The ID of this query.
	QueryId uint32 `protobuf:"varint,1,opt,name=query_id,json=queryId,proto3" json:"queryId,omitempty"`
}

func (x *RGQLQueryFinish) Reset() {
	*x = RGQLQueryFinish{}
}

func (*RGQLQueryFinish) ProtoMessage() {}

func (x *RGQLQueryFinish) GetQueryId() uint32 {
	if x != nil {
		return x.QueryId
	}
	return 0
}

type RGQLServerMessage struct {
	unknownFields []byte
	QueryError    *RGQLQueryError    `protobuf:"bytes,2,opt,name=query_error,json=queryError,proto3" json:"queryError,omitempty"`
	ValueInit     *RGQLValueInit     `protobuf:"bytes,4,opt,name=value_init,json=valueInit,proto3" json:"valueInit,omitempty"`
	ValueBatch    *RGQLValueBatch    `protobuf:"bytes,5,opt,name=value_batch,json=valueBatch,proto3" json:"valueBatch,omitempty"`
	ValueFinalize *RGQLValueFinalize `protobuf:"bytes,6,opt,name=value_finalize,json=valueFinalize,proto3" json:"valueFinalize,omitempty"`
}

func (x *RGQLServerMessage) Reset() {
	*x = RGQLServerMessage{}
}

func (*RGQLServerMessage) ProtoMessage() {}

func (x *RGQLServerMessage) GetQueryError() *RGQLQueryError {
	if x != nil {
		return x.QueryError
	}
	return nil
}

func (x *RGQLServerMessage) GetValueInit() *RGQLValueInit {
	if x != nil {
		return x.ValueInit
	}
	return nil
}

func (x *RGQLServerMessage) GetValueBatch() *RGQLValueBatch {
	if x != nil {
		return x.ValueBatch
	}
	return nil
}

func (x *RGQLServerMessage) GetValueFinalize() *RGQLValueFinalize {
	if x != nil {
		return x.ValueFinalize
	}
	return nil
}

// RGQLValueInit initializes a result value tree.
type RGQLValueInit struct {
	unknownFields []byte
	// result_id is the identifier for the result tree.
	ResultId uint32 `protobuf:"varint,1,opt,name=result_id,json=resultId,proto3" json:"resultId,omitempty"`
	// query_id is the identifier for the corresponding query.
	QueryId uint32 `protobuf:"varint,2,opt,name=query_id,json=queryId,proto3" json:"queryId,omitempty"`
	// cache_strategy is the strategy used for the path cache.
	CacheStrategy RGQLValueInit_CacheStrategy `protobuf:"varint,3,opt,name=cache_strategy,json=cacheStrategy,proto3" json:"cacheStrategy,omitempty"`
	// cache_size is the size of the path cache, if necessary.
	CacheSize uint32 `protobuf:"varint,4,opt,name=cache_size,json=cacheSize,proto3" json:"cacheSize,omitempty"`
}

func (x *RGQLValueInit) Reset() {
	*x = RGQLValueInit{}
}

func (*RGQLValueInit) ProtoMessage() {}

func (x *RGQLValueInit) GetResultId() uint32 {
	if x != nil {
		return x.ResultId
	}
	return 0
}

func (x *RGQLValueInit) GetQueryId() uint32 {
	if x != nil {
		return x.QueryId
	}
	return 0
}

func (x *RGQLValueInit) GetCacheStrategy() RGQLValueInit_CacheStrategy {
	if x != nil {
		return x.CacheStrategy
	}
	return RGQLValueInit_CACHE_LRU
}

func (x *RGQLValueInit) GetCacheSize() uint32 {
	if x != nil {
		return x.CacheSize
	}
	return 0
}

// RGQLValueFinalize finalizes a result tree.
type RGQLValueFinalize struct {
	unknownFields []byte
	ResultId      uint32 `protobuf:"varint,1,opt,name=result_id,json=resultId,proto3" json:"resultId,omitempty"`
}

func (x *RGQLValueFinalize) Reset() {
	*x = RGQLValueFinalize{}
}

func (*RGQLValueFinalize) ProtoMessage() {}

func (x *RGQLValueFinalize) GetResultId() uint32 {
	if x != nil {
		return x.ResultId
	}
	return 0
}

// Communicating a failure in the input query.
type RGQLQueryError struct {
	unknownFields []byte
	QueryId       uint32 `protobuf:"varint,1,opt,name=query_id,json=queryId,proto3" json:"queryId,omitempty"`
	QueryNodeId   uint32 `protobuf:"varint,2,opt,name=query_node_id,json=queryNodeId,proto3" json:"queryNodeId,omitempty"`
	Error         string `protobuf:"bytes,3,opt,name=error,proto3" json:"error,omitempty"`
}

func (x *RGQLQueryError) Reset() {
	*x = RGQLQueryError{}
}

func (*RGQLQueryError) ProtoMessage() {}

func (x *RGQLQueryError) GetQueryId() uint32 {
	if x != nil {
		return x.QueryId
	}
	return 0
}

func (x *RGQLQueryError) GetQueryNodeId() uint32 {
	if x != nil {
		return x.QueryNodeId
	}
	return 0
}

func (x *RGQLQueryError) GetError() string {
	if x != nil {
		return x.Error
	}
	return ""
}

type RGQLValue struct {
	unknownFields []byte
	// The ID of the field in the query tree, if a field.
	QueryNodeId uint32 `protobuf:"varint,1,opt,name=query_node_id,json=queryNodeId,proto3" json:"queryNodeId,omitempty"`
	// The 1-based index, if an array element.
	ArrayIndex uint32 `protobuf:"varint,2,opt,name=array_index,json=arrayIndex,proto3" json:"arrayIndex,omitempty"`
	// If this is a 0-th index value, this is a pointer to a previous identifier.
	// Otherwise, this is an identifier for adding an alias to this path.
	PosIdentifier uint32 `protobuf:"varint,3,opt,name=pos_identifier,json=posIdentifier,proto3" json:"posIdentifier,omitempty"`
	// The value, if we have one.
	Value *RGQLPrimitive `protobuf:"bytes,4,opt,name=value,proto3" json:"value,omitempty"`
	// The error, if we are erroring this field.
	Error string `protobuf:"bytes,5,opt,name=error,proto3" json:"error,omitempty"`
}

func (x *RGQLValue) Reset() {
	*x = RGQLValue{}
}

func (*RGQLValue) ProtoMessage() {}

func (x *RGQLValue) GetQueryNodeId() uint32 {
	if x != nil {
		return x.QueryNodeId
	}
	return 0
}

func (x *RGQLValue) GetArrayIndex() uint32 {
	if x != nil {
		return x.ArrayIndex
	}
	return 0
}

func (x *RGQLValue) GetPosIdentifier() uint32 {
	if x != nil {
		return x.PosIdentifier
	}
	return 0
}

func (x *RGQLValue) GetValue() *RGQLPrimitive {
	if x != nil {
		return x.Value
	}
	return nil
}

func (x *RGQLValue) GetError() string {
	if x != nil {
		return x.Error
	}
	return ""
}

type RGQLValueBatch struct {
	unknownFields []byte
	// The ID of the result tree this batch is for.
	ResultId uint32 `protobuf:"varint,1,opt,name=result_id,json=resultId,proto3" json:"resultId,omitempty"`
	// The batch of RGQLValue values, encoded.
	Values [][]byte `protobuf:"bytes,2,rep,name=values,proto3" json:"values,omitempty"`
}

func (x *RGQLValueBatch) Reset() {
	*x = RGQLValueBatch{}
}

func (*RGQLValueBatch) ProtoMessage() {}

func (x *RGQLValueBatch) GetResultId() uint32 {
	if x != nil {
		return x.ResultId
	}
	return 0
}

func (x *RGQLValueBatch) GetValues() [][]byte {
	if x != nil {
		return x.Values
	}
	return nil
}

type RGQLQueryTreeMutation_NodeMutation struct {
	unknownFields []byte
	// ID of the node we are operating on.
	NodeId uint32 `protobuf:"varint,1,opt,name=node_id,json=nodeId,proto3" json:"nodeId,omitempty"`
	// Operation we are taking.
	Operation RGQLQueryTreeMutation_SubtreeOperation `protobuf:"varint,2,opt,name=operation,proto3" json:"operation,omitempty"`
	// The new node tree to add, if we are adding a child.
	Node *RGQLQueryTreeNode `protobuf:"bytes,3,opt,name=node,proto3" json:"node,omitempty"`
}

func (x *RGQLQueryTreeMutation_NodeMutation) Reset() {
	*x = RGQLQueryTreeMutation_NodeMutation{}
}

func (*RGQLQueryTreeMutation_NodeMutation) ProtoMessage() {}

func (x *RGQLQueryTreeMutation_NodeMutation) GetNodeId() uint32 {
	if x != nil {
		return x.NodeId
	}
	return 0
}

func (x *RGQLQueryTreeMutation_NodeMutation) GetOperation() RGQLQueryTreeMutation_SubtreeOperation {
	if x != nil {
		return x.Operation
	}
	return RGQLQueryTreeMutation_SUBTREE_ADD_CHILD
}

func (x *RGQLQueryTreeMutation_NodeMutation) GetNode() *RGQLQueryTreeNode {
	if x != nil {
		return x.Node
	}
	return nil
}

func (m *RGQLQueryFieldDirective) CloneVT() *RGQLQueryFieldDirective {
	if m == nil {
		return (*RGQLQueryFieldDirective)(nil)
	}
	r := new(RGQLQueryFieldDirective)
	r.Name = m.Name
	if rhs := m.Args; rhs != nil {
		tmpContainer := make([]*FieldArgument, len(rhs))
		for k, v := range rhs {
			tmpContainer[k] = v.CloneVT()
		}
		r.Args = tmpContainer
	}
	if len(m.unknownFields) > 0 {
		r.unknownFields = make([]byte, len(m.unknownFields))
		copy(r.unknownFields, m.unknownFields)
	}
	return r
}

func (m *RGQLQueryFieldDirective) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *RGQLQueryTreeNode) CloneVT() *RGQLQueryTreeNode {
	if m == nil {
		return (*RGQLQueryTreeNode)(nil)
	}
	r := new(RGQLQueryTreeNode)
	r.Id = m.Id
	r.FieldName = m.FieldName
	if rhs := m.Args; rhs != nil {
		tmpContainer := make([]*FieldArgument, len(rhs))
		for k, v := range rhs {
			tmpContainer[k] = v.CloneVT()
		}
		r.Args = tmpContainer
	}
	if rhs := m.Directive; rhs != nil {
		tmpContainer := make([]*RGQLQueryFieldDirective, len(rhs))
		for k, v := range rhs {
			tmpContainer[k] = v.CloneVT()
		}
		r.Directive = tmpContainer
	}
	if rhs := m.Children; rhs != nil {
		tmpContainer := make([]*RGQLQueryTreeNode, len(rhs))
		for k, v := range rhs {
			tmpContainer[k] = v.CloneVT()
		}
		r.Children = tmpContainer
	}
	if len(m.unknownFields) > 0 {
		r.unknownFields = make([]byte, len(m.unknownFields))
		copy(r.unknownFields, m.unknownFields)
	}
	return r
}

func (m *RGQLQueryTreeNode) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *FieldArgument) CloneVT() *FieldArgument {
	if m == nil {
		return (*FieldArgument)(nil)
	}
	r := new(FieldArgument)
	r.Name = m.Name
	r.VariableId = m.VariableId
	if len(m.unknownFields) > 0 {
		r.unknownFields = make([]byte, len(m.unknownFields))
		copy(r.unknownFields, m.unknownFields)
	}
	return r
}

func (m *FieldArgument) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *ASTVariable) CloneVT() *ASTVariable {
	if m == nil {
		return (*ASTVariable)(nil)
	}
	r := new(ASTVariable)
	r.Id = m.Id
	r.Value = m.Value.CloneVT()
	if len(m.unknownFields) > 0 {
		r.unknownFields = make([]byte, len(m.unknownFields))
		copy(r.unknownFields, m.unknownFields)
	}
	return r
}

func (m *ASTVariable) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *RGQLPrimitive) CloneVT() *RGQLPrimitive {
	if m == nil {
		return (*RGQLPrimitive)(nil)
	}
	r := new(RGQLPrimitive)
	r.Kind = m.Kind
	r.IntValue = m.IntValue
	r.FloatValue = m.FloatValue
	r.StringValue = m.StringValue
	r.BoolValue = m.BoolValue
	if len(m.unknownFields) > 0 {
		r.unknownFields = make([]byte, len(m.unknownFields))
		copy(r.unknownFields, m.unknownFields)
	}
	return r
}

func (m *RGQLPrimitive) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *RGQLClientMessage) CloneVT() *RGQLClientMessage {
	if m == nil {
		return (*RGQLClientMessage)(nil)
	}
	r := new(RGQLClientMessage)
	r.InitQuery = m.InitQuery.CloneVT()
	r.MutateTree = m.MutateTree.CloneVT()
	r.FinishQuery = m.FinishQuery.CloneVT()
	if len(m.unknownFields) > 0 {
		r.unknownFields = make([]byte, len(m.unknownFields))
		copy(r.unknownFields, m.unknownFields)
	}
	return r
}

func (m *RGQLClientMessage) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *RGQLQueryInit) CloneVT() *RGQLQueryInit {
	if m == nil {
		return (*RGQLQueryInit)(nil)
	}
	r := new(RGQLQueryInit)
	r.QueryId = m.QueryId
	r.ForceSerial = m.ForceSerial
	r.OperationType = m.OperationType
	if len(m.unknownFields) > 0 {
		r.unknownFields = make([]byte, len(m.unknownFields))
		copy(r.unknownFields, m.unknownFields)
	}
	return r
}

func (m *RGQLQueryInit) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *RGQLQueryTreeMutation_NodeMutation) CloneVT() *RGQLQueryTreeMutation_NodeMutation {
	if m == nil {
		return (*RGQLQueryTreeMutation_NodeMutation)(nil)
	}
	r := new(RGQLQueryTreeMutation_NodeMutation)
	r.NodeId = m.NodeId
	r.Operation = m.Operation
	r.Node = m.Node.CloneVT()
	if len(m.unknownFields) > 0 {
		r.unknownFields = make([]byte, len(m.unknownFields))
		copy(r.unknownFields, m.unknownFields)
	}
	return r
}

func (m *RGQLQueryTreeMutation_NodeMutation) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *RGQLQueryTreeMutation) CloneVT() *RGQLQueryTreeMutation {
	if m == nil {
		return (*RGQLQueryTreeMutation)(nil)
	}
	r := new(RGQLQueryTreeMutation)
	r.QueryId = m.QueryId
	if rhs := m.NodeMutation; rhs != nil {
		tmpContainer := make([]*RGQLQueryTreeMutation_NodeMutation, len(rhs))
		for k, v := range rhs {
			tmpContainer[k] = v.CloneVT()
		}
		r.NodeMutation = tmpContainer
	}
	if rhs := m.Variables; rhs != nil {
		tmpContainer := make([]*ASTVariable, len(rhs))
		for k, v := range rhs {
			tmpContainer[k] = v.CloneVT()
		}
		r.Variables = tmpContainer
	}
	if len(m.unknownFields) > 0 {
		r.unknownFields = make([]byte, len(m.unknownFields))
		copy(r.unknownFields, m.unknownFields)
	}
	return r
}

func (m *RGQLQueryTreeMutation) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *RGQLQueryFinish) CloneVT() *RGQLQueryFinish {
	if m == nil {
		return (*RGQLQueryFinish)(nil)
	}
	r := new(RGQLQueryFinish)
	r.QueryId = m.QueryId
	if len(m.unknownFields) > 0 {
		r.unknownFields = make([]byte, len(m.unknownFields))
		copy(r.unknownFields, m.unknownFields)
	}
	return r
}

func (m *RGQLQueryFinish) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *RGQLServerMessage) CloneVT() *RGQLServerMessage {
	if m == nil {
		return (*RGQLServerMessage)(nil)
	}
	r := new(RGQLServerMessage)
	r.QueryError = m.QueryError.CloneVT()
	r.ValueInit = m.ValueInit.CloneVT()
	r.ValueBatch = m.ValueBatch.CloneVT()
	r.ValueFinalize = m.ValueFinalize.CloneVT()
	if len(m.unknownFields) > 0 {
		r.unknownFields = make([]byte, len(m.unknownFields))
		copy(r.unknownFields, m.unknownFields)
	}
	return r
}

func (m *RGQLServerMessage) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *RGQLValueInit) CloneVT() *RGQLValueInit {
	if m == nil {
		return (*RGQLValueInit)(nil)
	}
	r := new(RGQLValueInit)
	r.ResultId = m.ResultId
	r.QueryId = m.QueryId
	r.CacheStrategy = m.CacheStrategy
	r.CacheSize = m.CacheSize
	if len(m.unknownFields) > 0 {
		r.unknownFields = make([]byte, len(m.unknownFields))
		copy(r.unknownFields, m.unknownFields)
	}
	return r
}

func (m *RGQLValueInit) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *RGQLValueFinalize) CloneVT() *RGQLValueFinalize {
	if m == nil {
		return (*RGQLValueFinalize)(nil)
	}
	r := new(RGQLValueFinalize)
	r.ResultId = m.ResultId
	if len(m.unknownFields) > 0 {
		r.unknownFields = make([]byte, len(m.unknownFields))
		copy(r.unknownFields, m.unknownFields)
	}
	return r
}

func (m *RGQLValueFinalize) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *RGQLQueryError) CloneVT() *RGQLQueryError {
	if m == nil {
		return (*RGQLQueryError)(nil)
	}
	r := new(RGQLQueryError)
	r.QueryId = m.QueryId
	r.QueryNodeId = m.QueryNodeId
	r.Error = m.Error
	if len(m.unknownFields) > 0 {
		r.unknownFields = make([]byte, len(m.unknownFields))
		copy(r.unknownFields, m.unknownFields)
	}
	return r
}

func (m *RGQLQueryError) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *RGQLValue) CloneVT() *RGQLValue {
	if m == nil {
		return (*RGQLValue)(nil)
	}
	r := new(RGQLValue)
	r.QueryNodeId = m.QueryNodeId
	r.ArrayIndex = m.ArrayIndex
	r.PosIdentifier = m.PosIdentifier
	r.Value = m.Value.CloneVT()
	r.Error = m.Error
	if len(m.unknownFields) > 0 {
		r.unknownFields = make([]byte, len(m.unknownFields))
		copy(r.unknownFields, m.unknownFields)
	}
	return r
}

func (m *RGQLValue) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (m *RGQLValueBatch) CloneVT() *RGQLValueBatch {
	if m == nil {
		return (*RGQLValueBatch)(nil)
	}
	r := new(RGQLValueBatch)
	r.ResultId = m.ResultId
	if rhs := m.Values; rhs != nil {
		tmpContainer := make([][]byte, len(rhs))
		for k, v := range rhs {
			tmpBytes := make([]byte, len(v))
			copy(tmpBytes, v)
			tmpContainer[k] = tmpBytes
		}
		r.Values = tmpContainer
	}
	if len(m.unknownFields) > 0 {
		r.unknownFields = make([]byte, len(m.unknownFields))
		copy(r.unknownFields, m.unknownFields)
	}
	return r
}

func (m *RGQLValueBatch) CloneMessageVT() protobuf_go_lite.CloneMessage {
	return m.CloneVT()
}

func (this *RGQLQueryFieldDirective) EqualVT(that *RGQLQueryFieldDirective) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if this.Name != that.Name {
		return false
	}
	if len(this.Args) != len(that.Args) {
		return false
	}
	for i, vx := range this.Args {
		vy := that.Args[i]
		if p, q := vx, vy; p != q {
			if p == nil {
				p = &FieldArgument{}
			}
			if q == nil {
				q = &FieldArgument{}
			}
			if !p.EqualVT(q) {
				return false
			}
		}
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *RGQLQueryFieldDirective) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*RGQLQueryFieldDirective)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}
func (this *RGQLQueryTreeNode) EqualVT(that *RGQLQueryTreeNode) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if this.Id != that.Id {
		return false
	}
	if this.FieldName != that.FieldName {
		return false
	}
	if len(this.Args) != len(that.Args) {
		return false
	}
	for i, vx := range this.Args {
		vy := that.Args[i]
		if p, q := vx, vy; p != q {
			if p == nil {
				p = &FieldArgument{}
			}
			if q == nil {
				q = &FieldArgument{}
			}
			if !p.EqualVT(q) {
				return false
			}
		}
	}
	if len(this.Directive) != len(that.Directive) {
		return false
	}
	for i, vx := range this.Directive {
		vy := that.Directive[i]
		if p, q := vx, vy; p != q {
			if p == nil {
				p = &RGQLQueryFieldDirective{}
			}
			if q == nil {
				q = &RGQLQueryFieldDirective{}
			}
			if !p.EqualVT(q) {
				return false
			}
		}
	}
	if len(this.Children) != len(that.Children) {
		return false
	}
	for i, vx := range this.Children {
		vy := that.Children[i]
		if p, q := vx, vy; p != q {
			if p == nil {
				p = &RGQLQueryTreeNode{}
			}
			if q == nil {
				q = &RGQLQueryTreeNode{}
			}
			if !p.EqualVT(q) {
				return false
			}
		}
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *RGQLQueryTreeNode) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*RGQLQueryTreeNode)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}
func (this *FieldArgument) EqualVT(that *FieldArgument) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if this.Name != that.Name {
		return false
	}
	if this.VariableId != that.VariableId {
		return false
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *FieldArgument) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*FieldArgument)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}
func (this *ASTVariable) EqualVT(that *ASTVariable) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if this.Id != that.Id {
		return false
	}
	if !this.Value.EqualVT(that.Value) {
		return false
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *ASTVariable) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*ASTVariable)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}
func (this *RGQLPrimitive) EqualVT(that *RGQLPrimitive) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if this.Kind != that.Kind {
		return false
	}
	if this.IntValue != that.IntValue {
		return false
	}
	if this.FloatValue != that.FloatValue {
		return false
	}
	if this.StringValue != that.StringValue {
		return false
	}
	if this.BoolValue != that.BoolValue {
		return false
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *RGQLPrimitive) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*RGQLPrimitive)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}
func (this *RGQLClientMessage) EqualVT(that *RGQLClientMessage) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if !this.InitQuery.EqualVT(that.InitQuery) {
		return false
	}
	if !this.MutateTree.EqualVT(that.MutateTree) {
		return false
	}
	if !this.FinishQuery.EqualVT(that.FinishQuery) {
		return false
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *RGQLClientMessage) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*RGQLClientMessage)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}
func (this *RGQLQueryInit) EqualVT(that *RGQLQueryInit) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if this.QueryId != that.QueryId {
		return false
	}
	if this.ForceSerial != that.ForceSerial {
		return false
	}
	if this.OperationType != that.OperationType {
		return false
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *RGQLQueryInit) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*RGQLQueryInit)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}
func (this *RGQLQueryTreeMutation_NodeMutation) EqualVT(that *RGQLQueryTreeMutation_NodeMutation) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if this.NodeId != that.NodeId {
		return false
	}
	if this.Operation != that.Operation {
		return false
	}
	if !this.Node.EqualVT(that.Node) {
		return false
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *RGQLQueryTreeMutation_NodeMutation) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*RGQLQueryTreeMutation_NodeMutation)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}
func (this *RGQLQueryTreeMutation) EqualVT(that *RGQLQueryTreeMutation) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if this.QueryId != that.QueryId {
		return false
	}
	if len(this.NodeMutation) != len(that.NodeMutation) {
		return false
	}
	for i, vx := range this.NodeMutation {
		vy := that.NodeMutation[i]
		if p, q := vx, vy; p != q {
			if p == nil {
				p = &RGQLQueryTreeMutation_NodeMutation{}
			}
			if q == nil {
				q = &RGQLQueryTreeMutation_NodeMutation{}
			}
			if !p.EqualVT(q) {
				return false
			}
		}
	}
	if len(this.Variables) != len(that.Variables) {
		return false
	}
	for i, vx := range this.Variables {
		vy := that.Variables[i]
		if p, q := vx, vy; p != q {
			if p == nil {
				p = &ASTVariable{}
			}
			if q == nil {
				q = &ASTVariable{}
			}
			if !p.EqualVT(q) {
				return false
			}
		}
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *RGQLQueryTreeMutation) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*RGQLQueryTreeMutation)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}
func (this *RGQLQueryFinish) EqualVT(that *RGQLQueryFinish) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if this.QueryId != that.QueryId {
		return false
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *RGQLQueryFinish) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*RGQLQueryFinish)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}
func (this *RGQLServerMessage) EqualVT(that *RGQLServerMessage) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if !this.QueryError.EqualVT(that.QueryError) {
		return false
	}
	if !this.ValueInit.EqualVT(that.ValueInit) {
		return false
	}
	if !this.ValueBatch.EqualVT(that.ValueBatch) {
		return false
	}
	if !this.ValueFinalize.EqualVT(that.ValueFinalize) {
		return false
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *RGQLServerMessage) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*RGQLServerMessage)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}
func (this *RGQLValueInit) EqualVT(that *RGQLValueInit) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if this.ResultId != that.ResultId {
		return false
	}
	if this.QueryId != that.QueryId {
		return false
	}
	if this.CacheStrategy != that.CacheStrategy {
		return false
	}
	if this.CacheSize != that.CacheSize {
		return false
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *RGQLValueInit) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*RGQLValueInit)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}
func (this *RGQLValueFinalize) EqualVT(that *RGQLValueFinalize) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if this.ResultId != that.ResultId {
		return false
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *RGQLValueFinalize) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*RGQLValueFinalize)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}
func (this *RGQLQueryError) EqualVT(that *RGQLQueryError) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if this.QueryId != that.QueryId {
		return false
	}
	if this.QueryNodeId != that.QueryNodeId {
		return false
	}
	if this.Error != that.Error {
		return false
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *RGQLQueryError) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*RGQLQueryError)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}
func (this *RGQLValue) EqualVT(that *RGQLValue) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if this.QueryNodeId != that.QueryNodeId {
		return false
	}
	if this.ArrayIndex != that.ArrayIndex {
		return false
	}
	if this.PosIdentifier != that.PosIdentifier {
		return false
	}
	if !this.Value.EqualVT(that.Value) {
		return false
	}
	if this.Error != that.Error {
		return false
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *RGQLValue) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*RGQLValue)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}
func (this *RGQLValueBatch) EqualVT(that *RGQLValueBatch) bool {
	if this == that {
		return true
	} else if this == nil || that == nil {
		return false
	}
	if this.ResultId != that.ResultId {
		return false
	}
	if len(this.Values) != len(that.Values) {
		return false
	}
	for i, vx := range this.Values {
		vy := that.Values[i]
		if string(vx) != string(vy) {
			return false
		}
	}
	return string(this.unknownFields) == string(that.unknownFields)
}

func (this *RGQLValueBatch) EqualMessageVT(thatMsg any) bool {
	that, ok := thatMsg.(*RGQLValueBatch)
	if !ok {
		return false
	}
	return this.EqualVT(that)
}

// MarshalProtoJSON marshals the RGQLQueryFieldDirective message to JSON.
func (x *RGQLQueryFieldDirective) MarshalProtoJSON(s *json.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.Name != "" || s.HasField("name") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("name")
		s.WriteString(x.Name)
	}
	if len(x.Args) > 0 || s.HasField("args") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("args")
		s.WriteArrayStart()
		var wroteElement bool
		for _, element := range x.Args {
			s.WriteMoreIf(&wroteElement)
			element.MarshalProtoJSON(s.WithField("args"))
		}
		s.WriteArrayEnd()
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the RGQLQueryFieldDirective to JSON.
func (x *RGQLQueryFieldDirective) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the RGQLQueryFieldDirective message from JSON.
func (x *RGQLQueryFieldDirective) UnmarshalProtoJSON(s *json.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.Skip() // ignore unknown field
		case "name":
			s.AddField("name")
			x.Name = s.ReadString()
		case "args":
			s.AddField("args")
			if s.ReadNil() {
				x.Args = nil
				return
			}
			s.ReadArray(func() {
				if s.ReadNil() {
					x.Args = append(x.Args, nil)
					return
				}
				v := &FieldArgument{}
				v.UnmarshalProtoJSON(s.WithField("args", false))
				if s.Err() != nil {
					return
				}
				x.Args = append(x.Args, v)
			})
		}
	})
}

// UnmarshalJSON unmarshals the RGQLQueryFieldDirective from JSON.
func (x *RGQLQueryFieldDirective) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the RGQLQueryTreeNode message to JSON.
func (x *RGQLQueryTreeNode) MarshalProtoJSON(s *json.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.Id != 0 || s.HasField("id") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("id")
		s.WriteUint32(x.Id)
	}
	if x.FieldName != "" || s.HasField("fieldName") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("fieldName")
		s.WriteString(x.FieldName)
	}
	if len(x.Args) > 0 || s.HasField("args") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("args")
		s.WriteArrayStart()
		var wroteElement bool
		for _, element := range x.Args {
			s.WriteMoreIf(&wroteElement)
			element.MarshalProtoJSON(s.WithField("args"))
		}
		s.WriteArrayEnd()
	}
	if len(x.Directive) > 0 || s.HasField("directive") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("directive")
		s.WriteArrayStart()
		var wroteElement bool
		for _, element := range x.Directive {
			s.WriteMoreIf(&wroteElement)
			element.MarshalProtoJSON(s.WithField("directive"))
		}
		s.WriteArrayEnd()
	}
	if len(x.Children) > 0 || s.HasField("children") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("children")
		s.WriteArrayStart()
		var wroteElement bool
		for _, element := range x.Children {
			s.WriteMoreIf(&wroteElement)
			element.MarshalProtoJSON(s.WithField("children"))
		}
		s.WriteArrayEnd()
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the RGQLQueryTreeNode to JSON.
func (x *RGQLQueryTreeNode) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the RGQLQueryTreeNode message from JSON.
func (x *RGQLQueryTreeNode) UnmarshalProtoJSON(s *json.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.Skip() // ignore unknown field
		case "id":
			s.AddField("id")
			x.Id = s.ReadUint32()
		case "field_name", "fieldName":
			s.AddField("field_name")
			x.FieldName = s.ReadString()
		case "args":
			s.AddField("args")
			if s.ReadNil() {
				x.Args = nil
				return
			}
			s.ReadArray(func() {
				if s.ReadNil() {
					x.Args = append(x.Args, nil)
					return
				}
				v := &FieldArgument{}
				v.UnmarshalProtoJSON(s.WithField("args", false))
				if s.Err() != nil {
					return
				}
				x.Args = append(x.Args, v)
			})
		case "directive":
			s.AddField("directive")
			if s.ReadNil() {
				x.Directive = nil
				return
			}
			s.ReadArray(func() {
				if s.ReadNil() {
					x.Directive = append(x.Directive, nil)
					return
				}
				v := &RGQLQueryFieldDirective{}
				v.UnmarshalProtoJSON(s.WithField("directive", false))
				if s.Err() != nil {
					return
				}
				x.Directive = append(x.Directive, v)
			})
		case "children":
			s.AddField("children")
			if s.ReadNil() {
				x.Children = nil
				return
			}
			s.ReadArray(func() {
				if s.ReadNil() {
					x.Children = append(x.Children, nil)
					return
				}
				v := &RGQLQueryTreeNode{}
				v.UnmarshalProtoJSON(s.WithField("children", false))
				if s.Err() != nil {
					return
				}
				x.Children = append(x.Children, v)
			})
		}
	})
}

// UnmarshalJSON unmarshals the RGQLQueryTreeNode from JSON.
func (x *RGQLQueryTreeNode) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the FieldArgument message to JSON.
func (x *FieldArgument) MarshalProtoJSON(s *json.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.Name != "" || s.HasField("name") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("name")
		s.WriteString(x.Name)
	}
	if x.VariableId != 0 || s.HasField("variableId") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("variableId")
		s.WriteUint32(x.VariableId)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the FieldArgument to JSON.
func (x *FieldArgument) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the FieldArgument message from JSON.
func (x *FieldArgument) UnmarshalProtoJSON(s *json.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.Skip() // ignore unknown field
		case "name":
			s.AddField("name")
			x.Name = s.ReadString()
		case "variable_id", "variableId":
			s.AddField("variable_id")
			x.VariableId = s.ReadUint32()
		}
	})
}

// UnmarshalJSON unmarshals the FieldArgument from JSON.
func (x *FieldArgument) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the ASTVariable message to JSON.
func (x *ASTVariable) MarshalProtoJSON(s *json.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.Id != 0 || s.HasField("id") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("id")
		s.WriteUint32(x.Id)
	}
	if x.Value != nil || s.HasField("value") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("value")
		x.Value.MarshalProtoJSON(s.WithField("value"))
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the ASTVariable to JSON.
func (x *ASTVariable) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the ASTVariable message from JSON.
func (x *ASTVariable) UnmarshalProtoJSON(s *json.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.Skip() // ignore unknown field
		case "id":
			s.AddField("id")
			x.Id = s.ReadUint32()
		case "value":
			if s.ReadNil() {
				x.Value = nil
				return
			}
			x.Value = &RGQLPrimitive{}
			x.Value.UnmarshalProtoJSON(s.WithField("value", true))
		}
	})
}

// UnmarshalJSON unmarshals the ASTVariable from JSON.
func (x *ASTVariable) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the RGQLPrimitive_Kind to JSON.
func (x RGQLPrimitive_Kind) MarshalProtoJSON(s *json.MarshalState) {
	s.WriteEnumString(int32(x), RGQLPrimitive_Kind_name)
}

// MarshalText marshals the RGQLPrimitive_Kind to text.
func (x RGQLPrimitive_Kind) MarshalText() ([]byte, error) {
	return []byte(json.GetEnumString(int32(x), RGQLPrimitive_Kind_name)), nil
}

// MarshalJSON marshals the RGQLPrimitive_Kind to JSON.
func (x RGQLPrimitive_Kind) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the RGQLPrimitive_Kind from JSON.
func (x *RGQLPrimitive_Kind) UnmarshalProtoJSON(s *json.UnmarshalState) {
	v := s.ReadEnum(RGQLPrimitive_Kind_value)
	if err := s.Err(); err != nil {
		s.SetErrorf("could not read Kind enum: %v", err)
		return
	}
	*x = RGQLPrimitive_Kind(v)
}

// UnmarshalText unmarshals the RGQLPrimitive_Kind from text.
func (x *RGQLPrimitive_Kind) UnmarshalText(b []byte) error {
	i, err := json.ParseEnumString(string(b), RGQLPrimitive_Kind_value)
	if err != nil {
		return err
	}
	*x = RGQLPrimitive_Kind(i)
	return nil
}

// UnmarshalJSON unmarshals the RGQLPrimitive_Kind from JSON.
func (x *RGQLPrimitive_Kind) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the RGQLPrimitive message to JSON.
func (x *RGQLPrimitive) MarshalProtoJSON(s *json.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.Kind != 0 || s.HasField("kind") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("kind")
		x.Kind.MarshalProtoJSON(s)
	}
	if x.IntValue != 0 || s.HasField("intValue") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("intValue")
		s.WriteInt32(x.IntValue)
	}
	if x.FloatValue != 0 || s.HasField("floatValue") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("floatValue")
		s.WriteFloat64(x.FloatValue)
	}
	if x.StringValue != "" || s.HasField("stringValue") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("stringValue")
		s.WriteString(x.StringValue)
	}
	if x.BoolValue || s.HasField("boolValue") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("boolValue")
		s.WriteBool(x.BoolValue)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the RGQLPrimitive to JSON.
func (x *RGQLPrimitive) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the RGQLPrimitive message from JSON.
func (x *RGQLPrimitive) UnmarshalProtoJSON(s *json.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.Skip() // ignore unknown field
		case "kind":
			s.AddField("kind")
			x.Kind.UnmarshalProtoJSON(s)
		case "int_value", "intValue":
			s.AddField("int_value")
			x.IntValue = s.ReadInt32()
		case "float_value", "floatValue":
			s.AddField("float_value")
			x.FloatValue = s.ReadFloat64()
		case "string_value", "stringValue":
			s.AddField("string_value")
			x.StringValue = s.ReadString()
		case "bool_value", "boolValue":
			s.AddField("bool_value")
			x.BoolValue = s.ReadBool()
		}
	})
}

// UnmarshalJSON unmarshals the RGQLPrimitive from JSON.
func (x *RGQLPrimitive) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the RGQLClientMessage message to JSON.
func (x *RGQLClientMessage) MarshalProtoJSON(s *json.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.InitQuery != nil || s.HasField("initQuery") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("initQuery")
		x.InitQuery.MarshalProtoJSON(s.WithField("initQuery"))
	}
	if x.MutateTree != nil || s.HasField("mutateTree") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("mutateTree")
		x.MutateTree.MarshalProtoJSON(s.WithField("mutateTree"))
	}
	if x.FinishQuery != nil || s.HasField("finishQuery") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("finishQuery")
		x.FinishQuery.MarshalProtoJSON(s.WithField("finishQuery"))
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the RGQLClientMessage to JSON.
func (x *RGQLClientMessage) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the RGQLClientMessage message from JSON.
func (x *RGQLClientMessage) UnmarshalProtoJSON(s *json.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.Skip() // ignore unknown field
		case "init_query", "initQuery":
			if s.ReadNil() {
				x.InitQuery = nil
				return
			}
			x.InitQuery = &RGQLQueryInit{}
			x.InitQuery.UnmarshalProtoJSON(s.WithField("init_query", true))
		case "mutate_tree", "mutateTree":
			if s.ReadNil() {
				x.MutateTree = nil
				return
			}
			x.MutateTree = &RGQLQueryTreeMutation{}
			x.MutateTree.UnmarshalProtoJSON(s.WithField("mutate_tree", true))
		case "finish_query", "finishQuery":
			if s.ReadNil() {
				x.FinishQuery = nil
				return
			}
			x.FinishQuery = &RGQLQueryFinish{}
			x.FinishQuery.UnmarshalProtoJSON(s.WithField("finish_query", true))
		}
	})
}

// UnmarshalJSON unmarshals the RGQLClientMessage from JSON.
func (x *RGQLClientMessage) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the RGQLQueryInit message to JSON.
func (x *RGQLQueryInit) MarshalProtoJSON(s *json.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.QueryId != 0 || s.HasField("queryId") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("queryId")
		s.WriteUint32(x.QueryId)
	}
	if x.ForceSerial || s.HasField("forceSerial") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("forceSerial")
		s.WriteBool(x.ForceSerial)
	}
	if x.OperationType != "" || s.HasField("operationType") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("operationType")
		s.WriteString(x.OperationType)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the RGQLQueryInit to JSON.
func (x *RGQLQueryInit) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the RGQLQueryInit message from JSON.
func (x *RGQLQueryInit) UnmarshalProtoJSON(s *json.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.Skip() // ignore unknown field
		case "query_id", "queryId":
			s.AddField("query_id")
			x.QueryId = s.ReadUint32()
		case "force_serial", "forceSerial":
			s.AddField("force_serial")
			x.ForceSerial = s.ReadBool()
		case "operation_type", "operationType":
			s.AddField("operation_type")
			x.OperationType = s.ReadString()
		}
	})
}

// UnmarshalJSON unmarshals the RGQLQueryInit from JSON.
func (x *RGQLQueryInit) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the RGQLQueryTreeMutation_SubtreeOperation to JSON.
func (x RGQLQueryTreeMutation_SubtreeOperation) MarshalProtoJSON(s *json.MarshalState) {
	s.WriteEnumString(int32(x), RGQLQueryTreeMutation_SubtreeOperation_name)
}

// MarshalText marshals the RGQLQueryTreeMutation_SubtreeOperation to text.
func (x RGQLQueryTreeMutation_SubtreeOperation) MarshalText() ([]byte, error) {
	return []byte(json.GetEnumString(int32(x), RGQLQueryTreeMutation_SubtreeOperation_name)), nil
}

// MarshalJSON marshals the RGQLQueryTreeMutation_SubtreeOperation to JSON.
func (x RGQLQueryTreeMutation_SubtreeOperation) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the RGQLQueryTreeMutation_SubtreeOperation from JSON.
func (x *RGQLQueryTreeMutation_SubtreeOperation) UnmarshalProtoJSON(s *json.UnmarshalState) {
	v := s.ReadEnum(RGQLQueryTreeMutation_SubtreeOperation_value)
	if err := s.Err(); err != nil {
		s.SetErrorf("could not read SubtreeOperation enum: %v", err)
		return
	}
	*x = RGQLQueryTreeMutation_SubtreeOperation(v)
}

// UnmarshalText unmarshals the RGQLQueryTreeMutation_SubtreeOperation from text.
func (x *RGQLQueryTreeMutation_SubtreeOperation) UnmarshalText(b []byte) error {
	i, err := json.ParseEnumString(string(b), RGQLQueryTreeMutation_SubtreeOperation_value)
	if err != nil {
		return err
	}
	*x = RGQLQueryTreeMutation_SubtreeOperation(i)
	return nil
}

// UnmarshalJSON unmarshals the RGQLQueryTreeMutation_SubtreeOperation from JSON.
func (x *RGQLQueryTreeMutation_SubtreeOperation) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the RGQLQueryTreeMutation_NodeMutation message to JSON.
func (x *RGQLQueryTreeMutation_NodeMutation) MarshalProtoJSON(s *json.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.NodeId != 0 || s.HasField("nodeId") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("nodeId")
		s.WriteUint32(x.NodeId)
	}
	if x.Operation != 0 || s.HasField("operation") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("operation")
		x.Operation.MarshalProtoJSON(s)
	}
	if x.Node != nil || s.HasField("node") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("node")
		x.Node.MarshalProtoJSON(s.WithField("node"))
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the RGQLQueryTreeMutation_NodeMutation to JSON.
func (x *RGQLQueryTreeMutation_NodeMutation) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the RGQLQueryTreeMutation_NodeMutation message from JSON.
func (x *RGQLQueryTreeMutation_NodeMutation) UnmarshalProtoJSON(s *json.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.Skip() // ignore unknown field
		case "node_id", "nodeId":
			s.AddField("node_id")
			x.NodeId = s.ReadUint32()
		case "operation":
			s.AddField("operation")
			x.Operation.UnmarshalProtoJSON(s)
		case "node":
			if s.ReadNil() {
				x.Node = nil
				return
			}
			x.Node = &RGQLQueryTreeNode{}
			x.Node.UnmarshalProtoJSON(s.WithField("node", true))
		}
	})
}

// UnmarshalJSON unmarshals the RGQLQueryTreeMutation_NodeMutation from JSON.
func (x *RGQLQueryTreeMutation_NodeMutation) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the RGQLQueryTreeMutation message to JSON.
func (x *RGQLQueryTreeMutation) MarshalProtoJSON(s *json.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.QueryId != 0 || s.HasField("queryId") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("queryId")
		s.WriteUint32(x.QueryId)
	}
	if len(x.NodeMutation) > 0 || s.HasField("nodeMutation") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("nodeMutation")
		s.WriteArrayStart()
		var wroteElement bool
		for _, element := range x.NodeMutation {
			s.WriteMoreIf(&wroteElement)
			element.MarshalProtoJSON(s.WithField("nodeMutation"))
		}
		s.WriteArrayEnd()
	}
	if len(x.Variables) > 0 || s.HasField("variables") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("variables")
		s.WriteArrayStart()
		var wroteElement bool
		for _, element := range x.Variables {
			s.WriteMoreIf(&wroteElement)
			element.MarshalProtoJSON(s.WithField("variables"))
		}
		s.WriteArrayEnd()
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the RGQLQueryTreeMutation to JSON.
func (x *RGQLQueryTreeMutation) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the RGQLQueryTreeMutation message from JSON.
func (x *RGQLQueryTreeMutation) UnmarshalProtoJSON(s *json.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.Skip() // ignore unknown field
		case "query_id", "queryId":
			s.AddField("query_id")
			x.QueryId = s.ReadUint32()
		case "node_mutation", "nodeMutation":
			s.AddField("node_mutation")
			if s.ReadNil() {
				x.NodeMutation = nil
				return
			}
			s.ReadArray(func() {
				if s.ReadNil() {
					x.NodeMutation = append(x.NodeMutation, nil)
					return
				}
				v := &RGQLQueryTreeMutation_NodeMutation{}
				v.UnmarshalProtoJSON(s.WithField("node_mutation", false))
				if s.Err() != nil {
					return
				}
				x.NodeMutation = append(x.NodeMutation, v)
			})
		case "variables":
			s.AddField("variables")
			if s.ReadNil() {
				x.Variables = nil
				return
			}
			s.ReadArray(func() {
				if s.ReadNil() {
					x.Variables = append(x.Variables, nil)
					return
				}
				v := &ASTVariable{}
				v.UnmarshalProtoJSON(s.WithField("variables", false))
				if s.Err() != nil {
					return
				}
				x.Variables = append(x.Variables, v)
			})
		}
	})
}

// UnmarshalJSON unmarshals the RGQLQueryTreeMutation from JSON.
func (x *RGQLQueryTreeMutation) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the RGQLQueryFinish message to JSON.
func (x *RGQLQueryFinish) MarshalProtoJSON(s *json.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.QueryId != 0 || s.HasField("queryId") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("queryId")
		s.WriteUint32(x.QueryId)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the RGQLQueryFinish to JSON.
func (x *RGQLQueryFinish) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the RGQLQueryFinish message from JSON.
func (x *RGQLQueryFinish) UnmarshalProtoJSON(s *json.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.Skip() // ignore unknown field
		case "query_id", "queryId":
			s.AddField("query_id")
			x.QueryId = s.ReadUint32()
		}
	})
}

// UnmarshalJSON unmarshals the RGQLQueryFinish from JSON.
func (x *RGQLQueryFinish) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the RGQLServerMessage message to JSON.
func (x *RGQLServerMessage) MarshalProtoJSON(s *json.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.QueryError != nil || s.HasField("queryError") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("queryError")
		x.QueryError.MarshalProtoJSON(s.WithField("queryError"))
	}
	if x.ValueInit != nil || s.HasField("valueInit") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("valueInit")
		x.ValueInit.MarshalProtoJSON(s.WithField("valueInit"))
	}
	if x.ValueBatch != nil || s.HasField("valueBatch") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("valueBatch")
		x.ValueBatch.MarshalProtoJSON(s.WithField("valueBatch"))
	}
	if x.ValueFinalize != nil || s.HasField("valueFinalize") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("valueFinalize")
		x.ValueFinalize.MarshalProtoJSON(s.WithField("valueFinalize"))
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the RGQLServerMessage to JSON.
func (x *RGQLServerMessage) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the RGQLServerMessage message from JSON.
func (x *RGQLServerMessage) UnmarshalProtoJSON(s *json.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.Skip() // ignore unknown field
		case "query_error", "queryError":
			if s.ReadNil() {
				x.QueryError = nil
				return
			}
			x.QueryError = &RGQLQueryError{}
			x.QueryError.UnmarshalProtoJSON(s.WithField("query_error", true))
		case "value_init", "valueInit":
			if s.ReadNil() {
				x.ValueInit = nil
				return
			}
			x.ValueInit = &RGQLValueInit{}
			x.ValueInit.UnmarshalProtoJSON(s.WithField("value_init", true))
		case "value_batch", "valueBatch":
			if s.ReadNil() {
				x.ValueBatch = nil
				return
			}
			x.ValueBatch = &RGQLValueBatch{}
			x.ValueBatch.UnmarshalProtoJSON(s.WithField("value_batch", true))
		case "value_finalize", "valueFinalize":
			if s.ReadNil() {
				x.ValueFinalize = nil
				return
			}
			x.ValueFinalize = &RGQLValueFinalize{}
			x.ValueFinalize.UnmarshalProtoJSON(s.WithField("value_finalize", true))
		}
	})
}

// UnmarshalJSON unmarshals the RGQLServerMessage from JSON.
func (x *RGQLServerMessage) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the RGQLValueInit_CacheStrategy to JSON.
func (x RGQLValueInit_CacheStrategy) MarshalProtoJSON(s *json.MarshalState) {
	s.WriteEnumString(int32(x), RGQLValueInit_CacheStrategy_name)
}

// MarshalText marshals the RGQLValueInit_CacheStrategy to text.
func (x RGQLValueInit_CacheStrategy) MarshalText() ([]byte, error) {
	return []byte(json.GetEnumString(int32(x), RGQLValueInit_CacheStrategy_name)), nil
}

// MarshalJSON marshals the RGQLValueInit_CacheStrategy to JSON.
func (x RGQLValueInit_CacheStrategy) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the RGQLValueInit_CacheStrategy from JSON.
func (x *RGQLValueInit_CacheStrategy) UnmarshalProtoJSON(s *json.UnmarshalState) {
	v := s.ReadEnum(RGQLValueInit_CacheStrategy_value)
	if err := s.Err(); err != nil {
		s.SetErrorf("could not read CacheStrategy enum: %v", err)
		return
	}
	*x = RGQLValueInit_CacheStrategy(v)
}

// UnmarshalText unmarshals the RGQLValueInit_CacheStrategy from text.
func (x *RGQLValueInit_CacheStrategy) UnmarshalText(b []byte) error {
	i, err := json.ParseEnumString(string(b), RGQLValueInit_CacheStrategy_value)
	if err != nil {
		return err
	}
	*x = RGQLValueInit_CacheStrategy(i)
	return nil
}

// UnmarshalJSON unmarshals the RGQLValueInit_CacheStrategy from JSON.
func (x *RGQLValueInit_CacheStrategy) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the RGQLValueInit message to JSON.
func (x *RGQLValueInit) MarshalProtoJSON(s *json.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.ResultId != 0 || s.HasField("resultId") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("resultId")
		s.WriteUint32(x.ResultId)
	}
	if x.QueryId != 0 || s.HasField("queryId") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("queryId")
		s.WriteUint32(x.QueryId)
	}
	if x.CacheStrategy != 0 || s.HasField("cacheStrategy") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("cacheStrategy")
		x.CacheStrategy.MarshalProtoJSON(s)
	}
	if x.CacheSize != 0 || s.HasField("cacheSize") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("cacheSize")
		s.WriteUint32(x.CacheSize)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the RGQLValueInit to JSON.
func (x *RGQLValueInit) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the RGQLValueInit message from JSON.
func (x *RGQLValueInit) UnmarshalProtoJSON(s *json.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.Skip() // ignore unknown field
		case "result_id", "resultId":
			s.AddField("result_id")
			x.ResultId = s.ReadUint32()
		case "query_id", "queryId":
			s.AddField("query_id")
			x.QueryId = s.ReadUint32()
		case "cache_strategy", "cacheStrategy":
			s.AddField("cache_strategy")
			x.CacheStrategy.UnmarshalProtoJSON(s)
		case "cache_size", "cacheSize":
			s.AddField("cache_size")
			x.CacheSize = s.ReadUint32()
		}
	})
}

// UnmarshalJSON unmarshals the RGQLValueInit from JSON.
func (x *RGQLValueInit) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the RGQLValueFinalize message to JSON.
func (x *RGQLValueFinalize) MarshalProtoJSON(s *json.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.ResultId != 0 || s.HasField("resultId") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("resultId")
		s.WriteUint32(x.ResultId)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the RGQLValueFinalize to JSON.
func (x *RGQLValueFinalize) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the RGQLValueFinalize message from JSON.
func (x *RGQLValueFinalize) UnmarshalProtoJSON(s *json.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.Skip() // ignore unknown field
		case "result_id", "resultId":
			s.AddField("result_id")
			x.ResultId = s.ReadUint32()
		}
	})
}

// UnmarshalJSON unmarshals the RGQLValueFinalize from JSON.
func (x *RGQLValueFinalize) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the RGQLQueryError message to JSON.
func (x *RGQLQueryError) MarshalProtoJSON(s *json.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.QueryId != 0 || s.HasField("queryId") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("queryId")
		s.WriteUint32(x.QueryId)
	}
	if x.QueryNodeId != 0 || s.HasField("queryNodeId") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("queryNodeId")
		s.WriteUint32(x.QueryNodeId)
	}
	if x.Error != "" || s.HasField("error") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("error")
		s.WriteString(x.Error)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the RGQLQueryError to JSON.
func (x *RGQLQueryError) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the RGQLQueryError message from JSON.
func (x *RGQLQueryError) UnmarshalProtoJSON(s *json.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.Skip() // ignore unknown field
		case "query_id", "queryId":
			s.AddField("query_id")
			x.QueryId = s.ReadUint32()
		case "query_node_id", "queryNodeId":
			s.AddField("query_node_id")
			x.QueryNodeId = s.ReadUint32()
		case "error":
			s.AddField("error")
			x.Error = s.ReadString()
		}
	})
}

// UnmarshalJSON unmarshals the RGQLQueryError from JSON.
func (x *RGQLQueryError) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the RGQLValue message to JSON.
func (x *RGQLValue) MarshalProtoJSON(s *json.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.QueryNodeId != 0 || s.HasField("queryNodeId") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("queryNodeId")
		s.WriteUint32(x.QueryNodeId)
	}
	if x.ArrayIndex != 0 || s.HasField("arrayIndex") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("arrayIndex")
		s.WriteUint32(x.ArrayIndex)
	}
	if x.PosIdentifier != 0 || s.HasField("posIdentifier") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("posIdentifier")
		s.WriteUint32(x.PosIdentifier)
	}
	if x.Value != nil || s.HasField("value") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("value")
		x.Value.MarshalProtoJSON(s.WithField("value"))
	}
	if x.Error != "" || s.HasField("error") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("error")
		s.WriteString(x.Error)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the RGQLValue to JSON.
func (x *RGQLValue) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the RGQLValue message from JSON.
func (x *RGQLValue) UnmarshalProtoJSON(s *json.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.Skip() // ignore unknown field
		case "query_node_id", "queryNodeId":
			s.AddField("query_node_id")
			x.QueryNodeId = s.ReadUint32()
		case "array_index", "arrayIndex":
			s.AddField("array_index")
			x.ArrayIndex = s.ReadUint32()
		case "pos_identifier", "posIdentifier":
			s.AddField("pos_identifier")
			x.PosIdentifier = s.ReadUint32()
		case "value":
			if s.ReadNil() {
				x.Value = nil
				return
			}
			x.Value = &RGQLPrimitive{}
			x.Value.UnmarshalProtoJSON(s.WithField("value", true))
		case "error":
			s.AddField("error")
			x.Error = s.ReadString()
		}
	})
}

// UnmarshalJSON unmarshals the RGQLValue from JSON.
func (x *RGQLValue) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

// MarshalProtoJSON marshals the RGQLValueBatch message to JSON.
func (x *RGQLValueBatch) MarshalProtoJSON(s *json.MarshalState) {
	if x == nil {
		s.WriteNil()
		return
	}
	s.WriteObjectStart()
	var wroteField bool
	if x.ResultId != 0 || s.HasField("resultId") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("resultId")
		s.WriteUint32(x.ResultId)
	}
	if len(x.Values) > 0 || s.HasField("values") {
		s.WriteMoreIf(&wroteField)
		s.WriteObjectField("values")
		s.WriteBytesArray(x.Values)
	}
	s.WriteObjectEnd()
}

// MarshalJSON marshals the RGQLValueBatch to JSON.
func (x *RGQLValueBatch) MarshalJSON() ([]byte, error) {
	return json.DefaultMarshalerConfig.Marshal(x)
}

// UnmarshalProtoJSON unmarshals the RGQLValueBatch message from JSON.
func (x *RGQLValueBatch) UnmarshalProtoJSON(s *json.UnmarshalState) {
	if s.ReadNil() {
		return
	}
	s.ReadObject(func(key string) {
		switch key {
		default:
			s.Skip() // ignore unknown field
		case "result_id", "resultId":
			s.AddField("result_id")
			x.ResultId = s.ReadUint32()
		case "values":
			s.AddField("values")
			if s.ReadNil() {
				x.Values = nil
				return
			}
			x.Values = s.ReadBytesArray()
		}
	})
}

// UnmarshalJSON unmarshals the RGQLValueBatch from JSON.
func (x *RGQLValueBatch) UnmarshalJSON(b []byte) error {
	return json.DefaultUnmarshalerConfig.Unmarshal(b, x)
}

func (m *RGQLQueryFieldDirective) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RGQLQueryFieldDirective) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *RGQLQueryFieldDirective) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if len(m.Args) > 0 {
		for iNdEx := len(m.Args) - 1; iNdEx >= 0; iNdEx-- {
			size, err := m.Args[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RGQLQueryTreeNode) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RGQLQueryTreeNode) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *RGQLQueryTreeNode) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if len(m.Children) > 0 {
		for iNdEx := len(m.Children) - 1; iNdEx >= 0; iNdEx-- {
			size, err := m.Children[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x2a
		}
	}
	if len(m.Directive) > 0 {
		for iNdEx := len(m.Directive) - 1; iNdEx >= 0; iNdEx-- {
			size, err := m.Directive[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.Args) > 0 {
		for iNdEx := len(m.Args) - 1; iNdEx >= 0; iNdEx-- {
			size, err := m.Args[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.FieldName) > 0 {
		i -= len(m.FieldName)
		copy(dAtA[i:], m.FieldName)
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(m.FieldName)))
		i--
		dAtA[i] = 0x12
	}
	if m.Id != 0 {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.Id))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *FieldArgument) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *FieldArgument) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *FieldArgument) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if m.VariableId != 0 {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.VariableId))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ASTVariable) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ASTVariable) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *ASTVariable) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if m.Value != nil {
		size, err := m.Value.MarshalToSizedBufferVT(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(size))
		i--
		dAtA[i] = 0x12
	}
	if m.Id != 0 {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.Id))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RGQLPrimitive) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RGQLPrimitive) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *RGQLPrimitive) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if m.BoolValue {
		i--
		if m.BoolValue {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x28
	}
	if len(m.StringValue) > 0 {
		i -= len(m.StringValue)
		copy(dAtA[i:], m.StringValue)
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(m.StringValue)))
		i--
		dAtA[i] = 0x22
	}
	if m.FloatValue != 0 {
		i -= 8
		binary.LittleEndian.PutUint64(dAtA[i:], uint64(math.Float64bits(float64(m.FloatValue))))
		i--
		dAtA[i] = 0x19
	}
	if m.IntValue != 0 {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.IntValue))
		i--
		dAtA[i] = 0x10
	}
	if m.Kind != 0 {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.Kind))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RGQLClientMessage) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RGQLClientMessage) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *RGQLClientMessage) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if m.FinishQuery != nil {
		size, err := m.FinishQuery.MarshalToSizedBufferVT(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(size))
		i--
		dAtA[i] = 0x1a
	}
	if m.MutateTree != nil {
		size, err := m.MutateTree.MarshalToSizedBufferVT(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(size))
		i--
		dAtA[i] = 0x12
	}
	if m.InitQuery != nil {
		size, err := m.InitQuery.MarshalToSizedBufferVT(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(size))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RGQLQueryInit) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RGQLQueryInit) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *RGQLQueryInit) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if len(m.OperationType) > 0 {
		i -= len(m.OperationType)
		copy(dAtA[i:], m.OperationType)
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(m.OperationType)))
		i--
		dAtA[i] = 0x1a
	}
	if m.ForceSerial {
		i--
		if m.ForceSerial {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if m.QueryId != 0 {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.QueryId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RGQLQueryTreeMutation_NodeMutation) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RGQLQueryTreeMutation_NodeMutation) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *RGQLQueryTreeMutation_NodeMutation) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if m.Node != nil {
		size, err := m.Node.MarshalToSizedBufferVT(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(size))
		i--
		dAtA[i] = 0x1a
	}
	if m.Operation != 0 {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.Operation))
		i--
		dAtA[i] = 0x10
	}
	if m.NodeId != 0 {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.NodeId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RGQLQueryTreeMutation) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RGQLQueryTreeMutation) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *RGQLQueryTreeMutation) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if len(m.Variables) > 0 {
		for iNdEx := len(m.Variables) - 1; iNdEx >= 0; iNdEx-- {
			size, err := m.Variables[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.NodeMutation) > 0 {
		for iNdEx := len(m.NodeMutation) - 1; iNdEx >= 0; iNdEx-- {
			size, err := m.NodeMutation[iNdEx].MarshalToSizedBufferVT(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(size))
			i--
			dAtA[i] = 0x12
		}
	}
	if m.QueryId != 0 {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.QueryId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RGQLQueryFinish) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RGQLQueryFinish) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *RGQLQueryFinish) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if m.QueryId != 0 {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.QueryId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RGQLServerMessage) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RGQLServerMessage) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *RGQLServerMessage) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if m.ValueFinalize != nil {
		size, err := m.ValueFinalize.MarshalToSizedBufferVT(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(size))
		i--
		dAtA[i] = 0x32
	}
	if m.ValueBatch != nil {
		size, err := m.ValueBatch.MarshalToSizedBufferVT(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(size))
		i--
		dAtA[i] = 0x2a
	}
	if m.ValueInit != nil {
		size, err := m.ValueInit.MarshalToSizedBufferVT(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(size))
		i--
		dAtA[i] = 0x22
	}
	if m.QueryError != nil {
		size, err := m.QueryError.MarshalToSizedBufferVT(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(size))
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}

func (m *RGQLValueInit) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RGQLValueInit) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *RGQLValueInit) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if m.CacheSize != 0 {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.CacheSize))
		i--
		dAtA[i] = 0x20
	}
	if m.CacheStrategy != 0 {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.CacheStrategy))
		i--
		dAtA[i] = 0x18
	}
	if m.QueryId != 0 {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.QueryId))
		i--
		dAtA[i] = 0x10
	}
	if m.ResultId != 0 {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.ResultId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RGQLValueFinalize) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RGQLValueFinalize) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *RGQLValueFinalize) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if m.ResultId != 0 {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.ResultId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RGQLQueryError) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RGQLQueryError) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *RGQLQueryError) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if len(m.Error) > 0 {
		i -= len(m.Error)
		copy(dAtA[i:], m.Error)
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(m.Error)))
		i--
		dAtA[i] = 0x1a
	}
	if m.QueryNodeId != 0 {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.QueryNodeId))
		i--
		dAtA[i] = 0x10
	}
	if m.QueryId != 0 {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.QueryId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RGQLValue) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RGQLValue) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *RGQLValue) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if len(m.Error) > 0 {
		i -= len(m.Error)
		copy(dAtA[i:], m.Error)
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(m.Error)))
		i--
		dAtA[i] = 0x2a
	}
	if m.Value != nil {
		size, err := m.Value.MarshalToSizedBufferVT(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(size))
		i--
		dAtA[i] = 0x22
	}
	if m.PosIdentifier != 0 {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.PosIdentifier))
		i--
		dAtA[i] = 0x18
	}
	if m.ArrayIndex != 0 {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.ArrayIndex))
		i--
		dAtA[i] = 0x10
	}
	if m.QueryNodeId != 0 {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.QueryNodeId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RGQLValueBatch) MarshalVT() (dAtA []byte, err error) {
	if m == nil {
		return nil, nil
	}
	size := m.SizeVT()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBufferVT(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *RGQLValueBatch) MarshalToVT(dAtA []byte) (int, error) {
	size := m.SizeVT()
	return m.MarshalToSizedBufferVT(dAtA[:size])
}

func (m *RGQLValueBatch) MarshalToSizedBufferVT(dAtA []byte) (int, error) {
	if m == nil {
		return 0, nil
	}
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.unknownFields != nil {
		i -= len(m.unknownFields)
		copy(dAtA[i:], m.unknownFields)
	}
	if len(m.Values) > 0 {
		for iNdEx := len(m.Values) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Values[iNdEx])
			copy(dAtA[i:], m.Values[iNdEx])
			i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(len(m.Values[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if m.ResultId != 0 {
		i = protobuf_go_lite.EncodeVarint(dAtA, i, uint64(m.ResultId))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *RGQLQueryFieldDirective) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + protobuf_go_lite.SizeOfVarint(uint64(l))
	}
	if len(m.Args) > 0 {
		for _, e := range m.Args {
			l = e.SizeVT()
			n += 1 + l + protobuf_go_lite.SizeOfVarint(uint64(l))
		}
	}
	n += len(m.unknownFields)
	return n
}

func (m *RGQLQueryTreeNode) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Id != 0 {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(m.Id))
	}
	l = len(m.FieldName)
	if l > 0 {
		n += 1 + l + protobuf_go_lite.SizeOfVarint(uint64(l))
	}
	if len(m.Args) > 0 {
		for _, e := range m.Args {
			l = e.SizeVT()
			n += 1 + l + protobuf_go_lite.SizeOfVarint(uint64(l))
		}
	}
	if len(m.Directive) > 0 {
		for _, e := range m.Directive {
			l = e.SizeVT()
			n += 1 + l + protobuf_go_lite.SizeOfVarint(uint64(l))
		}
	}
	if len(m.Children) > 0 {
		for _, e := range m.Children {
			l = e.SizeVT()
			n += 1 + l + protobuf_go_lite.SizeOfVarint(uint64(l))
		}
	}
	n += len(m.unknownFields)
	return n
}

func (m *FieldArgument) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + protobuf_go_lite.SizeOfVarint(uint64(l))
	}
	if m.VariableId != 0 {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(m.VariableId))
	}
	n += len(m.unknownFields)
	return n
}

func (m *ASTVariable) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Id != 0 {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(m.Id))
	}
	if m.Value != nil {
		l = m.Value.SizeVT()
		n += 1 + l + protobuf_go_lite.SizeOfVarint(uint64(l))
	}
	n += len(m.unknownFields)
	return n
}

func (m *RGQLPrimitive) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Kind != 0 {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(m.Kind))
	}
	if m.IntValue != 0 {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(m.IntValue))
	}
	if m.FloatValue != 0 {
		n += 9
	}
	l = len(m.StringValue)
	if l > 0 {
		n += 1 + l + protobuf_go_lite.SizeOfVarint(uint64(l))
	}
	if m.BoolValue {
		n += 2
	}
	n += len(m.unknownFields)
	return n
}

func (m *RGQLClientMessage) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.InitQuery != nil {
		l = m.InitQuery.SizeVT()
		n += 1 + l + protobuf_go_lite.SizeOfVarint(uint64(l))
	}
	if m.MutateTree != nil {
		l = m.MutateTree.SizeVT()
		n += 1 + l + protobuf_go_lite.SizeOfVarint(uint64(l))
	}
	if m.FinishQuery != nil {
		l = m.FinishQuery.SizeVT()
		n += 1 + l + protobuf_go_lite.SizeOfVarint(uint64(l))
	}
	n += len(m.unknownFields)
	return n
}

func (m *RGQLQueryInit) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.QueryId != 0 {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(m.QueryId))
	}
	if m.ForceSerial {
		n += 2
	}
	l = len(m.OperationType)
	if l > 0 {
		n += 1 + l + protobuf_go_lite.SizeOfVarint(uint64(l))
	}
	n += len(m.unknownFields)
	return n
}

func (m *RGQLQueryTreeMutation_NodeMutation) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.NodeId != 0 {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(m.NodeId))
	}
	if m.Operation != 0 {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(m.Operation))
	}
	if m.Node != nil {
		l = m.Node.SizeVT()
		n += 1 + l + protobuf_go_lite.SizeOfVarint(uint64(l))
	}
	n += len(m.unknownFields)
	return n
}

func (m *RGQLQueryTreeMutation) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.QueryId != 0 {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(m.QueryId))
	}
	if len(m.NodeMutation) > 0 {
		for _, e := range m.NodeMutation {
			l = e.SizeVT()
			n += 1 + l + protobuf_go_lite.SizeOfVarint(uint64(l))
		}
	}
	if len(m.Variables) > 0 {
		for _, e := range m.Variables {
			l = e.SizeVT()
			n += 1 + l + protobuf_go_lite.SizeOfVarint(uint64(l))
		}
	}
	n += len(m.unknownFields)
	return n
}

func (m *RGQLQueryFinish) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.QueryId != 0 {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(m.QueryId))
	}
	n += len(m.unknownFields)
	return n
}

func (m *RGQLServerMessage) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.QueryError != nil {
		l = m.QueryError.SizeVT()
		n += 1 + l + protobuf_go_lite.SizeOfVarint(uint64(l))
	}
	if m.ValueInit != nil {
		l = m.ValueInit.SizeVT()
		n += 1 + l + protobuf_go_lite.SizeOfVarint(uint64(l))
	}
	if m.ValueBatch != nil {
		l = m.ValueBatch.SizeVT()
		n += 1 + l + protobuf_go_lite.SizeOfVarint(uint64(l))
	}
	if m.ValueFinalize != nil {
		l = m.ValueFinalize.SizeVT()
		n += 1 + l + protobuf_go_lite.SizeOfVarint(uint64(l))
	}
	n += len(m.unknownFields)
	return n
}

func (m *RGQLValueInit) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ResultId != 0 {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(m.ResultId))
	}
	if m.QueryId != 0 {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(m.QueryId))
	}
	if m.CacheStrategy != 0 {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(m.CacheStrategy))
	}
	if m.CacheSize != 0 {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(m.CacheSize))
	}
	n += len(m.unknownFields)
	return n
}

func (m *RGQLValueFinalize) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ResultId != 0 {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(m.ResultId))
	}
	n += len(m.unknownFields)
	return n
}

func (m *RGQLQueryError) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.QueryId != 0 {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(m.QueryId))
	}
	if m.QueryNodeId != 0 {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(m.QueryNodeId))
	}
	l = len(m.Error)
	if l > 0 {
		n += 1 + l + protobuf_go_lite.SizeOfVarint(uint64(l))
	}
	n += len(m.unknownFields)
	return n
}

func (m *RGQLValue) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.QueryNodeId != 0 {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(m.QueryNodeId))
	}
	if m.ArrayIndex != 0 {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(m.ArrayIndex))
	}
	if m.PosIdentifier != 0 {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(m.PosIdentifier))
	}
	if m.Value != nil {
		l = m.Value.SizeVT()
		n += 1 + l + protobuf_go_lite.SizeOfVarint(uint64(l))
	}
	l = len(m.Error)
	if l > 0 {
		n += 1 + l + protobuf_go_lite.SizeOfVarint(uint64(l))
	}
	n += len(m.unknownFields)
	return n
}

func (m *RGQLValueBatch) SizeVT() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ResultId != 0 {
		n += 1 + protobuf_go_lite.SizeOfVarint(uint64(m.ResultId))
	}
	if len(m.Values) > 0 {
		for _, b := range m.Values {
			l = len(b)
			n += 1 + l + protobuf_go_lite.SizeOfVarint(uint64(l))
		}
	}
	n += len(m.unknownFields)
	return n
}

func (x *RGQLQueryFieldDirective) MarshalProtoText() string {
	var sb strings.Builder
	sb.WriteString("RGQLQueryFieldDirective { ")
	if x.Name != "" {
		sb.WriteString(" name: ")
		sb.WriteString(strconv.Quote(x.Name))
	}
	if len(x.Args) > 0 {
		sb.WriteString(" args: [")
		for i, v := range x.Args {
			if i > 0 {
				sb.WriteString(", ")
			}
			sb.WriteString(v.MarshalProtoText())
		}
		sb.WriteString("]")
	}
	sb.WriteString("}")
	return sb.String()
}
func (x *RGQLQueryFieldDirective) String() string {
	return x.MarshalProtoText()
}
func (x *RGQLQueryTreeNode) MarshalProtoText() string {
	var sb strings.Builder
	sb.WriteString("RGQLQueryTreeNode { ")
	if x.Id != 0 {
		sb.WriteString(" id: ")
		sb.WriteString(strconv.FormatUint(uint64(x.Id), 10))
	}
	if x.FieldName != "" {
		sb.WriteString(" field_name: ")
		sb.WriteString(strconv.Quote(x.FieldName))
	}
	if len(x.Args) > 0 {
		sb.WriteString(" args: [")
		for i, v := range x.Args {
			if i > 0 {
				sb.WriteString(", ")
			}
			sb.WriteString(v.MarshalProtoText())
		}
		sb.WriteString("]")
	}
	if len(x.Directive) > 0 {
		sb.WriteString(" directive: [")
		for i, v := range x.Directive {
			if i > 0 {
				sb.WriteString(", ")
			}
			sb.WriteString(v.MarshalProtoText())
		}
		sb.WriteString("]")
	}
	if len(x.Children) > 0 {
		sb.WriteString(" children: [")
		for i, v := range x.Children {
			if i > 0 {
				sb.WriteString(", ")
			}
			sb.WriteString(v.MarshalProtoText())
		}
		sb.WriteString("]")
	}
	sb.WriteString("}")
	return sb.String()
}
func (x *RGQLQueryTreeNode) String() string {
	return x.MarshalProtoText()
}
func (x *FieldArgument) MarshalProtoText() string {
	var sb strings.Builder
	sb.WriteString("FieldArgument { ")
	if x.Name != "" {
		sb.WriteString(" name: ")
		sb.WriteString(strconv.Quote(x.Name))
	}
	if x.VariableId != 0 {
		sb.WriteString(" variable_id: ")
		sb.WriteString(strconv.FormatUint(uint64(x.VariableId), 10))
	}
	sb.WriteString("}")
	return sb.String()
}
func (x *FieldArgument) String() string {
	return x.MarshalProtoText()
}
func (x *ASTVariable) MarshalProtoText() string {
	var sb strings.Builder
	sb.WriteString("ASTVariable { ")
	if x.Id != 0 {
		sb.WriteString(" id: ")
		sb.WriteString(strconv.FormatUint(uint64(x.Id), 10))
	}
	if x.Value != nil {
		sb.WriteString(" value: ")
		sb.WriteString(x.Value.MarshalProtoText())
	}
	sb.WriteString("}")
	return sb.String()
}
func (x *ASTVariable) String() string {
	return x.MarshalProtoText()
}
func (x RGQLPrimitive_Kind) MarshalProtoText() string {
	return x.String()
}
func (x *RGQLPrimitive) MarshalProtoText() string {
	var sb strings.Builder
	sb.WriteString("RGQLPrimitive { ")
	if x.Kind != 0 {
		sb.WriteString(" kind: ")
		sb.WriteString(RGQLPrimitive_Kind(x.Kind).String())
	}
	if x.IntValue != 0 {
		sb.WriteString(" int_value: ")
		sb.WriteString(strconv.FormatInt(int64(x.IntValue), 10))
	}
	if x.FloatValue != 0 {
		sb.WriteString(" float_value: ")
		sb.WriteString(strconv.FormatFloat(x.FloatValue, 'g', -1, 64))
	}
	if x.StringValue != "" {
		sb.WriteString(" string_value: ")
		sb.WriteString(strconv.Quote(x.StringValue))
	}
	if x.BoolValue {
		sb.WriteString(" bool_value: ")
		sb.WriteString(strconv.FormatBool(x.BoolValue))
	}
	sb.WriteString("}")
	return sb.String()
}
func (x *RGQLPrimitive) String() string {
	return x.MarshalProtoText()
}
func (x *RGQLClientMessage) MarshalProtoText() string {
	var sb strings.Builder
	sb.WriteString("RGQLClientMessage { ")
	if x.InitQuery != nil {
		sb.WriteString(" init_query: ")
		sb.WriteString(x.InitQuery.MarshalProtoText())
	}
	if x.MutateTree != nil {
		sb.WriteString(" mutate_tree: ")
		sb.WriteString(x.MutateTree.MarshalProtoText())
	}
	if x.FinishQuery != nil {
		sb.WriteString(" finish_query: ")
		sb.WriteString(x.FinishQuery.MarshalProtoText())
	}
	sb.WriteString("}")
	return sb.String()
}
func (x *RGQLClientMessage) String() string {
	return x.MarshalProtoText()
}
func (x *RGQLQueryInit) MarshalProtoText() string {
	var sb strings.Builder
	sb.WriteString("RGQLQueryInit { ")
	if x.QueryId != 0 {
		sb.WriteString(" query_id: ")
		sb.WriteString(strconv.FormatUint(uint64(x.QueryId), 10))
	}
	if x.ForceSerial {
		sb.WriteString(" force_serial: ")
		sb.WriteString(strconv.FormatBool(x.ForceSerial))
	}
	if x.OperationType != "" {
		sb.WriteString(" operation_type: ")
		sb.WriteString(strconv.Quote(x.OperationType))
	}
	sb.WriteString("}")
	return sb.String()
}
func (x *RGQLQueryInit) String() string {
	return x.MarshalProtoText()
}
func (x RGQLQueryTreeMutation_SubtreeOperation) MarshalProtoText() string {
	return x.String()
}
func (x *RGQLQueryTreeMutation_NodeMutation) MarshalProtoText() string {
	var sb strings.Builder
	sb.WriteString("NodeMutation { ")
	if x.NodeId != 0 {
		sb.WriteString(" node_id: ")
		sb.WriteString(strconv.FormatUint(uint64(x.NodeId), 10))
	}
	if x.Operation != 0 {
		sb.WriteString(" operation: ")
		sb.WriteString(RGQLQueryTreeMutation_SubtreeOperation(x.Operation).String())
	}
	if x.Node != nil {
		sb.WriteString(" node: ")
		sb.WriteString(x.Node.MarshalProtoText())
	}
	sb.WriteString("}")
	return sb.String()
}
func (x *RGQLQueryTreeMutation_NodeMutation) String() string {
	return x.MarshalProtoText()
}
func (x *RGQLQueryTreeMutation) MarshalProtoText() string {
	var sb strings.Builder
	sb.WriteString("RGQLQueryTreeMutation { ")
	if x.QueryId != 0 {
		sb.WriteString(" query_id: ")
		sb.WriteString(strconv.FormatUint(uint64(x.QueryId), 10))
	}
	if len(x.NodeMutation) > 0 {
		sb.WriteString(" node_mutation: [")
		for i, v := range x.NodeMutation {
			if i > 0 {
				sb.WriteString(", ")
			}
			sb.WriteString(v.MarshalProtoText())
		}
		sb.WriteString("]")
	}
	if len(x.Variables) > 0 {
		sb.WriteString(" variables: [")
		for i, v := range x.Variables {
			if i > 0 {
				sb.WriteString(", ")
			}
			sb.WriteString(v.MarshalProtoText())
		}
		sb.WriteString("]")
	}
	sb.WriteString("}")
	return sb.String()
}
func (x *RGQLQueryTreeMutation) String() string {
	return x.MarshalProtoText()
}
func (x *RGQLQueryFinish) MarshalProtoText() string {
	var sb strings.Builder
	sb.WriteString("RGQLQueryFinish { ")
	if x.QueryId != 0 {
		sb.WriteString(" query_id: ")
		sb.WriteString(strconv.FormatUint(uint64(x.QueryId), 10))
	}
	sb.WriteString("}")
	return sb.String()
}
func (x *RGQLQueryFinish) String() string {
	return x.MarshalProtoText()
}
func (x *RGQLServerMessage) MarshalProtoText() string {
	var sb strings.Builder
	sb.WriteString("RGQLServerMessage { ")
	if x.QueryError != nil {
		sb.WriteString(" query_error: ")
		sb.WriteString(x.QueryError.MarshalProtoText())
	}
	if x.ValueInit != nil {
		sb.WriteString(" value_init: ")
		sb.WriteString(x.ValueInit.MarshalProtoText())
	}
	if x.ValueBatch != nil {
		sb.WriteString(" value_batch: ")
		sb.WriteString(x.ValueBatch.MarshalProtoText())
	}
	if x.ValueFinalize != nil {
		sb.WriteString(" value_finalize: ")
		sb.WriteString(x.ValueFinalize.MarshalProtoText())
	}
	sb.WriteString("}")
	return sb.String()
}
func (x *RGQLServerMessage) String() string {
	return x.MarshalProtoText()
}
func (x RGQLValueInit_CacheStrategy) MarshalProtoText() string {
	return x.String()
}
func (x *RGQLValueInit) MarshalProtoText() string {
	var sb strings.Builder
	sb.WriteString("RGQLValueInit { ")
	if x.ResultId != 0 {
		sb.WriteString(" result_id: ")
		sb.WriteString(strconv.FormatUint(uint64(x.ResultId), 10))
	}
	if x.QueryId != 0 {
		sb.WriteString(" query_id: ")
		sb.WriteString(strconv.FormatUint(uint64(x.QueryId), 10))
	}
	if x.CacheStrategy != 0 {
		sb.WriteString(" cache_strategy: ")
		sb.WriteString(RGQLValueInit_CacheStrategy(x.CacheStrategy).String())
	}
	if x.CacheSize != 0 {
		sb.WriteString(" cache_size: ")
		sb.WriteString(strconv.FormatUint(uint64(x.CacheSize), 10))
	}
	sb.WriteString("}")
	return sb.String()
}
func (x *RGQLValueInit) String() string {
	return x.MarshalProtoText()
}
func (x *RGQLValueFinalize) MarshalProtoText() string {
	var sb strings.Builder
	sb.WriteString("RGQLValueFinalize { ")
	if x.ResultId != 0 {
		sb.WriteString(" result_id: ")
		sb.WriteString(strconv.FormatUint(uint64(x.ResultId), 10))
	}
	sb.WriteString("}")
	return sb.String()
}
func (x *RGQLValueFinalize) String() string {
	return x.MarshalProtoText()
}
func (x *RGQLQueryError) MarshalProtoText() string {
	var sb strings.Builder
	sb.WriteString("RGQLQueryError { ")
	if x.QueryId != 0 {
		sb.WriteString(" query_id: ")
		sb.WriteString(strconv.FormatUint(uint64(x.QueryId), 10))
	}
	if x.QueryNodeId != 0 {
		sb.WriteString(" query_node_id: ")
		sb.WriteString(strconv.FormatUint(uint64(x.QueryNodeId), 10))
	}
	if x.Error != "" {
		sb.WriteString(" error: ")
		sb.WriteString(strconv.Quote(x.Error))
	}
	sb.WriteString("}")
	return sb.String()
}
func (x *RGQLQueryError) String() string {
	return x.MarshalProtoText()
}
func (x *RGQLValue) MarshalProtoText() string {
	var sb strings.Builder
	sb.WriteString("RGQLValue { ")
	if x.QueryNodeId != 0 {
		sb.WriteString(" query_node_id: ")
		sb.WriteString(strconv.FormatUint(uint64(x.QueryNodeId), 10))
	}
	if x.ArrayIndex != 0 {
		sb.WriteString(" array_index: ")
		sb.WriteString(strconv.FormatUint(uint64(x.ArrayIndex), 10))
	}
	if x.PosIdentifier != 0 {
		sb.WriteString(" pos_identifier: ")
		sb.WriteString(strconv.FormatUint(uint64(x.PosIdentifier), 10))
	}
	if x.Value != nil {
		sb.WriteString(" value: ")
		sb.WriteString(x.Value.MarshalProtoText())
	}
	if x.Error != "" {
		sb.WriteString(" error: ")
		sb.WriteString(strconv.Quote(x.Error))
	}
	sb.WriteString("}")
	return sb.String()
}
func (x *RGQLValue) String() string {
	return x.MarshalProtoText()
}
func (x *RGQLValueBatch) MarshalProtoText() string {
	var sb strings.Builder
	sb.WriteString("RGQLValueBatch { ")
	if x.ResultId != 0 {
		sb.WriteString(" result_id: ")
		sb.WriteString(strconv.FormatUint(uint64(x.ResultId), 10))
	}
	if len(x.Values) > 0 {
		sb.WriteString(" values: [")
		for i, v := range x.Values {
			if i > 0 {
				sb.WriteString(", ")
			}
			sb.WriteString("\"")
			sb.WriteString(base64.StdEncoding.EncodeToString(v))
			sb.WriteString("\"")
		}
		sb.WriteString("]")
	}
	sb.WriteString("}")
	return sb.String()
}
func (x *RGQLValueBatch) String() string {
	return x.MarshalProtoText()
}
func (m *RGQLQueryFieldDirective) UnmarshalVT(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return protobuf_go_lite.ErrIntOverflow
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RGQLQueryFieldDirective: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RGQLQueryFieldDirective: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Args", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Args = append(m.Args, &FieldArgument{})
			if err := m.Args[len(m.Args)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RGQLQueryTreeNode) UnmarshalVT(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return protobuf_go_lite.ErrIntOverflow
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RGQLQueryTreeNode: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RGQLQueryTreeNode: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			m.Id = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Id |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FieldName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FieldName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Args", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Args = append(m.Args, &FieldArgument{})
			if err := m.Args[len(m.Args)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Directive", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Directive = append(m.Directive, &RGQLQueryFieldDirective{})
			if err := m.Directive[len(m.Directive)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Children", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Children = append(m.Children, &RGQLQueryTreeNode{})
			if err := m.Children[len(m.Children)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *FieldArgument) UnmarshalVT(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return protobuf_go_lite.ErrIntOverflow
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: FieldArgument: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FieldArgument: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field VariableId", wireType)
			}
			m.VariableId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.VariableId |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ASTVariable) UnmarshalVT(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return protobuf_go_lite.ErrIntOverflow
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ASTVariable: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ASTVariable: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			m.Id = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Id |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Value == nil {
				m.Value = &RGQLPrimitive{}
			}
			if err := m.Value.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RGQLPrimitive) UnmarshalVT(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return protobuf_go_lite.ErrIntOverflow
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RGQLPrimitive: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RGQLPrimitive: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
			}
			m.Kind = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Kind |= RGQLPrimitive_Kind(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IntValue", wireType)
			}
			m.IntValue = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.IntValue |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 1 {
				return fmt.Errorf("proto: wrong wireType = %d for field FloatValue", wireType)
			}
			var v uint64
			if (iNdEx + 8) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint64(binary.LittleEndian.Uint64(dAtA[iNdEx:]))
			iNdEx += 8
			m.FloatValue = float64(math.Float64frombits(v))
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StringValue", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StringValue = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BoolValue", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.BoolValue = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RGQLClientMessage) UnmarshalVT(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return protobuf_go_lite.ErrIntOverflow
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RGQLClientMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RGQLClientMessage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InitQuery", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.InitQuery == nil {
				m.InitQuery = &RGQLQueryInit{}
			}
			if err := m.InitQuery.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MutateTree", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MutateTree == nil {
				m.MutateTree = &RGQLQueryTreeMutation{}
			}
			if err := m.MutateTree.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FinishQuery", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.FinishQuery == nil {
				m.FinishQuery = &RGQLQueryFinish{}
			}
			if err := m.FinishQuery.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RGQLQueryInit) UnmarshalVT(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return protobuf_go_lite.ErrIntOverflow
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RGQLQueryInit: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RGQLQueryInit: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field QueryId", wireType)
			}
			m.QueryId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.QueryId |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ForceSerial", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ForceSerial = bool(v != 0)
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OperationType", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.OperationType = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RGQLQueryTreeMutation_NodeMutation) UnmarshalVT(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return protobuf_go_lite.ErrIntOverflow
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RGQLQueryTreeMutation_NodeMutation: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RGQLQueryTreeMutation_NodeMutation: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field NodeId", wireType)
			}
			m.NodeId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.NodeId |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Operation", wireType)
			}
			m.Operation = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Operation |= RGQLQueryTreeMutation_SubtreeOperation(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Node", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Node == nil {
				m.Node = &RGQLQueryTreeNode{}
			}
			if err := m.Node.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RGQLQueryTreeMutation) UnmarshalVT(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return protobuf_go_lite.ErrIntOverflow
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RGQLQueryTreeMutation: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RGQLQueryTreeMutation: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field QueryId", wireType)
			}
			m.QueryId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.QueryId |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NodeMutation", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NodeMutation = append(m.NodeMutation, &RGQLQueryTreeMutation_NodeMutation{})
			if err := m.NodeMutation[len(m.NodeMutation)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Variables", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Variables = append(m.Variables, &ASTVariable{})
			if err := m.Variables[len(m.Variables)-1].UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RGQLQueryFinish) UnmarshalVT(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return protobuf_go_lite.ErrIntOverflow
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RGQLQueryFinish: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RGQLQueryFinish: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field QueryId", wireType)
			}
			m.QueryId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.QueryId |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RGQLServerMessage) UnmarshalVT(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return protobuf_go_lite.ErrIntOverflow
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RGQLServerMessage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RGQLServerMessage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field QueryError", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.QueryError == nil {
				m.QueryError = &RGQLQueryError{}
			}
			if err := m.QueryError.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValueInit", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ValueInit == nil {
				m.ValueInit = &RGQLValueInit{}
			}
			if err := m.ValueInit.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValueBatch", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ValueBatch == nil {
				m.ValueBatch = &RGQLValueBatch{}
			}
			if err := m.ValueBatch.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValueFinalize", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ValueFinalize == nil {
				m.ValueFinalize = &RGQLValueFinalize{}
			}
			if err := m.ValueFinalize.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RGQLValueInit) UnmarshalVT(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return protobuf_go_lite.ErrIntOverflow
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RGQLValueInit: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RGQLValueInit: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResultId", wireType)
			}
			m.ResultId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ResultId |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field QueryId", wireType)
			}
			m.QueryId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.QueryId |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CacheStrategy", wireType)
			}
			m.CacheStrategy = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CacheStrategy |= RGQLValueInit_CacheStrategy(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CacheSize", wireType)
			}
			m.CacheSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CacheSize |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RGQLValueFinalize) UnmarshalVT(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return protobuf_go_lite.ErrIntOverflow
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RGQLValueFinalize: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RGQLValueFinalize: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResultId", wireType)
			}
			m.ResultId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ResultId |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RGQLQueryError) UnmarshalVT(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return protobuf_go_lite.ErrIntOverflow
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RGQLQueryError: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RGQLQueryError: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field QueryId", wireType)
			}
			m.QueryId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.QueryId |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field QueryNodeId", wireType)
			}
			m.QueryNodeId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.QueryNodeId |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Error = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RGQLValue) UnmarshalVT(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return protobuf_go_lite.ErrIntOverflow
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RGQLValue: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RGQLValue: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field QueryNodeId", wireType)
			}
			m.QueryNodeId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.QueryNodeId |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ArrayIndex", wireType)
			}
			m.ArrayIndex = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ArrayIndex |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field PosIdentifier", wireType)
			}
			m.PosIdentifier = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.PosIdentifier |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Value == nil {
				m.Value = &RGQLPrimitive{}
			}
			if err := m.Value.UnmarshalVT(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Error = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RGQLValueBatch) UnmarshalVT(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return protobuf_go_lite.ErrIntOverflow
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: RGQLValueBatch: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RGQLValueBatch: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResultId", wireType)
			}
			m.ResultId = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ResultId |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return protobuf_go_lite.ErrIntOverflow
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				byteLen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			postIndex := iNdEx + byteLen
			if postIndex < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Values = append(m.Values, make([]byte, postIndex-iNdEx))
			copy(m.Values[len(m.Values)-1], dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := protobuf_go_lite.Skip(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return protobuf_go_lite.ErrInvalidLength
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.unknownFields = append(m.unknownFields, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}