// Code generated by protoc-gen-go. DO NOT EDIT.
// source: search.proto

package otsprotocol

import (
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	math "math"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion3 // please upgrade the proto package

// query
type QueryType int32

const (
	QueryType_MATCH_QUERY            QueryType = 1
	QueryType_MATCH_PHRASE_QUERY     QueryType = 2
	QueryType_TERM_QUERY             QueryType = 3
	QueryType_RANGE_QUERY            QueryType = 4
	QueryType_PREFIX_QUERY           QueryType = 5
	QueryType_BOOL_QUERY             QueryType = 6
	QueryType_CONST_SCORE_QUERY      QueryType = 7
	QueryType_FUNCTION_SCORE_QUERY   QueryType = 8
	QueryType_NESTED_QUERY           QueryType = 9
	QueryType_WILDCARD_QUERY         QueryType = 10
	QueryType_MATCH_ALL_QUERY        QueryType = 11
	QueryType_GEO_BOUNDING_BOX_QUERY QueryType = 12
	QueryType_GEO_DISTANCE_QUERY     QueryType = 13
	QueryType_GEO_POLYGON_QUERY      QueryType = 14
	QueryType_TERMS_QUERY            QueryType = 15
	QueryType_EXISTS_QUERY           QueryType = 16
	QueryType_KNN_VECTOR_QUERY       QueryType = 17
	QueryType_FUNCTIONS_SCORE_QUERY  QueryType = 18
)

var QueryType_name = map[int32]string{
	1:  "MATCH_QUERY",
	2:  "MATCH_PHRASE_QUERY",
	3:  "TERM_QUERY",
	4:  "RANGE_QUERY",
	5:  "PREFIX_QUERY",
	6:  "BOOL_QUERY",
	7:  "CONST_SCORE_QUERY",
	8:  "FUNCTION_SCORE_QUERY",
	9:  "NESTED_QUERY",
	10: "WILDCARD_QUERY",
	11: "MATCH_ALL_QUERY",
	12: "GEO_BOUNDING_BOX_QUERY",
	13: "GEO_DISTANCE_QUERY",
	14: "GEO_POLYGON_QUERY",
	15: "TERMS_QUERY",
	16: "EXISTS_QUERY",
	17: "KNN_VECTOR_QUERY",
	18: "FUNCTIONS_SCORE_QUERY",
}

var QueryType_value = map[string]int32{
	"MATCH_QUERY":            1,
	"MATCH_PHRASE_QUERY":     2,
	"TERM_QUERY":             3,
	"RANGE_QUERY":            4,
	"PREFIX_QUERY":           5,
	"BOOL_QUERY":             6,
	"CONST_SCORE_QUERY":      7,
	"FUNCTION_SCORE_QUERY":   8,
	"NESTED_QUERY":           9,
	"WILDCARD_QUERY":         10,
	"MATCH_ALL_QUERY":        11,
	"GEO_BOUNDING_BOX_QUERY": 12,
	"GEO_DISTANCE_QUERY":     13,
	"GEO_POLYGON_QUERY":      14,
	"TERMS_QUERY":            15,
	"EXISTS_QUERY":           16,
	"KNN_VECTOR_QUERY":       17,
	"FUNCTIONS_SCORE_QUERY":  18,
}

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

func (x QueryType) String() string {
	return proto.EnumName(QueryType_name, int32(x))
}

func (x *QueryType) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(QueryType_value, data, "QueryType")
	if err != nil {
		return err
	}
	*x = QueryType(value)
	return nil
}

func (QueryType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{0}
}

type QueryOperator int32

const (
	QueryOperator_OR  QueryOperator = 1
	QueryOperator_AND QueryOperator = 2
)

var QueryOperator_name = map[int32]string{
	1: "OR",
	2: "AND",
}

var QueryOperator_value = map[string]int32{
	"OR":  1,
	"AND": 2,
}

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

func (x QueryOperator) String() string {
	return proto.EnumName(QueryOperator_name, int32(x))
}

func (x *QueryOperator) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(QueryOperator_value, data, "QueryOperator")
	if err != nil {
		return err
	}
	*x = QueryOperator(value)
	return nil
}

func (QueryOperator) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{1}
}

type FunctionModifier int32

const (
	FunctionModifier_FM_NONE       FunctionModifier = 1
	FunctionModifier_FM_LOG        FunctionModifier = 2
	FunctionModifier_FM_LOG1P      FunctionModifier = 3
	FunctionModifier_FM_LOG2P      FunctionModifier = 4
	FunctionModifier_FM_LN         FunctionModifier = 5
	FunctionModifier_FM_LN1P       FunctionModifier = 6
	FunctionModifier_FM_LN2P       FunctionModifier = 7
	FunctionModifier_FM_SQUARE     FunctionModifier = 8
	FunctionModifier_FM_SQRT       FunctionModifier = 9
	FunctionModifier_FM_RECIPROCAL FunctionModifier = 10
)

var FunctionModifier_name = map[int32]string{
	1:  "FM_NONE",
	2:  "FM_LOG",
	3:  "FM_LOG1P",
	4:  "FM_LOG2P",
	5:  "FM_LN",
	6:  "FM_LN1P",
	7:  "FM_LN2P",
	8:  "FM_SQUARE",
	9:  "FM_SQRT",
	10: "FM_RECIPROCAL",
}

var FunctionModifier_value = map[string]int32{
	"FM_NONE":       1,
	"FM_LOG":        2,
	"FM_LOG1P":      3,
	"FM_LOG2P":      4,
	"FM_LN":         5,
	"FM_LN1P":       6,
	"FM_LN2P":       7,
	"FM_SQUARE":     8,
	"FM_SQRT":       9,
	"FM_RECIPROCAL": 10,
}

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

func (x FunctionModifier) String() string {
	return proto.EnumName(FunctionModifier_name, int32(x))
}

func (x *FunctionModifier) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(FunctionModifier_value, data, "FunctionModifier")
	if err != nil {
		return err
	}
	*x = FunctionModifier(value)
	return nil
}

func (FunctionModifier) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{2}
}

type DecayFuncParamType int32

const (
	DecayFuncParamType_DF_DATE_PARAM    DecayFuncParamType = 1
	DecayFuncParamType_DF_NUMERIC_PARAM DecayFuncParamType = 2
	DecayFuncParamType_DF_GEO_PARAM     DecayFuncParamType = 3
)

var DecayFuncParamType_name = map[int32]string{
	1: "DF_DATE_PARAM",
	2: "DF_NUMERIC_PARAM",
	3: "DF_GEO_PARAM",
}

var DecayFuncParamType_value = map[string]int32{
	"DF_DATE_PARAM":    1,
	"DF_NUMERIC_PARAM": 2,
	"DF_GEO_PARAM":     3,
}

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

func (x DecayFuncParamType) String() string {
	return proto.EnumName(DecayFuncParamType_name, int32(x))
}

func (x *DecayFuncParamType) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(DecayFuncParamType_value, data, "DecayFuncParamType")
	if err != nil {
		return err
	}
	*x = DecayFuncParamType(value)
	return nil
}

func (DecayFuncParamType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{3}
}

type DecayMathFunction int32

const (
	DecayMathFunction_GAUSS  DecayMathFunction = 1
	DecayMathFunction_EXP    DecayMathFunction = 2
	DecayMathFunction_LINEAR DecayMathFunction = 3
)

var DecayMathFunction_name = map[int32]string{
	1: "GAUSS",
	2: "EXP",
	3: "LINEAR",
}

var DecayMathFunction_value = map[string]int32{
	"GAUSS":  1,
	"EXP":    2,
	"LINEAR": 3,
}

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

func (x DecayMathFunction) String() string {
	return proto.EnumName(DecayMathFunction_name, int32(x))
}

func (x *DecayMathFunction) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(DecayMathFunction_value, data, "DecayMathFunction")
	if err != nil {
		return err
	}
	*x = DecayMathFunction(value)
	return nil
}

func (DecayMathFunction) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{4}
}

type MultiValueMode int32

const (
	MultiValueMode_MVM_MAX MultiValueMode = 1
	MultiValueMode_MVM_MIN MultiValueMode = 2
	MultiValueMode_MVM_SUM MultiValueMode = 3
	MultiValueMode_MVM_AVG MultiValueMode = 4
)

var MultiValueMode_name = map[int32]string{
	1: "MVM_MAX",
	2: "MVM_MIN",
	3: "MVM_SUM",
	4: "MVM_AVG",
}

var MultiValueMode_value = map[string]int32{
	"MVM_MAX": 1,
	"MVM_MIN": 2,
	"MVM_SUM": 3,
	"MVM_AVG": 4,
}

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

func (x MultiValueMode) String() string {
	return proto.EnumName(MultiValueMode_name, int32(x))
}

func (x *MultiValueMode) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(MultiValueMode_value, data, "MultiValueMode")
	if err != nil {
		return err
	}
	*x = MultiValueMode(value)
	return nil
}

func (MultiValueMode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{5}
}

type FunctionScoreMode int32

const (
	FunctionScoreMode_FSM_AVG      FunctionScoreMode = 1
	FunctionScoreMode_FSM_MAX      FunctionScoreMode = 2
	FunctionScoreMode_FSM_SUM      FunctionScoreMode = 3
	FunctionScoreMode_FSM_MIN      FunctionScoreMode = 4
	FunctionScoreMode_FSM_MULTIPLY FunctionScoreMode = 5
	FunctionScoreMode_FSM_FIRST    FunctionScoreMode = 6
)

var FunctionScoreMode_name = map[int32]string{
	1: "FSM_AVG",
	2: "FSM_MAX",
	3: "FSM_SUM",
	4: "FSM_MIN",
	5: "FSM_MULTIPLY",
	6: "FSM_FIRST",
}

var FunctionScoreMode_value = map[string]int32{
	"FSM_AVG":      1,
	"FSM_MAX":      2,
	"FSM_SUM":      3,
	"FSM_MIN":      4,
	"FSM_MULTIPLY": 5,
	"FSM_FIRST":    6,
}

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

func (x FunctionScoreMode) String() string {
	return proto.EnumName(FunctionScoreMode_name, int32(x))
}

func (x *FunctionScoreMode) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(FunctionScoreMode_value, data, "FunctionScoreMode")
	if err != nil {
		return err
	}
	*x = FunctionScoreMode(value)
	return nil
}

func (FunctionScoreMode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{6}
}

type FunctionCombineMode int32

const (
	FunctionCombineMode_FCM_MULTIPLY FunctionCombineMode = 1
	FunctionCombineMode_FCM_AVG      FunctionCombineMode = 2
	FunctionCombineMode_FCM_MAX      FunctionCombineMode = 3
	FunctionCombineMode_FCM_SUM      FunctionCombineMode = 4
	FunctionCombineMode_FCM_MIN      FunctionCombineMode = 5
	FunctionCombineMode_FCM_REPLACE  FunctionCombineMode = 6
)

var FunctionCombineMode_name = map[int32]string{
	1: "FCM_MULTIPLY",
	2: "FCM_AVG",
	3: "FCM_MAX",
	4: "FCM_SUM",
	5: "FCM_MIN",
	6: "FCM_REPLACE",
}

var FunctionCombineMode_value = map[string]int32{
	"FCM_MULTIPLY": 1,
	"FCM_AVG":      2,
	"FCM_MAX":      3,
	"FCM_SUM":      4,
	"FCM_MIN":      5,
	"FCM_REPLACE":  6,
}

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

func (x FunctionCombineMode) String() string {
	return proto.EnumName(FunctionCombineMode_name, int32(x))
}

func (x *FunctionCombineMode) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(FunctionCombineMode_value, data, "FunctionCombineMode")
	if err != nil {
		return err
	}
	*x = FunctionCombineMode(value)
	return nil
}

func (FunctionCombineMode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{7}
}

type ScoreMode int32

const (
	ScoreMode_SCORE_MODE_NONE  ScoreMode = 1
	ScoreMode_SCORE_MODE_AVG   ScoreMode = 2
	ScoreMode_SCORE_MODE_MAX   ScoreMode = 3
	ScoreMode_SCORE_MODE_TOTAL ScoreMode = 4
	ScoreMode_SCORE_MODE_MIN   ScoreMode = 5
)

var ScoreMode_name = map[int32]string{
	1: "SCORE_MODE_NONE",
	2: "SCORE_MODE_AVG",
	3: "SCORE_MODE_MAX",
	4: "SCORE_MODE_TOTAL",
	5: "SCORE_MODE_MIN",
}

var ScoreMode_value = map[string]int32{
	"SCORE_MODE_NONE":  1,
	"SCORE_MODE_AVG":   2,
	"SCORE_MODE_MAX":   3,
	"SCORE_MODE_TOTAL": 4,
	"SCORE_MODE_MIN":   5,
}

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

func (x ScoreMode) String() string {
	return proto.EnumName(ScoreMode_name, int32(x))
}

func (x *ScoreMode) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(ScoreMode_value, data, "ScoreMode")
	if err != nil {
		return err
	}
	*x = ScoreMode(value)
	return nil
}

func (ScoreMode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{8}
}

type SortOrder int32

const (
	SortOrder_SORT_ORDER_ASC  SortOrder = 0
	SortOrder_SORT_ORDER_DESC SortOrder = 1
)

var SortOrder_name = map[int32]string{
	0: "SORT_ORDER_ASC",
	1: "SORT_ORDER_DESC",
}

var SortOrder_value = map[string]int32{
	"SORT_ORDER_ASC":  0,
	"SORT_ORDER_DESC": 1,
}

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

func (x SortOrder) String() string {
	return proto.EnumName(SortOrder_name, int32(x))
}

func (x *SortOrder) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(SortOrder_value, data, "SortOrder")
	if err != nil {
		return err
	}
	*x = SortOrder(value)
	return nil
}

func (SortOrder) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{9}
}

type SortMode int32

const (
	SortMode_SORT_MODE_MIN SortMode = 0
	SortMode_SORT_MODE_MAX SortMode = 1
	SortMode_SORT_MODE_AVG SortMode = 2
)

var SortMode_name = map[int32]string{
	0: "SORT_MODE_MIN",
	1: "SORT_MODE_MAX",
	2: "SORT_MODE_AVG",
}

var SortMode_value = map[string]int32{
	"SORT_MODE_MIN": 0,
	"SORT_MODE_MAX": 1,
	"SORT_MODE_AVG": 2,
}

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

func (x SortMode) String() string {
	return proto.EnumName(SortMode_name, int32(x))
}

func (x *SortMode) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(SortMode_value, data, "SortMode")
	if err != nil {
		return err
	}
	*x = SortMode(value)
	return nil
}

func (SortMode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{10}
}

type GeoDistanceType int32

const (
	GeoDistanceType_GEO_DISTANCE_ARC   GeoDistanceType = 0
	GeoDistanceType_GEO_DISTANCE_PLANE GeoDistanceType = 1
)

var GeoDistanceType_name = map[int32]string{
	0: "GEO_DISTANCE_ARC",
	1: "GEO_DISTANCE_PLANE",
}

var GeoDistanceType_value = map[string]int32{
	"GEO_DISTANCE_ARC":   0,
	"GEO_DISTANCE_PLANE": 1,
}

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

func (x GeoDistanceType) String() string {
	return proto.EnumName(GeoDistanceType_name, int32(x))
}

func (x *GeoDistanceType) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(GeoDistanceType_value, data, "GeoDistanceType")
	if err != nil {
		return err
	}
	*x = GeoDistanceType(value)
	return nil
}

func (GeoDistanceType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{11}
}

type HighlightFragmentOrder int32

const (
	HighlightFragmentOrder_TEXT_SEQUENCE HighlightFragmentOrder = 1
	HighlightFragmentOrder_SCORE         HighlightFragmentOrder = 2
)

var HighlightFragmentOrder_name = map[int32]string{
	1: "TEXT_SEQUENCE",
	2: "SCORE",
}

var HighlightFragmentOrder_value = map[string]int32{
	"TEXT_SEQUENCE": 1,
	"SCORE":         2,
}

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

func (x HighlightFragmentOrder) String() string {
	return proto.EnumName(HighlightFragmentOrder_name, int32(x))
}

func (x *HighlightFragmentOrder) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(HighlightFragmentOrder_value, data, "HighlightFragmentOrder")
	if err != nil {
		return err
	}
	*x = HighlightFragmentOrder(value)
	return nil
}

func (HighlightFragmentOrder) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{12}
}

type HighlightEncoder int32

const (
	HighlightEncoder_PLAIN_MODE HighlightEncoder = 1
	HighlightEncoder_HTML_MODE  HighlightEncoder = 2
)

var HighlightEncoder_name = map[int32]string{
	1: "PLAIN_MODE",
	2: "HTML_MODE",
}

var HighlightEncoder_value = map[string]int32{
	"PLAIN_MODE": 1,
	"HTML_MODE":  2,
}

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

func (x HighlightEncoder) String() string {
	return proto.EnumName(HighlightEncoder_name, int32(x))
}

func (x *HighlightEncoder) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(HighlightEncoder_value, data, "HighlightEncoder")
	if err != nil {
		return err
	}
	*x = HighlightEncoder(value)
	return nil
}

func (HighlightEncoder) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{13}
}

type ColumnReturnType int32

const (
	ColumnReturnType_RETURN_ALL            ColumnReturnType = 1
	ColumnReturnType_RETURN_SPECIFIED      ColumnReturnType = 2
	ColumnReturnType_RETURN_NONE           ColumnReturnType = 3
	ColumnReturnType_RETURN_ALL_FROM_INDEX ColumnReturnType = 4
)

var ColumnReturnType_name = map[int32]string{
	1: "RETURN_ALL",
	2: "RETURN_SPECIFIED",
	3: "RETURN_NONE",
	4: "RETURN_ALL_FROM_INDEX",
}

var ColumnReturnType_value = map[string]int32{
	"RETURN_ALL":            1,
	"RETURN_SPECIFIED":      2,
	"RETURN_NONE":           3,
	"RETURN_ALL_FROM_INDEX": 4,
}

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

func (x ColumnReturnType) String() string {
	return proto.EnumName(ColumnReturnType_name, int32(x))
}

func (x *ColumnReturnType) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(ColumnReturnType_value, data, "ColumnReturnType")
	if err != nil {
		return err
	}
	*x = ColumnReturnType(value)
	return nil
}

func (ColumnReturnType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{14}
}

type IndexOptions int32

const (
	IndexOptions_DOCS      IndexOptions = 1
	IndexOptions_FREQS     IndexOptions = 2
	IndexOptions_POSITIONS IndexOptions = 3
	IndexOptions_OFFSETS   IndexOptions = 4
)

var IndexOptions_name = map[int32]string{
	1: "DOCS",
	2: "FREQS",
	3: "POSITIONS",
	4: "OFFSETS",
}

var IndexOptions_value = map[string]int32{
	"DOCS":      1,
	"FREQS":     2,
	"POSITIONS": 3,
	"OFFSETS":   4,
}

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

func (x IndexOptions) String() string {
	return proto.EnumName(IndexOptions_name, int32(x))
}

func (x *IndexOptions) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(IndexOptions_value, data, "IndexOptions")
	if err != nil {
		return err
	}
	*x = IndexOptions(value)
	return nil
}

func (IndexOptions) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{15}
}

type FieldType int32

const (
	FieldType_LONG      FieldType = 1
	FieldType_DOUBLE    FieldType = 2
	FieldType_BOOLEAN   FieldType = 3
	FieldType_KEYWORD   FieldType = 4
	FieldType_TEXT      FieldType = 5
	FieldType_NESTED    FieldType = 6
	FieldType_GEO_POINT FieldType = 7
	FieldType_DATE      FieldType = 8
	FieldType_VECTOR    FieldType = 9
)

var FieldType_name = map[int32]string{
	1: "LONG",
	2: "DOUBLE",
	3: "BOOLEAN",
	4: "KEYWORD",
	5: "TEXT",
	6: "NESTED",
	7: "GEO_POINT",
	8: "DATE",
	9: "VECTOR",
}

var FieldType_value = map[string]int32{
	"LONG":      1,
	"DOUBLE":    2,
	"BOOLEAN":   3,
	"KEYWORD":   4,
	"TEXT":      5,
	"NESTED":    6,
	"GEO_POINT": 7,
	"DATE":      8,
	"VECTOR":    9,
}

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

func (x FieldType) String() string {
	return proto.EnumName(FieldType_name, int32(x))
}

func (x *FieldType) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(FieldType_value, data, "FieldType")
	if err != nil {
		return err
	}
	*x = FieldType(value)
	return nil
}

func (FieldType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{16}
}

type DateTimeUnit int32

const (
	DateTimeUnit_YEAR         DateTimeUnit = 1
	DateTimeUnit_QUARTER_YEAR DateTimeUnit = 2
	DateTimeUnit_MONTH        DateTimeUnit = 3
	DateTimeUnit_WEEK         DateTimeUnit = 4
	DateTimeUnit_DAY          DateTimeUnit = 5
	DateTimeUnit_HOUR         DateTimeUnit = 6
	DateTimeUnit_MINUTE       DateTimeUnit = 7
	DateTimeUnit_SECOND       DateTimeUnit = 8
)

var DateTimeUnit_name = map[int32]string{
	1: "YEAR",
	2: "QUARTER_YEAR",
	3: "MONTH",
	4: "WEEK",
	5: "DAY",
	6: "HOUR",
	7: "MINUTE",
	8: "SECOND",
}

var DateTimeUnit_value = map[string]int32{
	"YEAR":         1,
	"QUARTER_YEAR": 2,
	"MONTH":        3,
	"WEEK":         4,
	"DAY":          5,
	"HOUR":         6,
	"MINUTE":       7,
	"SECOND":       8,
}

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

func (x DateTimeUnit) String() string {
	return proto.EnumName(DateTimeUnit_name, int32(x))
}

func (x *DateTimeUnit) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(DateTimeUnit_value, data, "DateTimeUnit")
	if err != nil {
		return err
	}
	*x = DateTimeUnit(value)
	return nil
}

func (DateTimeUnit) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{17}
}

type VectorDataType int32

const (
	VectorDataType_VD_FLOAT_32 VectorDataType = 2
)

var VectorDataType_name = map[int32]string{
	2: "VD_FLOAT_32",
}

var VectorDataType_value = map[string]int32{
	"VD_FLOAT_32": 2,
}

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

func (x VectorDataType) String() string {
	return proto.EnumName(VectorDataType_name, int32(x))
}

func (x *VectorDataType) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(VectorDataType_value, data, "VectorDataType")
	if err != nil {
		return err
	}
	*x = VectorDataType(value)
	return nil
}

func (VectorDataType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{18}
}

type VectorMetricType int32

const (
	VectorMetricType_VM_EUCLIDEAN   VectorMetricType = 0
	VectorMetricType_VM_COSINE      VectorMetricType = 1
	VectorMetricType_VM_DOT_PRODUCT VectorMetricType = 2
)

var VectorMetricType_name = map[int32]string{
	0: "VM_EUCLIDEAN",
	1: "VM_COSINE",
	2: "VM_DOT_PRODUCT",
}

var VectorMetricType_value = map[string]int32{
	"VM_EUCLIDEAN":   0,
	"VM_COSINE":      1,
	"VM_DOT_PRODUCT": 2,
}

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

func (x VectorMetricType) String() string {
	return proto.EnumName(VectorMetricType_name, int32(x))
}

func (x *VectorMetricType) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(VectorMetricType_value, data, "VectorMetricType")
	if err != nil {
		return err
	}
	*x = VectorMetricType(value)
	return nil
}

func (VectorMetricType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{19}
}

type SyncPhase int32

const (
	SyncPhase_FULL SyncPhase = 1
	SyncPhase_INCR SyncPhase = 2
)

var SyncPhase_name = map[int32]string{
	1: "FULL",
	2: "INCR",
}

var SyncPhase_value = map[string]int32{
	"FULL": 1,
	"INCR": 2,
}

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

func (x SyncPhase) String() string {
	return proto.EnumName(SyncPhase_name, int32(x))
}

func (x *SyncPhase) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(SyncPhase_value, data, "SyncPhase")
	if err != nil {
		return err
	}
	*x = SyncPhase(value)
	return nil
}

func (SyncPhase) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{20}
}

// aggregation & group by
type AggregationType int32

const (
	AggregationType_AGG_AVG            AggregationType = 1
	AggregationType_AGG_DISTINCT_COUNT AggregationType = 6
	AggregationType_AGG_MAX            AggregationType = 2
	AggregationType_AGG_MIN            AggregationType = 3
	AggregationType_AGG_SUM            AggregationType = 4
	AggregationType_AGG_COUNT          AggregationType = 5
	AggregationType_AGG_TOP_ROWS       AggregationType = 7
	AggregationType_AGG_PERCENTILES    AggregationType = 8
)

var AggregationType_name = map[int32]string{
	1: "AGG_AVG",
	6: "AGG_DISTINCT_COUNT",
	2: "AGG_MAX",
	3: "AGG_MIN",
	4: "AGG_SUM",
	5: "AGG_COUNT",
	7: "AGG_TOP_ROWS",
	8: "AGG_PERCENTILES",
}

var AggregationType_value = map[string]int32{
	"AGG_AVG":            1,
	"AGG_DISTINCT_COUNT": 6,
	"AGG_MAX":            2,
	"AGG_MIN":            3,
	"AGG_SUM":            4,
	"AGG_COUNT":          5,
	"AGG_TOP_ROWS":       7,
	"AGG_PERCENTILES":    8,
}

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

func (x AggregationType) String() string {
	return proto.EnumName(AggregationType_name, int32(x))
}

func (x *AggregationType) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(AggregationType_value, data, "AggregationType")
	if err != nil {
		return err
	}
	*x = AggregationType(value)
	return nil
}

func (AggregationType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{21}
}

type GroupByType int32

const (
	GroupByType_GROUP_BY_FIELD          GroupByType = 1
	GroupByType_GROUP_BY_RANGE          GroupByType = 2
	GroupByType_GROUP_BY_FILTER         GroupByType = 3
	GroupByType_GROUP_BY_GEO_DISTANCE   GroupByType = 4
	GroupByType_GROUP_BY_HISTOGRAM      GroupByType = 5
	GroupByType_GROUP_BY_DATE_HISTOGRAM GroupByType = 6
	GroupByType_GROUP_BY_GEO_GRID       GroupByType = 7
	GroupByType_GROUP_BY_COMPOSITE      GroupByType = 8
)

var GroupByType_name = map[int32]string{
	1: "GROUP_BY_FIELD",
	2: "GROUP_BY_RANGE",
	3: "GROUP_BY_FILTER",
	4: "GROUP_BY_GEO_DISTANCE",
	5: "GROUP_BY_HISTOGRAM",
	6: "GROUP_BY_DATE_HISTOGRAM",
	7: "GROUP_BY_GEO_GRID",
	8: "GROUP_BY_COMPOSITE",
}

var GroupByType_value = map[string]int32{
	"GROUP_BY_FIELD":          1,
	"GROUP_BY_RANGE":          2,
	"GROUP_BY_FILTER":         3,
	"GROUP_BY_GEO_DISTANCE":   4,
	"GROUP_BY_HISTOGRAM":      5,
	"GROUP_BY_DATE_HISTOGRAM": 6,
	"GROUP_BY_GEO_GRID":       7,
	"GROUP_BY_COMPOSITE":      8,
}

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

func (x GroupByType) String() string {
	return proto.EnumName(GroupByType_name, int32(x))
}

func (x *GroupByType) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(GroupByType_value, data, "GroupByType")
	if err != nil {
		return err
	}
	*x = GroupByType(value)
	return nil
}

func (GroupByType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{22}
}

type GeoHashPrecision int32

const (
	GeoHashPrecision_GHP_5009KM_4992KM_1 GeoHashPrecision = 1
	GeoHashPrecision_GHP_1252KM_624KM_2  GeoHashPrecision = 2
	GeoHashPrecision_GHP_156KM_156KM_3   GeoHashPrecision = 3
	GeoHashPrecision_GHP_39KM_19KM_4     GeoHashPrecision = 4
	GeoHashPrecision_GHP_4900M_4900M_5   GeoHashPrecision = 5
	GeoHashPrecision_GHP_1200M_609M_6    GeoHashPrecision = 6
	GeoHashPrecision_GHP_152M_152M_7     GeoHashPrecision = 7
	GeoHashPrecision_GHP_38M_19M_8       GeoHashPrecision = 8
	GeoHashPrecision_GHP_480CM_480CM_9   GeoHashPrecision = 9
	GeoHashPrecision_GHP_120CM_595MM_10  GeoHashPrecision = 10
	GeoHashPrecision_GHP_149MM_149MM_11  GeoHashPrecision = 11
	GeoHashPrecision_GHP_37MM_19MM_12    GeoHashPrecision = 12
)

var GeoHashPrecision_name = map[int32]string{
	1:  "GHP_5009KM_4992KM_1",
	2:  "GHP_1252KM_624KM_2",
	3:  "GHP_156KM_156KM_3",
	4:  "GHP_39KM_19KM_4",
	5:  "GHP_4900M_4900M_5",
	6:  "GHP_1200M_609M_6",
	7:  "GHP_152M_152M_7",
	8:  "GHP_38M_19M_8",
	9:  "GHP_480CM_480CM_9",
	10: "GHP_120CM_595MM_10",
	11: "GHP_149MM_149MM_11",
	12: "GHP_37MM_19MM_12",
}

var GeoHashPrecision_value = map[string]int32{
	"GHP_5009KM_4992KM_1": 1,
	"GHP_1252KM_624KM_2":  2,
	"GHP_156KM_156KM_3":   3,
	"GHP_39KM_19KM_4":     4,
	"GHP_4900M_4900M_5":   5,
	"GHP_1200M_609M_6":    6,
	"GHP_152M_152M_7":     7,
	"GHP_38M_19M_8":       8,
	"GHP_480CM_480CM_9":   9,
	"GHP_120CM_595MM_10":  10,
	"GHP_149MM_149MM_11":  11,
	"GHP_37MM_19MM_12":    12,
}

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

func (x GeoHashPrecision) String() string {
	return proto.EnumName(GeoHashPrecision_name, int32(x))
}

func (x *GeoHashPrecision) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(GeoHashPrecision_value, data, "GeoHashPrecision")
	if err != nil {
		return err
	}
	*x = GeoHashPrecision(value)
	return nil
}

func (GeoHashPrecision) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{23}
}

type MatchQuery struct {
	FieldName            *string        `protobuf:"bytes,1,opt,name=field_name,json=fieldName" json:"field_name,omitempty"`
	Text                 *string        `protobuf:"bytes,2,opt,name=text" json:"text,omitempty"`
	MinimumShouldMatch   *int32         `protobuf:"varint,3,opt,name=minimum_should_match,json=minimumShouldMatch" json:"minimum_should_match,omitempty"`
	Operator             *QueryOperator `protobuf:"varint,4,opt,name=operator,enum=otsprotocol.QueryOperator" json:"operator,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (m *MatchQuery) Reset()         { *m = MatchQuery{} }
func (m *MatchQuery) String() string { return proto.CompactTextString(m) }
func (*MatchQuery) ProtoMessage()    {}
func (*MatchQuery) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{0}
}

func (m *MatchQuery) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MatchQuery.Unmarshal(m, b)
}
func (m *MatchQuery) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MatchQuery.Marshal(b, m, deterministic)
}
func (m *MatchQuery) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MatchQuery.Merge(m, src)
}
func (m *MatchQuery) XXX_Size() int {
	return xxx_messageInfo_MatchQuery.Size(m)
}
func (m *MatchQuery) XXX_DiscardUnknown() {
	xxx_messageInfo_MatchQuery.DiscardUnknown(m)
}

var xxx_messageInfo_MatchQuery proto.InternalMessageInfo

func (m *MatchQuery) GetFieldName() string {
	if m != nil && m.FieldName != nil {
		return *m.FieldName
	}
	return ""
}

func (m *MatchQuery) GetText() string {
	if m != nil && m.Text != nil {
		return *m.Text
	}
	return ""
}

func (m *MatchQuery) GetMinimumShouldMatch() int32 {
	if m != nil && m.MinimumShouldMatch != nil {
		return *m.MinimumShouldMatch
	}
	return 0
}

func (m *MatchQuery) GetOperator() QueryOperator {
	if m != nil && m.Operator != nil {
		return *m.Operator
	}
	return QueryOperator_OR
}

type MatchPhraseQuery struct {
	FieldName            *string  `protobuf:"bytes,1,opt,name=field_name,json=fieldName" json:"field_name,omitempty"`
	Text                 *string  `protobuf:"bytes,2,opt,name=text" json:"text,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *MatchPhraseQuery) Reset()         { *m = MatchPhraseQuery{} }
func (m *MatchPhraseQuery) String() string { return proto.CompactTextString(m) }
func (*MatchPhraseQuery) ProtoMessage()    {}
func (*MatchPhraseQuery) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{1}
}

func (m *MatchPhraseQuery) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MatchPhraseQuery.Unmarshal(m, b)
}
func (m *MatchPhraseQuery) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MatchPhraseQuery.Marshal(b, m, deterministic)
}
func (m *MatchPhraseQuery) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MatchPhraseQuery.Merge(m, src)
}
func (m *MatchPhraseQuery) XXX_Size() int {
	return xxx_messageInfo_MatchPhraseQuery.Size(m)
}
func (m *MatchPhraseQuery) XXX_DiscardUnknown() {
	xxx_messageInfo_MatchPhraseQuery.DiscardUnknown(m)
}

var xxx_messageInfo_MatchPhraseQuery proto.InternalMessageInfo

func (m *MatchPhraseQuery) GetFieldName() string {
	if m != nil && m.FieldName != nil {
		return *m.FieldName
	}
	return ""
}

func (m *MatchPhraseQuery) GetText() string {
	if m != nil && m.Text != nil {
		return *m.Text
	}
	return ""
}

type MatchAllQuery struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *MatchAllQuery) Reset()         { *m = MatchAllQuery{} }
func (m *MatchAllQuery) String() string { return proto.CompactTextString(m) }
func (*MatchAllQuery) ProtoMessage()    {}
func (*MatchAllQuery) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{2}
}

func (m *MatchAllQuery) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MatchAllQuery.Unmarshal(m, b)
}
func (m *MatchAllQuery) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MatchAllQuery.Marshal(b, m, deterministic)
}
func (m *MatchAllQuery) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MatchAllQuery.Merge(m, src)
}
func (m *MatchAllQuery) XXX_Size() int {
	return xxx_messageInfo_MatchAllQuery.Size(m)
}
func (m *MatchAllQuery) XXX_DiscardUnknown() {
	xxx_messageInfo_MatchAllQuery.DiscardUnknown(m)
}

var xxx_messageInfo_MatchAllQuery proto.InternalMessageInfo

type TermQuery struct {
	FieldName            *string  `protobuf:"bytes,1,opt,name=field_name,json=fieldName" json:"field_name,omitempty"`
	Term                 []byte   `protobuf:"bytes,2,opt,name=term" json:"term,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TermQuery) Reset()         { *m = TermQuery{} }
func (m *TermQuery) String() string { return proto.CompactTextString(m) }
func (*TermQuery) ProtoMessage()    {}
func (*TermQuery) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{3}
}

func (m *TermQuery) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TermQuery.Unmarshal(m, b)
}
func (m *TermQuery) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TermQuery.Marshal(b, m, deterministic)
}
func (m *TermQuery) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TermQuery.Merge(m, src)
}
func (m *TermQuery) XXX_Size() int {
	return xxx_messageInfo_TermQuery.Size(m)
}
func (m *TermQuery) XXX_DiscardUnknown() {
	xxx_messageInfo_TermQuery.DiscardUnknown(m)
}

var xxx_messageInfo_TermQuery proto.InternalMessageInfo

func (m *TermQuery) GetFieldName() string {
	if m != nil && m.FieldName != nil {
		return *m.FieldName
	}
	return ""
}

func (m *TermQuery) GetTerm() []byte {
	if m != nil {
		return m.Term
	}
	return nil
}

type TermsQuery struct {
	FieldName            *string  `protobuf:"bytes,1,opt,name=field_name,json=fieldName" json:"field_name,omitempty"`
	Terms                [][]byte `protobuf:"bytes,2,rep,name=terms" json:"terms,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TermsQuery) Reset()         { *m = TermsQuery{} }
func (m *TermsQuery) String() string { return proto.CompactTextString(m) }
func (*TermsQuery) ProtoMessage()    {}
func (*TermsQuery) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{4}
}

func (m *TermsQuery) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TermsQuery.Unmarshal(m, b)
}
func (m *TermsQuery) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TermsQuery.Marshal(b, m, deterministic)
}
func (m *TermsQuery) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TermsQuery.Merge(m, src)
}
func (m *TermsQuery) XXX_Size() int {
	return xxx_messageInfo_TermsQuery.Size(m)
}
func (m *TermsQuery) XXX_DiscardUnknown() {
	xxx_messageInfo_TermsQuery.DiscardUnknown(m)
}

var xxx_messageInfo_TermsQuery proto.InternalMessageInfo

func (m *TermsQuery) GetFieldName() string {
	if m != nil && m.FieldName != nil {
		return *m.FieldName
	}
	return ""
}

func (m *TermsQuery) GetTerms() [][]byte {
	if m != nil {
		return m.Terms
	}
	return nil
}

type RangeQuery struct {
	FieldName            *string  `protobuf:"bytes,1,opt,name=field_name,json=fieldName" json:"field_name,omitempty"`
	RangeFrom            []byte   `protobuf:"bytes,2,opt,name=range_from,json=rangeFrom" json:"range_from,omitempty"`
	RangeTo              []byte   `protobuf:"bytes,3,opt,name=range_to,json=rangeTo" json:"range_to,omitempty"`
	IncludeLower         *bool    `protobuf:"varint,4,opt,name=include_lower,json=includeLower" json:"include_lower,omitempty"`
	IncludeUpper         *bool    `protobuf:"varint,5,opt,name=include_upper,json=includeUpper" json:"include_upper,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *RangeQuery) Reset()         { *m = RangeQuery{} }
func (m *RangeQuery) String() string { return proto.CompactTextString(m) }
func (*RangeQuery) ProtoMessage()    {}
func (*RangeQuery) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{5}
}

func (m *RangeQuery) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RangeQuery.Unmarshal(m, b)
}
func (m *RangeQuery) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RangeQuery.Marshal(b, m, deterministic)
}
func (m *RangeQuery) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RangeQuery.Merge(m, src)
}
func (m *RangeQuery) XXX_Size() int {
	return xxx_messageInfo_RangeQuery.Size(m)
}
func (m *RangeQuery) XXX_DiscardUnknown() {
	xxx_messageInfo_RangeQuery.DiscardUnknown(m)
}

var xxx_messageInfo_RangeQuery proto.InternalMessageInfo

func (m *RangeQuery) GetFieldName() string {
	if m != nil && m.FieldName != nil {
		return *m.FieldName
	}
	return ""
}

func (m *RangeQuery) GetRangeFrom() []byte {
	if m != nil {
		return m.RangeFrom
	}
	return nil
}

func (m *RangeQuery) GetRangeTo() []byte {
	if m != nil {
		return m.RangeTo
	}
	return nil
}

func (m *RangeQuery) GetIncludeLower() bool {
	if m != nil && m.IncludeLower != nil {
		return *m.IncludeLower
	}
	return false
}

func (m *RangeQuery) GetIncludeUpper() bool {
	if m != nil && m.IncludeUpper != nil {
		return *m.IncludeUpper
	}
	return false
}

type PrefixQuery struct {
	FieldName            *string  `protobuf:"bytes,1,opt,name=field_name,json=fieldName" json:"field_name,omitempty"`
	Prefix               *string  `protobuf:"bytes,2,opt,name=prefix" json:"prefix,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PrefixQuery) Reset()         { *m = PrefixQuery{} }
func (m *PrefixQuery) String() string { return proto.CompactTextString(m) }
func (*PrefixQuery) ProtoMessage()    {}
func (*PrefixQuery) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{6}
}

func (m *PrefixQuery) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PrefixQuery.Unmarshal(m, b)
}
func (m *PrefixQuery) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PrefixQuery.Marshal(b, m, deterministic)
}
func (m *PrefixQuery) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PrefixQuery.Merge(m, src)
}
func (m *PrefixQuery) XXX_Size() int {
	return xxx_messageInfo_PrefixQuery.Size(m)
}
func (m *PrefixQuery) XXX_DiscardUnknown() {
	xxx_messageInfo_PrefixQuery.DiscardUnknown(m)
}

var xxx_messageInfo_PrefixQuery proto.InternalMessageInfo

func (m *PrefixQuery) GetFieldName() string {
	if m != nil && m.FieldName != nil {
		return *m.FieldName
	}
	return ""
}

func (m *PrefixQuery) GetPrefix() string {
	if m != nil && m.Prefix != nil {
		return *m.Prefix
	}
	return ""
}

type WildcardQuery struct {
	FieldName            *string  `protobuf:"bytes,1,opt,name=field_name,json=fieldName" json:"field_name,omitempty"`
	Value                *string  `protobuf:"bytes,2,opt,name=value" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *WildcardQuery) Reset()         { *m = WildcardQuery{} }
func (m *WildcardQuery) String() string { return proto.CompactTextString(m) }
func (*WildcardQuery) ProtoMessage()    {}
func (*WildcardQuery) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{7}
}

func (m *WildcardQuery) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_WildcardQuery.Unmarshal(m, b)
}
func (m *WildcardQuery) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_WildcardQuery.Marshal(b, m, deterministic)
}
func (m *WildcardQuery) XXX_Merge(src proto.Message) {
	xxx_messageInfo_WildcardQuery.Merge(m, src)
}
func (m *WildcardQuery) XXX_Size() int {
	return xxx_messageInfo_WildcardQuery.Size(m)
}
func (m *WildcardQuery) XXX_DiscardUnknown() {
	xxx_messageInfo_WildcardQuery.DiscardUnknown(m)
}

var xxx_messageInfo_WildcardQuery proto.InternalMessageInfo

func (m *WildcardQuery) GetFieldName() string {
	if m != nil && m.FieldName != nil {
		return *m.FieldName
	}
	return ""
}

func (m *WildcardQuery) GetValue() string {
	if m != nil && m.Value != nil {
		return *m.Value
	}
	return ""
}

type BoolQuery struct {
	MustQueries          []*Query `protobuf:"bytes,1,rep,name=must_queries,json=mustQueries" json:"must_queries,omitempty"`
	MustNotQueries       []*Query `protobuf:"bytes,2,rep,name=must_not_queries,json=mustNotQueries" json:"must_not_queries,omitempty"`
	FilterQueries        []*Query `protobuf:"bytes,3,rep,name=filter_queries,json=filterQueries" json:"filter_queries,omitempty"`
	ShouldQueries        []*Query `protobuf:"bytes,4,rep,name=should_queries,json=shouldQueries" json:"should_queries,omitempty"`
	MinimumShouldMatch   *int32   `protobuf:"varint,5,opt,name=minimum_should_match,json=minimumShouldMatch" json:"minimum_should_match,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *BoolQuery) Reset()         { *m = BoolQuery{} }
func (m *BoolQuery) String() string { return proto.CompactTextString(m) }
func (*BoolQuery) ProtoMessage()    {}
func (*BoolQuery) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{8}
}

func (m *BoolQuery) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_BoolQuery.Unmarshal(m, b)
}
func (m *BoolQuery) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_BoolQuery.Marshal(b, m, deterministic)
}
func (m *BoolQuery) XXX_Merge(src proto.Message) {
	xxx_messageInfo_BoolQuery.Merge(m, src)
}
func (m *BoolQuery) XXX_Size() int {
	return xxx_messageInfo_BoolQuery.Size(m)
}
func (m *BoolQuery) XXX_DiscardUnknown() {
	xxx_messageInfo_BoolQuery.DiscardUnknown(m)
}

var xxx_messageInfo_BoolQuery proto.InternalMessageInfo

func (m *BoolQuery) GetMustQueries() []*Query {
	if m != nil {
		return m.MustQueries
	}
	return nil
}

func (m *BoolQuery) GetMustNotQueries() []*Query {
	if m != nil {
		return m.MustNotQueries
	}
	return nil
}

func (m *BoolQuery) GetFilterQueries() []*Query {
	if m != nil {
		return m.FilterQueries
	}
	return nil
}

func (m *BoolQuery) GetShouldQueries() []*Query {
	if m != nil {
		return m.ShouldQueries
	}
	return nil
}

func (m *BoolQuery) GetMinimumShouldMatch() int32 {
	if m != nil && m.MinimumShouldMatch != nil {
		return *m.MinimumShouldMatch
	}
	return 0
}

type ConstScoreQuery struct {
	Filter               *Query   `protobuf:"bytes,1,opt,name=filter" json:"filter,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ConstScoreQuery) Reset()         { *m = ConstScoreQuery{} }
func (m *ConstScoreQuery) String() string { return proto.CompactTextString(m) }
func (*ConstScoreQuery) ProtoMessage()    {}
func (*ConstScoreQuery) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{9}
}

func (m *ConstScoreQuery) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ConstScoreQuery.Unmarshal(m, b)
}
func (m *ConstScoreQuery) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ConstScoreQuery.Marshal(b, m, deterministic)
}
func (m *ConstScoreQuery) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ConstScoreQuery.Merge(m, src)
}
func (m *ConstScoreQuery) XXX_Size() int {
	return xxx_messageInfo_ConstScoreQuery.Size(m)
}
func (m *ConstScoreQuery) XXX_DiscardUnknown() {
	xxx_messageInfo_ConstScoreQuery.DiscardUnknown(m)
}

var xxx_messageInfo_ConstScoreQuery proto.InternalMessageInfo

func (m *ConstScoreQuery) GetFilter() *Query {
	if m != nil {
		return m.Filter
	}
	return nil
}

type FieldValueFactor struct {
	FieldName            *string  `protobuf:"bytes,1,opt,name=field_name,json=fieldName" json:"field_name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *FieldValueFactor) Reset()         { *m = FieldValueFactor{} }
func (m *FieldValueFactor) String() string { return proto.CompactTextString(m) }
func (*FieldValueFactor) ProtoMessage()    {}
func (*FieldValueFactor) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{10}
}

func (m *FieldValueFactor) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_FieldValueFactor.Unmarshal(m, b)
}
func (m *FieldValueFactor) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_FieldValueFactor.Marshal(b, m, deterministic)
}
func (m *FieldValueFactor) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FieldValueFactor.Merge(m, src)
}
func (m *FieldValueFactor) XXX_Size() int {
	return xxx_messageInfo_FieldValueFactor.Size(m)
}
func (m *FieldValueFactor) XXX_DiscardUnknown() {
	xxx_messageInfo_FieldValueFactor.DiscardUnknown(m)
}

var xxx_messageInfo_FieldValueFactor proto.InternalMessageInfo

func (m *FieldValueFactor) GetFieldName() string {
	if m != nil && m.FieldName != nil {
		return *m.FieldName
	}
	return ""
}

type FunctionScoreQuery struct {
	Query                *Query            `protobuf:"bytes,1,opt,name=query" json:"query,omitempty"`
	FieldValueFactor     *FieldValueFactor `protobuf:"bytes,2,opt,name=field_value_factor,json=fieldValueFactor" json:"field_value_factor,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *FunctionScoreQuery) Reset()         { *m = FunctionScoreQuery{} }
func (m *FunctionScoreQuery) String() string { return proto.CompactTextString(m) }
func (*FunctionScoreQuery) ProtoMessage()    {}
func (*FunctionScoreQuery) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{11}
}

func (m *FunctionScoreQuery) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_FunctionScoreQuery.Unmarshal(m, b)
}
func (m *FunctionScoreQuery) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_FunctionScoreQuery.Marshal(b, m, deterministic)
}
func (m *FunctionScoreQuery) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FunctionScoreQuery.Merge(m, src)
}
func (m *FunctionScoreQuery) XXX_Size() int {
	return xxx_messageInfo_FunctionScoreQuery.Size(m)
}
func (m *FunctionScoreQuery) XXX_DiscardUnknown() {
	xxx_messageInfo_FunctionScoreQuery.DiscardUnknown(m)
}

var xxx_messageInfo_FunctionScoreQuery proto.InternalMessageInfo

func (m *FunctionScoreQuery) GetQuery() *Query {
	if m != nil {
		return m.Query
	}
	return nil
}

func (m *FunctionScoreQuery) GetFieldValueFactor() *FieldValueFactor {
	if m != nil {
		return m.FieldValueFactor
	}
	return nil
}

type FunctionsScoreQuery struct {
	Query                *Query               `protobuf:"bytes,1,opt,name=query" json:"query,omitempty"`
	Functions            []*Function          `protobuf:"bytes,2,rep,name=functions" json:"functions,omitempty"`
	SocreMode            *FunctionScoreMode   `protobuf:"varint,3,opt,name=socre_mode,json=socreMode,enum=otsprotocol.FunctionScoreMode" json:"socre_mode,omitempty"`
	CombineMode          *FunctionCombineMode `protobuf:"varint,4,opt,name=combine_mode,json=combineMode,enum=otsprotocol.FunctionCombineMode" json:"combine_mode,omitempty"`
	MinScore             *float32             `protobuf:"fixed32,5,opt,name=min_score,json=minScore" json:"min_score,omitempty"`
	MaxScore             *float32             `protobuf:"fixed32,6,opt,name=max_score,json=maxScore" json:"max_score,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (m *FunctionsScoreQuery) Reset()         { *m = FunctionsScoreQuery{} }
func (m *FunctionsScoreQuery) String() string { return proto.CompactTextString(m) }
func (*FunctionsScoreQuery) ProtoMessage()    {}
func (*FunctionsScoreQuery) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{12}
}

func (m *FunctionsScoreQuery) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_FunctionsScoreQuery.Unmarshal(m, b)
}
func (m *FunctionsScoreQuery) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_FunctionsScoreQuery.Marshal(b, m, deterministic)
}
func (m *FunctionsScoreQuery) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FunctionsScoreQuery.Merge(m, src)
}
func (m *FunctionsScoreQuery) XXX_Size() int {
	return xxx_messageInfo_FunctionsScoreQuery.Size(m)
}
func (m *FunctionsScoreQuery) XXX_DiscardUnknown() {
	xxx_messageInfo_FunctionsScoreQuery.DiscardUnknown(m)
}

var xxx_messageInfo_FunctionsScoreQuery proto.InternalMessageInfo

func (m *FunctionsScoreQuery) GetQuery() *Query {
	if m != nil {
		return m.Query
	}
	return nil
}

func (m *FunctionsScoreQuery) GetFunctions() []*Function {
	if m != nil {
		return m.Functions
	}
	return nil
}

func (m *FunctionsScoreQuery) GetSocreMode() FunctionScoreMode {
	if m != nil && m.SocreMode != nil {
		return *m.SocreMode
	}
	return FunctionScoreMode_FSM_AVG
}

func (m *FunctionsScoreQuery) GetCombineMode() FunctionCombineMode {
	if m != nil && m.CombineMode != nil {
		return *m.CombineMode
	}
	return FunctionCombineMode_FCM_MULTIPLY
}

func (m *FunctionsScoreQuery) GetMinScore() float32 {
	if m != nil && m.MinScore != nil {
		return *m.MinScore
	}
	return 0
}

func (m *FunctionsScoreQuery) GetMaxScore() float32 {
	if m != nil && m.MaxScore != nil {
		return *m.MaxScore
	}
	return 0
}

type Function struct {
	FieldValueFactor     *FieldValueFactorFunction `protobuf:"bytes,1,opt,name=field_value_factor,json=fieldValueFactor" json:"field_value_factor,omitempty"`
	Random               *RandomScoreFunction      `protobuf:"bytes,2,opt,name=random" json:"random,omitempty"`
	Decay                *DecayFunction            `protobuf:"bytes,3,opt,name=decay" json:"decay,omitempty"`
	Weight               *float32                  `protobuf:"fixed32,4,opt,name=weight" json:"weight,omitempty"`
	Filter               *Query                    `protobuf:"bytes,5,opt,name=filter" json:"filter,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                  `json:"-"`
	XXX_unrecognized     []byte                    `json:"-"`
	XXX_sizecache        int32                     `json:"-"`
}

func (m *Function) Reset()         { *m = Function{} }
func (m *Function) String() string { return proto.CompactTextString(m) }
func (*Function) ProtoMessage()    {}
func (*Function) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{13}
}

func (m *Function) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Function.Unmarshal(m, b)
}
func (m *Function) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Function.Marshal(b, m, deterministic)
}
func (m *Function) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Function.Merge(m, src)
}
func (m *Function) XXX_Size() int {
	return xxx_messageInfo_Function.Size(m)
}
func (m *Function) XXX_DiscardUnknown() {
	xxx_messageInfo_Function.DiscardUnknown(m)
}

var xxx_messageInfo_Function proto.InternalMessageInfo

func (m *Function) GetFieldValueFactor() *FieldValueFactorFunction {
	if m != nil {
		return m.FieldValueFactor
	}
	return nil
}

func (m *Function) GetRandom() *RandomScoreFunction {
	if m != nil {
		return m.Random
	}
	return nil
}

func (m *Function) GetDecay() *DecayFunction {
	if m != nil {
		return m.Decay
	}
	return nil
}

func (m *Function) GetWeight() float32 {
	if m != nil && m.Weight != nil {
		return *m.Weight
	}
	return 0
}

func (m *Function) GetFilter() *Query {
	if m != nil {
		return m.Filter
	}
	return nil
}

type FieldValueFactorFunction struct {
	FieldName            *string           `protobuf:"bytes,1,opt,name=field_name,json=fieldName" json:"field_name,omitempty"`
	Factor               *float32          `protobuf:"fixed32,2,opt,name=factor" json:"factor,omitempty"`
	Modifier             *FunctionModifier `protobuf:"varint,3,opt,name=modifier,enum=otsprotocol.FunctionModifier" json:"modifier,omitempty"`
	Missing              *float64          `protobuf:"fixed64,4,opt,name=missing" json:"missing,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *FieldValueFactorFunction) Reset()         { *m = FieldValueFactorFunction{} }
func (m *FieldValueFactorFunction) String() string { return proto.CompactTextString(m) }
func (*FieldValueFactorFunction) ProtoMessage()    {}
func (*FieldValueFactorFunction) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{14}
}

func (m *FieldValueFactorFunction) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_FieldValueFactorFunction.Unmarshal(m, b)
}
func (m *FieldValueFactorFunction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_FieldValueFactorFunction.Marshal(b, m, deterministic)
}
func (m *FieldValueFactorFunction) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FieldValueFactorFunction.Merge(m, src)
}
func (m *FieldValueFactorFunction) XXX_Size() int {
	return xxx_messageInfo_FieldValueFactorFunction.Size(m)
}
func (m *FieldValueFactorFunction) XXX_DiscardUnknown() {
	xxx_messageInfo_FieldValueFactorFunction.DiscardUnknown(m)
}

var xxx_messageInfo_FieldValueFactorFunction proto.InternalMessageInfo

func (m *FieldValueFactorFunction) GetFieldName() string {
	if m != nil && m.FieldName != nil {
		return *m.FieldName
	}
	return ""
}

func (m *FieldValueFactorFunction) GetFactor() float32 {
	if m != nil && m.Factor != nil {
		return *m.Factor
	}
	return 0
}

func (m *FieldValueFactorFunction) GetModifier() FunctionModifier {
	if m != nil && m.Modifier != nil {
		return *m.Modifier
	}
	return FunctionModifier_FM_NONE
}

func (m *FieldValueFactorFunction) GetMissing() float64 {
	if m != nil && m.Missing != nil {
		return *m.Missing
	}
	return 0
}

type DecayFunction struct {
	FieldName            *string             `protobuf:"bytes,1,opt,name=field_name,json=fieldName" json:"field_name,omitempty"`
	MathFunction         *DecayMathFunction  `protobuf:"varint,2,opt,name=math_function,json=mathFunction,enum=otsprotocol.DecayMathFunction" json:"math_function,omitempty"`
	ParamType            *DecayFuncParamType `protobuf:"varint,3,opt,name=param_type,json=paramType,enum=otsprotocol.DecayFuncParamType" json:"param_type,omitempty"`
	Param                []byte              `protobuf:"bytes,4,opt,name=param" json:"param,omitempty"`
	Decay                *float64            `protobuf:"fixed64,5,opt,name=decay" json:"decay,omitempty"`
	MultiValueMode       *MultiValueMode     `protobuf:"varint,6,opt,name=multi_value_mode,json=multiValueMode,enum=otsprotocol.MultiValueMode" json:"multi_value_mode,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

func (m *DecayFunction) Reset()         { *m = DecayFunction{} }
func (m *DecayFunction) String() string { return proto.CompactTextString(m) }
func (*DecayFunction) ProtoMessage()    {}
func (*DecayFunction) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{15}
}

func (m *DecayFunction) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DecayFunction.Unmarshal(m, b)
}
func (m *DecayFunction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DecayFunction.Marshal(b, m, deterministic)
}
func (m *DecayFunction) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DecayFunction.Merge(m, src)
}
func (m *DecayFunction) XXX_Size() int {
	return xxx_messageInfo_DecayFunction.Size(m)
}
func (m *DecayFunction) XXX_DiscardUnknown() {
	xxx_messageInfo_DecayFunction.DiscardUnknown(m)
}

var xxx_messageInfo_DecayFunction proto.InternalMessageInfo

func (m *DecayFunction) GetFieldName() string {
	if m != nil && m.FieldName != nil {
		return *m.FieldName
	}
	return ""
}

func (m *DecayFunction) GetMathFunction() DecayMathFunction {
	if m != nil && m.MathFunction != nil {
		return *m.MathFunction
	}
	return DecayMathFunction_GAUSS
}

func (m *DecayFunction) GetParamType() DecayFuncParamType {
	if m != nil && m.ParamType != nil {
		return *m.ParamType
	}
	return DecayFuncParamType_DF_DATE_PARAM
}

func (m *DecayFunction) GetParam() []byte {
	if m != nil {
		return m.Param
	}
	return nil
}

func (m *DecayFunction) GetDecay() float64 {
	if m != nil && m.Decay != nil {
		return *m.Decay
	}
	return 0
}

func (m *DecayFunction) GetMultiValueMode() MultiValueMode {
	if m != nil && m.MultiValueMode != nil {
		return *m.MultiValueMode
	}
	return MultiValueMode_MVM_MAX
}

type DecayFuncDateParam struct {
	OriginLong           *int64         `protobuf:"varint,1,opt,name=origin_long,json=originLong" json:"origin_long,omitempty"`
	OriginString         *string        `protobuf:"bytes,2,opt,name=origin_string,json=originString" json:"origin_string,omitempty"`
	Scale                *DateTimeValue `protobuf:"bytes,3,opt,name=scale" json:"scale,omitempty"`
	Offset               *DateTimeValue `protobuf:"bytes,4,opt,name=offset" json:"offset,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (m *DecayFuncDateParam) Reset()         { *m = DecayFuncDateParam{} }
func (m *DecayFuncDateParam) String() string { return proto.CompactTextString(m) }
func (*DecayFuncDateParam) ProtoMessage()    {}
func (*DecayFuncDateParam) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{16}
}

func (m *DecayFuncDateParam) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DecayFuncDateParam.Unmarshal(m, b)
}
func (m *DecayFuncDateParam) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DecayFuncDateParam.Marshal(b, m, deterministic)
}
func (m *DecayFuncDateParam) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DecayFuncDateParam.Merge(m, src)
}
func (m *DecayFuncDateParam) XXX_Size() int {
	return xxx_messageInfo_DecayFuncDateParam.Size(m)
}
func (m *DecayFuncDateParam) XXX_DiscardUnknown() {
	xxx_messageInfo_DecayFuncDateParam.DiscardUnknown(m)
}

var xxx_messageInfo_DecayFuncDateParam proto.InternalMessageInfo

func (m *DecayFuncDateParam) GetOriginLong() int64 {
	if m != nil && m.OriginLong != nil {
		return *m.OriginLong
	}
	return 0
}

func (m *DecayFuncDateParam) GetOriginString() string {
	if m != nil && m.OriginString != nil {
		return *m.OriginString
	}
	return ""
}

func (m *DecayFuncDateParam) GetScale() *DateTimeValue {
	if m != nil {
		return m.Scale
	}
	return nil
}

func (m *DecayFuncDateParam) GetOffset() *DateTimeValue {
	if m != nil {
		return m.Offset
	}
	return nil
}

type DecayFuncNumericParam struct {
	Origin               *float64 `protobuf:"fixed64,1,opt,name=origin" json:"origin,omitempty"`
	Scale                *float64 `protobuf:"fixed64,2,opt,name=scale" json:"scale,omitempty"`
	Offset               *float64 `protobuf:"fixed64,3,opt,name=offset" json:"offset,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *DecayFuncNumericParam) Reset()         { *m = DecayFuncNumericParam{} }
func (m *DecayFuncNumericParam) String() string { return proto.CompactTextString(m) }
func (*DecayFuncNumericParam) ProtoMessage()    {}
func (*DecayFuncNumericParam) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{17}
}

func (m *DecayFuncNumericParam) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DecayFuncNumericParam.Unmarshal(m, b)
}
func (m *DecayFuncNumericParam) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DecayFuncNumericParam.Marshal(b, m, deterministic)
}
func (m *DecayFuncNumericParam) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DecayFuncNumericParam.Merge(m, src)
}
func (m *DecayFuncNumericParam) XXX_Size() int {
	return xxx_messageInfo_DecayFuncNumericParam.Size(m)
}
func (m *DecayFuncNumericParam) XXX_DiscardUnknown() {
	xxx_messageInfo_DecayFuncNumericParam.DiscardUnknown(m)
}

var xxx_messageInfo_DecayFuncNumericParam proto.InternalMessageInfo

func (m *DecayFuncNumericParam) GetOrigin() float64 {
	if m != nil && m.Origin != nil {
		return *m.Origin
	}
	return 0
}

func (m *DecayFuncNumericParam) GetScale() float64 {
	if m != nil && m.Scale != nil {
		return *m.Scale
	}
	return 0
}

func (m *DecayFuncNumericParam) GetOffset() float64 {
	if m != nil && m.Offset != nil {
		return *m.Offset
	}
	return 0
}

type DecayFuncGeoParam struct {
	Origin               *string  `protobuf:"bytes,1,opt,name=origin" json:"origin,omitempty"`
	Scale                *float64 `protobuf:"fixed64,2,opt,name=scale" json:"scale,omitempty"`
	Offset               *float64 `protobuf:"fixed64,3,opt,name=offset" json:"offset,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *DecayFuncGeoParam) Reset()         { *m = DecayFuncGeoParam{} }
func (m *DecayFuncGeoParam) String() string { return proto.CompactTextString(m) }
func (*DecayFuncGeoParam) ProtoMessage()    {}
func (*DecayFuncGeoParam) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{18}
}

func (m *DecayFuncGeoParam) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DecayFuncGeoParam.Unmarshal(m, b)
}
func (m *DecayFuncGeoParam) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DecayFuncGeoParam.Marshal(b, m, deterministic)
}
func (m *DecayFuncGeoParam) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DecayFuncGeoParam.Merge(m, src)
}
func (m *DecayFuncGeoParam) XXX_Size() int {
	return xxx_messageInfo_DecayFuncGeoParam.Size(m)
}
func (m *DecayFuncGeoParam) XXX_DiscardUnknown() {
	xxx_messageInfo_DecayFuncGeoParam.DiscardUnknown(m)
}

var xxx_messageInfo_DecayFuncGeoParam proto.InternalMessageInfo

func (m *DecayFuncGeoParam) GetOrigin() string {
	if m != nil && m.Origin != nil {
		return *m.Origin
	}
	return ""
}

func (m *DecayFuncGeoParam) GetScale() float64 {
	if m != nil && m.Scale != nil {
		return *m.Scale
	}
	return 0
}

func (m *DecayFuncGeoParam) GetOffset() float64 {
	if m != nil && m.Offset != nil {
		return *m.Offset
	}
	return 0
}

type RandomScoreFunction struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *RandomScoreFunction) Reset()         { *m = RandomScoreFunction{} }
func (m *RandomScoreFunction) String() string { return proto.CompactTextString(m) }
func (*RandomScoreFunction) ProtoMessage()    {}
func (*RandomScoreFunction) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{19}
}

func (m *RandomScoreFunction) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RandomScoreFunction.Unmarshal(m, b)
}
func (m *RandomScoreFunction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RandomScoreFunction.Marshal(b, m, deterministic)
}
func (m *RandomScoreFunction) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RandomScoreFunction.Merge(m, src)
}
func (m *RandomScoreFunction) XXX_Size() int {
	return xxx_messageInfo_RandomScoreFunction.Size(m)
}
func (m *RandomScoreFunction) XXX_DiscardUnknown() {
	xxx_messageInfo_RandomScoreFunction.DiscardUnknown(m)
}

var xxx_messageInfo_RandomScoreFunction proto.InternalMessageInfo

type NestedQuery struct {
	Path                 *string    `protobuf:"bytes,1,opt,name=path" json:"path,omitempty"`
	Query                *Query     `protobuf:"bytes,2,opt,name=query" json:"query,omitempty"`
	ScoreMode            *ScoreMode `protobuf:"varint,3,opt,name=score_mode,json=scoreMode,enum=otsprotocol.ScoreMode" json:"score_mode,omitempty"`
	InnerHits            *InnerHits `protobuf:"bytes,5,opt,name=inner_hits,json=innerHits" json:"inner_hits,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *NestedQuery) Reset()         { *m = NestedQuery{} }
func (m *NestedQuery) String() string { return proto.CompactTextString(m) }
func (*NestedQuery) ProtoMessage()    {}
func (*NestedQuery) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{20}
}

func (m *NestedQuery) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_NestedQuery.Unmarshal(m, b)
}
func (m *NestedQuery) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_NestedQuery.Marshal(b, m, deterministic)
}
func (m *NestedQuery) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NestedQuery.Merge(m, src)
}
func (m *NestedQuery) XXX_Size() int {
	return xxx_messageInfo_NestedQuery.Size(m)
}
func (m *NestedQuery) XXX_DiscardUnknown() {
	xxx_messageInfo_NestedQuery.DiscardUnknown(m)
}

var xxx_messageInfo_NestedQuery proto.InternalMessageInfo

func (m *NestedQuery) GetPath() string {
	if m != nil && m.Path != nil {
		return *m.Path
	}
	return ""
}

func (m *NestedQuery) GetQuery() *Query {
	if m != nil {
		return m.Query
	}
	return nil
}

func (m *NestedQuery) GetScoreMode() ScoreMode {
	if m != nil && m.ScoreMode != nil {
		return *m.ScoreMode
	}
	return ScoreMode_SCORE_MODE_NONE
}

func (m *NestedQuery) GetInnerHits() *InnerHits {
	if m != nil {
		return m.InnerHits
	}
	return nil
}

type InnerHits struct {
	Sort                 *Sort      `protobuf:"bytes,1,opt,name=sort" json:"sort,omitempty"`
	Offset               *int32     `protobuf:"varint,2,opt,name=offset" json:"offset,omitempty"`
	Limit                *int32     `protobuf:"varint,3,opt,name=limit" json:"limit,omitempty"`
	Highlight            *Highlight `protobuf:"bytes,4,opt,name=highlight" json:"highlight,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *InnerHits) Reset()         { *m = InnerHits{} }
func (m *InnerHits) String() string { return proto.CompactTextString(m) }
func (*InnerHits) ProtoMessage()    {}
func (*InnerHits) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{21}
}

func (m *InnerHits) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_InnerHits.Unmarshal(m, b)
}
func (m *InnerHits) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_InnerHits.Marshal(b, m, deterministic)
}
func (m *InnerHits) XXX_Merge(src proto.Message) {
	xxx_messageInfo_InnerHits.Merge(m, src)
}
func (m *InnerHits) XXX_Size() int {
	return xxx_messageInfo_InnerHits.Size(m)
}
func (m *InnerHits) XXX_DiscardUnknown() {
	xxx_messageInfo_InnerHits.DiscardUnknown(m)
}

var xxx_messageInfo_InnerHits proto.InternalMessageInfo

func (m *InnerHits) GetSort() *Sort {
	if m != nil {
		return m.Sort
	}
	return nil
}

func (m *InnerHits) GetOffset() int32 {
	if m != nil && m.Offset != nil {
		return *m.Offset
	}
	return 0
}

func (m *InnerHits) GetLimit() int32 {
	if m != nil && m.Limit != nil {
		return *m.Limit
	}
	return 0
}

func (m *InnerHits) GetHighlight() *Highlight {
	if m != nil {
		return m.Highlight
	}
	return nil
}

type GeoBoundingBoxQuery struct {
	FieldName            *string  `protobuf:"bytes,1,opt,name=field_name,json=fieldName" json:"field_name,omitempty"`
	TopLeft              *string  `protobuf:"bytes,2,opt,name=top_left,json=topLeft" json:"top_left,omitempty"`
	BottomRight          *string  `protobuf:"bytes,3,opt,name=bottom_right,json=bottomRight" json:"bottom_right,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GeoBoundingBoxQuery) Reset()         { *m = GeoBoundingBoxQuery{} }
func (m *GeoBoundingBoxQuery) String() string { return proto.CompactTextString(m) }
func (*GeoBoundingBoxQuery) ProtoMessage()    {}
func (*GeoBoundingBoxQuery) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{22}
}

func (m *GeoBoundingBoxQuery) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GeoBoundingBoxQuery.Unmarshal(m, b)
}
func (m *GeoBoundingBoxQuery) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GeoBoundingBoxQuery.Marshal(b, m, deterministic)
}
func (m *GeoBoundingBoxQuery) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GeoBoundingBoxQuery.Merge(m, src)
}
func (m *GeoBoundingBoxQuery) XXX_Size() int {
	return xxx_messageInfo_GeoBoundingBoxQuery.Size(m)
}
func (m *GeoBoundingBoxQuery) XXX_DiscardUnknown() {
	xxx_messageInfo_GeoBoundingBoxQuery.DiscardUnknown(m)
}

var xxx_messageInfo_GeoBoundingBoxQuery proto.InternalMessageInfo

func (m *GeoBoundingBoxQuery) GetFieldName() string {
	if m != nil && m.FieldName != nil {
		return *m.FieldName
	}
	return ""
}

func (m *GeoBoundingBoxQuery) GetTopLeft() string {
	if m != nil && m.TopLeft != nil {
		return *m.TopLeft
	}
	return ""
}

func (m *GeoBoundingBoxQuery) GetBottomRight() string {
	if m != nil && m.BottomRight != nil {
		return *m.BottomRight
	}
	return ""
}

type GeoDistanceQuery struct {
	FieldName            *string  `protobuf:"bytes,1,opt,name=field_name,json=fieldName" json:"field_name,omitempty"`
	CenterPoint          *string  `protobuf:"bytes,2,opt,name=center_point,json=centerPoint" json:"center_point,omitempty"`
	Distance             *float64 `protobuf:"fixed64,3,opt,name=distance" json:"distance,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GeoDistanceQuery) Reset()         { *m = GeoDistanceQuery{} }
func (m *GeoDistanceQuery) String() string { return proto.CompactTextString(m) }
func (*GeoDistanceQuery) ProtoMessage()    {}
func (*GeoDistanceQuery) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{23}
}

func (m *GeoDistanceQuery) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GeoDistanceQuery.Unmarshal(m, b)
}
func (m *GeoDistanceQuery) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GeoDistanceQuery.Marshal(b, m, deterministic)
}
func (m *GeoDistanceQuery) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GeoDistanceQuery.Merge(m, src)
}
func (m *GeoDistanceQuery) XXX_Size() int {
	return xxx_messageInfo_GeoDistanceQuery.Size(m)
}
func (m *GeoDistanceQuery) XXX_DiscardUnknown() {
	xxx_messageInfo_GeoDistanceQuery.DiscardUnknown(m)
}

var xxx_messageInfo_GeoDistanceQuery proto.InternalMessageInfo

func (m *GeoDistanceQuery) GetFieldName() string {
	if m != nil && m.FieldName != nil {
		return *m.FieldName
	}
	return ""
}

func (m *GeoDistanceQuery) GetCenterPoint() string {
	if m != nil && m.CenterPoint != nil {
		return *m.CenterPoint
	}
	return ""
}

func (m *GeoDistanceQuery) GetDistance() float64 {
	if m != nil && m.Distance != nil {
		return *m.Distance
	}
	return 0
}

type GeoPolygonQuery struct {
	FieldName            *string  `protobuf:"bytes,1,opt,name=field_name,json=fieldName" json:"field_name,omitempty"`
	Points               []string `protobuf:"bytes,2,rep,name=points" json:"points,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GeoPolygonQuery) Reset()         { *m = GeoPolygonQuery{} }
func (m *GeoPolygonQuery) String() string { return proto.CompactTextString(m) }
func (*GeoPolygonQuery) ProtoMessage()    {}
func (*GeoPolygonQuery) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{24}
}

func (m *GeoPolygonQuery) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GeoPolygonQuery.Unmarshal(m, b)
}
func (m *GeoPolygonQuery) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GeoPolygonQuery.Marshal(b, m, deterministic)
}
func (m *GeoPolygonQuery) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GeoPolygonQuery.Merge(m, src)
}
func (m *GeoPolygonQuery) XXX_Size() int {
	return xxx_messageInfo_GeoPolygonQuery.Size(m)
}
func (m *GeoPolygonQuery) XXX_DiscardUnknown() {
	xxx_messageInfo_GeoPolygonQuery.DiscardUnknown(m)
}

var xxx_messageInfo_GeoPolygonQuery proto.InternalMessageInfo

func (m *GeoPolygonQuery) GetFieldName() string {
	if m != nil && m.FieldName != nil {
		return *m.FieldName
	}
	return ""
}

func (m *GeoPolygonQuery) GetPoints() []string {
	if m != nil {
		return m.Points
	}
	return nil
}

type ExistsQuery struct {
	FieldName            *string  `protobuf:"bytes,1,opt,name=field_name,json=fieldName" json:"field_name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ExistsQuery) Reset()         { *m = ExistsQuery{} }
func (m *ExistsQuery) String() string { return proto.CompactTextString(m) }
func (*ExistsQuery) ProtoMessage()    {}
func (*ExistsQuery) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{25}
}

func (m *ExistsQuery) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ExistsQuery.Unmarshal(m, b)
}
func (m *ExistsQuery) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ExistsQuery.Marshal(b, m, deterministic)
}
func (m *ExistsQuery) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ExistsQuery.Merge(m, src)
}
func (m *ExistsQuery) XXX_Size() int {
	return xxx_messageInfo_ExistsQuery.Size(m)
}
func (m *ExistsQuery) XXX_DiscardUnknown() {
	xxx_messageInfo_ExistsQuery.DiscardUnknown(m)
}

var xxx_messageInfo_ExistsQuery proto.InternalMessageInfo

func (m *ExistsQuery) GetFieldName() string {
	if m != nil && m.FieldName != nil {
		return *m.FieldName
	}
	return ""
}

type KnnVectorQuery struct {
	FieldName            *string   `protobuf:"bytes,1,opt,name=field_name,json=fieldName" json:"field_name,omitempty"`
	TopK                 *int32    `protobuf:"varint,2,opt,name=top_k,json=topK" json:"top_k,omitempty"`
	Float32QueryVector   []float32 `protobuf:"fixed32,4,rep,name=float32_query_vector,json=float32QueryVector" json:"float32_query_vector,omitempty"`
	Filter               *Query    `protobuf:"bytes,5,opt,name=filter" json:"filter,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *KnnVectorQuery) Reset()         { *m = KnnVectorQuery{} }
func (m *KnnVectorQuery) String() string { return proto.CompactTextString(m) }
func (*KnnVectorQuery) ProtoMessage()    {}
func (*KnnVectorQuery) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{26}
}

func (m *KnnVectorQuery) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_KnnVectorQuery.Unmarshal(m, b)
}
func (m *KnnVectorQuery) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_KnnVectorQuery.Marshal(b, m, deterministic)
}
func (m *KnnVectorQuery) XXX_Merge(src proto.Message) {
	xxx_messageInfo_KnnVectorQuery.Merge(m, src)
}
func (m *KnnVectorQuery) XXX_Size() int {
	return xxx_messageInfo_KnnVectorQuery.Size(m)
}
func (m *KnnVectorQuery) XXX_DiscardUnknown() {
	xxx_messageInfo_KnnVectorQuery.DiscardUnknown(m)
}

var xxx_messageInfo_KnnVectorQuery proto.InternalMessageInfo

func (m *KnnVectorQuery) GetFieldName() string {
	if m != nil && m.FieldName != nil {
		return *m.FieldName
	}
	return ""
}

func (m *KnnVectorQuery) GetTopK() int32 {
	if m != nil && m.TopK != nil {
		return *m.TopK
	}
	return 0
}

func (m *KnnVectorQuery) GetFloat32QueryVector() []float32 {
	if m != nil {
		return m.Float32QueryVector
	}
	return nil
}

func (m *KnnVectorQuery) GetFilter() *Query {
	if m != nil {
		return m.Filter
	}
	return nil
}

type Query struct {
	Type                 *QueryType `protobuf:"varint,1,opt,name=type,enum=otsprotocol.QueryType" json:"type,omitempty"`
	Query                []byte     `protobuf:"bytes,2,opt,name=query" json:"query,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *Query) Reset()         { *m = Query{} }
func (m *Query) String() string { return proto.CompactTextString(m) }
func (*Query) ProtoMessage()    {}
func (*Query) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{27}
}

func (m *Query) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Query.Unmarshal(m, b)
}
func (m *Query) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Query.Marshal(b, m, deterministic)
}
func (m *Query) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Query.Merge(m, src)
}
func (m *Query) XXX_Size() int {
	return xxx_messageInfo_Query.Size(m)
}
func (m *Query) XXX_DiscardUnknown() {
	xxx_messageInfo_Query.DiscardUnknown(m)
}

var xxx_messageInfo_Query proto.InternalMessageInfo

func (m *Query) GetType() QueryType {
	if m != nil && m.Type != nil {
		return *m.Type
	}
	return QueryType_MATCH_QUERY
}

func (m *Query) GetQuery() []byte {
	if m != nil {
		return m.Query
	}
	return nil
}

type Collapse struct {
	FieldName            *string  `protobuf:"bytes,1,opt,name=field_name,json=fieldName" json:"field_name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Collapse) Reset()         { *m = Collapse{} }
func (m *Collapse) String() string { return proto.CompactTextString(m) }
func (*Collapse) ProtoMessage()    {}
func (*Collapse) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{28}
}

func (m *Collapse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Collapse.Unmarshal(m, b)
}
func (m *Collapse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Collapse.Marshal(b, m, deterministic)
}
func (m *Collapse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Collapse.Merge(m, src)
}
func (m *Collapse) XXX_Size() int {
	return xxx_messageInfo_Collapse.Size(m)
}
func (m *Collapse) XXX_DiscardUnknown() {
	xxx_messageInfo_Collapse.DiscardUnknown(m)
}

var xxx_messageInfo_Collapse proto.InternalMessageInfo

func (m *Collapse) GetFieldName() string {
	if m != nil && m.FieldName != nil {
		return *m.FieldName
	}
	return ""
}

type NestedFilter struct {
	Path                 *string  `protobuf:"bytes,1,opt,name=path" json:"path,omitempty"`
	Filter               *Query   `protobuf:"bytes,2,opt,name=filter" json:"filter,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *NestedFilter) Reset()         { *m = NestedFilter{} }
func (m *NestedFilter) String() string { return proto.CompactTextString(m) }
func (*NestedFilter) ProtoMessage()    {}
func (*NestedFilter) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{29}
}

func (m *NestedFilter) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_NestedFilter.Unmarshal(m, b)
}
func (m *NestedFilter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_NestedFilter.Marshal(b, m, deterministic)
}
func (m *NestedFilter) XXX_Merge(src proto.Message) {
	xxx_messageInfo_NestedFilter.Merge(m, src)
}
func (m *NestedFilter) XXX_Size() int {
	return xxx_messageInfo_NestedFilter.Size(m)
}
func (m *NestedFilter) XXX_DiscardUnknown() {
	xxx_messageInfo_NestedFilter.DiscardUnknown(m)
}

var xxx_messageInfo_NestedFilter proto.InternalMessageInfo

func (m *NestedFilter) GetPath() string {
	if m != nil && m.Path != nil {
		return *m.Path
	}
	return ""
}

func (m *NestedFilter) GetFilter() *Query {
	if m != nil {
		return m.Filter
	}
	return nil
}

type DocSort struct {
	Order                *SortOrder `protobuf:"varint,1,opt,name=order,enum=otsprotocol.SortOrder" json:"order,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *DocSort) Reset()         { *m = DocSort{} }
func (m *DocSort) String() string { return proto.CompactTextString(m) }
func (*DocSort) ProtoMessage()    {}
func (*DocSort) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{30}
}

func (m *DocSort) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DocSort.Unmarshal(m, b)
}
func (m *DocSort) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DocSort.Marshal(b, m, deterministic)
}
func (m *DocSort) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DocSort.Merge(m, src)
}
func (m *DocSort) XXX_Size() int {
	return xxx_messageInfo_DocSort.Size(m)
}
func (m *DocSort) XXX_DiscardUnknown() {
	xxx_messageInfo_DocSort.DiscardUnknown(m)
}

var xxx_messageInfo_DocSort proto.InternalMessageInfo

func (m *DocSort) GetOrder() SortOrder {
	if m != nil && m.Order != nil {
		return *m.Order
	}
	return SortOrder_SORT_ORDER_ASC
}

type ScoreSort struct {
	Order                *SortOrder `protobuf:"varint,1,opt,name=order,enum=otsprotocol.SortOrder" json:"order,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *ScoreSort) Reset()         { *m = ScoreSort{} }
func (m *ScoreSort) String() string { return proto.CompactTextString(m) }
func (*ScoreSort) ProtoMessage()    {}
func (*ScoreSort) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{31}
}

func (m *ScoreSort) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ScoreSort.Unmarshal(m, b)
}
func (m *ScoreSort) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ScoreSort.Marshal(b, m, deterministic)
}
func (m *ScoreSort) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ScoreSort.Merge(m, src)
}
func (m *ScoreSort) XXX_Size() int {
	return xxx_messageInfo_ScoreSort.Size(m)
}
func (m *ScoreSort) XXX_DiscardUnknown() {
	xxx_messageInfo_ScoreSort.DiscardUnknown(m)
}

var xxx_messageInfo_ScoreSort proto.InternalMessageInfo

func (m *ScoreSort) GetOrder() SortOrder {
	if m != nil && m.Order != nil {
		return *m.Order
	}
	return SortOrder_SORT_ORDER_ASC
}

type FieldSort struct {
	FieldName            *string       `protobuf:"bytes,1,opt,name=field_name,json=fieldName" json:"field_name,omitempty"`
	Order                *SortOrder    `protobuf:"varint,2,opt,name=order,enum=otsprotocol.SortOrder" json:"order,omitempty"`
	Mode                 *SortMode     `protobuf:"varint,3,opt,name=mode,enum=otsprotocol.SortMode" json:"mode,omitempty"`
	NestedFilter         *NestedFilter `protobuf:"bytes,4,opt,name=nested_filter,json=nestedFilter" json:"nested_filter,omitempty"`
	MissingValue         []byte        `protobuf:"bytes,5,opt,name=missing_value,json=missingValue" json:"missing_value,omitempty"`
	MissingField         *string       `protobuf:"bytes,6,opt,name=missing_field,json=missingField" json:"missing_field,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

func (m *FieldSort) Reset()         { *m = FieldSort{} }
func (m *FieldSort) String() string { return proto.CompactTextString(m) }
func (*FieldSort) ProtoMessage()    {}
func (*FieldSort) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{32}
}

func (m *FieldSort) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_FieldSort.Unmarshal(m, b)
}
func (m *FieldSort) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_FieldSort.Marshal(b, m, deterministic)
}
func (m *FieldSort) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FieldSort.Merge(m, src)
}
func (m *FieldSort) XXX_Size() int {
	return xxx_messageInfo_FieldSort.Size(m)
}
func (m *FieldSort) XXX_DiscardUnknown() {
	xxx_messageInfo_FieldSort.DiscardUnknown(m)
}

var xxx_messageInfo_FieldSort proto.InternalMessageInfo

func (m *FieldSort) GetFieldName() string {
	if m != nil && m.FieldName != nil {
		return *m.FieldName
	}
	return ""
}

func (m *FieldSort) GetOrder() SortOrder {
	if m != nil && m.Order != nil {
		return *m.Order
	}
	return SortOrder_SORT_ORDER_ASC
}

func (m *FieldSort) GetMode() SortMode {
	if m != nil && m.Mode != nil {
		return *m.Mode
	}
	return SortMode_SORT_MODE_MIN
}

func (m *FieldSort) GetNestedFilter() *NestedFilter {
	if m != nil {
		return m.NestedFilter
	}
	return nil
}

func (m *FieldSort) GetMissingValue() []byte {
	if m != nil {
		return m.MissingValue
	}
	return nil
}

func (m *FieldSort) GetMissingField() string {
	if m != nil && m.MissingField != nil {
		return *m.MissingField
	}
	return ""
}

type GeoDistanceSort struct {
	FieldName            *string          `protobuf:"bytes,1,opt,name=field_name,json=fieldName" json:"field_name,omitempty"`
	Points               []string         `protobuf:"bytes,2,rep,name=points" json:"points,omitempty"`
	Order                *SortOrder       `protobuf:"varint,3,opt,name=order,enum=otsprotocol.SortOrder" json:"order,omitempty"`
	Mode                 *SortMode        `protobuf:"varint,4,opt,name=mode,enum=otsprotocol.SortMode" json:"mode,omitempty"`
	DistanceType         *GeoDistanceType `protobuf:"varint,5,opt,name=distance_type,json=distanceType,enum=otsprotocol.GeoDistanceType" json:"distance_type,omitempty"`
	NestedFilter         *NestedFilter    `protobuf:"bytes,6,opt,name=nested_filter,json=nestedFilter" json:"nested_filter,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

func (m *GeoDistanceSort) Reset()         { *m = GeoDistanceSort{} }
func (m *GeoDistanceSort) String() string { return proto.CompactTextString(m) }
func (*GeoDistanceSort) ProtoMessage()    {}
func (*GeoDistanceSort) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{33}
}

func (m *GeoDistanceSort) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GeoDistanceSort.Unmarshal(m, b)
}
func (m *GeoDistanceSort) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GeoDistanceSort.Marshal(b, m, deterministic)
}
func (m *GeoDistanceSort) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GeoDistanceSort.Merge(m, src)
}
func (m *GeoDistanceSort) XXX_Size() int {
	return xxx_messageInfo_GeoDistanceSort.Size(m)
}
func (m *GeoDistanceSort) XXX_DiscardUnknown() {
	xxx_messageInfo_GeoDistanceSort.DiscardUnknown(m)
}

var xxx_messageInfo_GeoDistanceSort proto.InternalMessageInfo

func (m *GeoDistanceSort) GetFieldName() string {
	if m != nil && m.FieldName != nil {
		return *m.FieldName
	}
	return ""
}

func (m *GeoDistanceSort) GetPoints() []string {
	if m != nil {
		return m.Points
	}
	return nil
}

func (m *GeoDistanceSort) GetOrder() SortOrder {
	if m != nil && m.Order != nil {
		return *m.Order
	}
	return SortOrder_SORT_ORDER_ASC
}

func (m *GeoDistanceSort) GetMode() SortMode {
	if m != nil && m.Mode != nil {
		return *m.Mode
	}
	return SortMode_SORT_MODE_MIN
}

func (m *GeoDistanceSort) GetDistanceType() GeoDistanceType {
	if m != nil && m.DistanceType != nil {
		return *m.DistanceType
	}
	return GeoDistanceType_GEO_DISTANCE_ARC
}

func (m *GeoDistanceSort) GetNestedFilter() *NestedFilter {
	if m != nil {
		return m.NestedFilter
	}
	return nil
}

type PrimaryKeySort struct {
	Order                *SortOrder `protobuf:"varint,1,opt,name=order,enum=otsprotocol.SortOrder" json:"order,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *PrimaryKeySort) Reset()         { *m = PrimaryKeySort{} }
func (m *PrimaryKeySort) String() string { return proto.CompactTextString(m) }
func (*PrimaryKeySort) ProtoMessage()    {}
func (*PrimaryKeySort) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{34}
}

func (m *PrimaryKeySort) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PrimaryKeySort.Unmarshal(m, b)
}
func (m *PrimaryKeySort) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PrimaryKeySort.Marshal(b, m, deterministic)
}
func (m *PrimaryKeySort) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PrimaryKeySort.Merge(m, src)
}
func (m *PrimaryKeySort) XXX_Size() int {
	return xxx_messageInfo_PrimaryKeySort.Size(m)
}
func (m *PrimaryKeySort) XXX_DiscardUnknown() {
	xxx_messageInfo_PrimaryKeySort.DiscardUnknown(m)
}

var xxx_messageInfo_PrimaryKeySort proto.InternalMessageInfo

func (m *PrimaryKeySort) GetOrder() SortOrder {
	if m != nil && m.Order != nil {
		return *m.Order
	}
	return SortOrder_SORT_ORDER_ASC
}

type Sorter struct {
	FieldSort            *FieldSort       `protobuf:"bytes,1,opt,name=field_sort,json=fieldSort" json:"field_sort,omitempty"`
	GeoDistanceSort      *GeoDistanceSort `protobuf:"bytes,2,opt,name=geo_distance_sort,json=geoDistanceSort" json:"geo_distance_sort,omitempty"`
	ScoreSort            *ScoreSort       `protobuf:"bytes,3,opt,name=score_sort,json=scoreSort" json:"score_sort,omitempty"`
	PkSort               *PrimaryKeySort  `protobuf:"bytes,4,opt,name=pk_sort,json=pkSort" json:"pk_sort,omitempty"`
	DocSort              *DocSort         `protobuf:"bytes,5,opt,name=doc_sort,json=docSort" json:"doc_sort,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

func (m *Sorter) Reset()         { *m = Sorter{} }
func (m *Sorter) String() string { return proto.CompactTextString(m) }
func (*Sorter) ProtoMessage()    {}
func (*Sorter) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{35}
}

func (m *Sorter) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Sorter.Unmarshal(m, b)
}
func (m *Sorter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Sorter.Marshal(b, m, deterministic)
}
func (m *Sorter) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Sorter.Merge(m, src)
}
func (m *Sorter) XXX_Size() int {
	return xxx_messageInfo_Sorter.Size(m)
}
func (m *Sorter) XXX_DiscardUnknown() {
	xxx_messageInfo_Sorter.DiscardUnknown(m)
}

var xxx_messageInfo_Sorter proto.InternalMessageInfo

func (m *Sorter) GetFieldSort() *FieldSort {
	if m != nil {
		return m.FieldSort
	}
	return nil
}

func (m *Sorter) GetGeoDistanceSort() *GeoDistanceSort {
	if m != nil {
		return m.GeoDistanceSort
	}
	return nil
}

func (m *Sorter) GetScoreSort() *ScoreSort {
	if m != nil {
		return m.ScoreSort
	}
	return nil
}

func (m *Sorter) GetPkSort() *PrimaryKeySort {
	if m != nil {
		return m.PkSort
	}
	return nil
}

func (m *Sorter) GetDocSort() *DocSort {
	if m != nil {
		return m.DocSort
	}
	return nil
}

type Sort struct {
	Sorter                 []*Sorter `protobuf:"bytes,1,rep,name=sorter" json:"sorter,omitempty"`
	DisableDefaultPkSorter *bool     `protobuf:"varint,2,opt,name=disable_default_pk_sorter,json=disableDefaultPkSorter" json:"disable_default_pk_sorter,omitempty"`
	XXX_NoUnkeyedLiteral   struct{}  `json:"-"`
	XXX_unrecognized       []byte    `json:"-"`
	XXX_sizecache          int32     `json:"-"`
}

func (m *Sort) Reset()         { *m = Sort{} }
func (m *Sort) String() string { return proto.CompactTextString(m) }
func (*Sort) ProtoMessage()    {}
func (*Sort) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{36}
}

func (m *Sort) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Sort.Unmarshal(m, b)
}
func (m *Sort) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Sort.Marshal(b, m, deterministic)
}
func (m *Sort) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Sort.Merge(m, src)
}
func (m *Sort) XXX_Size() int {
	return xxx_messageInfo_Sort.Size(m)
}
func (m *Sort) XXX_DiscardUnknown() {
	xxx_messageInfo_Sort.DiscardUnknown(m)
}

var xxx_messageInfo_Sort proto.InternalMessageInfo

func (m *Sort) GetSorter() []*Sorter {
	if m != nil {
		return m.Sorter
	}
	return nil
}

func (m *Sort) GetDisableDefaultPkSorter() bool {
	if m != nil && m.DisableDefaultPkSorter != nil {
		return *m.DisableDefaultPkSorter
	}
	return false
}

type SearchQuery struct {
	Offset               *int32        `protobuf:"varint,1,opt,name=offset" json:"offset,omitempty"`
	Limit                *int32        `protobuf:"varint,2,opt,name=limit" json:"limit,omitempty"`
	Query                *Query        `protobuf:"bytes,4,opt,name=query" json:"query,omitempty"`
	Collapse             *Collapse     `protobuf:"bytes,5,opt,name=collapse" json:"collapse,omitempty"`
	Sort                 *Sort         `protobuf:"bytes,6,opt,name=sort" json:"sort,omitempty"`
	GetTotalCount        *bool         `protobuf:"varint,8,opt,name=getTotalCount" json:"getTotalCount,omitempty"`
	Token                []byte        `protobuf:"bytes,9,opt,name=token" json:"token,omitempty"`
	Aggs                 *Aggregations `protobuf:"bytes,10,opt,name=aggs" json:"aggs,omitempty"`
	GroupBys             *GroupBys     `protobuf:"bytes,11,opt,name=group_bys,json=groupBys" json:"group_bys,omitempty"`
	Highlight            *Highlight    `protobuf:"bytes,12,opt,name=highlight" json:"highlight,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

func (m *SearchQuery) Reset()         { *m = SearchQuery{} }
func (m *SearchQuery) String() string { return proto.CompactTextString(m) }
func (*SearchQuery) ProtoMessage()    {}
func (*SearchQuery) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{37}
}

func (m *SearchQuery) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SearchQuery.Unmarshal(m, b)
}
func (m *SearchQuery) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SearchQuery.Marshal(b, m, deterministic)
}
func (m *SearchQuery) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SearchQuery.Merge(m, src)
}
func (m *SearchQuery) XXX_Size() int {
	return xxx_messageInfo_SearchQuery.Size(m)
}
func (m *SearchQuery) XXX_DiscardUnknown() {
	xxx_messageInfo_SearchQuery.DiscardUnknown(m)
}

var xxx_messageInfo_SearchQuery proto.InternalMessageInfo

func (m *SearchQuery) GetOffset() int32 {
	if m != nil && m.Offset != nil {
		return *m.Offset
	}
	return 0
}

func (m *SearchQuery) GetLimit() int32 {
	if m != nil && m.Limit != nil {
		return *m.Limit
	}
	return 0
}

func (m *SearchQuery) GetQuery() *Query {
	if m != nil {
		return m.Query
	}
	return nil
}

func (m *SearchQuery) GetCollapse() *Collapse {
	if m != nil {
		return m.Collapse
	}
	return nil
}

func (m *SearchQuery) GetSort() *Sort {
	if m != nil {
		return m.Sort
	}
	return nil
}

func (m *SearchQuery) GetGetTotalCount() bool {
	if m != nil && m.GetTotalCount != nil {
		return *m.GetTotalCount
	}
	return false
}

func (m *SearchQuery) GetToken() []byte {
	if m != nil {
		return m.Token
	}
	return nil
}

func (m *SearchQuery) GetAggs() *Aggregations {
	if m != nil {
		return m.Aggs
	}
	return nil
}

func (m *SearchQuery) GetGroupBys() *GroupBys {
	if m != nil {
		return m.GroupBys
	}
	return nil
}

func (m *SearchQuery) GetHighlight() *Highlight {
	if m != nil {
		return m.Highlight
	}
	return nil
}

type Highlight struct {
	HighlightParameters  []*HighlightParameter `protobuf:"bytes,1,rep,name=highlight_parameters,json=highlightParameters" json:"highlight_parameters,omitempty"`
	HighlightEncoder     *HighlightEncoder     `protobuf:"varint,2,opt,name=highlight_encoder,json=highlightEncoder,enum=otsprotocol.HighlightEncoder,def=1" json:"highlight_encoder,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

func (m *Highlight) Reset()         { *m = Highlight{} }
func (m *Highlight) String() string { return proto.CompactTextString(m) }
func (*Highlight) ProtoMessage()    {}
func (*Highlight) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{38}
}

func (m *Highlight) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Highlight.Unmarshal(m, b)
}
func (m *Highlight) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Highlight.Marshal(b, m, deterministic)
}
func (m *Highlight) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Highlight.Merge(m, src)
}
func (m *Highlight) XXX_Size() int {
	return xxx_messageInfo_Highlight.Size(m)
}
func (m *Highlight) XXX_DiscardUnknown() {
	xxx_messageInfo_Highlight.DiscardUnknown(m)
}

var xxx_messageInfo_Highlight proto.InternalMessageInfo

const Default_Highlight_HighlightEncoder HighlightEncoder = HighlightEncoder_PLAIN_MODE

func (m *Highlight) GetHighlightParameters() []*HighlightParameter {
	if m != nil {
		return m.HighlightParameters
	}
	return nil
}

func (m *Highlight) GetHighlightEncoder() HighlightEncoder {
	if m != nil && m.HighlightEncoder != nil {
		return *m.HighlightEncoder
	}
	return Default_Highlight_HighlightEncoder
}

type HighlightParameter struct {
	FieldName            *string                 `protobuf:"bytes,1,opt,name=field_name,json=fieldName" json:"field_name,omitempty"`
	NumberOfFragments    *int32                  `protobuf:"varint,2,opt,name=number_of_fragments,json=numberOfFragments" json:"number_of_fragments,omitempty"`
	FragmentSize         *int32                  `protobuf:"varint,3,opt,name=fragment_size,json=fragmentSize" json:"fragment_size,omitempty"`
	PreTag               *string                 `protobuf:"bytes,4,opt,name=pre_tag,json=preTag" json:"pre_tag,omitempty"`
	PostTag              *string                 `protobuf:"bytes,5,opt,name=post_tag,json=postTag" json:"post_tag,omitempty"`
	FragmentsOrder       *HighlightFragmentOrder `protobuf:"varint,6,opt,name=fragments_order,json=fragmentsOrder,enum=otsprotocol.HighlightFragmentOrder,def=1" json:"fragments_order,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

func (m *HighlightParameter) Reset()         { *m = HighlightParameter{} }
func (m *HighlightParameter) String() string { return proto.CompactTextString(m) }
func (*HighlightParameter) ProtoMessage()    {}
func (*HighlightParameter) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{39}
}

func (m *HighlightParameter) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_HighlightParameter.Unmarshal(m, b)
}
func (m *HighlightParameter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_HighlightParameter.Marshal(b, m, deterministic)
}
func (m *HighlightParameter) XXX_Merge(src proto.Message) {
	xxx_messageInfo_HighlightParameter.Merge(m, src)
}
func (m *HighlightParameter) XXX_Size() int {
	return xxx_messageInfo_HighlightParameter.Size(m)
}
func (m *HighlightParameter) XXX_DiscardUnknown() {
	xxx_messageInfo_HighlightParameter.DiscardUnknown(m)
}

var xxx_messageInfo_HighlightParameter proto.InternalMessageInfo

const Default_HighlightParameter_FragmentsOrder HighlightFragmentOrder = HighlightFragmentOrder_TEXT_SEQUENCE

func (m *HighlightParameter) GetFieldName() string {
	if m != nil && m.FieldName != nil {
		return *m.FieldName
	}
	return ""
}

func (m *HighlightParameter) GetNumberOfFragments() int32 {
	if m != nil && m.NumberOfFragments != nil {
		return *m.NumberOfFragments
	}
	return 0
}

func (m *HighlightParameter) GetFragmentSize() int32 {
	if m != nil && m.FragmentSize != nil {
		return *m.FragmentSize
	}
	return 0
}

func (m *HighlightParameter) GetPreTag() string {
	if m != nil && m.PreTag != nil {
		return *m.PreTag
	}
	return ""
}

func (m *HighlightParameter) GetPostTag() string {
	if m != nil && m.PostTag != nil {
		return *m.PostTag
	}
	return ""
}

func (m *HighlightParameter) GetFragmentsOrder() HighlightFragmentOrder {
	if m != nil && m.FragmentsOrder != nil {
		return *m.FragmentsOrder
	}
	return Default_HighlightParameter_FragmentsOrder
}

type ColumnsToGet struct {
	ReturnType           *ColumnReturnType `protobuf:"varint,1,opt,name=return_type,json=returnType,enum=otsprotocol.ColumnReturnType" json:"return_type,omitempty"`
	ColumnNames          []string          `protobuf:"bytes,2,rep,name=column_names,json=columnNames" json:"column_names,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *ColumnsToGet) Reset()         { *m = ColumnsToGet{} }
func (m *ColumnsToGet) String() string { return proto.CompactTextString(m) }
func (*ColumnsToGet) ProtoMessage()    {}
func (*ColumnsToGet) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{40}
}

func (m *ColumnsToGet) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ColumnsToGet.Unmarshal(m, b)
}
func (m *ColumnsToGet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ColumnsToGet.Marshal(b, m, deterministic)
}
func (m *ColumnsToGet) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ColumnsToGet.Merge(m, src)
}
func (m *ColumnsToGet) XXX_Size() int {
	return xxx_messageInfo_ColumnsToGet.Size(m)
}
func (m *ColumnsToGet) XXX_DiscardUnknown() {
	xxx_messageInfo_ColumnsToGet.DiscardUnknown(m)
}

var xxx_messageInfo_ColumnsToGet proto.InternalMessageInfo

func (m *ColumnsToGet) GetReturnType() ColumnReturnType {
	if m != nil && m.ReturnType != nil {
		return *m.ReturnType
	}
	return ColumnReturnType_RETURN_ALL
}

func (m *ColumnsToGet) GetColumnNames() []string {
	if m != nil {
		return m.ColumnNames
	}
	return nil
}

type SearchRequest struct {
	TableName            *string       `protobuf:"bytes,1,opt,name=table_name,json=tableName" json:"table_name,omitempty"`
	IndexName            *string       `protobuf:"bytes,2,opt,name=index_name,json=indexName" json:"index_name,omitempty"`
	ColumnsToGet         *ColumnsToGet `protobuf:"bytes,3,opt,name=columns_to_get,json=columnsToGet" json:"columns_to_get,omitempty"`
	SearchQuery          []byte        `protobuf:"bytes,4,opt,name=search_query,json=searchQuery" json:"search_query,omitempty"`
	RoutingValues        [][]byte      `protobuf:"bytes,5,rep,name=routing_values,json=routingValues" json:"routing_values,omitempty"`
	TimeoutMs            *int32        `protobuf:"varint,6,opt,name=timeoutMs" json:"timeoutMs,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

func (m *SearchRequest) Reset()         { *m = SearchRequest{} }
func (m *SearchRequest) String() string { return proto.CompactTextString(m) }
func (*SearchRequest) ProtoMessage()    {}
func (*SearchRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{41}
}

func (m *SearchRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SearchRequest.Unmarshal(m, b)
}
func (m *SearchRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SearchRequest.Marshal(b, m, deterministic)
}
func (m *SearchRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SearchRequest.Merge(m, src)
}
func (m *SearchRequest) XXX_Size() int {
	return xxx_messageInfo_SearchRequest.Size(m)
}
func (m *SearchRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_SearchRequest.DiscardUnknown(m)
}

var xxx_messageInfo_SearchRequest proto.InternalMessageInfo

func (m *SearchRequest) GetTableName() string {
	if m != nil && m.TableName != nil {
		return *m.TableName
	}
	return ""
}

func (m *SearchRequest) GetIndexName() string {
	if m != nil && m.IndexName != nil {
		return *m.IndexName
	}
	return ""
}

func (m *SearchRequest) GetColumnsToGet() *ColumnsToGet {
	if m != nil {
		return m.ColumnsToGet
	}
	return nil
}

func (m *SearchRequest) GetSearchQuery() []byte {
	if m != nil {
		return m.SearchQuery
	}
	return nil
}

func (m *SearchRequest) GetRoutingValues() [][]byte {
	if m != nil {
		return m.RoutingValues
	}
	return nil
}

func (m *SearchRequest) GetTimeoutMs() int32 {
	if m != nil && m.TimeoutMs != nil {
		return *m.TimeoutMs
	}
	return 0
}

type SearchResponse struct {
	TotalHits            *int64            `protobuf:"varint,1,opt,name=total_hits,json=totalHits" json:"total_hits,omitempty"`
	Rows                 [][]byte          `protobuf:"bytes,2,rep,name=rows" json:"rows,omitempty"`
	IsAllSucceeded       *bool             `protobuf:"varint,3,opt,name=is_all_succeeded,json=isAllSucceeded" json:"is_all_succeeded,omitempty"`
	SearchHits           []*SearchHit      `protobuf:"bytes,5,rep,name=search_hits,json=searchHits" json:"search_hits,omitempty"`
	NextToken            []byte            `protobuf:"bytes,6,opt,name=next_token,json=nextToken" json:"next_token,omitempty"`
	Aggs                 []byte            `protobuf:"bytes,7,opt,name=aggs" json:"aggs,omitempty"`
	GroupBys             []byte            `protobuf:"bytes,8,opt,name=group_bys,json=groupBys" json:"group_bys,omitempty"`
	Consumed             *ConsumedCapacity `protobuf:"bytes,9,opt,name=consumed" json:"consumed,omitempty"`
	ReservedConsumed     *ConsumedCapacity `protobuf:"bytes,10,opt,name=reserved_consumed,json=reservedConsumed" json:"reserved_consumed,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *SearchResponse) Reset()         { *m = SearchResponse{} }
func (m *SearchResponse) String() string { return proto.CompactTextString(m) }
func (*SearchResponse) ProtoMessage()    {}
func (*SearchResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{42}
}

func (m *SearchResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SearchResponse.Unmarshal(m, b)
}
func (m *SearchResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SearchResponse.Marshal(b, m, deterministic)
}
func (m *SearchResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SearchResponse.Merge(m, src)
}
func (m *SearchResponse) XXX_Size() int {
	return xxx_messageInfo_SearchResponse.Size(m)
}
func (m *SearchResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_SearchResponse.DiscardUnknown(m)
}

var xxx_messageInfo_SearchResponse proto.InternalMessageInfo

func (m *SearchResponse) GetTotalHits() int64 {
	if m != nil && m.TotalHits != nil {
		return *m.TotalHits
	}
	return 0
}

func (m *SearchResponse) GetRows() [][]byte {
	if m != nil {
		return m.Rows
	}
	return nil
}

func (m *SearchResponse) GetIsAllSucceeded() bool {
	if m != nil && m.IsAllSucceeded != nil {
		return *m.IsAllSucceeded
	}
	return false
}

func (m *SearchResponse) GetSearchHits() []*SearchHit {
	if m != nil {
		return m.SearchHits
	}
	return nil
}

func (m *SearchResponse) GetNextToken() []byte {
	if m != nil {
		return m.NextToken
	}
	return nil
}

func (m *SearchResponse) GetAggs() []byte {
	if m != nil {
		return m.Aggs
	}
	return nil
}

func (m *SearchResponse) GetGroupBys() []byte {
	if m != nil {
		return m.GroupBys
	}
	return nil
}

func (m *SearchResponse) GetConsumed() *ConsumedCapacity {
	if m != nil {
		return m.Consumed
	}
	return nil
}

func (m *SearchResponse) GetReservedConsumed() *ConsumedCapacity {
	if m != nil {
		return m.ReservedConsumed
	}
	return nil
}

type SearchHit struct {
	Score                *float64          `protobuf:"fixed64,3,opt,name=score" json:"score,omitempty"`
	HighlightResult      *HighlightResult  `protobuf:"bytes,4,opt,name=highlight_result,json=highlightResult" json:"highlight_result,omitempty"`
	SearchInnerHits      []*SearchInnerHit `protobuf:"bytes,5,rep,name=search_inner_hits,json=searchInnerHits" json:"search_inner_hits,omitempty"`
	NestedDocOffset      *int32            `protobuf:"varint,6,opt,name=nested_doc_offset,json=nestedDocOffset" json:"nested_doc_offset,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *SearchHit) Reset()         { *m = SearchHit{} }
func (m *SearchHit) String() string { return proto.CompactTextString(m) }
func (*SearchHit) ProtoMessage()    {}
func (*SearchHit) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{43}
}

func (m *SearchHit) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SearchHit.Unmarshal(m, b)
}
func (m *SearchHit) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SearchHit.Marshal(b, m, deterministic)
}
func (m *SearchHit) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SearchHit.Merge(m, src)
}
func (m *SearchHit) XXX_Size() int {
	return xxx_messageInfo_SearchHit.Size(m)
}
func (m *SearchHit) XXX_DiscardUnknown() {
	xxx_messageInfo_SearchHit.DiscardUnknown(m)
}

var xxx_messageInfo_SearchHit proto.InternalMessageInfo

func (m *SearchHit) GetScore() float64 {
	if m != nil && m.Score != nil {
		return *m.Score
	}
	return 0
}

func (m *SearchHit) GetHighlightResult() *HighlightResult {
	if m != nil {
		return m.HighlightResult
	}
	return nil
}

func (m *SearchHit) GetSearchInnerHits() []*SearchInnerHit {
	if m != nil {
		return m.SearchInnerHits
	}
	return nil
}

func (m *SearchHit) GetNestedDocOffset() int32 {
	if m != nil && m.NestedDocOffset != nil {
		return *m.NestedDocOffset
	}
	return 0
}

type SearchInnerHit struct {
	Path                 *string      `protobuf:"bytes,1,opt,name=path" json:"path,omitempty"`
	SearchHits           []*SearchHit `protobuf:"bytes,2,rep,name=search_hits,json=searchHits" json:"search_hits,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *SearchInnerHit) Reset()         { *m = SearchInnerHit{} }
func (m *SearchInnerHit) String() string { return proto.CompactTextString(m) }
func (*SearchInnerHit) ProtoMessage()    {}
func (*SearchInnerHit) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{44}
}

func (m *SearchInnerHit) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SearchInnerHit.Unmarshal(m, b)
}
func (m *SearchInnerHit) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SearchInnerHit.Marshal(b, m, deterministic)
}
func (m *SearchInnerHit) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SearchInnerHit.Merge(m, src)
}
func (m *SearchInnerHit) XXX_Size() int {
	return xxx_messageInfo_SearchInnerHit.Size(m)
}
func (m *SearchInnerHit) XXX_DiscardUnknown() {
	xxx_messageInfo_SearchInnerHit.DiscardUnknown(m)
}

var xxx_messageInfo_SearchInnerHit proto.InternalMessageInfo

func (m *SearchInnerHit) GetPath() string {
	if m != nil && m.Path != nil {
		return *m.Path
	}
	return ""
}

func (m *SearchInnerHit) GetSearchHits() []*SearchHit {
	if m != nil {
		return m.SearchHits
	}
	return nil
}

type HighlightResult struct {
	HighlightFields      []*HighlightField `protobuf:"bytes,1,rep,name=highlight_fields,json=highlightFields" json:"highlight_fields,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *HighlightResult) Reset()         { *m = HighlightResult{} }
func (m *HighlightResult) String() string { return proto.CompactTextString(m) }
func (*HighlightResult) ProtoMessage()    {}
func (*HighlightResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{45}
}

func (m *HighlightResult) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_HighlightResult.Unmarshal(m, b)
}
func (m *HighlightResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_HighlightResult.Marshal(b, m, deterministic)
}
func (m *HighlightResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_HighlightResult.Merge(m, src)
}
func (m *HighlightResult) XXX_Size() int {
	return xxx_messageInfo_HighlightResult.Size(m)
}
func (m *HighlightResult) XXX_DiscardUnknown() {
	xxx_messageInfo_HighlightResult.DiscardUnknown(m)
}

var xxx_messageInfo_HighlightResult proto.InternalMessageInfo

func (m *HighlightResult) GetHighlightFields() []*HighlightField {
	if m != nil {
		return m.HighlightFields
	}
	return nil
}

type HighlightField struct {
	FieldName            *string  `protobuf:"bytes,1,opt,name=field_name,json=fieldName" json:"field_name,omitempty"`
	FieldFragments       []string `protobuf:"bytes,2,rep,name=field_fragments,json=fieldFragments" json:"field_fragments,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *HighlightField) Reset()         { *m = HighlightField{} }
func (m *HighlightField) String() string { return proto.CompactTextString(m) }
func (*HighlightField) ProtoMessage()    {}
func (*HighlightField) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{46}
}

func (m *HighlightField) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_HighlightField.Unmarshal(m, b)
}
func (m *HighlightField) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_HighlightField.Marshal(b, m, deterministic)
}
func (m *HighlightField) XXX_Merge(src proto.Message) {
	xxx_messageInfo_HighlightField.Merge(m, src)
}
func (m *HighlightField) XXX_Size() int {
	return xxx_messageInfo_HighlightField.Size(m)
}
func (m *HighlightField) XXX_DiscardUnknown() {
	xxx_messageInfo_HighlightField.DiscardUnknown(m)
}

var xxx_messageInfo_HighlightField proto.InternalMessageInfo

func (m *HighlightField) GetFieldName() string {
	if m != nil && m.FieldName != nil {
		return *m.FieldName
	}
	return ""
}

func (m *HighlightField) GetFieldFragments() []string {
	if m != nil {
		return m.FieldFragments
	}
	return nil
}

type DateTimeValue struct {
	Value                *int32        `protobuf:"varint,1,opt,name=value" json:"value,omitempty"`
	Unit                 *DateTimeUnit `protobuf:"varint,2,opt,name=unit,enum=otsprotocol.DateTimeUnit" json:"unit,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

func (m *DateTimeValue) Reset()         { *m = DateTimeValue{} }
func (m *DateTimeValue) String() string { return proto.CompactTextString(m) }
func (*DateTimeValue) ProtoMessage()    {}
func (*DateTimeValue) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{47}
}

func (m *DateTimeValue) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DateTimeValue.Unmarshal(m, b)
}
func (m *DateTimeValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DateTimeValue.Marshal(b, m, deterministic)
}
func (m *DateTimeValue) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DateTimeValue.Merge(m, src)
}
func (m *DateTimeValue) XXX_Size() int {
	return xxx_messageInfo_DateTimeValue.Size(m)
}
func (m *DateTimeValue) XXX_DiscardUnknown() {
	xxx_messageInfo_DateTimeValue.DiscardUnknown(m)
}

var xxx_messageInfo_DateTimeValue proto.InternalMessageInfo

func (m *DateTimeValue) GetValue() int32 {
	if m != nil && m.Value != nil {
		return *m.Value
	}
	return 0
}

func (m *DateTimeValue) GetUnit() DateTimeUnit {
	if m != nil && m.Unit != nil {
		return *m.Unit
	}
	return DateTimeUnit_YEAR
}

type SingleWordAnalyzerParameter struct {
	CaseSensitive        *bool    `protobuf:"varint,1,opt,name=case_sensitive,json=caseSensitive" json:"case_sensitive,omitempty"`
	DelimitWord          *bool    `protobuf:"varint,2,opt,name=delimit_word,json=delimitWord" json:"delimit_word,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *SingleWordAnalyzerParameter) Reset()         { *m = SingleWordAnalyzerParameter{} }
func (m *SingleWordAnalyzerParameter) String() string { return proto.CompactTextString(m) }
func (*SingleWordAnalyzerParameter) ProtoMessage()    {}
func (*SingleWordAnalyzerParameter) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{48}
}

func (m *SingleWordAnalyzerParameter) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SingleWordAnalyzerParameter.Unmarshal(m, b)
}
func (m *SingleWordAnalyzerParameter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SingleWordAnalyzerParameter.Marshal(b, m, deterministic)
}
func (m *SingleWordAnalyzerParameter) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SingleWordAnalyzerParameter.Merge(m, src)
}
func (m *SingleWordAnalyzerParameter) XXX_Size() int {
	return xxx_messageInfo_SingleWordAnalyzerParameter.Size(m)
}
func (m *SingleWordAnalyzerParameter) XXX_DiscardUnknown() {
	xxx_messageInfo_SingleWordAnalyzerParameter.DiscardUnknown(m)
}

var xxx_messageInfo_SingleWordAnalyzerParameter proto.InternalMessageInfo

func (m *SingleWordAnalyzerParameter) GetCaseSensitive() bool {
	if m != nil && m.CaseSensitive != nil {
		return *m.CaseSensitive
	}
	return false
}

func (m *SingleWordAnalyzerParameter) GetDelimitWord() bool {
	if m != nil && m.DelimitWord != nil {
		return *m.DelimitWord
	}
	return false
}

type SplitAnalyzerParameter struct {
	Delimiter            *string  `protobuf:"bytes,1,opt,name=delimiter" json:"delimiter,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *SplitAnalyzerParameter) Reset()         { *m = SplitAnalyzerParameter{} }
func (m *SplitAnalyzerParameter) String() string { return proto.CompactTextString(m) }
func (*SplitAnalyzerParameter) ProtoMessage()    {}
func (*SplitAnalyzerParameter) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{49}
}

func (m *SplitAnalyzerParameter) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SplitAnalyzerParameter.Unmarshal(m, b)
}
func (m *SplitAnalyzerParameter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SplitAnalyzerParameter.Marshal(b, m, deterministic)
}
func (m *SplitAnalyzerParameter) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SplitAnalyzerParameter.Merge(m, src)
}
func (m *SplitAnalyzerParameter) XXX_Size() int {
	return xxx_messageInfo_SplitAnalyzerParameter.Size(m)
}
func (m *SplitAnalyzerParameter) XXX_DiscardUnknown() {
	xxx_messageInfo_SplitAnalyzerParameter.DiscardUnknown(m)
}

var xxx_messageInfo_SplitAnalyzerParameter proto.InternalMessageInfo

func (m *SplitAnalyzerParameter) GetDelimiter() string {
	if m != nil && m.Delimiter != nil {
		return *m.Delimiter
	}
	return ""
}

type FuzzyAnalyzerParameter struct {
	MinChars             *int32   `protobuf:"varint,1,opt,name=min_chars,json=minChars" json:"min_chars,omitempty"`
	MaxChars             *int32   `protobuf:"varint,2,opt,name=max_chars,json=maxChars" json:"max_chars,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *FuzzyAnalyzerParameter) Reset()         { *m = FuzzyAnalyzerParameter{} }
func (m *FuzzyAnalyzerParameter) String() string { return proto.CompactTextString(m) }
func (*FuzzyAnalyzerParameter) ProtoMessage()    {}
func (*FuzzyAnalyzerParameter) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{50}
}

func (m *FuzzyAnalyzerParameter) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_FuzzyAnalyzerParameter.Unmarshal(m, b)
}
func (m *FuzzyAnalyzerParameter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_FuzzyAnalyzerParameter.Marshal(b, m, deterministic)
}
func (m *FuzzyAnalyzerParameter) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FuzzyAnalyzerParameter.Merge(m, src)
}
func (m *FuzzyAnalyzerParameter) XXX_Size() int {
	return xxx_messageInfo_FuzzyAnalyzerParameter.Size(m)
}
func (m *FuzzyAnalyzerParameter) XXX_DiscardUnknown() {
	xxx_messageInfo_FuzzyAnalyzerParameter.DiscardUnknown(m)
}

var xxx_messageInfo_FuzzyAnalyzerParameter proto.InternalMessageInfo

func (m *FuzzyAnalyzerParameter) GetMinChars() int32 {
	if m != nil && m.MinChars != nil {
		return *m.MinChars
	}
	return 0
}

func (m *FuzzyAnalyzerParameter) GetMaxChars() int32 {
	if m != nil && m.MaxChars != nil {
		return *m.MaxChars
	}
	return 0
}

type FieldSchema struct {
	FieldName            *string        `protobuf:"bytes,1,opt,name=field_name,json=fieldName" json:"field_name,omitempty"`
	FieldType            *FieldType     `protobuf:"varint,2,opt,name=field_type,json=fieldType,enum=otsprotocol.FieldType" json:"field_type,omitempty"`
	IndexOptions         *IndexOptions  `protobuf:"varint,3,opt,name=index_options,json=indexOptions,enum=otsprotocol.IndexOptions" json:"index_options,omitempty"`
	Analyzer             *string        `protobuf:"bytes,4,opt,name=analyzer" json:"analyzer,omitempty"`
	Index                *bool          `protobuf:"varint,5,opt,name=index" json:"index,omitempty"`
	SortAndAgg           *bool          `protobuf:"varint,6,opt,name=sort_and_agg,json=sortAndAgg" json:"sort_and_agg,omitempty"`
	Store                *bool          `protobuf:"varint,7,opt,name=store" json:"store,omitempty"`
	FieldSchemas         []*FieldSchema `protobuf:"bytes,8,rep,name=field_schemas,json=fieldSchemas" json:"field_schemas,omitempty"`
	IsArray              *bool          `protobuf:"varint,9,opt,name=is_array,json=isArray" json:"is_array,omitempty"`
	AnalyzerParameter    []byte         `protobuf:"bytes,10,opt,name=analyzer_parameter,json=analyzerParameter" json:"analyzer_parameter,omitempty"`
	IsVirtualField       *bool          `protobuf:"varint,11,opt,name=is_virtual_field,json=isVirtualField" json:"is_virtual_field,omitempty"`
	SourceFieldNames     []string       `protobuf:"bytes,12,rep,name=source_field_names,json=sourceFieldNames" json:"source_field_names,omitempty"`
	DateFormats          []string       `protobuf:"bytes,13,rep,name=date_formats,json=dateFormats" json:"date_formats,omitempty"`
	EnableHighlighting   *bool          `protobuf:"varint,14,opt,name=enable_highlighting,json=enableHighlighting" json:"enable_highlighting,omitempty"`
	VectorOptions        *VectorOptions `protobuf:"bytes,15,opt,name=vector_options,json=vectorOptions" json:"vector_options,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (m *FieldSchema) Reset()         { *m = FieldSchema{} }
func (m *FieldSchema) String() string { return proto.CompactTextString(m) }
func (*FieldSchema) ProtoMessage()    {}
func (*FieldSchema) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{51}
}

func (m *FieldSchema) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_FieldSchema.Unmarshal(m, b)
}
func (m *FieldSchema) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_FieldSchema.Marshal(b, m, deterministic)
}
func (m *FieldSchema) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FieldSchema.Merge(m, src)
}
func (m *FieldSchema) XXX_Size() int {
	return xxx_messageInfo_FieldSchema.Size(m)
}
func (m *FieldSchema) XXX_DiscardUnknown() {
	xxx_messageInfo_FieldSchema.DiscardUnknown(m)
}

var xxx_messageInfo_FieldSchema proto.InternalMessageInfo

func (m *FieldSchema) GetFieldName() string {
	if m != nil && m.FieldName != nil {
		return *m.FieldName
	}
	return ""
}

func (m *FieldSchema) GetFieldType() FieldType {
	if m != nil && m.FieldType != nil {
		return *m.FieldType
	}
	return FieldType_LONG
}

func (m *FieldSchema) GetIndexOptions() IndexOptions {
	if m != nil && m.IndexOptions != nil {
		return *m.IndexOptions
	}
	return IndexOptions_DOCS
}

func (m *FieldSchema) GetAnalyzer() string {
	if m != nil && m.Analyzer != nil {
		return *m.Analyzer
	}
	return ""
}

func (m *FieldSchema) GetIndex() bool {
	if m != nil && m.Index != nil {
		return *m.Index
	}
	return false
}

func (m *FieldSchema) GetSortAndAgg() bool {
	if m != nil && m.SortAndAgg != nil {
		return *m.SortAndAgg
	}
	return false
}

func (m *FieldSchema) GetStore() bool {
	if m != nil && m.Store != nil {
		return *m.Store
	}
	return false
}

func (m *FieldSchema) GetFieldSchemas() []*FieldSchema {
	if m != nil {
		return m.FieldSchemas
	}
	return nil
}

func (m *FieldSchema) GetIsArray() bool {
	if m != nil && m.IsArray != nil {
		return *m.IsArray
	}
	return false
}

func (m *FieldSchema) GetAnalyzerParameter() []byte {
	if m != nil {
		return m.AnalyzerParameter
	}
	return nil
}

func (m *FieldSchema) GetIsVirtualField() bool {
	if m != nil && m.IsVirtualField != nil {
		return *m.IsVirtualField
	}
	return false
}

func (m *FieldSchema) GetSourceFieldNames() []string {
	if m != nil {
		return m.SourceFieldNames
	}
	return nil
}

func (m *FieldSchema) GetDateFormats() []string {
	if m != nil {
		return m.DateFormats
	}
	return nil
}

func (m *FieldSchema) GetEnableHighlighting() bool {
	if m != nil && m.EnableHighlighting != nil {
		return *m.EnableHighlighting
	}
	return false
}

func (m *FieldSchema) GetVectorOptions() *VectorOptions {
	if m != nil {
		return m.VectorOptions
	}
	return nil
}

type VectorOptions struct {
	DataType             *VectorDataType   `protobuf:"varint,1,opt,name=data_type,json=dataType,enum=otsprotocol.VectorDataType" json:"data_type,omitempty"`
	Dimension            *int32            `protobuf:"varint,2,opt,name=dimension" json:"dimension,omitempty"`
	MetricType           *VectorMetricType `protobuf:"varint,3,opt,name=metric_type,json=metricType,enum=otsprotocol.VectorMetricType" json:"metric_type,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *VectorOptions) Reset()         { *m = VectorOptions{} }
func (m *VectorOptions) String() string { return proto.CompactTextString(m) }
func (*VectorOptions) ProtoMessage()    {}
func (*VectorOptions) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{52}
}

func (m *VectorOptions) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_VectorOptions.Unmarshal(m, b)
}
func (m *VectorOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_VectorOptions.Marshal(b, m, deterministic)
}
func (m *VectorOptions) XXX_Merge(src proto.Message) {
	xxx_messageInfo_VectorOptions.Merge(m, src)
}
func (m *VectorOptions) XXX_Size() int {
	return xxx_messageInfo_VectorOptions.Size(m)
}
func (m *VectorOptions) XXX_DiscardUnknown() {
	xxx_messageInfo_VectorOptions.DiscardUnknown(m)
}

var xxx_messageInfo_VectorOptions proto.InternalMessageInfo

func (m *VectorOptions) GetDataType() VectorDataType {
	if m != nil && m.DataType != nil {
		return *m.DataType
	}
	return VectorDataType_VD_FLOAT_32
}

func (m *VectorOptions) GetDimension() int32 {
	if m != nil && m.Dimension != nil {
		return *m.Dimension
	}
	return 0
}

func (m *VectorOptions) GetMetricType() VectorMetricType {
	if m != nil && m.MetricType != nil {
		return *m.MetricType
	}
	return VectorMetricType_VM_EUCLIDEAN
}

type IndexSchema struct {
	FieldSchemas         []*FieldSchema `protobuf:"bytes,1,rep,name=field_schemas,json=fieldSchemas" json:"field_schemas,omitempty"`
	IndexSetting         *IndexSetting  `protobuf:"bytes,2,opt,name=index_setting,json=indexSetting" json:"index_setting,omitempty"`
	IndexSort            *Sort          `protobuf:"bytes,3,opt,name=index_sort,json=indexSort" json:"index_sort,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (m *IndexSchema) Reset()         { *m = IndexSchema{} }
func (m *IndexSchema) String() string { return proto.CompactTextString(m) }
func (*IndexSchema) ProtoMessage()    {}
func (*IndexSchema) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{53}
}

func (m *IndexSchema) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_IndexSchema.Unmarshal(m, b)
}
func (m *IndexSchema) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_IndexSchema.Marshal(b, m, deterministic)
}
func (m *IndexSchema) XXX_Merge(src proto.Message) {
	xxx_messageInfo_IndexSchema.Merge(m, src)
}
func (m *IndexSchema) XXX_Size() int {
	return xxx_messageInfo_IndexSchema.Size(m)
}
func (m *IndexSchema) XXX_DiscardUnknown() {
	xxx_messageInfo_IndexSchema.DiscardUnknown(m)
}

var xxx_messageInfo_IndexSchema proto.InternalMessageInfo

func (m *IndexSchema) GetFieldSchemas() []*FieldSchema {
	if m != nil {
		return m.FieldSchemas
	}
	return nil
}

func (m *IndexSchema) GetIndexSetting() *IndexSetting {
	if m != nil {
		return m.IndexSetting
	}
	return nil
}

func (m *IndexSchema) GetIndexSort() *Sort {
	if m != nil {
		return m.IndexSort
	}
	return nil
}

type IndexSetting struct {
	NumberOfShards       *int32   `protobuf:"varint,1,opt,name=number_of_shards,json=numberOfShards" json:"number_of_shards,omitempty"`
	RoutingFields        []string `protobuf:"bytes,2,rep,name=routing_fields,json=routingFields" json:"routing_fields,omitempty"`
	RoutingPartitionSize *int32   `protobuf:"varint,3,opt,name=routing_partition_size,json=routingPartitionSize" json:"routing_partition_size,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *IndexSetting) Reset()         { *m = IndexSetting{} }
func (m *IndexSetting) String() string { return proto.CompactTextString(m) }
func (*IndexSetting) ProtoMessage()    {}
func (*IndexSetting) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{54}
}

func (m *IndexSetting) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_IndexSetting.Unmarshal(m, b)
}
func (m *IndexSetting) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_IndexSetting.Marshal(b, m, deterministic)
}
func (m *IndexSetting) XXX_Merge(src proto.Message) {
	xxx_messageInfo_IndexSetting.Merge(m, src)
}
func (m *IndexSetting) XXX_Size() int {
	return xxx_messageInfo_IndexSetting.Size(m)
}
func (m *IndexSetting) XXX_DiscardUnknown() {
	xxx_messageInfo_IndexSetting.DiscardUnknown(m)
}

var xxx_messageInfo_IndexSetting proto.InternalMessageInfo

func (m *IndexSetting) GetNumberOfShards() int32 {
	if m != nil && m.NumberOfShards != nil {
		return *m.NumberOfShards
	}
	return 0
}

func (m *IndexSetting) GetRoutingFields() []string {
	if m != nil {
		return m.RoutingFields
	}
	return nil
}

func (m *IndexSetting) GetRoutingPartitionSize() int32 {
	if m != nil && m.RoutingPartitionSize != nil {
		return *m.RoutingPartitionSize
	}
	return 0
}

type CreateSearchIndexRequest struct {
	TableName            *string      `protobuf:"bytes,1,req,name=table_name,json=tableName" json:"table_name,omitempty"`
	IndexName            *string      `protobuf:"bytes,2,req,name=index_name,json=indexName" json:"index_name,omitempty"`
	Schema               *IndexSchema `protobuf:"bytes,3,opt,name=schema" json:"schema,omitempty"`
	SourceIndexName      *string      `protobuf:"bytes,4,opt,name=source_index_name,json=sourceIndexName" json:"source_index_name,omitempty"`
	TimeToLive           *int32       `protobuf:"varint,5,opt,name=time_to_live,json=timeToLive" json:"time_to_live,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *CreateSearchIndexRequest) Reset()         { *m = CreateSearchIndexRequest{} }
func (m *CreateSearchIndexRequest) String() string { return proto.CompactTextString(m) }
func (*CreateSearchIndexRequest) ProtoMessage()    {}
func (*CreateSearchIndexRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{55}
}

func (m *CreateSearchIndexRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CreateSearchIndexRequest.Unmarshal(m, b)
}
func (m *CreateSearchIndexRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CreateSearchIndexRequest.Marshal(b, m, deterministic)
}
func (m *CreateSearchIndexRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CreateSearchIndexRequest.Merge(m, src)
}
func (m *CreateSearchIndexRequest) XXX_Size() int {
	return xxx_messageInfo_CreateSearchIndexRequest.Size(m)
}
func (m *CreateSearchIndexRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_CreateSearchIndexRequest.DiscardUnknown(m)
}

var xxx_messageInfo_CreateSearchIndexRequest proto.InternalMessageInfo

func (m *CreateSearchIndexRequest) GetTableName() string {
	if m != nil && m.TableName != nil {
		return *m.TableName
	}
	return ""
}

func (m *CreateSearchIndexRequest) GetIndexName() string {
	if m != nil && m.IndexName != nil {
		return *m.IndexName
	}
	return ""
}

func (m *CreateSearchIndexRequest) GetSchema() *IndexSchema {
	if m != nil {
		return m.Schema
	}
	return nil
}

func (m *CreateSearchIndexRequest) GetSourceIndexName() string {
	if m != nil && m.SourceIndexName != nil {
		return *m.SourceIndexName
	}
	return ""
}

func (m *CreateSearchIndexRequest) GetTimeToLive() int32 {
	if m != nil && m.TimeToLive != nil {
		return *m.TimeToLive
	}
	return 0
}

type CreateSearchIndexResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CreateSearchIndexResponse) Reset()         { *m = CreateSearchIndexResponse{} }
func (m *CreateSearchIndexResponse) String() string { return proto.CompactTextString(m) }
func (*CreateSearchIndexResponse) ProtoMessage()    {}
func (*CreateSearchIndexResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{56}
}

func (m *CreateSearchIndexResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CreateSearchIndexResponse.Unmarshal(m, b)
}
func (m *CreateSearchIndexResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CreateSearchIndexResponse.Marshal(b, m, deterministic)
}
func (m *CreateSearchIndexResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CreateSearchIndexResponse.Merge(m, src)
}
func (m *CreateSearchIndexResponse) XXX_Size() int {
	return xxx_messageInfo_CreateSearchIndexResponse.Size(m)
}
func (m *CreateSearchIndexResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_CreateSearchIndexResponse.DiscardUnknown(m)
}

var xxx_messageInfo_CreateSearchIndexResponse proto.InternalMessageInfo

// Update Search Index
type QueryFlowWeight struct {
	IndexName            *string  `protobuf:"bytes,1,opt,name=index_name,json=indexName" json:"index_name,omitempty"`
	Weight               *int32   `protobuf:"varint,2,opt,name=weight" json:"weight,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *QueryFlowWeight) Reset()         { *m = QueryFlowWeight{} }
func (m *QueryFlowWeight) String() string { return proto.CompactTextString(m) }
func (*QueryFlowWeight) ProtoMessage()    {}
func (*QueryFlowWeight) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{57}
}

func (m *QueryFlowWeight) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_QueryFlowWeight.Unmarshal(m, b)
}
func (m *QueryFlowWeight) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_QueryFlowWeight.Marshal(b, m, deterministic)
}
func (m *QueryFlowWeight) XXX_Merge(src proto.Message) {
	xxx_messageInfo_QueryFlowWeight.Merge(m, src)
}
func (m *QueryFlowWeight) XXX_Size() int {
	return xxx_messageInfo_QueryFlowWeight.Size(m)
}
func (m *QueryFlowWeight) XXX_DiscardUnknown() {
	xxx_messageInfo_QueryFlowWeight.DiscardUnknown(m)
}

var xxx_messageInfo_QueryFlowWeight proto.InternalMessageInfo

func (m *QueryFlowWeight) GetIndexName() string {
	if m != nil && m.IndexName != nil {
		return *m.IndexName
	}
	return ""
}

func (m *QueryFlowWeight) GetWeight() int32 {
	if m != nil && m.Weight != nil {
		return *m.Weight
	}
	return 0
}

type UpdateSearchIndexRequest struct {
	TableName            *string            `protobuf:"bytes,1,opt,name=table_name,json=tableName" json:"table_name,omitempty"`
	IndexName            *string            `protobuf:"bytes,2,opt,name=index_name,json=indexName" json:"index_name,omitempty"`
	SwitchIndexName      *string            `protobuf:"bytes,3,opt,name=switch_index_name,json=switchIndexName" json:"switch_index_name,omitempty"`
	QueryFlowWeight      []*QueryFlowWeight `protobuf:"bytes,4,rep,name=query_flow_weight,json=queryFlowWeight" json:"query_flow_weight,omitempty"`
	TimeToLive           *int32             `protobuf:"varint,5,opt,name=time_to_live,json=timeToLive" json:"time_to_live,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

func (m *UpdateSearchIndexRequest) Reset()         { *m = UpdateSearchIndexRequest{} }
func (m *UpdateSearchIndexRequest) String() string { return proto.CompactTextString(m) }
func (*UpdateSearchIndexRequest) ProtoMessage()    {}
func (*UpdateSearchIndexRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{58}
}

func (m *UpdateSearchIndexRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_UpdateSearchIndexRequest.Unmarshal(m, b)
}
func (m *UpdateSearchIndexRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_UpdateSearchIndexRequest.Marshal(b, m, deterministic)
}
func (m *UpdateSearchIndexRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UpdateSearchIndexRequest.Merge(m, src)
}
func (m *UpdateSearchIndexRequest) XXX_Size() int {
	return xxx_messageInfo_UpdateSearchIndexRequest.Size(m)
}
func (m *UpdateSearchIndexRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_UpdateSearchIndexRequest.DiscardUnknown(m)
}

var xxx_messageInfo_UpdateSearchIndexRequest proto.InternalMessageInfo

func (m *UpdateSearchIndexRequest) GetTableName() string {
	if m != nil && m.TableName != nil {
		return *m.TableName
	}
	return ""
}

func (m *UpdateSearchIndexRequest) GetIndexName() string {
	if m != nil && m.IndexName != nil {
		return *m.IndexName
	}
	return ""
}

func (m *UpdateSearchIndexRequest) GetSwitchIndexName() string {
	if m != nil && m.SwitchIndexName != nil {
		return *m.SwitchIndexName
	}
	return ""
}

func (m *UpdateSearchIndexRequest) GetQueryFlowWeight() []*QueryFlowWeight {
	if m != nil {
		return m.QueryFlowWeight
	}
	return nil
}

func (m *UpdateSearchIndexRequest) GetTimeToLive() int32 {
	if m != nil && m.TimeToLive != nil {
		return *m.TimeToLive
	}
	return 0
}

type UpdateSearchIndexResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *UpdateSearchIndexResponse) Reset()         { *m = UpdateSearchIndexResponse{} }
func (m *UpdateSearchIndexResponse) String() string { return proto.CompactTextString(m) }
func (*UpdateSearchIndexResponse) ProtoMessage()    {}
func (*UpdateSearchIndexResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{59}
}

func (m *UpdateSearchIndexResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_UpdateSearchIndexResponse.Unmarshal(m, b)
}
func (m *UpdateSearchIndexResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_UpdateSearchIndexResponse.Marshal(b, m, deterministic)
}
func (m *UpdateSearchIndexResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_UpdateSearchIndexResponse.Merge(m, src)
}
func (m *UpdateSearchIndexResponse) XXX_Size() int {
	return xxx_messageInfo_UpdateSearchIndexResponse.Size(m)
}
func (m *UpdateSearchIndexResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_UpdateSearchIndexResponse.DiscardUnknown(m)
}

var xxx_messageInfo_UpdateSearchIndexResponse proto.InternalMessageInfo

type IndexInfo struct {
	TableName            *string  `protobuf:"bytes,1,opt,name=table_name,json=tableName" json:"table_name,omitempty"`
	IndexName            *string  `protobuf:"bytes,2,opt,name=index_name,json=indexName" json:"index_name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *IndexInfo) Reset()         { *m = IndexInfo{} }
func (m *IndexInfo) String() string { return proto.CompactTextString(m) }
func (*IndexInfo) ProtoMessage()    {}
func (*IndexInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{60}
}

func (m *IndexInfo) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_IndexInfo.Unmarshal(m, b)
}
func (m *IndexInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_IndexInfo.Marshal(b, m, deterministic)
}
func (m *IndexInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_IndexInfo.Merge(m, src)
}
func (m *IndexInfo) XXX_Size() int {
	return xxx_messageInfo_IndexInfo.Size(m)
}
func (m *IndexInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_IndexInfo.DiscardUnknown(m)
}

var xxx_messageInfo_IndexInfo proto.InternalMessageInfo

func (m *IndexInfo) GetTableName() string {
	if m != nil && m.TableName != nil {
		return *m.TableName
	}
	return ""
}

func (m *IndexInfo) GetIndexName() string {
	if m != nil && m.IndexName != nil {
		return *m.IndexName
	}
	return ""
}

type ListSearchIndexRequest struct {
	TableName            *string  `protobuf:"bytes,1,opt,name=table_name,json=tableName" json:"table_name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ListSearchIndexRequest) Reset()         { *m = ListSearchIndexRequest{} }
func (m *ListSearchIndexRequest) String() string { return proto.CompactTextString(m) }
func (*ListSearchIndexRequest) ProtoMessage()    {}
func (*ListSearchIndexRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{61}
}

func (m *ListSearchIndexRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ListSearchIndexRequest.Unmarshal(m, b)
}
func (m *ListSearchIndexRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ListSearchIndexRequest.Marshal(b, m, deterministic)
}
func (m *ListSearchIndexRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ListSearchIndexRequest.Merge(m, src)
}
func (m *ListSearchIndexRequest) XXX_Size() int {
	return xxx_messageInfo_ListSearchIndexRequest.Size(m)
}
func (m *ListSearchIndexRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ListSearchIndexRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ListSearchIndexRequest proto.InternalMessageInfo

func (m *ListSearchIndexRequest) GetTableName() string {
	if m != nil && m.TableName != nil {
		return *m.TableName
	}
	return ""
}

type ListSearchIndexResponse struct {
	Indices              []*IndexInfo `protobuf:"bytes,1,rep,name=indices" json:"indices,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *ListSearchIndexResponse) Reset()         { *m = ListSearchIndexResponse{} }
func (m *ListSearchIndexResponse) String() string { return proto.CompactTextString(m) }
func (*ListSearchIndexResponse) ProtoMessage()    {}
func (*ListSearchIndexResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{62}
}

func (m *ListSearchIndexResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ListSearchIndexResponse.Unmarshal(m, b)
}
func (m *ListSearchIndexResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ListSearchIndexResponse.Marshal(b, m, deterministic)
}
func (m *ListSearchIndexResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ListSearchIndexResponse.Merge(m, src)
}
func (m *ListSearchIndexResponse) XXX_Size() int {
	return xxx_messageInfo_ListSearchIndexResponse.Size(m)
}
func (m *ListSearchIndexResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ListSearchIndexResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ListSearchIndexResponse proto.InternalMessageInfo

func (m *ListSearchIndexResponse) GetIndices() []*IndexInfo {
	if m != nil {
		return m.Indices
	}
	return nil
}

type DeleteSearchIndexRequest struct {
	TableName            *string  `protobuf:"bytes,1,opt,name=table_name,json=tableName" json:"table_name,omitempty"`
	IndexName            *string  `protobuf:"bytes,2,opt,name=index_name,json=indexName" json:"index_name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *DeleteSearchIndexRequest) Reset()         { *m = DeleteSearchIndexRequest{} }
func (m *DeleteSearchIndexRequest) String() string { return proto.CompactTextString(m) }
func (*DeleteSearchIndexRequest) ProtoMessage()    {}
func (*DeleteSearchIndexRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{63}
}

func (m *DeleteSearchIndexRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DeleteSearchIndexRequest.Unmarshal(m, b)
}
func (m *DeleteSearchIndexRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DeleteSearchIndexRequest.Marshal(b, m, deterministic)
}
func (m *DeleteSearchIndexRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DeleteSearchIndexRequest.Merge(m, src)
}
func (m *DeleteSearchIndexRequest) XXX_Size() int {
	return xxx_messageInfo_DeleteSearchIndexRequest.Size(m)
}
func (m *DeleteSearchIndexRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_DeleteSearchIndexRequest.DiscardUnknown(m)
}

var xxx_messageInfo_DeleteSearchIndexRequest proto.InternalMessageInfo

func (m *DeleteSearchIndexRequest) GetTableName() string {
	if m != nil && m.TableName != nil {
		return *m.TableName
	}
	return ""
}

func (m *DeleteSearchIndexRequest) GetIndexName() string {
	if m != nil && m.IndexName != nil {
		return *m.IndexName
	}
	return ""
}

type DeleteSearchIndexResponse struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *DeleteSearchIndexResponse) Reset()         { *m = DeleteSearchIndexResponse{} }
func (m *DeleteSearchIndexResponse) String() string { return proto.CompactTextString(m) }
func (*DeleteSearchIndexResponse) ProtoMessage()    {}
func (*DeleteSearchIndexResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{64}
}

func (m *DeleteSearchIndexResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DeleteSearchIndexResponse.Unmarshal(m, b)
}
func (m *DeleteSearchIndexResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DeleteSearchIndexResponse.Marshal(b, m, deterministic)
}
func (m *DeleteSearchIndexResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DeleteSearchIndexResponse.Merge(m, src)
}
func (m *DeleteSearchIndexResponse) XXX_Size() int {
	return xxx_messageInfo_DeleteSearchIndexResponse.Size(m)
}
func (m *DeleteSearchIndexResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_DeleteSearchIndexResponse.DiscardUnknown(m)
}

var xxx_messageInfo_DeleteSearchIndexResponse proto.InternalMessageInfo

type SyncStat struct {
	SyncPhase            *SyncPhase `protobuf:"varint,1,opt,name=sync_phase,json=syncPhase,enum=otsprotocol.SyncPhase" json:"sync_phase,omitempty"`
	CurrentSyncTimestamp *int64     `protobuf:"varint,2,opt,name=current_sync_timestamp,json=currentSyncTimestamp" json:"current_sync_timestamp,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *SyncStat) Reset()         { *m = SyncStat{} }
func (m *SyncStat) String() string { return proto.CompactTextString(m) }
func (*SyncStat) ProtoMessage()    {}
func (*SyncStat) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{65}
}

func (m *SyncStat) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SyncStat.Unmarshal(m, b)
}
func (m *SyncStat) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SyncStat.Marshal(b, m, deterministic)
}
func (m *SyncStat) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SyncStat.Merge(m, src)
}
func (m *SyncStat) XXX_Size() int {
	return xxx_messageInfo_SyncStat.Size(m)
}
func (m *SyncStat) XXX_DiscardUnknown() {
	xxx_messageInfo_SyncStat.DiscardUnknown(m)
}

var xxx_messageInfo_SyncStat proto.InternalMessageInfo

func (m *SyncStat) GetSyncPhase() SyncPhase {
	if m != nil && m.SyncPhase != nil {
		return *m.SyncPhase
	}
	return SyncPhase_FULL
}

func (m *SyncStat) GetCurrentSyncTimestamp() int64 {
	if m != nil && m.CurrentSyncTimestamp != nil {
		return *m.CurrentSyncTimestamp
	}
	return 0
}

type MeteringInfo struct {
	StorageSize          *int64   `protobuf:"varint,1,opt,name=storage_size,json=storageSize" json:"storage_size,omitempty"`
	RowCount             *int64   `protobuf:"varint,2,opt,name=row_count,json=rowCount" json:"row_count,omitempty"`
	ReservedReadCu       *int64   `protobuf:"varint,3,opt,name=reserved_read_cu,json=reservedReadCu" json:"reserved_read_cu,omitempty"`
	Timestamp            *int64   `protobuf:"varint,4,opt,name=timestamp" json:"timestamp,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *MeteringInfo) Reset()         { *m = MeteringInfo{} }
func (m *MeteringInfo) String() string { return proto.CompactTextString(m) }
func (*MeteringInfo) ProtoMessage()    {}
func (*MeteringInfo) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{66}
}

func (m *MeteringInfo) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MeteringInfo.Unmarshal(m, b)
}
func (m *MeteringInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MeteringInfo.Marshal(b, m, deterministic)
}
func (m *MeteringInfo) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MeteringInfo.Merge(m, src)
}
func (m *MeteringInfo) XXX_Size() int {
	return xxx_messageInfo_MeteringInfo.Size(m)
}
func (m *MeteringInfo) XXX_DiscardUnknown() {
	xxx_messageInfo_MeteringInfo.DiscardUnknown(m)
}

var xxx_messageInfo_MeteringInfo proto.InternalMessageInfo

func (m *MeteringInfo) GetStorageSize() int64 {
	if m != nil && m.StorageSize != nil {
		return *m.StorageSize
	}
	return 0
}

func (m *MeteringInfo) GetRowCount() int64 {
	if m != nil && m.RowCount != nil {
		return *m.RowCount
	}
	return 0
}

func (m *MeteringInfo) GetReservedReadCu() int64 {
	if m != nil && m.ReservedReadCu != nil {
		return *m.ReservedReadCu
	}
	return 0
}

func (m *MeteringInfo) GetTimestamp() int64 {
	if m != nil && m.Timestamp != nil {
		return *m.Timestamp
	}
	return 0
}

type DescribeSearchIndexRequest struct {
	TableName            *string  `protobuf:"bytes,1,opt,name=table_name,json=tableName" json:"table_name,omitempty"`
	IndexName            *string  `protobuf:"bytes,2,opt,name=index_name,json=indexName" json:"index_name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *DescribeSearchIndexRequest) Reset()         { *m = DescribeSearchIndexRequest{} }
func (m *DescribeSearchIndexRequest) String() string { return proto.CompactTextString(m) }
func (*DescribeSearchIndexRequest) ProtoMessage()    {}
func (*DescribeSearchIndexRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{67}
}

func (m *DescribeSearchIndexRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DescribeSearchIndexRequest.Unmarshal(m, b)
}
func (m *DescribeSearchIndexRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DescribeSearchIndexRequest.Marshal(b, m, deterministic)
}
func (m *DescribeSearchIndexRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DescribeSearchIndexRequest.Merge(m, src)
}
func (m *DescribeSearchIndexRequest) XXX_Size() int {
	return xxx_messageInfo_DescribeSearchIndexRequest.Size(m)
}
func (m *DescribeSearchIndexRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_DescribeSearchIndexRequest.DiscardUnknown(m)
}

var xxx_messageInfo_DescribeSearchIndexRequest proto.InternalMessageInfo

func (m *DescribeSearchIndexRequest) GetTableName() string {
	if m != nil && m.TableName != nil {
		return *m.TableName
	}
	return ""
}

func (m *DescribeSearchIndexRequest) GetIndexName() string {
	if m != nil && m.IndexName != nil {
		return *m.IndexName
	}
	return ""
}

type DescribeSearchIndexResponse struct {
	Schema               *IndexSchema       `protobuf:"bytes,1,opt,name=schema" json:"schema,omitempty"`
	SyncStat             *SyncStat          `protobuf:"bytes,2,opt,name=sync_stat,json=syncStat" json:"sync_stat,omitempty"`
	MeteringInfo         *MeteringInfo      `protobuf:"bytes,3,opt,name=metering_info,json=meteringInfo" json:"metering_info,omitempty"`
	BrotherIndexName     *string            `protobuf:"bytes,4,opt,name=brother_index_name,json=brotherIndexName" json:"brother_index_name,omitempty"`
	QueryFlowWeight      []*QueryFlowWeight `protobuf:"bytes,5,rep,name=query_flow_weight,json=queryFlowWeight" json:"query_flow_weight,omitempty"`
	CreateTime           *int64             `protobuf:"varint,6,opt,name=create_time,json=createTime" json:"create_time,omitempty"`
	TimeToLive           *int32             `protobuf:"varint,7,opt,name=time_to_live,json=timeToLive" json:"time_to_live,omitempty"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

func (m *DescribeSearchIndexResponse) Reset()         { *m = DescribeSearchIndexResponse{} }
func (m *DescribeSearchIndexResponse) String() string { return proto.CompactTextString(m) }
func (*DescribeSearchIndexResponse) ProtoMessage()    {}
func (*DescribeSearchIndexResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{68}
}

func (m *DescribeSearchIndexResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DescribeSearchIndexResponse.Unmarshal(m, b)
}
func (m *DescribeSearchIndexResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DescribeSearchIndexResponse.Marshal(b, m, deterministic)
}
func (m *DescribeSearchIndexResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DescribeSearchIndexResponse.Merge(m, src)
}
func (m *DescribeSearchIndexResponse) XXX_Size() int {
	return xxx_messageInfo_DescribeSearchIndexResponse.Size(m)
}
func (m *DescribeSearchIndexResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_DescribeSearchIndexResponse.DiscardUnknown(m)
}

var xxx_messageInfo_DescribeSearchIndexResponse proto.InternalMessageInfo

func (m *DescribeSearchIndexResponse) GetSchema() *IndexSchema {
	if m != nil {
		return m.Schema
	}
	return nil
}

func (m *DescribeSearchIndexResponse) GetSyncStat() *SyncStat {
	if m != nil {
		return m.SyncStat
	}
	return nil
}

func (m *DescribeSearchIndexResponse) GetMeteringInfo() *MeteringInfo {
	if m != nil {
		return m.MeteringInfo
	}
	return nil
}

func (m *DescribeSearchIndexResponse) GetBrotherIndexName() string {
	if m != nil && m.BrotherIndexName != nil {
		return *m.BrotherIndexName
	}
	return ""
}

func (m *DescribeSearchIndexResponse) GetQueryFlowWeight() []*QueryFlowWeight {
	if m != nil {
		return m.QueryFlowWeight
	}
	return nil
}

func (m *DescribeSearchIndexResponse) GetCreateTime() int64 {
	if m != nil && m.CreateTime != nil {
		return *m.CreateTime
	}
	return 0
}

func (m *DescribeSearchIndexResponse) GetTimeToLive() int32 {
	if m != nil && m.TimeToLive != nil {
		return *m.TimeToLive
	}
	return 0
}

// agg & group by
type Aggregation struct {
	Name                 *string          `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
	Type                 *AggregationType `protobuf:"varint,2,opt,name=type,enum=otsprotocol.AggregationType" json:"type,omitempty"`
	Body                 []byte           `protobuf:"bytes,3,opt,name=body" json:"body,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

func (m *Aggregation) Reset()         { *m = Aggregation{} }
func (m *Aggregation) String() string { return proto.CompactTextString(m) }
func (*Aggregation) ProtoMessage()    {}
func (*Aggregation) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{69}
}

func (m *Aggregation) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Aggregation.Unmarshal(m, b)
}
func (m *Aggregation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Aggregation.Marshal(b, m, deterministic)
}
func (m *Aggregation) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Aggregation.Merge(m, src)
}
func (m *Aggregation) XXX_Size() int {
	return xxx_messageInfo_Aggregation.Size(m)
}
func (m *Aggregation) XXX_DiscardUnknown() {
	xxx_messageInfo_Aggregation.DiscardUnknown(m)
}

var xxx_messageInfo_Aggregation proto.InternalMessageInfo

func (m *Aggregation) GetName() string {
	if m != nil && m.Name != nil {
		return *m.Name
	}
	return ""
}

func (m *Aggregation) GetType() AggregationType {
	if m != nil && m.Type != nil {
		return *m.Type
	}
	return AggregationType_AGG_AVG
}

func (m *Aggregation) GetBody() []byte {
	if m != nil {
		return m.Body
	}
	return nil
}

type Aggregations struct {
	Aggs                 []*Aggregation `protobuf:"bytes,1,rep,name=aggs" json:"aggs,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (m *Aggregations) Reset()         { *m = Aggregations{} }
func (m *Aggregations) String() string { return proto.CompactTextString(m) }
func (*Aggregations) ProtoMessage()    {}
func (*Aggregations) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{70}
}

func (m *Aggregations) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Aggregations.Unmarshal(m, b)
}
func (m *Aggregations) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Aggregations.Marshal(b, m, deterministic)
}
func (m *Aggregations) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Aggregations.Merge(m, src)
}
func (m *Aggregations) XXX_Size() int {
	return xxx_messageInfo_Aggregations.Size(m)
}
func (m *Aggregations) XXX_DiscardUnknown() {
	xxx_messageInfo_Aggregations.DiscardUnknown(m)
}

var xxx_messageInfo_Aggregations proto.InternalMessageInfo

func (m *Aggregations) GetAggs() []*Aggregation {
	if m != nil {
		return m.Aggs
	}
	return nil
}

type GroupBy struct {
	Name                 *string      `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
	Type                 *GroupByType `protobuf:"varint,2,opt,name=type,enum=otsprotocol.GroupByType" json:"type,omitempty"`
	Body                 []byte       `protobuf:"bytes,3,opt,name=body" json:"body,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *GroupBy) Reset()         { *m = GroupBy{} }
func (m *GroupBy) String() string { return proto.CompactTextString(m) }
func (*GroupBy) ProtoMessage()    {}
func (*GroupBy) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{71}
}

func (m *GroupBy) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GroupBy.Unmarshal(m, b)
}
func (m *GroupBy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GroupBy.Marshal(b, m, deterministic)
}
func (m *GroupBy) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GroupBy.Merge(m, src)
}
func (m *GroupBy) XXX_Size() int {
	return xxx_messageInfo_GroupBy.Size(m)
}
func (m *GroupBy) XXX_DiscardUnknown() {
	xxx_messageInfo_GroupBy.DiscardUnknown(m)
}

var xxx_messageInfo_GroupBy proto.InternalMessageInfo

func (m *GroupBy) GetName() string {
	if m != nil && m.Name != nil {
		return *m.Name
	}
	return ""
}

func (m *GroupBy) GetType() GroupByType {
	if m != nil && m.Type != nil {
		return *m.Type
	}
	return GroupByType_GROUP_BY_FIELD
}

func (m *GroupBy) GetBody() []byte {
	if m != nil {
		return m.Body
	}
	return nil
}

type GroupBys struct {
	GroupBys             []*GroupBy `protobuf:"bytes,1,rep,name=group_bys,json=groupBys" json:"group_bys,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *GroupBys) Reset()         { *m = GroupBys{} }
func (m *GroupBys) String() string { return proto.CompactTextString(m) }
func (*GroupBys) ProtoMessage()    {}
func (*GroupBys) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{72}
}

func (m *GroupBys) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GroupBys.Unmarshal(m, b)
}
func (m *GroupBys) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GroupBys.Marshal(b, m, deterministic)
}
func (m *GroupBys) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GroupBys.Merge(m, src)
}
func (m *GroupBys) XXX_Size() int {
	return xxx_messageInfo_GroupBys.Size(m)
}
func (m *GroupBys) XXX_DiscardUnknown() {
	xxx_messageInfo_GroupBys.DiscardUnknown(m)
}

var xxx_messageInfo_GroupBys proto.InternalMessageInfo

func (m *GroupBys) GetGroupBys() []*GroupBy {
	if m != nil {
		return m.GroupBys
	}
	return nil
}

// single agg
type AvgAggregation struct {
	FieldName            *string  `protobuf:"bytes,1,opt,name=field_name,json=fieldName" json:"field_name,omitempty"`
	Missing              []byte   `protobuf:"bytes,2,opt,name=missing" json:"missing,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *AvgAggregation) Reset()         { *m = AvgAggregation{} }
func (m *AvgAggregation) String() string { return proto.CompactTextString(m) }
func (*AvgAggregation) ProtoMessage()    {}
func (*AvgAggregation) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{73}
}

func (m *AvgAggregation) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_AvgAggregation.Unmarshal(m, b)
}
func (m *AvgAggregation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_AvgAggregation.Marshal(b, m, deterministic)
}
func (m *AvgAggregation) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AvgAggregation.Merge(m, src)
}
func (m *AvgAggregation) XXX_Size() int {
	return xxx_messageInfo_AvgAggregation.Size(m)
}
func (m *AvgAggregation) XXX_DiscardUnknown() {
	xxx_messageInfo_AvgAggregation.DiscardUnknown(m)
}

var xxx_messageInfo_AvgAggregation proto.InternalMessageInfo

func (m *AvgAggregation) GetFieldName() string {
	if m != nil && m.FieldName != nil {
		return *m.FieldName
	}
	return ""
}

func (m *AvgAggregation) GetMissing() []byte {
	if m != nil {
		return m.Missing
	}
	return nil
}

type MaxAggregation struct {
	FieldName            *string  `protobuf:"bytes,1,opt,name=field_name,json=fieldName" json:"field_name,omitempty"`
	Missing              []byte   `protobuf:"bytes,2,opt,name=missing" json:"missing,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *MaxAggregation) Reset()         { *m = MaxAggregation{} }
func (m *MaxAggregation) String() string { return proto.CompactTextString(m) }
func (*MaxAggregation) ProtoMessage()    {}
func (*MaxAggregation) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{74}
}

func (m *MaxAggregation) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MaxAggregation.Unmarshal(m, b)
}
func (m *MaxAggregation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MaxAggregation.Marshal(b, m, deterministic)
}
func (m *MaxAggregation) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MaxAggregation.Merge(m, src)
}
func (m *MaxAggregation) XXX_Size() int {
	return xxx_messageInfo_MaxAggregation.Size(m)
}
func (m *MaxAggregation) XXX_DiscardUnknown() {
	xxx_messageInfo_MaxAggregation.DiscardUnknown(m)
}

var xxx_messageInfo_MaxAggregation proto.InternalMessageInfo

func (m *MaxAggregation) GetFieldName() string {
	if m != nil && m.FieldName != nil {
		return *m.FieldName
	}
	return ""
}

func (m *MaxAggregation) GetMissing() []byte {
	if m != nil {
		return m.Missing
	}
	return nil
}

type MinAggregation struct {
	FieldName            *string  `protobuf:"bytes,1,opt,name=field_name,json=fieldName" json:"field_name,omitempty"`
	Missing              []byte   `protobuf:"bytes,2,opt,name=missing" json:"missing,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *MinAggregation) Reset()         { *m = MinAggregation{} }
func (m *MinAggregation) String() string { return proto.CompactTextString(m) }
func (*MinAggregation) ProtoMessage()    {}
func (*MinAggregation) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{75}
}

func (m *MinAggregation) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MinAggregation.Unmarshal(m, b)
}
func (m *MinAggregation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MinAggregation.Marshal(b, m, deterministic)
}
func (m *MinAggregation) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MinAggregation.Merge(m, src)
}
func (m *MinAggregation) XXX_Size() int {
	return xxx_messageInfo_MinAggregation.Size(m)
}
func (m *MinAggregation) XXX_DiscardUnknown() {
	xxx_messageInfo_MinAggregation.DiscardUnknown(m)
}

var xxx_messageInfo_MinAggregation proto.InternalMessageInfo

func (m *MinAggregation) GetFieldName() string {
	if m != nil && m.FieldName != nil {
		return *m.FieldName
	}
	return ""
}

func (m *MinAggregation) GetMissing() []byte {
	if m != nil {
		return m.Missing
	}
	return nil
}

type SumAggregation struct {
	FieldName            *string  `protobuf:"bytes,1,opt,name=field_name,json=fieldName" json:"field_name,omitempty"`
	Missing              []byte   `protobuf:"bytes,2,opt,name=missing" json:"missing,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *SumAggregation) Reset()         { *m = SumAggregation{} }
func (m *SumAggregation) String() string { return proto.CompactTextString(m) }
func (*SumAggregation) ProtoMessage()    {}
func (*SumAggregation) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{76}
}

func (m *SumAggregation) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SumAggregation.Unmarshal(m, b)
}
func (m *SumAggregation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SumAggregation.Marshal(b, m, deterministic)
}
func (m *SumAggregation) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SumAggregation.Merge(m, src)
}
func (m *SumAggregation) XXX_Size() int {
	return xxx_messageInfo_SumAggregation.Size(m)
}
func (m *SumAggregation) XXX_DiscardUnknown() {
	xxx_messageInfo_SumAggregation.DiscardUnknown(m)
}

var xxx_messageInfo_SumAggregation proto.InternalMessageInfo

func (m *SumAggregation) GetFieldName() string {
	if m != nil && m.FieldName != nil {
		return *m.FieldName
	}
	return ""
}

func (m *SumAggregation) GetMissing() []byte {
	if m != nil {
		return m.Missing
	}
	return nil
}

type CountAggregation struct {
	FieldName            *string  `protobuf:"bytes,1,opt,name=field_name,json=fieldName" json:"field_name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CountAggregation) Reset()         { *m = CountAggregation{} }
func (m *CountAggregation) String() string { return proto.CompactTextString(m) }
func (*CountAggregation) ProtoMessage()    {}
func (*CountAggregation) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{77}
}

func (m *CountAggregation) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CountAggregation.Unmarshal(m, b)
}
func (m *CountAggregation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CountAggregation.Marshal(b, m, deterministic)
}
func (m *CountAggregation) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CountAggregation.Merge(m, src)
}
func (m *CountAggregation) XXX_Size() int {
	return xxx_messageInfo_CountAggregation.Size(m)
}
func (m *CountAggregation) XXX_DiscardUnknown() {
	xxx_messageInfo_CountAggregation.DiscardUnknown(m)
}

var xxx_messageInfo_CountAggregation proto.InternalMessageInfo

func (m *CountAggregation) GetFieldName() string {
	if m != nil && m.FieldName != nil {
		return *m.FieldName
	}
	return ""
}

type DistinctCountAggregation struct {
	FieldName            *string  `protobuf:"bytes,1,opt,name=field_name,json=fieldName" json:"field_name,omitempty"`
	Missing              []byte   `protobuf:"bytes,2,opt,name=missing" json:"missing,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *DistinctCountAggregation) Reset()         { *m = DistinctCountAggregation{} }
func (m *DistinctCountAggregation) String() string { return proto.CompactTextString(m) }
func (*DistinctCountAggregation) ProtoMessage()    {}
func (*DistinctCountAggregation) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{78}
}

func (m *DistinctCountAggregation) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DistinctCountAggregation.Unmarshal(m, b)
}
func (m *DistinctCountAggregation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DistinctCountAggregation.Marshal(b, m, deterministic)
}
func (m *DistinctCountAggregation) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DistinctCountAggregation.Merge(m, src)
}
func (m *DistinctCountAggregation) XXX_Size() int {
	return xxx_messageInfo_DistinctCountAggregation.Size(m)
}
func (m *DistinctCountAggregation) XXX_DiscardUnknown() {
	xxx_messageInfo_DistinctCountAggregation.DiscardUnknown(m)
}

var xxx_messageInfo_DistinctCountAggregation proto.InternalMessageInfo

func (m *DistinctCountAggregation) GetFieldName() string {
	if m != nil && m.FieldName != nil {
		return *m.FieldName
	}
	return ""
}

func (m *DistinctCountAggregation) GetMissing() []byte {
	if m != nil {
		return m.Missing
	}
	return nil
}

type TopRowsAggregation struct {
	Limit                *int32   `protobuf:"varint,1,opt,name=limit" json:"limit,omitempty"`
	Sort                 *Sort    `protobuf:"bytes,2,opt,name=sort" json:"sort,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TopRowsAggregation) Reset()         { *m = TopRowsAggregation{} }
func (m *TopRowsAggregation) String() string { return proto.CompactTextString(m) }
func (*TopRowsAggregation) ProtoMessage()    {}
func (*TopRowsAggregation) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{79}
}

func (m *TopRowsAggregation) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TopRowsAggregation.Unmarshal(m, b)
}
func (m *TopRowsAggregation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TopRowsAggregation.Marshal(b, m, deterministic)
}
func (m *TopRowsAggregation) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TopRowsAggregation.Merge(m, src)
}
func (m *TopRowsAggregation) XXX_Size() int {
	return xxx_messageInfo_TopRowsAggregation.Size(m)
}
func (m *TopRowsAggregation) XXX_DiscardUnknown() {
	xxx_messageInfo_TopRowsAggregation.DiscardUnknown(m)
}

var xxx_messageInfo_TopRowsAggregation proto.InternalMessageInfo

func (m *TopRowsAggregation) GetLimit() int32 {
	if m != nil && m.Limit != nil {
		return *m.Limit
	}
	return 0
}

func (m *TopRowsAggregation) GetSort() *Sort {
	if m != nil {
		return m.Sort
	}
	return nil
}

type PercentilesAggregation struct {
	FieldName            *string   `protobuf:"bytes,1,opt,name=field_name,json=fieldName" json:"field_name,omitempty"`
	Percentiles          []float64 `protobuf:"fixed64,2,rep,name=percentiles" json:"percentiles,omitempty"`
	Missing              []byte    `protobuf:"bytes,3,opt,name=missing" json:"missing,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *PercentilesAggregation) Reset()         { *m = PercentilesAggregation{} }
func (m *PercentilesAggregation) String() string { return proto.CompactTextString(m) }
func (*PercentilesAggregation) ProtoMessage()    {}
func (*PercentilesAggregation) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{80}
}

func (m *PercentilesAggregation) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PercentilesAggregation.Unmarshal(m, b)
}
func (m *PercentilesAggregation) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PercentilesAggregation.Marshal(b, m, deterministic)
}
func (m *PercentilesAggregation) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PercentilesAggregation.Merge(m, src)
}
func (m *PercentilesAggregation) XXX_Size() int {
	return xxx_messageInfo_PercentilesAggregation.Size(m)
}
func (m *PercentilesAggregation) XXX_DiscardUnknown() {
	xxx_messageInfo_PercentilesAggregation.DiscardUnknown(m)
}

var xxx_messageInfo_PercentilesAggregation proto.InternalMessageInfo

func (m *PercentilesAggregation) GetFieldName() string {
	if m != nil && m.FieldName != nil {
		return *m.FieldName
	}
	return ""
}

func (m *PercentilesAggregation) GetPercentiles() []float64 {
	if m != nil {
		return m.Percentiles
	}
	return nil
}

func (m *PercentilesAggregation) GetMissing() []byte {
	if m != nil {
		return m.Missing
	}
	return nil
}

type FieldRange struct {
	Min                  []byte   `protobuf:"bytes,1,opt,name=min" json:"min,omitempty"`
	Max                  []byte   `protobuf:"bytes,2,opt,name=max" json:"max,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *FieldRange) Reset()         { *m = FieldRange{} }
func (m *FieldRange) String() string { return proto.CompactTextString(m) }
func (*FieldRange) ProtoMessage()    {}
func (*FieldRange) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{81}
}

func (m *FieldRange) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_FieldRange.Unmarshal(m, b)
}
func (m *FieldRange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_FieldRange.Marshal(b, m, deterministic)
}
func (m *FieldRange) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FieldRange.Merge(m, src)
}
func (m *FieldRange) XXX_Size() int {
	return xxx_messageInfo_FieldRange.Size(m)
}
func (m *FieldRange) XXX_DiscardUnknown() {
	xxx_messageInfo_FieldRange.DiscardUnknown(m)
}

var xxx_messageInfo_FieldRange proto.InternalMessageInfo

func (m *FieldRange) GetMin() []byte {
	if m != nil {
		return m.Min
	}
	return nil
}

func (m *FieldRange) GetMax() []byte {
	if m != nil {
		return m.Max
	}
	return nil
}

type GroupByDateHistogram struct {
	FieldName            *string        `protobuf:"bytes,1,opt,name=field_name,json=fieldName" json:"field_name,omitempty"`
	Interval             *DateTimeValue `protobuf:"bytes,2,opt,name=interval" json:"interval,omitempty"`
	FieldRange           *FieldRange    `protobuf:"bytes,3,opt,name=field_range,json=fieldRange" json:"field_range,omitempty"`
	Missing              []byte         `protobuf:"bytes,4,opt,name=missing" json:"missing,omitempty"`
	MinDocCount          *int64         `protobuf:"varint,5,opt,name=min_doc_count,json=minDocCount" json:"min_doc_count,omitempty"`
	TimeZone             *string        `protobuf:"bytes,6,opt,name=time_zone,json=timeZone" json:"time_zone,omitempty"`
	Sort                 *GroupBySort   `protobuf:"bytes,7,opt,name=sort" json:"sort,omitempty"`
	SubAggs              *Aggregations  `protobuf:"bytes,8,opt,name=sub_aggs,json=subAggs" json:"sub_aggs,omitempty"`
	SubGroupBys          *GroupBys      `protobuf:"bytes,9,opt,name=sub_group_bys,json=subGroupBys" json:"sub_group_bys,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

func (m *GroupByDateHistogram) Reset()         { *m = GroupByDateHistogram{} }
func (m *GroupByDateHistogram) String() string { return proto.CompactTextString(m) }
func (*GroupByDateHistogram) ProtoMessage()    {}
func (*GroupByDateHistogram) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{82}
}

func (m *GroupByDateHistogram) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GroupByDateHistogram.Unmarshal(m, b)
}
func (m *GroupByDateHistogram) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GroupByDateHistogram.Marshal(b, m, deterministic)
}
func (m *GroupByDateHistogram) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GroupByDateHistogram.Merge(m, src)
}
func (m *GroupByDateHistogram) XXX_Size() int {
	return xxx_messageInfo_GroupByDateHistogram.Size(m)
}
func (m *GroupByDateHistogram) XXX_DiscardUnknown() {
	xxx_messageInfo_GroupByDateHistogram.DiscardUnknown(m)
}

var xxx_messageInfo_GroupByDateHistogram proto.InternalMessageInfo

func (m *GroupByDateHistogram) GetFieldName() string {
	if m != nil && m.FieldName != nil {
		return *m.FieldName
	}
	return ""
}

func (m *GroupByDateHistogram) GetInterval() *DateTimeValue {
	if m != nil {
		return m.Interval
	}
	return nil
}

func (m *GroupByDateHistogram) GetFieldRange() *FieldRange {
	if m != nil {
		return m.FieldRange
	}
	return nil
}

func (m *GroupByDateHistogram) GetMissing() []byte {
	if m != nil {
		return m.Missing
	}
	return nil
}

func (m *GroupByDateHistogram) GetMinDocCount() int64 {
	if m != nil && m.MinDocCount != nil {
		return *m.MinDocCount
	}
	return 0
}

func (m *GroupByDateHistogram) GetTimeZone() string {
	if m != nil && m.TimeZone != nil {
		return *m.TimeZone
	}
	return ""
}

func (m *GroupByDateHistogram) GetSort() *GroupBySort {
	if m != nil {
		return m.Sort
	}
	return nil
}

func (m *GroupByDateHistogram) GetSubAggs() *Aggregations {
	if m != nil {
		return m.SubAggs
	}
	return nil
}

func (m *GroupByDateHistogram) GetSubGroupBys() *GroupBys {
	if m != nil {
		return m.SubGroupBys
	}
	return nil
}

type GroupByHistogram struct {
	FieldName            *string       `protobuf:"bytes,1,opt,name=field_name,json=fieldName" json:"field_name,omitempty"`
	Interval             []byte        `protobuf:"bytes,2,opt,name=interval" json:"interval,omitempty"`
	Missing              []byte        `protobuf:"bytes,3,opt,name=missing" json:"missing,omitempty"`
	MinDocCount          *int64        `protobuf:"varint,4,opt,name=min_doc_count,json=minDocCount" json:"min_doc_count,omitempty"`
	Sort                 *GroupBySort  `protobuf:"bytes,5,opt,name=sort" json:"sort,omitempty"`
	FieldRange           *FieldRange   `protobuf:"bytes,6,opt,name=field_range,json=fieldRange" json:"field_range,omitempty"`
	SubAggs              *Aggregations `protobuf:"bytes,7,opt,name=sub_aggs,json=subAggs" json:"sub_aggs,omitempty"`
	SubGroupBys          *GroupBys     `protobuf:"bytes,8,opt,name=sub_group_bys,json=subGroupBys" json:"sub_group_bys,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

func (m *GroupByHistogram) Reset()         { *m = GroupByHistogram{} }
func (m *GroupByHistogram) String() string { return proto.CompactTextString(m) }
func (*GroupByHistogram) ProtoMessage()    {}
func (*GroupByHistogram) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{83}
}

func (m *GroupByHistogram) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GroupByHistogram.Unmarshal(m, b)
}
func (m *GroupByHistogram) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GroupByHistogram.Marshal(b, m, deterministic)
}
func (m *GroupByHistogram) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GroupByHistogram.Merge(m, src)
}
func (m *GroupByHistogram) XXX_Size() int {
	return xxx_messageInfo_GroupByHistogram.Size(m)
}
func (m *GroupByHistogram) XXX_DiscardUnknown() {
	xxx_messageInfo_GroupByHistogram.DiscardUnknown(m)
}

var xxx_messageInfo_GroupByHistogram proto.InternalMessageInfo

func (m *GroupByHistogram) GetFieldName() string {
	if m != nil && m.FieldName != nil {
		return *m.FieldName
	}
	return ""
}

func (m *GroupByHistogram) GetInterval() []byte {
	if m != nil {
		return m.Interval
	}
	return nil
}

func (m *GroupByHistogram) GetMissing() []byte {
	if m != nil {
		return m.Missing
	}
	return nil
}

func (m *GroupByHistogram) GetMinDocCount() int64 {
	if m != nil && m.MinDocCount != nil {
		return *m.MinDocCount
	}
	return 0
}

func (m *GroupByHistogram) GetSort() *GroupBySort {
	if m != nil {
		return m.Sort
	}
	return nil
}

func (m *GroupByHistogram) GetFieldRange() *FieldRange {
	if m != nil {
		return m.FieldRange
	}
	return nil
}

func (m *GroupByHistogram) GetSubAggs() *Aggregations {
	if m != nil {
		return m.SubAggs
	}
	return nil
}

func (m *GroupByHistogram) GetSubGroupBys() *GroupBys {
	if m != nil {
		return m.SubGroupBys
	}
	return nil
}

// group agg
type GroupKeySort struct {
	Order                *SortOrder `protobuf:"varint,1,opt,name=order,enum=otsprotocol.SortOrder" json:"order,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *GroupKeySort) Reset()         { *m = GroupKeySort{} }
func (m *GroupKeySort) String() string { return proto.CompactTextString(m) }
func (*GroupKeySort) ProtoMessage()    {}
func (*GroupKeySort) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{84}
}

func (m *GroupKeySort) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GroupKeySort.Unmarshal(m, b)
}
func (m *GroupKeySort) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GroupKeySort.Marshal(b, m, deterministic)
}
func (m *GroupKeySort) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GroupKeySort.Merge(m, src)
}
func (m *GroupKeySort) XXX_Size() int {
	return xxx_messageInfo_GroupKeySort.Size(m)
}
func (m *GroupKeySort) XXX_DiscardUnknown() {
	xxx_messageInfo_GroupKeySort.DiscardUnknown(m)
}

var xxx_messageInfo_GroupKeySort proto.InternalMessageInfo

func (m *GroupKeySort) GetOrder() SortOrder {
	if m != nil && m.Order != nil {
		return *m.Order
	}
	return SortOrder_SORT_ORDER_ASC
}

type RowCountSort struct {
	Order                *SortOrder `protobuf:"varint,1,opt,name=order,enum=otsprotocol.SortOrder" json:"order,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *RowCountSort) Reset()         { *m = RowCountSort{} }
func (m *RowCountSort) String() string { return proto.CompactTextString(m) }
func (*RowCountSort) ProtoMessage()    {}
func (*RowCountSort) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{85}
}

func (m *RowCountSort) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_RowCountSort.Unmarshal(m, b)
}
func (m *RowCountSort) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_RowCountSort.Marshal(b, m, deterministic)
}
func (m *RowCountSort) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RowCountSort.Merge(m, src)
}
func (m *RowCountSort) XXX_Size() int {
	return xxx_messageInfo_RowCountSort.Size(m)
}
func (m *RowCountSort) XXX_DiscardUnknown() {
	xxx_messageInfo_RowCountSort.DiscardUnknown(m)
}

var xxx_messageInfo_RowCountSort proto.InternalMessageInfo

func (m *RowCountSort) GetOrder() SortOrder {
	if m != nil && m.Order != nil {
		return *m.Order
	}
	return SortOrder_SORT_ORDER_ASC
}

type SubAggSort struct {
	SubAggName           *string    `protobuf:"bytes,1,opt,name=sub_agg_name,json=subAggName" json:"sub_agg_name,omitempty"`
	Order                *SortOrder `protobuf:"varint,2,opt,name=order,enum=otsprotocol.SortOrder" json:"order,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *SubAggSort) Reset()         { *m = SubAggSort{} }
func (m *SubAggSort) String() string { return proto.CompactTextString(m) }
func (*SubAggSort) ProtoMessage()    {}
func (*SubAggSort) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{86}
}

func (m *SubAggSort) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SubAggSort.Unmarshal(m, b)
}
func (m *SubAggSort) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SubAggSort.Marshal(b, m, deterministic)
}
func (m *SubAggSort) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SubAggSort.Merge(m, src)
}
func (m *SubAggSort) XXX_Size() int {
	return xxx_messageInfo_SubAggSort.Size(m)
}
func (m *SubAggSort) XXX_DiscardUnknown() {
	xxx_messageInfo_SubAggSort.DiscardUnknown(m)
}

var xxx_messageInfo_SubAggSort proto.InternalMessageInfo

func (m *SubAggSort) GetSubAggName() string {
	if m != nil && m.SubAggName != nil {
		return *m.SubAggName
	}
	return ""
}

func (m *SubAggSort) GetOrder() SortOrder {
	if m != nil && m.Order != nil {
		return *m.Order
	}
	return SortOrder_SORT_ORDER_ASC
}

type GroupBySorter struct {
	GroupKeySort         *GroupKeySort `protobuf:"bytes,1,opt,name=group_key_sort,json=groupKeySort" json:"group_key_sort,omitempty"`
	RowCountSort         *RowCountSort `protobuf:"bytes,2,opt,name=row_count_sort,json=rowCountSort" json:"row_count_sort,omitempty"`
	SubAggSort           *SubAggSort   `protobuf:"bytes,3,opt,name=sub_agg_sort,json=subAggSort" json:"sub_agg_sort,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

func (m *GroupBySorter) Reset()         { *m = GroupBySorter{} }
func (m *GroupBySorter) String() string { return proto.CompactTextString(m) }
func (*GroupBySorter) ProtoMessage()    {}
func (*GroupBySorter) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{87}
}

func (m *GroupBySorter) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GroupBySorter.Unmarshal(m, b)
}
func (m *GroupBySorter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GroupBySorter.Marshal(b, m, deterministic)
}
func (m *GroupBySorter) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GroupBySorter.Merge(m, src)
}
func (m *GroupBySorter) XXX_Size() int {
	return xxx_messageInfo_GroupBySorter.Size(m)
}
func (m *GroupBySorter) XXX_DiscardUnknown() {
	xxx_messageInfo_GroupBySorter.DiscardUnknown(m)
}

var xxx_messageInfo_GroupBySorter proto.InternalMessageInfo

func (m *GroupBySorter) GetGroupKeySort() *GroupKeySort {
	if m != nil {
		return m.GroupKeySort
	}
	return nil
}

func (m *GroupBySorter) GetRowCountSort() *RowCountSort {
	if m != nil {
		return m.RowCountSort
	}
	return nil
}

func (m *GroupBySorter) GetSubAggSort() *SubAggSort {
	if m != nil {
		return m.SubAggSort
	}
	return nil
}

type GroupBySort struct {
	Sorters              []*GroupBySorter `protobuf:"bytes,1,rep,name=sorters" json:"sorters,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

func (m *GroupBySort) Reset()         { *m = GroupBySort{} }
func (m *GroupBySort) String() string { return proto.CompactTextString(m) }
func (*GroupBySort) ProtoMessage()    {}
func (*GroupBySort) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{88}
}

func (m *GroupBySort) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GroupBySort.Unmarshal(m, b)
}
func (m *GroupBySort) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GroupBySort.Marshal(b, m, deterministic)
}
func (m *GroupBySort) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GroupBySort.Merge(m, src)
}
func (m *GroupBySort) XXX_Size() int {
	return xxx_messageInfo_GroupBySort.Size(m)
}
func (m *GroupBySort) XXX_DiscardUnknown() {
	xxx_messageInfo_GroupBySort.DiscardUnknown(m)
}

var xxx_messageInfo_GroupBySort proto.InternalMessageInfo

func (m *GroupBySort) GetSorters() []*GroupBySorter {
	if m != nil {
		return m.Sorters
	}
	return nil
}

type GroupByComposite struct {
	Sources              *GroupBys     `protobuf:"bytes,1,opt,name=sources" json:"sources,omitempty"`
	Size                 *int32        `protobuf:"varint,2,opt,name=size" json:"size,omitempty"`
	SubAggs              *Aggregations `protobuf:"bytes,4,opt,name=sub_aggs,json=subAggs" json:"sub_aggs,omitempty"`
	SubGroupBys          *GroupBys     `protobuf:"bytes,5,opt,name=sub_group_bys,json=subGroupBys" json:"sub_group_bys,omitempty"`
	NextToken            *string       `protobuf:"bytes,6,opt,name=next_token,json=nextToken" json:"next_token,omitempty"`
	SuggestedSize        *int32        `protobuf:"varint,7,opt,name=suggested_size,json=suggestedSize" json:"suggested_size,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

func (m *GroupByComposite) Reset()         { *m = GroupByComposite{} }
func (m *GroupByComposite) String() string { return proto.CompactTextString(m) }
func (*GroupByComposite) ProtoMessage()    {}
func (*GroupByComposite) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{89}
}

func (m *GroupByComposite) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GroupByComposite.Unmarshal(m, b)
}
func (m *GroupByComposite) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GroupByComposite.Marshal(b, m, deterministic)
}
func (m *GroupByComposite) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GroupByComposite.Merge(m, src)
}
func (m *GroupByComposite) XXX_Size() int {
	return xxx_messageInfo_GroupByComposite.Size(m)
}
func (m *GroupByComposite) XXX_DiscardUnknown() {
	xxx_messageInfo_GroupByComposite.DiscardUnknown(m)
}

var xxx_messageInfo_GroupByComposite proto.InternalMessageInfo

func (m *GroupByComposite) GetSources() *GroupBys {
	if m != nil {
		return m.Sources
	}
	return nil
}

func (m *GroupByComposite) GetSize() int32 {
	if m != nil && m.Size != nil {
		return *m.Size
	}
	return 0
}

func (m *GroupByComposite) GetSubAggs() *Aggregations {
	if m != nil {
		return m.SubAggs
	}
	return nil
}

func (m *GroupByComposite) GetSubGroupBys() *GroupBys {
	if m != nil {
		return m.SubGroupBys
	}
	return nil
}

func (m *GroupByComposite) GetNextToken() string {
	if m != nil && m.NextToken != nil {
		return *m.NextToken
	}
	return ""
}

func (m *GroupByComposite) GetSuggestedSize() int32 {
	if m != nil && m.SuggestedSize != nil {
		return *m.SuggestedSize
	}
	return 0
}

type GroupByCompositeResultItem struct {
	Keys                 []string            `protobuf:"bytes,1,rep,name=keys" json:"keys,omitempty"`
	IsNullKeys           []bool              `protobuf:"varint,5,rep,name=is_null_keys,json=isNullKeys" json:"is_null_keys,omitempty"`
	RowCount             *int64              `protobuf:"varint,2,opt,name=row_count,json=rowCount" json:"row_count,omitempty"`
	SubAggsResult        *AggregationsResult `protobuf:"bytes,3,opt,name=sub_aggs_result,json=subAggsResult" json:"sub_aggs_result,omitempty"`
	SubGroupBysResult    *GroupBysResult     `protobuf:"bytes,4,opt,name=sub_group_bys_result,json=subGroupBysResult" json:"sub_group_bys_result,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

func (m *GroupByCompositeResultItem) Reset()         { *m = GroupByCompositeResultItem{} }
func (m *GroupByCompositeResultItem) String() string { return proto.CompactTextString(m) }
func (*GroupByCompositeResultItem) ProtoMessage()    {}
func (*GroupByCompositeResultItem) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{90}
}

func (m *GroupByCompositeResultItem) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GroupByCompositeResultItem.Unmarshal(m, b)
}
func (m *GroupByCompositeResultItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GroupByCompositeResultItem.Marshal(b, m, deterministic)
}
func (m *GroupByCompositeResultItem) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GroupByCompositeResultItem.Merge(m, src)
}
func (m *GroupByCompositeResultItem) XXX_Size() int {
	return xxx_messageInfo_GroupByCompositeResultItem.Size(m)
}
func (m *GroupByCompositeResultItem) XXX_DiscardUnknown() {
	xxx_messageInfo_GroupByCompositeResultItem.DiscardUnknown(m)
}

var xxx_messageInfo_GroupByCompositeResultItem proto.InternalMessageInfo

func (m *GroupByCompositeResultItem) GetKeys() []string {
	if m != nil {
		return m.Keys
	}
	return nil
}

func (m *GroupByCompositeResultItem) GetIsNullKeys() []bool {
	if m != nil {
		return m.IsNullKeys
	}
	return nil
}

func (m *GroupByCompositeResultItem) GetRowCount() int64 {
	if m != nil && m.RowCount != nil {
		return *m.RowCount
	}
	return 0
}

func (m *GroupByCompositeResultItem) GetSubAggsResult() *AggregationsResult {
	if m != nil {
		return m.SubAggsResult
	}
	return nil
}

func (m *GroupByCompositeResultItem) GetSubGroupBysResult() *GroupBysResult {
	if m != nil {
		return m.SubGroupBysResult
	}
	return nil
}

type GroupByCompositeResult struct {
	GroupByCompositeResultItems []*GroupByCompositeResultItem `protobuf:"bytes,1,rep,name=group_by_composite_result_items,json=groupByCompositeResultItems" json:"group_by_composite_result_items,omitempty"`
	SourceGroupByNames          []string                      `protobuf:"bytes,2,rep,name=source_group_by_names,json=sourceGroupByNames" json:"source_group_by_names,omitempty"`
	NextToken                   *string                       `protobuf:"bytes,3,opt,name=next_token,json=nextToken" json:"next_token,omitempty"`
	XXX_NoUnkeyedLiteral        struct{}                      `json:"-"`
	XXX_unrecognized            []byte                        `json:"-"`
	XXX_sizecache               int32                         `json:"-"`
}

func (m *GroupByCompositeResult) Reset()         { *m = GroupByCompositeResult{} }
func (m *GroupByCompositeResult) String() string { return proto.CompactTextString(m) }
func (*GroupByCompositeResult) ProtoMessage()    {}
func (*GroupByCompositeResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{91}
}

func (m *GroupByCompositeResult) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GroupByCompositeResult.Unmarshal(m, b)
}
func (m *GroupByCompositeResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GroupByCompositeResult.Marshal(b, m, deterministic)
}
func (m *GroupByCompositeResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GroupByCompositeResult.Merge(m, src)
}
func (m *GroupByCompositeResult) XXX_Size() int {
	return xxx_messageInfo_GroupByCompositeResult.Size(m)
}
func (m *GroupByCompositeResult) XXX_DiscardUnknown() {
	xxx_messageInfo_GroupByCompositeResult.DiscardUnknown(m)
}

var xxx_messageInfo_GroupByCompositeResult proto.InternalMessageInfo

func (m *GroupByCompositeResult) GetGroupByCompositeResultItems() []*GroupByCompositeResultItem {
	if m != nil {
		return m.GroupByCompositeResultItems
	}
	return nil
}

func (m *GroupByCompositeResult) GetSourceGroupByNames() []string {
	if m != nil {
		return m.SourceGroupByNames
	}
	return nil
}

func (m *GroupByCompositeResult) GetNextToken() string {
	if m != nil && m.NextToken != nil {
		return *m.NextToken
	}
	return ""
}

type GroupByField struct {
	FieldName            *string       `protobuf:"bytes,1,opt,name=field_name,json=fieldName" json:"field_name,omitempty"`
	Size                 *int32        `protobuf:"varint,2,opt,name=size" json:"size,omitempty"`
	Sort                 *GroupBySort  `protobuf:"bytes,3,opt,name=sort" json:"sort,omitempty"`
	SubAggs              *Aggregations `protobuf:"bytes,4,opt,name=sub_aggs,json=subAggs" json:"sub_aggs,omitempty"`
	SubGroupBys          *GroupBys     `protobuf:"bytes,5,opt,name=sub_group_bys,json=subGroupBys" json:"sub_group_bys,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

func (m *GroupByField) Reset()         { *m = GroupByField{} }
func (m *GroupByField) String() string { return proto.CompactTextString(m) }
func (*GroupByField) ProtoMessage()    {}
func (*GroupByField) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{92}
}

func (m *GroupByField) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GroupByField.Unmarshal(m, b)
}
func (m *GroupByField) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GroupByField.Marshal(b, m, deterministic)
}
func (m *GroupByField) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GroupByField.Merge(m, src)
}
func (m *GroupByField) XXX_Size() int {
	return xxx_messageInfo_GroupByField.Size(m)
}
func (m *GroupByField) XXX_DiscardUnknown() {
	xxx_messageInfo_GroupByField.DiscardUnknown(m)
}

var xxx_messageInfo_GroupByField proto.InternalMessageInfo

func (m *GroupByField) GetFieldName() string {
	if m != nil && m.FieldName != nil {
		return *m.FieldName
	}
	return ""
}

func (m *GroupByField) GetSize() int32 {
	if m != nil && m.Size != nil {
		return *m.Size
	}
	return 0
}

func (m *GroupByField) GetSort() *GroupBySort {
	if m != nil {
		return m.Sort
	}
	return nil
}

func (m *GroupByField) GetSubAggs() *Aggregations {
	if m != nil {
		return m.SubAggs
	}
	return nil
}

func (m *GroupByField) GetSubGroupBys() *GroupBys {
	if m != nil {
		return m.SubGroupBys
	}
	return nil
}

type Range struct {
	From                 *float64 `protobuf:"fixed64,1,opt,name=from" json:"from,omitempty"`
	To                   *float64 `protobuf:"fixed64,2,opt,name=to" json:"to,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *Range) Reset()         { *m = Range{} }
func (m *Range) String() string { return proto.CompactTextString(m) }
func (*Range) ProtoMessage()    {}
func (*Range) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{93}
}

func (m *Range) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Range.Unmarshal(m, b)
}
func (m *Range) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Range.Marshal(b, m, deterministic)
}
func (m *Range) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Range.Merge(m, src)
}
func (m *Range) XXX_Size() int {
	return xxx_messageInfo_Range.Size(m)
}
func (m *Range) XXX_DiscardUnknown() {
	xxx_messageInfo_Range.DiscardUnknown(m)
}

var xxx_messageInfo_Range proto.InternalMessageInfo

func (m *Range) GetFrom() float64 {
	if m != nil && m.From != nil {
		return *m.From
	}
	return 0
}

func (m *Range) GetTo() float64 {
	if m != nil && m.To != nil {
		return *m.To
	}
	return 0
}

type GroupByRange struct {
	FieldName            *string       `protobuf:"bytes,1,opt,name=field_name,json=fieldName" json:"field_name,omitempty"`
	Ranges               []*Range      `protobuf:"bytes,2,rep,name=ranges" json:"ranges,omitempty"`
	SubAggs              *Aggregations `protobuf:"bytes,3,opt,name=sub_aggs,json=subAggs" json:"sub_aggs,omitempty"`
	SubGroupBys          *GroupBys     `protobuf:"bytes,4,opt,name=sub_group_bys,json=subGroupBys" json:"sub_group_bys,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

func (m *GroupByRange) Reset()         { *m = GroupByRange{} }
func (m *GroupByRange) String() string { return proto.CompactTextString(m) }
func (*GroupByRange) ProtoMessage()    {}
func (*GroupByRange) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{94}
}

func (m *GroupByRange) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GroupByRange.Unmarshal(m, b)
}
func (m *GroupByRange) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GroupByRange.Marshal(b, m, deterministic)
}
func (m *GroupByRange) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GroupByRange.Merge(m, src)
}
func (m *GroupByRange) XXX_Size() int {
	return xxx_messageInfo_GroupByRange.Size(m)
}
func (m *GroupByRange) XXX_DiscardUnknown() {
	xxx_messageInfo_GroupByRange.DiscardUnknown(m)
}

var xxx_messageInfo_GroupByRange proto.InternalMessageInfo

func (m *GroupByRange) GetFieldName() string {
	if m != nil && m.FieldName != nil {
		return *m.FieldName
	}
	return ""
}

func (m *GroupByRange) GetRanges() []*Range {
	if m != nil {
		return m.Ranges
	}
	return nil
}

func (m *GroupByRange) GetSubAggs() *Aggregations {
	if m != nil {
		return m.SubAggs
	}
	return nil
}

func (m *GroupByRange) GetSubGroupBys() *GroupBys {
	if m != nil {
		return m.SubGroupBys
	}
	return nil
}

type GroupByFilter struct {
	Filters              []*Query      `protobuf:"bytes,1,rep,name=filters" json:"filters,omitempty"`
	SubAggs              *Aggregations `protobuf:"bytes,2,opt,name=sub_aggs,json=subAggs" json:"sub_aggs,omitempty"`
	SubGroupBys          *GroupBys     `protobuf:"bytes,3,opt,name=sub_group_bys,json=subGroupBys" json:"sub_group_bys,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

func (m *GroupByFilter) Reset()         { *m = GroupByFilter{} }
func (m *GroupByFilter) String() string { return proto.CompactTextString(m) }
func (*GroupByFilter) ProtoMessage()    {}
func (*GroupByFilter) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{95}
}

func (m *GroupByFilter) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GroupByFilter.Unmarshal(m, b)
}
func (m *GroupByFilter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GroupByFilter.Marshal(b, m, deterministic)
}
func (m *GroupByFilter) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GroupByFilter.Merge(m, src)
}
func (m *GroupByFilter) XXX_Size() int {
	return xxx_messageInfo_GroupByFilter.Size(m)
}
func (m *GroupByFilter) XXX_DiscardUnknown() {
	xxx_messageInfo_GroupByFilter.DiscardUnknown(m)
}

var xxx_messageInfo_GroupByFilter proto.InternalMessageInfo

func (m *GroupByFilter) GetFilters() []*Query {
	if m != nil {
		return m.Filters
	}
	return nil
}

func (m *GroupByFilter) GetSubAggs() *Aggregations {
	if m != nil {
		return m.SubAggs
	}
	return nil
}

func (m *GroupByFilter) GetSubGroupBys() *GroupBys {
	if m != nil {
		return m.SubGroupBys
	}
	return nil
}

type GeoPoint struct {
	Lat                  *float64 `protobuf:"fixed64,1,opt,name=lat" json:"lat,omitempty"`
	Lon                  *float64 `protobuf:"fixed64,2,opt,name=lon" json:"lon,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *GeoPoint) Reset()         { *m = GeoPoint{} }
func (m *GeoPoint) String() string { return proto.CompactTextString(m) }
func (*GeoPoint) ProtoMessage()    {}
func (*GeoPoint) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{96}
}

func (m *GeoPoint) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GeoPoint.Unmarshal(m, b)
}
func (m *GeoPoint) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GeoPoint.Marshal(b, m, deterministic)
}
func (m *GeoPoint) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GeoPoint.Merge(m, src)
}
func (m *GeoPoint) XXX_Size() int {
	return xxx_messageInfo_GeoPoint.Size(m)
}
func (m *GeoPoint) XXX_DiscardUnknown() {
	xxx_messageInfo_GeoPoint.DiscardUnknown(m)
}

var xxx_messageInfo_GeoPoint proto.InternalMessageInfo

func (m *GeoPoint) GetLat() float64 {
	if m != nil && m.Lat != nil {
		return *m.Lat
	}
	return 0
}

func (m *GeoPoint) GetLon() float64 {
	if m != nil && m.Lon != nil {
		return *m.Lon
	}
	return 0
}

type GroupByGeoDistance struct {
	FieldName            *string       `protobuf:"bytes,1,opt,name=field_name,json=fieldName" json:"field_name,omitempty"`
	Origin               *GeoPoint     `protobuf:"bytes,2,opt,name=origin" json:"origin,omitempty"`
	Ranges               []*Range      `protobuf:"bytes,3,rep,name=ranges" json:"ranges,omitempty"`
	SubAggs              *Aggregations `protobuf:"bytes,4,opt,name=sub_aggs,json=subAggs" json:"sub_aggs,omitempty"`
	SubGroupBys          *GroupBys     `protobuf:"bytes,5,opt,name=sub_group_bys,json=subGroupBys" json:"sub_group_bys,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

func (m *GroupByGeoDistance) Reset()         { *m = GroupByGeoDistance{} }
func (m *GroupByGeoDistance) String() string { return proto.CompactTextString(m) }
func (*GroupByGeoDistance) ProtoMessage()    {}
func (*GroupByGeoDistance) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{97}
}

func (m *GroupByGeoDistance) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GroupByGeoDistance.Unmarshal(m, b)
}
func (m *GroupByGeoDistance) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GroupByGeoDistance.Marshal(b, m, deterministic)
}
func (m *GroupByGeoDistance) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GroupByGeoDistance.Merge(m, src)
}
func (m *GroupByGeoDistance) XXX_Size() int {
	return xxx_messageInfo_GroupByGeoDistance.Size(m)
}
func (m *GroupByGeoDistance) XXX_DiscardUnknown() {
	xxx_messageInfo_GroupByGeoDistance.DiscardUnknown(m)
}

var xxx_messageInfo_GroupByGeoDistance proto.InternalMessageInfo

func (m *GroupByGeoDistance) GetFieldName() string {
	if m != nil && m.FieldName != nil {
		return *m.FieldName
	}
	return ""
}

func (m *GroupByGeoDistance) GetOrigin() *GeoPoint {
	if m != nil {
		return m.Origin
	}
	return nil
}

func (m *GroupByGeoDistance) GetRanges() []*Range {
	if m != nil {
		return m.Ranges
	}
	return nil
}

func (m *GroupByGeoDistance) GetSubAggs() *Aggregations {
	if m != nil {
		return m.SubAggs
	}
	return nil
}

func (m *GroupByGeoDistance) GetSubGroupBys() *GroupBys {
	if m != nil {
		return m.SubGroupBys
	}
	return nil
}

type GroupByGeoGrid struct {
	FieldName            *string           `protobuf:"bytes,1,opt,name=field_name,json=fieldName" json:"field_name,omitempty"`
	Precision            *GeoHashPrecision `protobuf:"varint,2,opt,name=precision,enum=otsprotocol.GeoHashPrecision" json:"precision,omitempty"`
	Size                 *int64            `protobuf:"varint,3,opt,name=size" json:"size,omitempty"`
	SubAggs              *Aggregations     `protobuf:"bytes,4,opt,name=sub_aggs,json=subAggs" json:"sub_aggs,omitempty"`
	SubGroupBys          *GroupBys         `protobuf:"bytes,5,opt,name=sub_group_bys,json=subGroupBys" json:"sub_group_bys,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *GroupByGeoGrid) Reset()         { *m = GroupByGeoGrid{} }
func (m *GroupByGeoGrid) String() string { return proto.CompactTextString(m) }
func (*GroupByGeoGrid) ProtoMessage()    {}
func (*GroupByGeoGrid) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{98}
}

func (m *GroupByGeoGrid) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GroupByGeoGrid.Unmarshal(m, b)
}
func (m *GroupByGeoGrid) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GroupByGeoGrid.Marshal(b, m, deterministic)
}
func (m *GroupByGeoGrid) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GroupByGeoGrid.Merge(m, src)
}
func (m *GroupByGeoGrid) XXX_Size() int {
	return xxx_messageInfo_GroupByGeoGrid.Size(m)
}
func (m *GroupByGeoGrid) XXX_DiscardUnknown() {
	xxx_messageInfo_GroupByGeoGrid.DiscardUnknown(m)
}

var xxx_messageInfo_GroupByGeoGrid proto.InternalMessageInfo

func (m *GroupByGeoGrid) GetFieldName() string {
	if m != nil && m.FieldName != nil {
		return *m.FieldName
	}
	return ""
}

func (m *GroupByGeoGrid) GetPrecision() GeoHashPrecision {
	if m != nil && m.Precision != nil {
		return *m.Precision
	}
	return GeoHashPrecision_GHP_5009KM_4992KM_1
}

func (m *GroupByGeoGrid) GetSize() int64 {
	if m != nil && m.Size != nil {
		return *m.Size
	}
	return 0
}

func (m *GroupByGeoGrid) GetSubAggs() *Aggregations {
	if m != nil {
		return m.SubAggs
	}
	return nil
}

func (m *GroupByGeoGrid) GetSubGroupBys() *GroupBys {
	if m != nil {
		return m.SubGroupBys
	}
	return nil
}

type GeoGrid struct {
	TopLeft              *GeoPoint `protobuf:"bytes,1,opt,name=top_left,json=topLeft" json:"top_left,omitempty"`
	BottomRight          *GeoPoint `protobuf:"bytes,2,opt,name=bottom_right,json=bottomRight" json:"bottom_right,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *GeoGrid) Reset()         { *m = GeoGrid{} }
func (m *GeoGrid) String() string { return proto.CompactTextString(m) }
func (*GeoGrid) ProtoMessage()    {}
func (*GeoGrid) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{99}
}

func (m *GeoGrid) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GeoGrid.Unmarshal(m, b)
}
func (m *GeoGrid) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GeoGrid.Marshal(b, m, deterministic)
}
func (m *GeoGrid) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GeoGrid.Merge(m, src)
}
func (m *GeoGrid) XXX_Size() int {
	return xxx_messageInfo_GeoGrid.Size(m)
}
func (m *GeoGrid) XXX_DiscardUnknown() {
	xxx_messageInfo_GeoGrid.DiscardUnknown(m)
}

var xxx_messageInfo_GeoGrid proto.InternalMessageInfo

func (m *GeoGrid) GetTopLeft() *GeoPoint {
	if m != nil {
		return m.TopLeft
	}
	return nil
}

func (m *GeoGrid) GetBottomRight() *GeoPoint {
	if m != nil {
		return m.BottomRight
	}
	return nil
}

//single agg result
type AvgAggregationResult struct {
	Value                *float64 `protobuf:"fixed64,1,opt,name=value" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *AvgAggregationResult) Reset()         { *m = AvgAggregationResult{} }
func (m *AvgAggregationResult) String() string { return proto.CompactTextString(m) }
func (*AvgAggregationResult) ProtoMessage()    {}
func (*AvgAggregationResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{100}
}

func (m *AvgAggregationResult) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_AvgAggregationResult.Unmarshal(m, b)
}
func (m *AvgAggregationResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_AvgAggregationResult.Marshal(b, m, deterministic)
}
func (m *AvgAggregationResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AvgAggregationResult.Merge(m, src)
}
func (m *AvgAggregationResult) XXX_Size() int {
	return xxx_messageInfo_AvgAggregationResult.Size(m)
}
func (m *AvgAggregationResult) XXX_DiscardUnknown() {
	xxx_messageInfo_AvgAggregationResult.DiscardUnknown(m)
}

var xxx_messageInfo_AvgAggregationResult proto.InternalMessageInfo

func (m *AvgAggregationResult) GetValue() float64 {
	if m != nil && m.Value != nil {
		return *m.Value
	}
	return 0
}

type DistinctCountAggregationResult struct {
	Value                *int64   `protobuf:"varint,1,opt,name=value" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *DistinctCountAggregationResult) Reset()         { *m = DistinctCountAggregationResult{} }
func (m *DistinctCountAggregationResult) String() string { return proto.CompactTextString(m) }
func (*DistinctCountAggregationResult) ProtoMessage()    {}
func (*DistinctCountAggregationResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{101}
}

func (m *DistinctCountAggregationResult) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_DistinctCountAggregationResult.Unmarshal(m, b)
}
func (m *DistinctCountAggregationResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_DistinctCountAggregationResult.Marshal(b, m, deterministic)
}
func (m *DistinctCountAggregationResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DistinctCountAggregationResult.Merge(m, src)
}
func (m *DistinctCountAggregationResult) XXX_Size() int {
	return xxx_messageInfo_DistinctCountAggregationResult.Size(m)
}
func (m *DistinctCountAggregationResult) XXX_DiscardUnknown() {
	xxx_messageInfo_DistinctCountAggregationResult.DiscardUnknown(m)
}

var xxx_messageInfo_DistinctCountAggregationResult proto.InternalMessageInfo

func (m *DistinctCountAggregationResult) GetValue() int64 {
	if m != nil && m.Value != nil {
		return *m.Value
	}
	return 0
}

type MaxAggregationResult struct {
	Value                *float64 `protobuf:"fixed64,1,opt,name=value" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *MaxAggregationResult) Reset()         { *m = MaxAggregationResult{} }
func (m *MaxAggregationResult) String() string { return proto.CompactTextString(m) }
func (*MaxAggregationResult) ProtoMessage()    {}
func (*MaxAggregationResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{102}
}

func (m *MaxAggregationResult) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MaxAggregationResult.Unmarshal(m, b)
}
func (m *MaxAggregationResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MaxAggregationResult.Marshal(b, m, deterministic)
}
func (m *MaxAggregationResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MaxAggregationResult.Merge(m, src)
}
func (m *MaxAggregationResult) XXX_Size() int {
	return xxx_messageInfo_MaxAggregationResult.Size(m)
}
func (m *MaxAggregationResult) XXX_DiscardUnknown() {
	xxx_messageInfo_MaxAggregationResult.DiscardUnknown(m)
}

var xxx_messageInfo_MaxAggregationResult proto.InternalMessageInfo

func (m *MaxAggregationResult) GetValue() float64 {
	if m != nil && m.Value != nil {
		return *m.Value
	}
	return 0
}

type MinAggregationResult struct {
	Value                *float64 `protobuf:"fixed64,1,opt,name=value" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *MinAggregationResult) Reset()         { *m = MinAggregationResult{} }
func (m *MinAggregationResult) String() string { return proto.CompactTextString(m) }
func (*MinAggregationResult) ProtoMessage()    {}
func (*MinAggregationResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{103}
}

func (m *MinAggregationResult) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MinAggregationResult.Unmarshal(m, b)
}
func (m *MinAggregationResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MinAggregationResult.Marshal(b, m, deterministic)
}
func (m *MinAggregationResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MinAggregationResult.Merge(m, src)
}
func (m *MinAggregationResult) XXX_Size() int {
	return xxx_messageInfo_MinAggregationResult.Size(m)
}
func (m *MinAggregationResult) XXX_DiscardUnknown() {
	xxx_messageInfo_MinAggregationResult.DiscardUnknown(m)
}

var xxx_messageInfo_MinAggregationResult proto.InternalMessageInfo

func (m *MinAggregationResult) GetValue() float64 {
	if m != nil && m.Value != nil {
		return *m.Value
	}
	return 0
}

type SumAggregationResult struct {
	Value                *float64 `protobuf:"fixed64,1,opt,name=value" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *SumAggregationResult) Reset()         { *m = SumAggregationResult{} }
func (m *SumAggregationResult) String() string { return proto.CompactTextString(m) }
func (*SumAggregationResult) ProtoMessage()    {}
func (*SumAggregationResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{104}
}

func (m *SumAggregationResult) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_SumAggregationResult.Unmarshal(m, b)
}
func (m *SumAggregationResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_SumAggregationResult.Marshal(b, m, deterministic)
}
func (m *SumAggregationResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_SumAggregationResult.Merge(m, src)
}
func (m *SumAggregationResult) XXX_Size() int {
	return xxx_messageInfo_SumAggregationResult.Size(m)
}
func (m *SumAggregationResult) XXX_DiscardUnknown() {
	xxx_messageInfo_SumAggregationResult.DiscardUnknown(m)
}

var xxx_messageInfo_SumAggregationResult proto.InternalMessageInfo

func (m *SumAggregationResult) GetValue() float64 {
	if m != nil && m.Value != nil {
		return *m.Value
	}
	return 0
}

type CountAggregationResult struct {
	Value                *int64   `protobuf:"varint,1,opt,name=value" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CountAggregationResult) Reset()         { *m = CountAggregationResult{} }
func (m *CountAggregationResult) String() string { return proto.CompactTextString(m) }
func (*CountAggregationResult) ProtoMessage()    {}
func (*CountAggregationResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{105}
}

func (m *CountAggregationResult) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_CountAggregationResult.Unmarshal(m, b)
}
func (m *CountAggregationResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_CountAggregationResult.Marshal(b, m, deterministic)
}
func (m *CountAggregationResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CountAggregationResult.Merge(m, src)
}
func (m *CountAggregationResult) XXX_Size() int {
	return xxx_messageInfo_CountAggregationResult.Size(m)
}
func (m *CountAggregationResult) XXX_DiscardUnknown() {
	xxx_messageInfo_CountAggregationResult.DiscardUnknown(m)
}

var xxx_messageInfo_CountAggregationResult proto.InternalMessageInfo

func (m *CountAggregationResult) GetValue() int64 {
	if m != nil && m.Value != nil {
		return *m.Value
	}
	return 0
}

type TopRowsAggregationResult struct {
	Rows                 [][]byte `protobuf:"bytes,1,rep,name=rows" json:"rows,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *TopRowsAggregationResult) Reset()         { *m = TopRowsAggregationResult{} }
func (m *TopRowsAggregationResult) String() string { return proto.CompactTextString(m) }
func (*TopRowsAggregationResult) ProtoMessage()    {}
func (*TopRowsAggregationResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{106}
}

func (m *TopRowsAggregationResult) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_TopRowsAggregationResult.Unmarshal(m, b)
}
func (m *TopRowsAggregationResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_TopRowsAggregationResult.Marshal(b, m, deterministic)
}
func (m *TopRowsAggregationResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TopRowsAggregationResult.Merge(m, src)
}
func (m *TopRowsAggregationResult) XXX_Size() int {
	return xxx_messageInfo_TopRowsAggregationResult.Size(m)
}
func (m *TopRowsAggregationResult) XXX_DiscardUnknown() {
	xxx_messageInfo_TopRowsAggregationResult.DiscardUnknown(m)
}

var xxx_messageInfo_TopRowsAggregationResult proto.InternalMessageInfo

func (m *TopRowsAggregationResult) GetRows() [][]byte {
	if m != nil {
		return m.Rows
	}
	return nil
}

type PercentilesAggregationItem struct {
	Key                  *float64 `protobuf:"fixed64,1,opt,name=key" json:"key,omitempty"`
	Value                []byte   `protobuf:"bytes,2,opt,name=value" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *PercentilesAggregationItem) Reset()         { *m = PercentilesAggregationItem{} }
func (m *PercentilesAggregationItem) String() string { return proto.CompactTextString(m) }
func (*PercentilesAggregationItem) ProtoMessage()    {}
func (*PercentilesAggregationItem) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{107}
}

func (m *PercentilesAggregationItem) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PercentilesAggregationItem.Unmarshal(m, b)
}
func (m *PercentilesAggregationItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PercentilesAggregationItem.Marshal(b, m, deterministic)
}
func (m *PercentilesAggregationItem) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PercentilesAggregationItem.Merge(m, src)
}
func (m *PercentilesAggregationItem) XXX_Size() int {
	return xxx_messageInfo_PercentilesAggregationItem.Size(m)
}
func (m *PercentilesAggregationItem) XXX_DiscardUnknown() {
	xxx_messageInfo_PercentilesAggregationItem.DiscardUnknown(m)
}

var xxx_messageInfo_PercentilesAggregationItem proto.InternalMessageInfo

func (m *PercentilesAggregationItem) GetKey() float64 {
	if m != nil && m.Key != nil {
		return *m.Key
	}
	return 0
}

func (m *PercentilesAggregationItem) GetValue() []byte {
	if m != nil {
		return m.Value
	}
	return nil
}

type PercentilesAggregationResult struct {
	PercentilesAggregationItems []*PercentilesAggregationItem `protobuf:"bytes,1,rep,name=percentiles_aggregation_items,json=percentilesAggregationItems" json:"percentiles_aggregation_items,omitempty"`
	XXX_NoUnkeyedLiteral        struct{}                      `json:"-"`
	XXX_unrecognized            []byte                        `json:"-"`
	XXX_sizecache               int32                         `json:"-"`
}

func (m *PercentilesAggregationResult) Reset()         { *m = PercentilesAggregationResult{} }
func (m *PercentilesAggregationResult) String() string { return proto.CompactTextString(m) }
func (*PercentilesAggregationResult) ProtoMessage()    {}
func (*PercentilesAggregationResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{108}
}

func (m *PercentilesAggregationResult) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_PercentilesAggregationResult.Unmarshal(m, b)
}
func (m *PercentilesAggregationResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_PercentilesAggregationResult.Marshal(b, m, deterministic)
}
func (m *PercentilesAggregationResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_PercentilesAggregationResult.Merge(m, src)
}
func (m *PercentilesAggregationResult) XXX_Size() int {
	return xxx_messageInfo_PercentilesAggregationResult.Size(m)
}
func (m *PercentilesAggregationResult) XXX_DiscardUnknown() {
	xxx_messageInfo_PercentilesAggregationResult.DiscardUnknown(m)
}

var xxx_messageInfo_PercentilesAggregationResult proto.InternalMessageInfo

func (m *PercentilesAggregationResult) GetPercentilesAggregationItems() []*PercentilesAggregationItem {
	if m != nil {
		return m.PercentilesAggregationItems
	}
	return nil
}

type AggregationResult struct {
	Name                 *string          `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
	Type                 *AggregationType `protobuf:"varint,2,opt,name=type,enum=otsprotocol.AggregationType" json:"type,omitempty"`
	AggResult            []byte           `protobuf:"bytes,3,opt,name=agg_result,json=aggResult" json:"agg_result,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

func (m *AggregationResult) Reset()         { *m = AggregationResult{} }
func (m *AggregationResult) String() string { return proto.CompactTextString(m) }
func (*AggregationResult) ProtoMessage()    {}
func (*AggregationResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{109}
}

func (m *AggregationResult) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_AggregationResult.Unmarshal(m, b)
}
func (m *AggregationResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_AggregationResult.Marshal(b, m, deterministic)
}
func (m *AggregationResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AggregationResult.Merge(m, src)
}
func (m *AggregationResult) XXX_Size() int {
	return xxx_messageInfo_AggregationResult.Size(m)
}
func (m *AggregationResult) XXX_DiscardUnknown() {
	xxx_messageInfo_AggregationResult.DiscardUnknown(m)
}

var xxx_messageInfo_AggregationResult proto.InternalMessageInfo

func (m *AggregationResult) GetName() string {
	if m != nil && m.Name != nil {
		return *m.Name
	}
	return ""
}

func (m *AggregationResult) GetType() AggregationType {
	if m != nil && m.Type != nil {
		return *m.Type
	}
	return AggregationType_AGG_AVG
}

func (m *AggregationResult) GetAggResult() []byte {
	if m != nil {
		return m.AggResult
	}
	return nil
}

type AggregationsResult struct {
	AggResults           []*AggregationResult `protobuf:"bytes,1,rep,name=agg_results,json=aggResults" json:"agg_results,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (m *AggregationsResult) Reset()         { *m = AggregationsResult{} }
func (m *AggregationsResult) String() string { return proto.CompactTextString(m) }
func (*AggregationsResult) ProtoMessage()    {}
func (*AggregationsResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{110}
}

func (m *AggregationsResult) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_AggregationsResult.Unmarshal(m, b)
}
func (m *AggregationsResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_AggregationsResult.Marshal(b, m, deterministic)
}
func (m *AggregationsResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AggregationsResult.Merge(m, src)
}
func (m *AggregationsResult) XXX_Size() int {
	return xxx_messageInfo_AggregationsResult.Size(m)
}
func (m *AggregationsResult) XXX_DiscardUnknown() {
	xxx_messageInfo_AggregationsResult.DiscardUnknown(m)
}

var xxx_messageInfo_AggregationsResult proto.InternalMessageInfo

func (m *AggregationsResult) GetAggResults() []*AggregationResult {
	if m != nil {
		return m.AggResults
	}
	return nil
}

//group by result
type GroupByFieldResultItem struct {
	Key                  *string             `protobuf:"bytes,1,opt,name=key" json:"key,omitempty"`
	RowCount             *int64              `protobuf:"varint,2,opt,name=row_count,json=rowCount" json:"row_count,omitempty"`
	SubAggsResult        *AggregationsResult `protobuf:"bytes,3,opt,name=sub_aggs_result,json=subAggsResult" json:"sub_aggs_result,omitempty"`
	SubGroupBysResult    *GroupBysResult     `protobuf:"bytes,4,opt,name=sub_group_bys_result,json=subGroupBysResult" json:"sub_group_bys_result,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

func (m *GroupByFieldResultItem) Reset()         { *m = GroupByFieldResultItem{} }
func (m *GroupByFieldResultItem) String() string { return proto.CompactTextString(m) }
func (*GroupByFieldResultItem) ProtoMessage()    {}
func (*GroupByFieldResultItem) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{111}
}

func (m *GroupByFieldResultItem) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GroupByFieldResultItem.Unmarshal(m, b)
}
func (m *GroupByFieldResultItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GroupByFieldResultItem.Marshal(b, m, deterministic)
}
func (m *GroupByFieldResultItem) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GroupByFieldResultItem.Merge(m, src)
}
func (m *GroupByFieldResultItem) XXX_Size() int {
	return xxx_messageInfo_GroupByFieldResultItem.Size(m)
}
func (m *GroupByFieldResultItem) XXX_DiscardUnknown() {
	xxx_messageInfo_GroupByFieldResultItem.DiscardUnknown(m)
}

var xxx_messageInfo_GroupByFieldResultItem proto.InternalMessageInfo

func (m *GroupByFieldResultItem) GetKey() string {
	if m != nil && m.Key != nil {
		return *m.Key
	}
	return ""
}

func (m *GroupByFieldResultItem) GetRowCount() int64 {
	if m != nil && m.RowCount != nil {
		return *m.RowCount
	}
	return 0
}

func (m *GroupByFieldResultItem) GetSubAggsResult() *AggregationsResult {
	if m != nil {
		return m.SubAggsResult
	}
	return nil
}

func (m *GroupByFieldResultItem) GetSubGroupBysResult() *GroupBysResult {
	if m != nil {
		return m.SubGroupBysResult
	}
	return nil
}

type GroupByFieldResult struct {
	GroupByFieldResultItems []*GroupByFieldResultItem `protobuf:"bytes,1,rep,name=group_by_field_result_items,json=groupByFieldResultItems" json:"group_by_field_result_items,omitempty"`
	XXX_NoUnkeyedLiteral    struct{}                  `json:"-"`
	XXX_unrecognized        []byte                    `json:"-"`
	XXX_sizecache           int32                     `json:"-"`
}

func (m *GroupByFieldResult) Reset()         { *m = GroupByFieldResult{} }
func (m *GroupByFieldResult) String() string { return proto.CompactTextString(m) }
func (*GroupByFieldResult) ProtoMessage()    {}
func (*GroupByFieldResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{112}
}

func (m *GroupByFieldResult) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GroupByFieldResult.Unmarshal(m, b)
}
func (m *GroupByFieldResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GroupByFieldResult.Marshal(b, m, deterministic)
}
func (m *GroupByFieldResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GroupByFieldResult.Merge(m, src)
}
func (m *GroupByFieldResult) XXX_Size() int {
	return xxx_messageInfo_GroupByFieldResult.Size(m)
}
func (m *GroupByFieldResult) XXX_DiscardUnknown() {
	xxx_messageInfo_GroupByFieldResult.DiscardUnknown(m)
}

var xxx_messageInfo_GroupByFieldResult proto.InternalMessageInfo

func (m *GroupByFieldResult) GetGroupByFieldResultItems() []*GroupByFieldResultItem {
	if m != nil {
		return m.GroupByFieldResultItems
	}
	return nil
}

type GroupByRangeResultItem struct {
	From                 *float64            `protobuf:"fixed64,1,opt,name=from" json:"from,omitempty"`
	To                   *float64            `protobuf:"fixed64,2,opt,name=to" json:"to,omitempty"`
	RowCount             *int64              `protobuf:"varint,3,opt,name=row_count,json=rowCount" json:"row_count,omitempty"`
	SubAggsResult        *AggregationsResult `protobuf:"bytes,4,opt,name=sub_aggs_result,json=subAggsResult" json:"sub_aggs_result,omitempty"`
	SubGroupBysResult    *GroupBysResult     `protobuf:"bytes,5,opt,name=sub_group_bys_result,json=subGroupBysResult" json:"sub_group_bys_result,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

func (m *GroupByRangeResultItem) Reset()         { *m = GroupByRangeResultItem{} }
func (m *GroupByRangeResultItem) String() string { return proto.CompactTextString(m) }
func (*GroupByRangeResultItem) ProtoMessage()    {}
func (*GroupByRangeResultItem) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{113}
}

func (m *GroupByRangeResultItem) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GroupByRangeResultItem.Unmarshal(m, b)
}
func (m *GroupByRangeResultItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GroupByRangeResultItem.Marshal(b, m, deterministic)
}
func (m *GroupByRangeResultItem) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GroupByRangeResultItem.Merge(m, src)
}
func (m *GroupByRangeResultItem) XXX_Size() int {
	return xxx_messageInfo_GroupByRangeResultItem.Size(m)
}
func (m *GroupByRangeResultItem) XXX_DiscardUnknown() {
	xxx_messageInfo_GroupByRangeResultItem.DiscardUnknown(m)
}

var xxx_messageInfo_GroupByRangeResultItem proto.InternalMessageInfo

func (m *GroupByRangeResultItem) GetFrom() float64 {
	if m != nil && m.From != nil {
		return *m.From
	}
	return 0
}

func (m *GroupByRangeResultItem) GetTo() float64 {
	if m != nil && m.To != nil {
		return *m.To
	}
	return 0
}

func (m *GroupByRangeResultItem) GetRowCount() int64 {
	if m != nil && m.RowCount != nil {
		return *m.RowCount
	}
	return 0
}

func (m *GroupByRangeResultItem) GetSubAggsResult() *AggregationsResult {
	if m != nil {
		return m.SubAggsResult
	}
	return nil
}

func (m *GroupByRangeResultItem) GetSubGroupBysResult() *GroupBysResult {
	if m != nil {
		return m.SubGroupBysResult
	}
	return nil
}

type GroupByRangeResult struct {
	GroupByRangeResultItems []*GroupByRangeResultItem `protobuf:"bytes,1,rep,name=group_by_range_result_items,json=groupByRangeResultItems" json:"group_by_range_result_items,omitempty"`
	XXX_NoUnkeyedLiteral    struct{}                  `json:"-"`
	XXX_unrecognized        []byte                    `json:"-"`
	XXX_sizecache           int32                     `json:"-"`
}

func (m *GroupByRangeResult) Reset()         { *m = GroupByRangeResult{} }
func (m *GroupByRangeResult) String() string { return proto.CompactTextString(m) }
func (*GroupByRangeResult) ProtoMessage()    {}
func (*GroupByRangeResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{114}
}

func (m *GroupByRangeResult) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GroupByRangeResult.Unmarshal(m, b)
}
func (m *GroupByRangeResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GroupByRangeResult.Marshal(b, m, deterministic)
}
func (m *GroupByRangeResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GroupByRangeResult.Merge(m, src)
}
func (m *GroupByRangeResult) XXX_Size() int {
	return xxx_messageInfo_GroupByRangeResult.Size(m)
}
func (m *GroupByRangeResult) XXX_DiscardUnknown() {
	xxx_messageInfo_GroupByRangeResult.DiscardUnknown(m)
}

var xxx_messageInfo_GroupByRangeResult proto.InternalMessageInfo

func (m *GroupByRangeResult) GetGroupByRangeResultItems() []*GroupByRangeResultItem {
	if m != nil {
		return m.GroupByRangeResultItems
	}
	return nil
}

type GroupByGeoDistanceResultItem struct {
	From                 *float64            `protobuf:"fixed64,1,opt,name=from" json:"from,omitempty"`
	To                   *float64            `protobuf:"fixed64,2,opt,name=to" json:"to,omitempty"`
	RowCount             *int64              `protobuf:"varint,3,opt,name=row_count,json=rowCount" json:"row_count,omitempty"`
	SubAggsResult        *AggregationsResult `protobuf:"bytes,4,opt,name=sub_aggs_result,json=subAggsResult" json:"sub_aggs_result,omitempty"`
	SubGroupBysResult    *GroupBysResult     `protobuf:"bytes,5,opt,name=sub_group_bys_result,json=subGroupBysResult" json:"sub_group_bys_result,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

func (m *GroupByGeoDistanceResultItem) Reset()         { *m = GroupByGeoDistanceResultItem{} }
func (m *GroupByGeoDistanceResultItem) String() string { return proto.CompactTextString(m) }
func (*GroupByGeoDistanceResultItem) ProtoMessage()    {}
func (*GroupByGeoDistanceResultItem) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{115}
}

func (m *GroupByGeoDistanceResultItem) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GroupByGeoDistanceResultItem.Unmarshal(m, b)
}
func (m *GroupByGeoDistanceResultItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GroupByGeoDistanceResultItem.Marshal(b, m, deterministic)
}
func (m *GroupByGeoDistanceResultItem) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GroupByGeoDistanceResultItem.Merge(m, src)
}
func (m *GroupByGeoDistanceResultItem) XXX_Size() int {
	return xxx_messageInfo_GroupByGeoDistanceResultItem.Size(m)
}
func (m *GroupByGeoDistanceResultItem) XXX_DiscardUnknown() {
	xxx_messageInfo_GroupByGeoDistanceResultItem.DiscardUnknown(m)
}

var xxx_messageInfo_GroupByGeoDistanceResultItem proto.InternalMessageInfo

func (m *GroupByGeoDistanceResultItem) GetFrom() float64 {
	if m != nil && m.From != nil {
		return *m.From
	}
	return 0
}

func (m *GroupByGeoDistanceResultItem) GetTo() float64 {
	if m != nil && m.To != nil {
		return *m.To
	}
	return 0
}

func (m *GroupByGeoDistanceResultItem) GetRowCount() int64 {
	if m != nil && m.RowCount != nil {
		return *m.RowCount
	}
	return 0
}

func (m *GroupByGeoDistanceResultItem) GetSubAggsResult() *AggregationsResult {
	if m != nil {
		return m.SubAggsResult
	}
	return nil
}

func (m *GroupByGeoDistanceResultItem) GetSubGroupBysResult() *GroupBysResult {
	if m != nil {
		return m.SubGroupBysResult
	}
	return nil
}

type GroupByGeoDistanceResult struct {
	GroupByGeoDistanceResultItems []*GroupByGeoDistanceResultItem `protobuf:"bytes,1,rep,name=group_by_geo_distance_result_items,json=groupByGeoDistanceResultItems" json:"group_by_geo_distance_result_items,omitempty"`
	XXX_NoUnkeyedLiteral          struct{}                        `json:"-"`
	XXX_unrecognized              []byte                          `json:"-"`
	XXX_sizecache                 int32                           `json:"-"`
}

func (m *GroupByGeoDistanceResult) Reset()         { *m = GroupByGeoDistanceResult{} }
func (m *GroupByGeoDistanceResult) String() string { return proto.CompactTextString(m) }
func (*GroupByGeoDistanceResult) ProtoMessage()    {}
func (*GroupByGeoDistanceResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{116}
}

func (m *GroupByGeoDistanceResult) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GroupByGeoDistanceResult.Unmarshal(m, b)
}
func (m *GroupByGeoDistanceResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GroupByGeoDistanceResult.Marshal(b, m, deterministic)
}
func (m *GroupByGeoDistanceResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GroupByGeoDistanceResult.Merge(m, src)
}
func (m *GroupByGeoDistanceResult) XXX_Size() int {
	return xxx_messageInfo_GroupByGeoDistanceResult.Size(m)
}
func (m *GroupByGeoDistanceResult) XXX_DiscardUnknown() {
	xxx_messageInfo_GroupByGeoDistanceResult.DiscardUnknown(m)
}

var xxx_messageInfo_GroupByGeoDistanceResult proto.InternalMessageInfo

func (m *GroupByGeoDistanceResult) GetGroupByGeoDistanceResultItems() []*GroupByGeoDistanceResultItem {
	if m != nil {
		return m.GroupByGeoDistanceResultItems
	}
	return nil
}

type GroupByFilterResultItem struct {
	RowCount             *int64              `protobuf:"varint,1,opt,name=row_count,json=rowCount" json:"row_count,omitempty"`
	SubAggsResult        *AggregationsResult `protobuf:"bytes,2,opt,name=sub_aggs_result,json=subAggsResult" json:"sub_aggs_result,omitempty"`
	SubGroupBysResult    *GroupBysResult     `protobuf:"bytes,3,opt,name=sub_group_bys_result,json=subGroupBysResult" json:"sub_group_bys_result,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

func (m *GroupByFilterResultItem) Reset()         { *m = GroupByFilterResultItem{} }
func (m *GroupByFilterResultItem) String() string { return proto.CompactTextString(m) }
func (*GroupByFilterResultItem) ProtoMessage()    {}
func (*GroupByFilterResultItem) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{117}
}

func (m *GroupByFilterResultItem) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GroupByFilterResultItem.Unmarshal(m, b)
}
func (m *GroupByFilterResultItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GroupByFilterResultItem.Marshal(b, m, deterministic)
}
func (m *GroupByFilterResultItem) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GroupByFilterResultItem.Merge(m, src)
}
func (m *GroupByFilterResultItem) XXX_Size() int {
	return xxx_messageInfo_GroupByFilterResultItem.Size(m)
}
func (m *GroupByFilterResultItem) XXX_DiscardUnknown() {
	xxx_messageInfo_GroupByFilterResultItem.DiscardUnknown(m)
}

var xxx_messageInfo_GroupByFilterResultItem proto.InternalMessageInfo

func (m *GroupByFilterResultItem) GetRowCount() int64 {
	if m != nil && m.RowCount != nil {
		return *m.RowCount
	}
	return 0
}

func (m *GroupByFilterResultItem) GetSubAggsResult() *AggregationsResult {
	if m != nil {
		return m.SubAggsResult
	}
	return nil
}

func (m *GroupByFilterResultItem) GetSubGroupBysResult() *GroupBysResult {
	if m != nil {
		return m.SubGroupBysResult
	}
	return nil
}

type GroupByFilterResult struct {
	GroupByFilterResultItems []*GroupByFilterResultItem `protobuf:"bytes,1,rep,name=group_by_filter_result_items,json=groupByFilterResultItems" json:"group_by_filter_result_items,omitempty"`
	XXX_NoUnkeyedLiteral     struct{}                   `json:"-"`
	XXX_unrecognized         []byte                     `json:"-"`
	XXX_sizecache            int32                      `json:"-"`
}

func (m *GroupByFilterResult) Reset()         { *m = GroupByFilterResult{} }
func (m *GroupByFilterResult) String() string { return proto.CompactTextString(m) }
func (*GroupByFilterResult) ProtoMessage()    {}
func (*GroupByFilterResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{118}
}

func (m *GroupByFilterResult) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GroupByFilterResult.Unmarshal(m, b)
}
func (m *GroupByFilterResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GroupByFilterResult.Marshal(b, m, deterministic)
}
func (m *GroupByFilterResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GroupByFilterResult.Merge(m, src)
}
func (m *GroupByFilterResult) XXX_Size() int {
	return xxx_messageInfo_GroupByFilterResult.Size(m)
}
func (m *GroupByFilterResult) XXX_DiscardUnknown() {
	xxx_messageInfo_GroupByFilterResult.DiscardUnknown(m)
}

var xxx_messageInfo_GroupByFilterResult proto.InternalMessageInfo

func (m *GroupByFilterResult) GetGroupByFilterResultItems() []*GroupByFilterResultItem {
	if m != nil {
		return m.GroupByFilterResultItems
	}
	return nil
}

type GroupByGeoGridResult struct {
	GroupByGeoGirdResultItems []*GroupByGeoGridResultItem `protobuf:"bytes,1,rep,name=group_by_geo_gird_result_items,json=groupByGeoGirdResultItems" json:"group_by_geo_gird_result_items,omitempty"`
	XXX_NoUnkeyedLiteral      struct{}                    `json:"-"`
	XXX_unrecognized          []byte                      `json:"-"`
	XXX_sizecache             int32                       `json:"-"`
}

func (m *GroupByGeoGridResult) Reset()         { *m = GroupByGeoGridResult{} }
func (m *GroupByGeoGridResult) String() string { return proto.CompactTextString(m) }
func (*GroupByGeoGridResult) ProtoMessage()    {}
func (*GroupByGeoGridResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{119}
}

func (m *GroupByGeoGridResult) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GroupByGeoGridResult.Unmarshal(m, b)
}
func (m *GroupByGeoGridResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GroupByGeoGridResult.Marshal(b, m, deterministic)
}
func (m *GroupByGeoGridResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GroupByGeoGridResult.Merge(m, src)
}
func (m *GroupByGeoGridResult) XXX_Size() int {
	return xxx_messageInfo_GroupByGeoGridResult.Size(m)
}
func (m *GroupByGeoGridResult) XXX_DiscardUnknown() {
	xxx_messageInfo_GroupByGeoGridResult.DiscardUnknown(m)
}

var xxx_messageInfo_GroupByGeoGridResult proto.InternalMessageInfo

func (m *GroupByGeoGridResult) GetGroupByGeoGirdResultItems() []*GroupByGeoGridResultItem {
	if m != nil {
		return m.GroupByGeoGirdResultItems
	}
	return nil
}

type GroupByGeoGridResultItem struct {
	Key                  *string             `protobuf:"bytes,1,opt,name=key" json:"key,omitempty"`
	GeoGrid              *GeoGrid            `protobuf:"bytes,2,opt,name=geo_grid,json=geoGrid" json:"geo_grid,omitempty"`
	RowCount             *int64              `protobuf:"varint,3,opt,name=row_count,json=rowCount" json:"row_count,omitempty"`
	SubAggsResult        *AggregationsResult `protobuf:"bytes,4,opt,name=sub_aggs_result,json=subAggsResult" json:"sub_aggs_result,omitempty"`
	SubGroupBysResult    *GroupBysResult     `protobuf:"bytes,5,opt,name=sub_group_bys_result,json=subGroupBysResult" json:"sub_group_bys_result,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

func (m *GroupByGeoGridResultItem) Reset()         { *m = GroupByGeoGridResultItem{} }
func (m *GroupByGeoGridResultItem) String() string { return proto.CompactTextString(m) }
func (*GroupByGeoGridResultItem) ProtoMessage()    {}
func (*GroupByGeoGridResultItem) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{120}
}

func (m *GroupByGeoGridResultItem) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GroupByGeoGridResultItem.Unmarshal(m, b)
}
func (m *GroupByGeoGridResultItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GroupByGeoGridResultItem.Marshal(b, m, deterministic)
}
func (m *GroupByGeoGridResultItem) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GroupByGeoGridResultItem.Merge(m, src)
}
func (m *GroupByGeoGridResultItem) XXX_Size() int {
	return xxx_messageInfo_GroupByGeoGridResultItem.Size(m)
}
func (m *GroupByGeoGridResultItem) XXX_DiscardUnknown() {
	xxx_messageInfo_GroupByGeoGridResultItem.DiscardUnknown(m)
}

var xxx_messageInfo_GroupByGeoGridResultItem proto.InternalMessageInfo

func (m *GroupByGeoGridResultItem) GetKey() string {
	if m != nil && m.Key != nil {
		return *m.Key
	}
	return ""
}

func (m *GroupByGeoGridResultItem) GetGeoGrid() *GeoGrid {
	if m != nil {
		return m.GeoGrid
	}
	return nil
}

func (m *GroupByGeoGridResultItem) GetRowCount() int64 {
	if m != nil && m.RowCount != nil {
		return *m.RowCount
	}
	return 0
}

func (m *GroupByGeoGridResultItem) GetSubAggsResult() *AggregationsResult {
	if m != nil {
		return m.SubAggsResult
	}
	return nil
}

func (m *GroupByGeoGridResultItem) GetSubGroupBysResult() *GroupBysResult {
	if m != nil {
		return m.SubGroupBysResult
	}
	return nil
}

type GroupByResult struct {
	Name                 *string      `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
	Type                 *GroupByType `protobuf:"varint,2,opt,name=type,enum=otsprotocol.GroupByType" json:"type,omitempty"`
	GroupByResult        []byte       `protobuf:"bytes,3,opt,name=group_by_result,json=groupByResult" json:"group_by_result,omitempty"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

func (m *GroupByResult) Reset()         { *m = GroupByResult{} }
func (m *GroupByResult) String() string { return proto.CompactTextString(m) }
func (*GroupByResult) ProtoMessage()    {}
func (*GroupByResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{121}
}

func (m *GroupByResult) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GroupByResult.Unmarshal(m, b)
}
func (m *GroupByResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GroupByResult.Marshal(b, m, deterministic)
}
func (m *GroupByResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GroupByResult.Merge(m, src)
}
func (m *GroupByResult) XXX_Size() int {
	return xxx_messageInfo_GroupByResult.Size(m)
}
func (m *GroupByResult) XXX_DiscardUnknown() {
	xxx_messageInfo_GroupByResult.DiscardUnknown(m)
}

var xxx_messageInfo_GroupByResult proto.InternalMessageInfo

func (m *GroupByResult) GetName() string {
	if m != nil && m.Name != nil {
		return *m.Name
	}
	return ""
}

func (m *GroupByResult) GetType() GroupByType {
	if m != nil && m.Type != nil {
		return *m.Type
	}
	return GroupByType_GROUP_BY_FIELD
}

func (m *GroupByResult) GetGroupByResult() []byte {
	if m != nil {
		return m.GroupByResult
	}
	return nil
}

type GroupBysResult struct {
	GroupByResults       []*GroupByResult `protobuf:"bytes,1,rep,name=group_by_results,json=groupByResults" json:"group_by_results,omitempty"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

func (m *GroupBysResult) Reset()         { *m = GroupBysResult{} }
func (m *GroupBysResult) String() string { return proto.CompactTextString(m) }
func (*GroupBysResult) ProtoMessage()    {}
func (*GroupBysResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{122}
}

func (m *GroupBysResult) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GroupBysResult.Unmarshal(m, b)
}
func (m *GroupBysResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GroupBysResult.Marshal(b, m, deterministic)
}
func (m *GroupBysResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GroupBysResult.Merge(m, src)
}
func (m *GroupBysResult) XXX_Size() int {
	return xxx_messageInfo_GroupBysResult.Size(m)
}
func (m *GroupBysResult) XXX_DiscardUnknown() {
	xxx_messageInfo_GroupBysResult.DiscardUnknown(m)
}

var xxx_messageInfo_GroupBysResult proto.InternalMessageInfo

func (m *GroupBysResult) GetGroupByResults() []*GroupByResult {
	if m != nil {
		return m.GroupByResults
	}
	return nil
}

type GroupByHistogramItem struct {
	Key                  []byte              `protobuf:"bytes,1,opt,name=key" json:"key,omitempty"`
	Value                *int64              `protobuf:"varint,2,opt,name=value" json:"value,omitempty"`
	SubAggsResult        *AggregationsResult `protobuf:"bytes,3,opt,name=sub_aggs_result,json=subAggsResult" json:"sub_aggs_result,omitempty"`
	SubGroupBysResult    *GroupBysResult     `protobuf:"bytes,4,opt,name=sub_group_bys_result,json=subGroupBysResult" json:"sub_group_bys_result,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

func (m *GroupByHistogramItem) Reset()         { *m = GroupByHistogramItem{} }
func (m *GroupByHistogramItem) String() string { return proto.CompactTextString(m) }
func (*GroupByHistogramItem) ProtoMessage()    {}
func (*GroupByHistogramItem) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{123}
}

func (m *GroupByHistogramItem) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GroupByHistogramItem.Unmarshal(m, b)
}
func (m *GroupByHistogramItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GroupByHistogramItem.Marshal(b, m, deterministic)
}
func (m *GroupByHistogramItem) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GroupByHistogramItem.Merge(m, src)
}
func (m *GroupByHistogramItem) XXX_Size() int {
	return xxx_messageInfo_GroupByHistogramItem.Size(m)
}
func (m *GroupByHistogramItem) XXX_DiscardUnknown() {
	xxx_messageInfo_GroupByHistogramItem.DiscardUnknown(m)
}

var xxx_messageInfo_GroupByHistogramItem proto.InternalMessageInfo

func (m *GroupByHistogramItem) GetKey() []byte {
	if m != nil {
		return m.Key
	}
	return nil
}

func (m *GroupByHistogramItem) GetValue() int64 {
	if m != nil && m.Value != nil {
		return *m.Value
	}
	return 0
}

func (m *GroupByHistogramItem) GetSubAggsResult() *AggregationsResult {
	if m != nil {
		return m.SubAggsResult
	}
	return nil
}

func (m *GroupByHistogramItem) GetSubGroupBysResult() *GroupBysResult {
	if m != nil {
		return m.SubGroupBysResult
	}
	return nil
}

type GroupByHistogramResult struct {
	GroupByHistograItems []*GroupByHistogramItem `protobuf:"bytes,1,rep,name=group_by_histogra_items,json=groupByHistograItems" json:"group_by_histogra_items,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

func (m *GroupByHistogramResult) Reset()         { *m = GroupByHistogramResult{} }
func (m *GroupByHistogramResult) String() string { return proto.CompactTextString(m) }
func (*GroupByHistogramResult) ProtoMessage()    {}
func (*GroupByHistogramResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{124}
}

func (m *GroupByHistogramResult) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GroupByHistogramResult.Unmarshal(m, b)
}
func (m *GroupByHistogramResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GroupByHistogramResult.Marshal(b, m, deterministic)
}
func (m *GroupByHistogramResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GroupByHistogramResult.Merge(m, src)
}
func (m *GroupByHistogramResult) XXX_Size() int {
	return xxx_messageInfo_GroupByHistogramResult.Size(m)
}
func (m *GroupByHistogramResult) XXX_DiscardUnknown() {
	xxx_messageInfo_GroupByHistogramResult.DiscardUnknown(m)
}

var xxx_messageInfo_GroupByHistogramResult proto.InternalMessageInfo

func (m *GroupByHistogramResult) GetGroupByHistograItems() []*GroupByHistogramItem {
	if m != nil {
		return m.GroupByHistograItems
	}
	return nil
}

type GroupByDateHistogramItem struct {
	Timestamp            *int64              `protobuf:"varint,1,opt,name=timestamp" json:"timestamp,omitempty"`
	RowCount             *int64              `protobuf:"varint,2,opt,name=row_count,json=rowCount" json:"row_count,omitempty"`
	SubAggsResult        *AggregationsResult `protobuf:"bytes,3,opt,name=sub_aggs_result,json=subAggsResult" json:"sub_aggs_result,omitempty"`
	SubGroupBysResult    *GroupBysResult     `protobuf:"bytes,4,opt,name=sub_group_bys_result,json=subGroupBysResult" json:"sub_group_bys_result,omitempty"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

func (m *GroupByDateHistogramItem) Reset()         { *m = GroupByDateHistogramItem{} }
func (m *GroupByDateHistogramItem) String() string { return proto.CompactTextString(m) }
func (*GroupByDateHistogramItem) ProtoMessage()    {}
func (*GroupByDateHistogramItem) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{125}
}

func (m *GroupByDateHistogramItem) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GroupByDateHistogramItem.Unmarshal(m, b)
}
func (m *GroupByDateHistogramItem) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GroupByDateHistogramItem.Marshal(b, m, deterministic)
}
func (m *GroupByDateHistogramItem) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GroupByDateHistogramItem.Merge(m, src)
}
func (m *GroupByDateHistogramItem) XXX_Size() int {
	return xxx_messageInfo_GroupByDateHistogramItem.Size(m)
}
func (m *GroupByDateHistogramItem) XXX_DiscardUnknown() {
	xxx_messageInfo_GroupByDateHistogramItem.DiscardUnknown(m)
}

var xxx_messageInfo_GroupByDateHistogramItem proto.InternalMessageInfo

func (m *GroupByDateHistogramItem) GetTimestamp() int64 {
	if m != nil && m.Timestamp != nil {
		return *m.Timestamp
	}
	return 0
}

func (m *GroupByDateHistogramItem) GetRowCount() int64 {
	if m != nil && m.RowCount != nil {
		return *m.RowCount
	}
	return 0
}

func (m *GroupByDateHistogramItem) GetSubAggsResult() *AggregationsResult {
	if m != nil {
		return m.SubAggsResult
	}
	return nil
}

func (m *GroupByDateHistogramItem) GetSubGroupBysResult() *GroupBysResult {
	if m != nil {
		return m.SubGroupBysResult
	}
	return nil
}

type GroupByDateHistogramResult struct {
	GroupByDateHistogramItems []*GroupByDateHistogramItem `protobuf:"bytes,1,rep,name=group_by_date_histogram_items,json=groupByDateHistogramItems" json:"group_by_date_histogram_items,omitempty"`
	XXX_NoUnkeyedLiteral      struct{}                    `json:"-"`
	XXX_unrecognized          []byte                      `json:"-"`
	XXX_sizecache             int32                       `json:"-"`
}

func (m *GroupByDateHistogramResult) Reset()         { *m = GroupByDateHistogramResult{} }
func (m *GroupByDateHistogramResult) String() string { return proto.CompactTextString(m) }
func (*GroupByDateHistogramResult) ProtoMessage()    {}
func (*GroupByDateHistogramResult) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{126}
}

func (m *GroupByDateHistogramResult) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_GroupByDateHistogramResult.Unmarshal(m, b)
}
func (m *GroupByDateHistogramResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_GroupByDateHistogramResult.Marshal(b, m, deterministic)
}
func (m *GroupByDateHistogramResult) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GroupByDateHistogramResult.Merge(m, src)
}
func (m *GroupByDateHistogramResult) XXX_Size() int {
	return xxx_messageInfo_GroupByDateHistogramResult.Size(m)
}
func (m *GroupByDateHistogramResult) XXX_DiscardUnknown() {
	xxx_messageInfo_GroupByDateHistogramResult.DiscardUnknown(m)
}

var xxx_messageInfo_GroupByDateHistogramResult proto.InternalMessageInfo

func (m *GroupByDateHistogramResult) GetGroupByDateHistogramItems() []*GroupByDateHistogramItem {
	if m != nil {
		return m.GroupByDateHistogramItems
	}
	return nil
}

// ParallelScan API, same to Search API
type ScanQuery struct {
	Query                *Query   `protobuf:"bytes,1,opt,name=query" json:"query,omitempty"`
	Limit                *int32   `protobuf:"varint,2,opt,name=limit" json:"limit,omitempty"`
	AliveTime            *int32   `protobuf:"varint,3,opt,name=alive_time,json=aliveTime" json:"alive_time,omitempty"`
	Token                []byte   `protobuf:"bytes,4,opt,name=token" json:"token,omitempty"`
	CurrentParallelId    *int32   `protobuf:"varint,5,opt,name=current_parallel_id,json=currentParallelId" json:"current_parallel_id,omitempty"`
	MaxParallel          *int32   `protobuf:"varint,6,opt,name=max_parallel,json=maxParallel" json:"max_parallel,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ScanQuery) Reset()         { *m = ScanQuery{} }
func (m *ScanQuery) String() string { return proto.CompactTextString(m) }
func (*ScanQuery) ProtoMessage()    {}
func (*ScanQuery) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{127}
}

func (m *ScanQuery) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ScanQuery.Unmarshal(m, b)
}
func (m *ScanQuery) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ScanQuery.Marshal(b, m, deterministic)
}
func (m *ScanQuery) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ScanQuery.Merge(m, src)
}
func (m *ScanQuery) XXX_Size() int {
	return xxx_messageInfo_ScanQuery.Size(m)
}
func (m *ScanQuery) XXX_DiscardUnknown() {
	xxx_messageInfo_ScanQuery.DiscardUnknown(m)
}

var xxx_messageInfo_ScanQuery proto.InternalMessageInfo

func (m *ScanQuery) GetQuery() *Query {
	if m != nil {
		return m.Query
	}
	return nil
}

func (m *ScanQuery) GetLimit() int32 {
	if m != nil && m.Limit != nil {
		return *m.Limit
	}
	return 0
}

func (m *ScanQuery) GetAliveTime() int32 {
	if m != nil && m.AliveTime != nil {
		return *m.AliveTime
	}
	return 0
}

func (m *ScanQuery) GetToken() []byte {
	if m != nil {
		return m.Token
	}
	return nil
}

func (m *ScanQuery) GetCurrentParallelId() int32 {
	if m != nil && m.CurrentParallelId != nil {
		return *m.CurrentParallelId
	}
	return 0
}

func (m *ScanQuery) GetMaxParallel() int32 {
	if m != nil && m.MaxParallel != nil {
		return *m.MaxParallel
	}
	return 0
}

type ParallelScanRequest struct {
	TableName            *string       `protobuf:"bytes,1,opt,name=table_name,json=tableName" json:"table_name,omitempty"`
	IndexName            *string       `protobuf:"bytes,2,opt,name=index_name,json=indexName" json:"index_name,omitempty"`
	ColumnsToGet         *ColumnsToGet `protobuf:"bytes,3,opt,name=columns_to_get,json=columnsToGet" json:"columns_to_get,omitempty"`
	SessionId            []byte        `protobuf:"bytes,4,opt,name=session_id,json=sessionId" json:"session_id,omitempty"`
	ScanQuery            []byte        `protobuf:"bytes,5,opt,name=scan_query,json=scanQuery" json:"scan_query,omitempty"`
	TimeoutMs            *int32        `protobuf:"varint,6,opt,name=timeoutMs" json:"timeoutMs,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

func (m *ParallelScanRequest) Reset()         { *m = ParallelScanRequest{} }
func (m *ParallelScanRequest) String() string { return proto.CompactTextString(m) }
func (*ParallelScanRequest) ProtoMessage()    {}
func (*ParallelScanRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{128}
}

func (m *ParallelScanRequest) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ParallelScanRequest.Unmarshal(m, b)
}
func (m *ParallelScanRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ParallelScanRequest.Marshal(b, m, deterministic)
}
func (m *ParallelScanRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ParallelScanRequest.Merge(m, src)
}
func (m *ParallelScanRequest) XXX_Size() int {
	return xxx_messageInfo_ParallelScanRequest.Size(m)
}
func (m *ParallelScanRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_ParallelScanRequest.DiscardUnknown(m)
}

var xxx_messageInfo_ParallelScanRequest proto.InternalMessageInfo

func (m *ParallelScanRequest) GetTableName() string {
	if m != nil && m.TableName != nil {
		return *m.TableName
	}
	return ""
}

func (m *ParallelScanRequest) GetIndexName() string {
	if m != nil && m.IndexName != nil {
		return *m.IndexName
	}
	return ""
}

func (m *ParallelScanRequest) GetColumnsToGet() *ColumnsToGet {
	if m != nil {
		return m.ColumnsToGet
	}
	return nil
}

func (m *ParallelScanRequest) GetSessionId() []byte {
	if m != nil {
		return m.SessionId
	}
	return nil
}

func (m *ParallelScanRequest) GetScanQuery() []byte {
	if m != nil {
		return m.ScanQuery
	}
	return nil
}

func (m *ParallelScanRequest) GetTimeoutMs() int32 {
	if m != nil && m.TimeoutMs != nil {
		return *m.TimeoutMs
	}
	return 0
}

type ParallelScanResponse struct {
	Rows                 [][]byte `protobuf:"bytes,1,rep,name=rows" json:"rows,omitempty"`
	NextToken            []byte   `protobuf:"bytes,2,opt,name=next_token,json=nextToken" json:"next_token,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *ParallelScanResponse) Reset()         { *m = ParallelScanResponse{} }
func (m *ParallelScanResponse) String() string { return proto.CompactTextString(m) }
func (*ParallelScanResponse) ProtoMessage()    {}
func (*ParallelScanResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_453745cff914010e, []int{129}
}

func (m *ParallelScanResponse) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_ParallelScanResponse.Unmarshal(m, b)
}
func (m *ParallelScanResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_ParallelScanResponse.Marshal(b, m, deterministic)
}
func (m *ParallelScanResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ParallelScanResponse.Merge(m, src)
}
func (m *ParallelScanResponse) XXX_Size() int {
	return xxx_messageInfo_ParallelScanResponse.Size(m)
}
func (m *ParallelScanResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_ParallelScanResponse.DiscardUnknown(m)
}

var xxx_messageInfo_ParallelScanResponse proto.InternalMessageInfo

func (m *ParallelScanResponse) GetRows() [][]byte {
	if m != nil {
		return m.Rows
	}
	return nil
}

func (m *ParallelScanResponse) GetNextToken() []byte {
	if m != nil {
		return m.NextToken
	}
	return nil
}

func init() {
	proto.RegisterEnum("otsprotocol.QueryType", QueryType_name, QueryType_value)
	proto.RegisterEnum("otsprotocol.QueryOperator", QueryOperator_name, QueryOperator_value)
	proto.RegisterEnum("otsprotocol.FunctionModifier", FunctionModifier_name, FunctionModifier_value)
	proto.RegisterEnum("otsprotocol.DecayFuncParamType", DecayFuncParamType_name, DecayFuncParamType_value)
	proto.RegisterEnum("otsprotocol.DecayMathFunction", DecayMathFunction_name, DecayMathFunction_value)
	proto.RegisterEnum("otsprotocol.MultiValueMode", MultiValueMode_name, MultiValueMode_value)
	proto.RegisterEnum("otsprotocol.FunctionScoreMode", FunctionScoreMode_name, FunctionScoreMode_value)
	proto.RegisterEnum("otsprotocol.FunctionCombineMode", FunctionCombineMode_name, FunctionCombineMode_value)
	proto.RegisterEnum("otsprotocol.ScoreMode", ScoreMode_name, ScoreMode_value)
	proto.RegisterEnum("otsprotocol.SortOrder", SortOrder_name, SortOrder_value)
	proto.RegisterEnum("otsprotocol.SortMode", SortMode_name, SortMode_value)
	proto.RegisterEnum("otsprotocol.GeoDistanceType", GeoDistanceType_name, GeoDistanceType_value)
	proto.RegisterEnum("otsprotocol.HighlightFragmentOrder", HighlightFragmentOrder_name, HighlightFragmentOrder_value)
	proto.RegisterEnum("otsprotocol.HighlightEncoder", HighlightEncoder_name, HighlightEncoder_value)
	proto.RegisterEnum("otsprotocol.ColumnReturnType", ColumnReturnType_name, ColumnReturnType_value)
	proto.RegisterEnum("otsprotocol.IndexOptions", IndexOptions_name, IndexOptions_value)
	proto.RegisterEnum("otsprotocol.FieldType", FieldType_name, FieldType_value)
	proto.RegisterEnum("otsprotocol.DateTimeUnit", DateTimeUnit_name, DateTimeUnit_value)
	proto.RegisterEnum("otsprotocol.VectorDataType", VectorDataType_name, VectorDataType_value)
	proto.RegisterEnum("otsprotocol.VectorMetricType", VectorMetricType_name, VectorMetricType_value)
	proto.RegisterEnum("otsprotocol.SyncPhase", SyncPhase_name, SyncPhase_value)
	proto.RegisterEnum("otsprotocol.AggregationType", AggregationType_name, AggregationType_value)
	proto.RegisterEnum("otsprotocol.GroupByType", GroupByType_name, GroupByType_value)
	proto.RegisterEnum("otsprotocol.GeoHashPrecision", GeoHashPrecision_name, GeoHashPrecision_value)
	proto.RegisterType((*MatchQuery)(nil), "otsprotocol.MatchQuery")
	proto.RegisterType((*MatchPhraseQuery)(nil), "otsprotocol.MatchPhraseQuery")
	proto.RegisterType((*MatchAllQuery)(nil), "otsprotocol.MatchAllQuery")
	proto.RegisterType((*TermQuery)(nil), "otsprotocol.TermQuery")
	proto.RegisterType((*TermsQuery)(nil), "otsprotocol.TermsQuery")
	proto.RegisterType((*RangeQuery)(nil), "otsprotocol.RangeQuery")
	proto.RegisterType((*PrefixQuery)(nil), "otsprotocol.PrefixQuery")
	proto.RegisterType((*WildcardQuery)(nil), "otsprotocol.WildcardQuery")
	proto.RegisterType((*BoolQuery)(nil), "otsprotocol.BoolQuery")
	proto.RegisterType((*ConstScoreQuery)(nil), "otsprotocol.ConstScoreQuery")
	proto.RegisterType((*FieldValueFactor)(nil), "otsprotocol.FieldValueFactor")
	proto.RegisterType((*FunctionScoreQuery)(nil), "otsprotocol.FunctionScoreQuery")
	proto.RegisterType((*FunctionsScoreQuery)(nil), "otsprotocol.FunctionsScoreQuery")
	proto.RegisterType((*Function)(nil), "otsprotocol.Function")
	proto.RegisterType((*FieldValueFactorFunction)(nil), "otsprotocol.FieldValueFactorFunction")
	proto.RegisterType((*DecayFunction)(nil), "otsprotocol.DecayFunction")
	proto.RegisterType((*DecayFuncDateParam)(nil), "otsprotocol.DecayFuncDateParam")
	proto.RegisterType((*DecayFuncNumericParam)(nil), "otsprotocol.DecayFuncNumericParam")
	proto.RegisterType((*DecayFuncGeoParam)(nil), "otsprotocol.DecayFuncGeoParam")
	proto.RegisterType((*RandomScoreFunction)(nil), "otsprotocol.RandomScoreFunction")
	proto.RegisterType((*NestedQuery)(nil), "otsprotocol.NestedQuery")
	proto.RegisterType((*InnerHits)(nil), "otsprotocol.InnerHits")
	proto.RegisterType((*GeoBoundingBoxQuery)(nil), "otsprotocol.GeoBoundingBoxQuery")
	proto.RegisterType((*GeoDistanceQuery)(nil), "otsprotocol.GeoDistanceQuery")
	proto.RegisterType((*GeoPolygonQuery)(nil), "otsprotocol.GeoPolygonQuery")
	proto.RegisterType((*ExistsQuery)(nil), "otsprotocol.ExistsQuery")
	proto.RegisterType((*KnnVectorQuery)(nil), "otsprotocol.KnnVectorQuery")
	proto.RegisterType((*Query)(nil), "otsprotocol.Query")
	proto.RegisterType((*Collapse)(nil), "otsprotocol.Collapse")
	proto.RegisterType((*NestedFilter)(nil), "otsprotocol.NestedFilter")
	proto.RegisterType((*DocSort)(nil), "otsprotocol.DocSort")
	proto.RegisterType((*ScoreSort)(nil), "otsprotocol.ScoreSort")
	proto.RegisterType((*FieldSort)(nil), "otsprotocol.FieldSort")
	proto.RegisterType((*GeoDistanceSort)(nil), "otsprotocol.GeoDistanceSort")
	proto.RegisterType((*PrimaryKeySort)(nil), "otsprotocol.PrimaryKeySort")
	proto.RegisterType((*Sorter)(nil), "otsprotocol.Sorter")
	proto.RegisterType((*Sort)(nil), "otsprotocol.Sort")
	proto.RegisterType((*SearchQuery)(nil), "otsprotocol.SearchQuery")
	proto.RegisterType((*Highlight)(nil), "otsprotocol.Highlight")
	proto.RegisterType((*HighlightParameter)(nil), "otsprotocol.HighlightParameter")
	proto.RegisterType((*ColumnsToGet)(nil), "otsprotocol.ColumnsToGet")
	proto.RegisterType((*SearchRequest)(nil), "otsprotocol.SearchRequest")
	proto.RegisterType((*SearchResponse)(nil), "otsprotocol.SearchResponse")
	proto.RegisterType((*SearchHit)(nil), "otsprotocol.SearchHit")
	proto.RegisterType((*SearchInnerHit)(nil), "otsprotocol.SearchInnerHit")
	proto.RegisterType((*HighlightResult)(nil), "otsprotocol.HighlightResult")
	proto.RegisterType((*HighlightField)(nil), "otsprotocol.HighlightField")
	proto.RegisterType((*DateTimeValue)(nil), "otsprotocol.DateTimeValue")
	proto.RegisterType((*SingleWordAnalyzerParameter)(nil), "otsprotocol.SingleWordAnalyzerParameter")
	proto.RegisterType((*SplitAnalyzerParameter)(nil), "otsprotocol.SplitAnalyzerParameter")
	proto.RegisterType((*FuzzyAnalyzerParameter)(nil), "otsprotocol.FuzzyAnalyzerParameter")
	proto.RegisterType((*FieldSchema)(nil), "otsprotocol.FieldSchema")
	proto.RegisterType((*VectorOptions)(nil), "otsprotocol.VectorOptions")
	proto.RegisterType((*IndexSchema)(nil), "otsprotocol.IndexSchema")
	proto.RegisterType((*IndexSetting)(nil), "otsprotocol.IndexSetting")
	proto.RegisterType((*CreateSearchIndexRequest)(nil), "otsprotocol.CreateSearchIndexRequest")
	proto.RegisterType((*CreateSearchIndexResponse)(nil), "otsprotocol.CreateSearchIndexResponse")
	proto.RegisterType((*QueryFlowWeight)(nil), "otsprotocol.QueryFlowWeight")
	proto.RegisterType((*UpdateSearchIndexRequest)(nil), "otsprotocol.UpdateSearchIndexRequest")
	proto.RegisterType((*UpdateSearchIndexResponse)(nil), "otsprotocol.UpdateSearchIndexResponse")
	proto.RegisterType((*IndexInfo)(nil), "otsprotocol.IndexInfo")
	proto.RegisterType((*ListSearchIndexRequest)(nil), "otsprotocol.ListSearchIndexRequest")
	proto.RegisterType((*ListSearchIndexResponse)(nil), "otsprotocol.ListSearchIndexResponse")
	proto.RegisterType((*DeleteSearchIndexRequest)(nil), "otsprotocol.DeleteSearchIndexRequest")
	proto.RegisterType((*DeleteSearchIndexResponse)(nil), "otsprotocol.DeleteSearchIndexResponse")
	proto.RegisterType((*SyncStat)(nil), "otsprotocol.SyncStat")
	proto.RegisterType((*MeteringInfo)(nil), "otsprotocol.MeteringInfo")
	proto.RegisterType((*DescribeSearchIndexRequest)(nil), "otsprotocol.DescribeSearchIndexRequest")
	proto.RegisterType((*DescribeSearchIndexResponse)(nil), "otsprotocol.DescribeSearchIndexResponse")
	proto.RegisterType((*Aggregation)(nil), "otsprotocol.Aggregation")
	proto.RegisterType((*Aggregations)(nil), "otsprotocol.Aggregations")
	proto.RegisterType((*GroupBy)(nil), "otsprotocol.GroupBy")
	proto.RegisterType((*GroupBys)(nil), "otsprotocol.GroupBys")
	proto.RegisterType((*AvgAggregation)(nil), "otsprotocol.AvgAggregation")
	proto.RegisterType((*MaxAggregation)(nil), "otsprotocol.MaxAggregation")
	proto.RegisterType((*MinAggregation)(nil), "otsprotocol.MinAggregation")
	proto.RegisterType((*SumAggregation)(nil), "otsprotocol.SumAggregation")
	proto.RegisterType((*CountAggregation)(nil), "otsprotocol.CountAggregation")
	proto.RegisterType((*DistinctCountAggregation)(nil), "otsprotocol.DistinctCountAggregation")
	proto.RegisterType((*TopRowsAggregation)(nil), "otsprotocol.TopRowsAggregation")
	proto.RegisterType((*PercentilesAggregation)(nil), "otsprotocol.PercentilesAggregation")
	proto.RegisterType((*FieldRange)(nil), "otsprotocol.FieldRange")
	proto.RegisterType((*GroupByDateHistogram)(nil), "otsprotocol.GroupByDateHistogram")
	proto.RegisterType((*GroupByHistogram)(nil), "otsprotocol.GroupByHistogram")
	proto.RegisterType((*GroupKeySort)(nil), "otsprotocol.GroupKeySort")
	proto.RegisterType((*RowCountSort)(nil), "otsprotocol.RowCountSort")
	proto.RegisterType((*SubAggSort)(nil), "otsprotocol.SubAggSort")
	proto.RegisterType((*GroupBySorter)(nil), "otsprotocol.GroupBySorter")
	proto.RegisterType((*GroupBySort)(nil), "otsprotocol.GroupBySort")
	proto.RegisterType((*GroupByComposite)(nil), "otsprotocol.GroupByComposite")
	proto.RegisterType((*GroupByCompositeResultItem)(nil), "otsprotocol.GroupByCompositeResultItem")
	proto.RegisterType((*GroupByCompositeResult)(nil), "otsprotocol.GroupByCompositeResult")
	proto.RegisterType((*GroupByField)(nil), "otsprotocol.GroupByField")
	proto.RegisterType((*Range)(nil), "otsprotocol.Range")
	proto.RegisterType((*GroupByRange)(nil), "otsprotocol.GroupByRange")
	proto.RegisterType((*GroupByFilter)(nil), "otsprotocol.GroupByFilter")
	proto.RegisterType((*GeoPoint)(nil), "otsprotocol.GeoPoint")
	proto.RegisterType((*GroupByGeoDistance)(nil), "otsprotocol.GroupByGeoDistance")
	proto.RegisterType((*GroupByGeoGrid)(nil), "otsprotocol.GroupByGeoGrid")
	proto.RegisterType((*GeoGrid)(nil), "otsprotocol.GeoGrid")
	proto.RegisterType((*AvgAggregationResult)(nil), "otsprotocol.AvgAggregationResult")
	proto.RegisterType((*DistinctCountAggregationResult)(nil), "otsprotocol.DistinctCountAggregationResult")
	proto.RegisterType((*MaxAggregationResult)(nil), "otsprotocol.MaxAggregationResult")
	proto.RegisterType((*MinAggregationResult)(nil), "otsprotocol.MinAggregationResult")
	proto.RegisterType((*SumAggregationResult)(nil), "otsprotocol.SumAggregationResult")
	proto.RegisterType((*CountAggregationResult)(nil), "otsprotocol.CountAggregationResult")
	proto.RegisterType((*TopRowsAggregationResult)(nil), "otsprotocol.TopRowsAggregationResult")
	proto.RegisterType((*PercentilesAggregationItem)(nil), "otsprotocol.PercentilesAggregationItem")
	proto.RegisterType((*PercentilesAggregationResult)(nil), "otsprotocol.PercentilesAggregationResult")
	proto.RegisterType((*AggregationResult)(nil), "otsprotocol.AggregationResult")
	proto.RegisterType((*AggregationsResult)(nil), "otsprotocol.AggregationsResult")
	proto.RegisterType((*GroupByFieldResultItem)(nil), "otsprotocol.GroupByFieldResultItem")
	proto.RegisterType((*GroupByFieldResult)(nil), "otsprotocol.GroupByFieldResult")
	proto.RegisterType((*GroupByRangeResultItem)(nil), "otsprotocol.GroupByRangeResultItem")
	proto.RegisterType((*GroupByRangeResult)(nil), "otsprotocol.GroupByRangeResult")
	proto.RegisterType((*GroupByGeoDistanceResultItem)(nil), "otsprotocol.GroupByGeoDistanceResultItem")
	proto.RegisterType((*GroupByGeoDistanceResult)(nil), "otsprotocol.GroupByGeoDistanceResult")
	proto.RegisterType((*GroupByFilterResultItem)(nil), "otsprotocol.GroupByFilterResultItem")
	proto.RegisterType((*GroupByFilterResult)(nil), "otsprotocol.GroupByFilterResult")
	proto.RegisterType((*GroupByGeoGridResult)(nil), "otsprotocol.GroupByGeoGridResult")
	proto.RegisterType((*GroupByGeoGridResultItem)(nil), "otsprotocol.GroupByGeoGridResultItem")
	proto.RegisterType((*GroupByResult)(nil), "otsprotocol.GroupByResult")
	proto.RegisterType((*GroupBysResult)(nil), "otsprotocol.GroupBysResult")
	proto.RegisterType((*GroupByHistogramItem)(nil), "otsprotocol.GroupByHistogramItem")
	proto.RegisterType((*GroupByHistogramResult)(nil), "otsprotocol.GroupByHistogramResult")
	proto.RegisterType((*GroupByDateHistogramItem)(nil), "otsprotocol.GroupByDateHistogramItem")
	proto.RegisterType((*GroupByDateHistogramResult)(nil), "otsprotocol.GroupByDateHistogramResult")
	proto.RegisterType((*ScanQuery)(nil), "otsprotocol.ScanQuery")
	proto.RegisterType((*ParallelScanRequest)(nil), "otsprotocol.ParallelScanRequest")
	proto.RegisterType((*ParallelScanResponse)(nil), "otsprotocol.ParallelScanResponse")
}

func init() { proto.RegisterFile("search.proto", fileDescriptor_453745cff914010e) }

var fileDescriptor_453745cff914010e = []byte{
	// 6482 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe4, 0x7c, 0x4b, 0x8c, 0x1b, 0x49,
	0x72, 0xe8, 0x16, 0x3f, 0x4d, 0x32, 0xf8, 0xe9, 0xea, 0x52, 0xab, 0xd5, 0x92, 0x46, 0x33, 0x9a,
	0x9a, 0x9d, 0xb7, 0xda, 0x5e, 0xad, 0xa6, 0xd5, 0x23, 0x69, 0xa6, 0xf7, 0xcd, 0x07, 0x14, 0x3f,
	0xdd, 0x7c, 0x6a, 0x7e, 0x94, 0x64, 0x6b, 0x34, 0xfb, 0xde, 0x43, 0xa1, 0x44, 0x66, 0xb3, 0xcb,
	0x22, 0xab, 0x38, 0x55, 0x45, 0x49, 0x3d, 0xbe, 0x18, 0x06, 0xd6, 0x97, 0x85, 0x7f, 0xb0, 0xbd,
	0x80, 0xe1, 0xd3, 0x1a, 0xc6, 0xae, 0x7d, 0xb1, 0x01, 0x5f, 0x0c, 0x5f, 0x0c, 0x5f, 0x6d, 0xd8,
	0x27, 0xc3, 0x80, 0x7d, 0xb1, 0x7d, 0xf0, 0xd1, 0x87, 0xf5, 0xc5, 0x37, 0x7f, 0x90, 0x91, 0x99,
	0xc5, 0x2a, 0xb2, 0xba, 0x9b, 0xd2, 0x0a, 0xeb, 0x5d, 0xf8, 0x42, 0x54, 0x46, 0x44, 0x46, 0xc6,
	0x2f, 0x23, 0x23, 0xb3, 0xb2, 0x08, 0x05, 0x8f, 0x9a, 0x6e, 0xff, 0xf8, 0xd6, 0xc4, 0x75, 0x7c,
	0x47, 0xcb, 0x3b, 0xbe, 0x87, 0x4f, 0x7d, 0x67, 0x74, 0x65, 0xcd, 0x37, 0x9f, 0x8c, 0xa8, 0xe1,
	0xf9, 0x8e, 0x4b, 0x39, 0x5e, 0xff, 0x03, 0x05, 0xa0, 0x69, 0xfa, 0xfd, 0xe3, 0x87, 0x53, 0xea,
	0x9e, 0x68, 0xd7, 0x00, 0x8e, 0x2c, 0x3a, 0x1a, 0x18, 0xb6, 0x39, 0xa6, 0x9b, 0xca, 0x75, 0xe5,
	0x46, 0x8e, 0xe4, 0x10, 0xd2, 0x32, 0xc7, 0x54, 0xd3, 0x20, 0xe5, 0xd3, 0x17, 0xfe, 0x66, 0x02,
	0x11, 0xf8, 0xac, 0x6d, 0xc3, 0xfa, 0xd8, 0xb2, 0xad, 0xf1, 0x74, 0x6c, 0x78, 0xc7, 0xce, 0x74,
	0x34, 0x30, 0xc6, 0x8c, 0xdf, 0x66, 0xf2, 0xba, 0x72, 0x23, 0x4d, 0x34, 0x81, 0xeb, 0x22, 0x0a,
	0x47, 0xd2, 0xee, 0x41, 0xd6, 0x99, 0x50, 0xd7, 0xf4, 0x1d, 0x77, 0x33, 0x75, 0x5d, 0xb9, 0x51,
	0xda, 0xb9, 0x72, 0x2b, 0x24, 0xe6, 0x2d, 0x14, 0xa5, 0x2d, 0x28, 0x48, 0x40, 0xab, 0xd7, 0x40,
	0x45, 0x06, 0x9d, 0x63, 0xd7, 0xf4, 0xe8, 0xab, 0x0a, 0xac, 0xaf, 0x42, 0x11, 0xd9, 0x94, 0x47,
	0x23, 0xe4, 0xa1, 0x7f, 0x02, 0xb9, 0x1e, 0x75, 0xc7, 0xcb, 0x33, 0x74, 0xc7, 0xc8, 0xb0, 0x40,
	0xf0, 0x59, 0x2f, 0x03, 0xb0, 0xfe, 0xde, 0x52, 0x0c, 0xd6, 0x21, 0xcd, 0x3a, 0x79, 0x9b, 0x89,
	0xeb, 0xc9, 0x1b, 0x05, 0xc2, 0x1b, 0xfa, 0x1f, 0x29, 0x00, 0xc4, 0xb4, 0x87, 0xcb, 0x69, 0x75,
	0x0d, 0xc0, 0x65, 0xc4, 0xc6, 0x91, 0xeb, 0x48, 0x51, 0x72, 0x08, 0xa9, 0xbb, 0xce, 0x58, 0xbb,
	0x0c, 0x59, 0x8e, 0xf6, 0x1d, 0xf4, 0x42, 0x81, 0x64, 0xb0, 0xdd, 0x73, 0xb4, 0x77, 0xa0, 0x68,
	0xd9, 0xfd, 0xd1, 0x74, 0x40, 0x8d, 0x91, 0xf3, 0x9c, 0x72, 0xfb, 0x67, 0x49, 0x41, 0x00, 0x0f,
	0x18, 0x2c, 0x4c, 0x34, 0x9d, 0x4c, 0xa8, 0xbb, 0x99, 0x8e, 0x10, 0x1d, 0x32, 0x98, 0x5e, 0x85,
	0x7c, 0xc7, 0xa5, 0x47, 0xd6, 0x8b, 0xa5, 0x24, 0xde, 0x80, 0x95, 0x09, 0x52, 0x0b, 0x4f, 0x88,
	0x96, 0x5e, 0x85, 0xe2, 0x67, 0xd6, 0x68, 0xd0, 0x37, 0xdd, 0xc1, 0xb2, 0xd6, 0x7b, 0x66, 0x8e,
	0xa6, 0x54, 0xb0, 0xe1, 0x0d, 0xfd, 0xf7, 0x13, 0x90, 0xbb, 0xef, 0x38, 0xdc, 0x9d, 0xda, 0x5d,
	0x28, 0x8c, 0xa7, 0x9e, 0x6f, 0x7c, 0x31, 0xa5, 0xae, 0x45, 0xbd, 0x4d, 0xe5, 0x7a, 0xf2, 0x46,
	0x7e, 0x47, 0x5b, 0x0c, 0x31, 0x92, 0x67, 0x74, 0x0f, 0x39, 0x99, 0xf6, 0x11, 0xa8, 0xd8, 0xcd,
	0x76, 0x66, 0x5d, 0x13, 0xa7, 0x76, 0x2d, 0x31, 0xda, 0x96, 0x13, 0xf4, 0xde, 0x85, 0xd2, 0x91,
	0x35, 0xf2, 0xa9, 0x1b, 0xf4, 0x4d, 0x9e, 0xda, 0xb7, 0xc8, 0x29, 0x43, 0x5d, 0xc5, 0xc4, 0x91,
	0x5d, 0x53, 0xa7, 0x77, 0xe5, 0x94, 0xb2, 0xeb, 0x69, 0x73, 0x2f, 0x7d, 0xda, 0xdc, 0xd3, 0x3f,
	0x86, 0xd5, 0x8a, 0x63, 0x7b, 0x7e, 0xb7, 0xef, 0xb8, 0x22, 0xd8, 0xb6, 0x60, 0x85, 0x0b, 0x84,
	0xe6, 0x8e, 0x1f, 0x57, 0x50, 0xe8, 0xb7, 0x41, 0xad, 0x33, 0x67, 0x3c, 0x62, 0x76, 0xaf, 0x9b,
	0x7d, 0xdf, 0x71, 0xcf, 0x71, 0x99, 0xfe, 0x5d, 0x05, 0xb4, 0xfa, 0xd4, 0xee, 0xfb, 0x96, 0x63,
	0x87, 0x46, 0xbd, 0x01, 0x69, 0xa6, 0xee, 0xc9, 0x19, 0x83, 0x72, 0x02, 0xed, 0x01, 0x68, 0x9c,
	0x3f, 0x3a, 0xdb, 0x38, 0xc2, 0x51, 0x31, 0x00, 0xf2, 0x3b, 0xd7, 0x22, 0xdd, 0xe6, 0x45, 0x23,
	0xea, 0xd1, 0x1c, 0x44, 0xff, 0xe3, 0x04, 0x5c, 0x90, 0xd2, 0x78, 0xaf, 0x24, 0xce, 0xfb, 0x90,
	0x3b, 0x92, 0x0c, 0x44, 0x80, 0x5c, 0x8c, 0x4a, 0x21, 0xb0, 0x64, 0x46, 0xa7, 0x7d, 0x0c, 0xe0,
	0x39, 0x7d, 0x97, 0x1a, 0x63, 0x67, 0x40, 0x71, 0x52, 0x96, 0x76, 0xde, 0x8c, 0xed, 0x85, 0x32,
	0x35, 0x9d, 0x01, 0x25, 0x39, 0xec, 0xc1, 0x1e, 0xb5, 0x0a, 0x14, 0xfa, 0xce, 0xf8, 0x89, 0x65,
	0x0b, 0x06, 0x3c, 0x6b, 0x5e, 0x8f, 0x65, 0x50, 0xe1, 0x84, 0xc8, 0x22, 0xdf, 0x9f, 0x35, 0xb4,
	0xab, 0x90, 0x1b, 0x5b, 0xb6, 0xe1, 0xb1, 0x01, 0x30, 0x42, 0x12, 0x24, 0x3b, 0xb6, 0xf8, 0x80,
	0x88, 0x34, 0x5f, 0x08, 0xe4, 0x8a, 0x40, 0x9a, 0x2f, 0x10, 0xa9, 0xff, 0x6a, 0x02, 0xb2, 0x92,
	0xbd, 0xd6, 0x8d, 0x75, 0x07, 0x37, 0xdb, 0xbb, 0x67, 0xba, 0x23, 0x30, 0xcc, 0x82, 0x5b, 0xb4,
	0x0f, 0x61, 0xc5, 0x35, 0xed, 0x81, 0xc8, 0x66, 0xf9, 0x39, 0xd5, 0x08, 0xa2, 0x50, 0x96, 0x80,
	0x87, 0xa0, 0xd7, 0xb6, 0x21, 0x3d, 0xa0, 0x7d, 0xf3, 0x04, 0x8d, 0x9a, 0x9f, 0x5b, 0x49, 0xaa,
	0x0c, 0x13, 0x74, 0xe1, 0x84, 0x2c, 0x17, 0x3d, 0xa7, 0xd6, 0xf0, 0xd8, 0x47, 0x33, 0x26, 0x88,
	0x68, 0x85, 0xe6, 0x41, 0xfa, 0xdc, 0x79, 0xf0, 0x03, 0x05, 0x36, 0x4f, 0x53, 0x6f, 0x89, 0x5c,
	0x18, 0x8a, 0xe1, 0x04, 0x11, 0x2d, 0x6d, 0x17, 0xb2, 0x63, 0x67, 0x60, 0x1d, 0x59, 0xd4, 0x15,
	0x11, 0x72, 0x2d, 0xd6, 0xc1, 0x4d, 0x41, 0x44, 0x02, 0x72, 0x6d, 0x13, 0x32, 0x63, 0xcb, 0xf3,
	0x2c, 0x7b, 0x88, 0x3a, 0x29, 0x44, 0x36, 0xf5, 0x1f, 0x24, 0xa0, 0x18, 0xb1, 0xc2, 0x79, 0xd2,
	0x55, 0xa0, 0x38, 0x36, 0xfd, 0x63, 0x43, 0xc6, 0x2e, 0x0a, 0x39, 0x1f, 0xac, 0xc8, 0xb1, 0x69,
	0xfa, 0xc7, 0x81, 0x6d, 0x0b, 0xe3, 0x50, 0x4b, 0xfb, 0x04, 0x60, 0x62, 0xba, 0xe6, 0xd8, 0xf0,
	0x4f, 0x26, 0x32, 0xdc, 0xdf, 0x8a, 0xf7, 0x4c, 0x87, 0xd1, 0xf5, 0x4e, 0x26, 0x94, 0xe4, 0x26,
	0xf2, 0x91, 0xa5, 0x79, 0x6c, 0xa0, 0x36, 0x05, 0xc2, 0x1b, 0x0c, 0xca, 0x5d, 0x9d, 0x46, 0x1d,
	0x85, 0x3b, 0x6b, 0x2c, 0x6f, 0x8f, 0x7c, 0x4b, 0xc4, 0x23, 0xce, 0x8f, 0x15, 0x1c, 0xf1, 0x6a,
	0x64, 0xc4, 0x26, 0x23, 0x42, 0x77, 0xe1, 0xd4, 0x28, 0x8d, 0x23, 0x6d, 0xfd, 0xcf, 0x15, 0xd0,
	0x02, 0xa1, 0xaa, 0xa6, 0x4f, 0x51, 0x30, 0xed, 0x2d, 0xc8, 0x3b, 0xae, 0x35, 0xb4, 0x6c, 0x63,
	0xe4, 0xd8, 0x43, 0x34, 0x57, 0x92, 0x00, 0x07, 0x1d, 0x38, 0xf6, 0x90, 0x2d, 0x96, 0x82, 0xc0,
	0xf3, 0x5d, 0xe6, 0x00, 0xbe, 0x32, 0x15, 0x38, 0xb0, 0x8b, 0x30, 0x16, 0xa4, 0x5e, 0xdf, 0x1c,
	0xd1, 0xf8, 0x20, 0x35, 0x7d, 0xda, 0xb3, 0xc6, 0x14, 0x65, 0x21, 0x9c, 0x50, 0xdb, 0x81, 0x15,
	0xe7, 0xe8, 0xc8, 0xa3, 0x3c, 0x48, 0xcf, 0xee, 0x22, 0x28, 0xf5, 0xff, 0x0f, 0x17, 0x03, 0x0d,
	0x5a, 0xd3, 0x31, 0x75, 0x2d, 0x6e, 0x5d, 0x16, 0x71, 0x5c, 0x1c, 0x94, 0x5f, 0x21, 0xa2, 0xc5,
	0x0c, 0xca, 0xc5, 0x4a, 0x70, 0x83, 0xf2, 0xa1, 0x37, 0x82, 0xa1, 0x93, 0x82, 0x9a, 0xb3, 0xff,
	0x1c, 0xd6, 0x02, 0xf6, 0x7b, 0xd4, 0x89, 0x63, 0x9d, 0x7b, 0x45, 0xd6, 0x17, 0xe1, 0x42, 0xcc,
	0x1c, 0xd7, 0xff, 0x54, 0x81, 0x7c, 0x8b, 0x7a, 0x3e, 0x15, 0xc5, 0x81, 0x06, 0xa9, 0x89, 0xe9,
	0x1f, 0x8b, 0xa1, 0xf0, 0x79, 0x96, 0xb8, 0x13, 0xe7, 0x25, 0xee, 0xbb, 0x00, 0x98, 0xde, 0xc2,
	0x39, 0x78, 0x23, 0x42, 0x1e, 0xce, 0xbd, 0xf2, 0x91, 0x75, 0xb3, 0x6c, 0x9b, 0xba, 0xc6, 0xb1,
	0xe5, 0x7b, 0x22, 0x35, 0x44, 0xbb, 0x35, 0x18, 0x7a, 0xdf, 0xf2, 0x3d, 0x92, 0xb3, 0xe4, 0xa3,
	0xfe, 0x3d, 0x05, 0x72, 0x01, 0x42, 0x7b, 0x17, 0x52, 0x9e, 0xe3, 0xfa, 0x22, 0x4d, 0xae, 0x45,
	0x47, 0x75, 0x5c, 0x9f, 0x20, 0x3a, 0x64, 0x9f, 0x04, 0xae, 0xe0, 0xa2, 0xc5, 0xac, 0x39, 0xb2,
	0xc6, 0x96, 0x2f, 0x8a, 0x6a, 0xde, 0xd0, 0xee, 0x40, 0xee, 0xd8, 0x1a, 0x1e, 0x8f, 0x82, 0x5c,
	0x36, 0x2f, 0xd8, 0xbe, 0xc4, 0x92, 0x19, 0xa1, 0xee, 0xc2, 0x85, 0x3d, 0xea, 0xdc, 0x77, 0xa6,
	0xf6, 0xc0, 0xb2, 0x87, 0xf7, 0x9d, 0xe5, 0x0a, 0xb8, 0xcb, 0x90, 0xf5, 0x9d, 0x89, 0x31, 0xa2,
	0x47, 0xb2, 0x98, 0xce, 0xf8, 0xce, 0xe4, 0x80, 0x1e, 0xf9, 0xda, 0xdb, 0x50, 0x78, 0xe2, 0xf8,
	0xbe, 0x33, 0x36, 0x5c, 0x94, 0x24, 0x89, 0xe8, 0x3c, 0x87, 0x11, 0x1c, 0x73, 0x02, 0xea, 0x1e,
	0x75, 0xaa, 0x96, 0xe7, 0x9b, 0x76, 0x7f, 0xb9, 0x1a, 0xf7, 0x6d, 0x28, 0xf4, 0xa9, 0xcd, 0x0a,
	0xaa, 0x89, 0x63, 0xd9, 0x72, 0xd0, 0x3c, 0x87, 0x75, 0x18, 0x48, 0xbb, 0x02, 0xd9, 0x81, 0x60,
	0x29, 0xe2, 0x29, 0x68, 0xeb, 0xfb, 0xb0, 0xca, 0x62, 0xd4, 0x19, 0x9d, 0x0c, 0x1d, 0x7b, 0xe9,
	0x12, 0x95, 0xb1, 0xe5, 0x8b, 0x3a, 0x2b, 0x51, 0xb1, 0xa5, 0xdf, 0x84, 0x7c, 0xed, 0x85, 0xe5,
	0xf9, 0x4b, 0x95, 0xf7, 0xfa, 0xef, 0x2a, 0x50, 0x7a, 0x60, 0xdb, 0x8f, 0x28, 0x4b, 0xe9, 0x4b,
	0x8d, 0x7b, 0x01, 0xd2, 0xcc, 0xb2, 0x4f, 0x85, 0xcb, 0x53, 0xbe, 0x33, 0x79, 0xc0, 0x0a, 0xbb,
	0xa3, 0x91, 0x63, 0xfa, 0xef, 0xef, 0x60, 0x51, 0x78, 0x62, 0x3c, 0x43, 0x86, 0x58, 0x19, 0x26,
	0x88, 0x26, 0x70, 0xc8, 0x9f, 0x0f, 0xf5, 0x52, 0xab, 0x57, 0x03, 0xd2, 0xb2, 0xf4, 0x4b, 0x61,
	0x86, 0x56, 0x62, 0x26, 0x03, 0x52, 0x60, 0x62, 0x46, 0x1a, 0x16, 0x83, 0xb3, 0x89, 0x56, 0x10,
	0x93, 0x4a, 0xff, 0x3a, 0x64, 0x2b, 0xce, 0x68, 0x64, 0x4e, 0x3c, 0x7a, 0x9e, 0x69, 0x5a, 0x50,
	0xe0, 0x93, 0xb9, 0x8e, 0x52, 0xc4, 0xce, 0xe6, 0x99, 0x16, 0x89, 0x73, 0xb5, 0xf8, 0x00, 0x32,
	0x55, 0xa7, 0xcf, 0x66, 0x8f, 0x76, 0x13, 0xd2, 0x8e, 0x3b, 0x10, 0x15, 0xec, 0xc2, 0xac, 0x76,
	0x5c, 0xbf, 0xcd, 0xb0, 0x84, 0x13, 0xe9, 0xbb, 0x90, 0xc3, 0x99, 0xfe, 0x0a, 0x5d, 0x7f, 0x39,
	0x01, 0x39, 0x5c, 0xf7, 0xb1, 0xef, 0x39, 0x9e, 0x0d, 0x58, 0x27, 0x96, 0x60, 0xad, 0x7d, 0x1d,
	0x52, 0xa1, 0xc4, 0x74, 0x71, 0x81, 0x18, 0xf3, 0x12, 0x92, 0x68, 0x9f, 0x40, 0xd1, 0x46, 0x4b,
	0x1a, 0xc2, 0x58, 0x7c, 0xf2, 0x5f, 0x8e, 0xf4, 0x09, 0xdb, 0x9a, 0x14, 0xec, 0xb0, 0xe5, 0xdf,
	0x81, 0xa2, 0xa8, 0x0f, 0xf8, 0xa2, 0x89, 0x21, 0x53, 0x20, 0x05, 0x01, 0xc4, 0x55, 0x25, 0x4c,
	0x84, 0x2a, 0xe1, 0xa2, 0x9a, 0x0b, 0x88, 0xd0, 0x0a, 0xfa, 0xef, 0x25, 0x70, 0x9e, 0xc9, 0x99,
	0xbd, 0x8c, 0x55, 0x4e, 0x99, 0x67, 0x33, 0x6b, 0x25, 0x5f, 0xc6, 0x5a, 0xa9, 0xf3, 0xad, 0x55,
	0x86, 0xa2, 0x4c, 0x0b, 0xbc, 0x1e, 0x49, 0x63, 0x9f, 0x37, 0x22, 0x7d, 0x42, 0x4a, 0x60, 0xcc,
	0x17, 0x06, 0xa1, 0xd6, 0xa2, 0xc1, 0x57, 0x5e, 0xca, 0xe0, 0xfa, 0x27, 0x50, 0xea, 0xb8, 0xd6,
	0xd8, 0x74, 0x4f, 0x1e, 0xd0, 0x93, 0x57, 0x08, 0xbb, 0x1f, 0x26, 0x60, 0x85, 0x01, 0xa9, 0xcb,
	0x96, 0x23, 0x6e, 0xdd, 0xd0, 0x7a, 0xb2, 0xb1, 0x58, 0x76, 0xe3, 0xa2, 0xc2, 0xad, 0x8e, 0xe3,
	0xed, 0xc3, 0xda, 0x90, 0x3a, 0x46, 0x60, 0x08, 0xec, 0xcd, 0xe7, 0xd8, 0xa9, 0x86, 0x40, 0x1e,
	0xab, 0xc3, 0x39, 0xf7, 0x06, 0xcb, 0x28, 0xb2, 0x48, 0xc6, 0x08, 0x10, 0x4c, 0x2e, 0xb1, 0x8c,
	0x62, 0xb7, 0x3b, 0x90, 0x99, 0x3c, 0xe5, 0x7d, 0x78, 0xb4, 0x46, 0xab, 0xb3, 0xa8, 0x79, 0xc8,
	0xca, 0xe4, 0x29, 0xf6, 0x7a, 0x0f, 0xb2, 0x03, 0xa7, 0xcf, 0xbb, 0xf1, 0xbc, 0xb6, 0x1e, 0x2d,
	0x84, 0x78, 0x02, 0x20, 0x99, 0x01, 0x7f, 0xd0, 0x6d, 0x48, 0x61, 0xc7, 0x6f, 0xc0, 0x8a, 0x87,
	0x06, 0x13, 0xdb, 0xff, 0x0b, 0x0b, 0x06, 0xa6, 0x2e, 0x11, 0x24, 0xda, 0x2e, 0x5c, 0x1e, 0x58,
	0x1e, 0x9e, 0x8d, 0x0d, 0xe8, 0x91, 0x39, 0x1d, 0xf9, 0x86, 0x90, 0x55, 0x4c, 0xde, 0x2c, 0xd9,
	0x10, 0x04, 0x55, 0x8e, 0xef, 0x3c, 0xe5, 0x2c, 0xf4, 0xdf, 0x4c, 0x42, 0xbe, 0x8b, 0x07, 0x6e,
	0x3c, 0xa3, 0xce, 0x56, 0x70, 0x25, 0x7e, 0x05, 0x4f, 0x84, 0x57, 0xf0, 0xa0, 0x78, 0x49, 0x9d,
	0x57, 0xbc, 0xdc, 0x86, 0x6c, 0x5f, 0xe4, 0x59, 0x61, 0x88, 0x68, 0xcc, 0xcb, 0x24, 0x4c, 0x02,
	0xb2, 0xa0, 0xe6, 0x58, 0x39, 0xbb, 0xe6, 0xf8, 0x2a, 0x14, 0x87, 0xd4, 0xef, 0x39, 0xbe, 0x39,
	0xaa, 0x38, 0x53, 0xdb, 0xdf, 0xcc, 0xa2, 0xc2, 0x51, 0x20, 0x1e, 0x5b, 0x39, 0x4f, 0xa9, 0xbd,
	0x99, 0xe3, 0xd9, 0x1f, 0x1b, 0xda, 0x37, 0x21, 0x65, 0x0e, 0x87, 0xde, 0x26, 0xc4, 0x4c, 0x87,
	0xf2, 0x70, 0xe8, 0xd2, 0xa1, 0x89, 0xfb, 0x5f, 0x82, 0x64, 0xda, 0x0e, 0xe4, 0x86, 0xae, 0x33,
	0x9d, 0x18, 0x4f, 0x4e, 0xbc, 0xcd, 0x7c, 0x8c, 0x16, 0x7b, 0x0c, 0x7b, 0xff, 0xc4, 0x23, 0xd9,
	0xa1, 0x78, 0x8a, 0x16, 0x39, 0x85, 0x65, 0x8b, 0x9c, 0x3f, 0x51, 0x20, 0x17, 0x20, 0x34, 0x02,
	0xeb, 0x01, 0xca, 0xc0, 0xbd, 0x04, 0xf5, 0xa9, 0x2b, 0x4f, 0x86, 0xde, 0x8a, 0x67, 0xd7, 0x91,
	0x74, 0xe4, 0xc2, 0xf1, 0x02, 0xcc, 0xd3, 0x1e, 0xc1, 0xda, 0x8c, 0x27, 0xb5, 0xfb, 0xce, 0x2c,
	0xd1, 0x5f, 0x8b, 0x67, 0x58, 0xe3, 0x44, 0xdf, 0x82, 0xce, 0x41, 0xb9, 0xd1, 0x32, 0x9a, 0xed,
	0x6a, 0x8d, 0xa8, 0xc7, 0x73, 0x58, 0xfd, 0xb7, 0x13, 0xa0, 0x2d, 0xca, 0x70, 0x5e, 0x52, 0xbd,
	0x05, 0x17, 0xec, 0xe9, 0xf8, 0x09, 0x75, 0x0d, 0xe7, 0xc8, 0x38, 0x72, 0xcd, 0xe1, 0x98, 0xf2,
	0x0c, 0xcb, 0x82, 0x6d, 0x8d, 0xa3, 0xda, 0x47, 0x75, 0x89, 0x60, 0xc9, 0x5d, 0x52, 0x19, 0x9e,
	0xf5, 0x25, 0x15, 0x85, 0x65, 0x41, 0x02, 0xbb, 0xd6, 0x97, 0x54, 0xbb, 0x04, 0x99, 0x89, 0x4b,
	0x0d, 0xdf, 0xe4, 0xbb, 0x4a, 0x7e, 0x6a, 0xd7, 0x33, 0x87, 0xac, 0x18, 0x9c, 0x38, 0x9e, 0x8f,
	0x98, 0x34, 0x2f, 0x06, 0x59, 0x9b, 0xa1, 0xfe, 0x2f, 0xac, 0x06, 0xc3, 0x1b, 0x3c, 0xc3, 0xf1,
	0xcd, 0xd8, 0x3b, 0xf1, 0x46, 0x91, 0x22, 0x61, 0xba, 0xfb, 0x56, 0xb1, 0x57, 0x7b, 0xdc, 0x33,
	0xba, 0xb5, 0x87, 0x87, 0xb5, 0x56, 0xa5, 0x46, 0x4a, 0x01, 0x2b, 0x44, 0xeb, 0x5f, 0x40, 0xa1,
	0xe2, 0x8c, 0xa6, 0x63, 0xdb, 0xeb, 0x39, 0x7b, 0xd4, 0xd7, 0x3e, 0x81, 0xbc, 0x4b, 0xfd, 0xa9,
	0x6b, 0x1b, 0xa1, 0x2a, 0xe6, 0xda, 0xfc, 0xbc, 0x98, 0x8e, 0x6d, 0x82, 0x54, 0x98, 0xd8, 0xc1,
	0x0d, 0x9e, 0xb1, 0xc6, 0x44, 0x3c, 0x5a, 0x55, 0x2e, 0x48, 0x79, 0x0e, 0x63, 0x76, 0xf5, 0xf4,
	0x7f, 0x53, 0xa0, 0xc8, 0xe7, 0x37, 0xa1, 0x5f, 0x4c, 0xa9, 0x87, 0xcb, 0x1b, 0x3f, 0x46, 0x0f,
	0x7b, 0x02, 0x21, 0xf2, 0x6c, 0xd6, 0xb2, 0x07, 0xf4, 0x05, 0x47, 0xf3, 0xaa, 0x35, 0x87, 0x10,
	0x44, 0x7f, 0x0a, 0x25, 0xce, 0xde, 0x33, 0x7c, 0xc7, 0x18, 0x52, 0x99, 0x41, 0x2f, 0xc7, 0x48,
	0xcd, 0xb5, 0x24, 0x42, 0x46, 0xa1, 0xf3, 0xdb, 0xf2, 0x80, 0xdf, 0x98, 0x65, 0x8e, 0x02, 0xc9,
	0x7b, 0xa1, 0x1c, 0xf4, 0x2e, 0x94, 0x5c, 0x67, 0xea, 0x07, 0xcb, 0x3b, 0xdb, 0xb5, 0x24, 0x6f,
	0x14, 0x48, 0x51, 0x40, 0x71, 0x7d, 0xf7, 0xb4, 0x37, 0x20, 0xe7, 0x5b, 0x63, 0xea, 0x4c, 0xfd,
	0xa6, 0x87, 0x4e, 0x4a, 0x93, 0x19, 0x40, 0xff, 0xf7, 0x04, 0x94, 0xa4, 0xe2, 0xde, 0xc4, 0xb1,
	0x79, 0x7d, 0xe7, 0xb3, 0x8c, 0xc0, 0x77, 0x42, 0x7c, 0x2b, 0x9c, 0x43, 0x08, 0xee, 0x71, 0x34,
	0x48, 0xb9, 0xce, 0x73, 0x79, 0xb0, 0x8d, 0xcf, 0xda, 0x0d, 0x50, 0x2d, 0xcf, 0x30, 0x47, 0x23,
	0xc3, 0x9b, 0xf6, 0xfb, 0x94, 0x0e, 0xe8, 0x00, 0x15, 0xce, 0x92, 0x92, 0xe5, 0x95, 0x47, 0xa3,
	0xae, 0x84, 0x6a, 0x1f, 0x80, 0xd0, 0x41, 0xee, 0xb3, 0x92, 0x8b, 0xeb, 0x0a, 0xe2, 0xf7, 0x2d,
	0x9f, 0x80, 0x27, 0x1f, 0x3d, 0x26, 0x95, 0x4d, 0x5f, 0xf8, 0x06, 0x4f, 0x4f, 0x2b, 0xfc, 0x30,
	0x9c, 0x41, 0x7a, 0x98, 0xa2, 0x34, 0x91, 0xa2, 0x32, 0xfc, 0xc0, 0x1e, 0xf3, 0xd0, 0xd5, 0x70,
	0x1e, 0xca, 0x22, 0x62, 0x96, 0x70, 0x76, 0x59, 0xa6, 0xb5, 0xbd, 0xe9, 0x98, 0x0e, 0x30, 0xd9,
	0xe5, 0x17, 0x22, 0x8a, 0x23, 0x2b, 0xe6, 0xc4, 0xec, 0x5b, 0xfe, 0x09, 0x09, 0xc8, 0xb5, 0xff,
	0x03, 0x6b, 0x2e, 0xf5, 0xa8, 0xfb, 0x8c, 0x0e, 0x8c, 0x80, 0x07, 0x2c, 0xc3, 0x43, 0x95, 0xfd,
	0x24, 0x46, 0xff, 0x47, 0x05, 0x72, 0x81, 0xc2, 0x7c, 0x3b, 0xed, 0xb8, 0x72, 0x9f, 0xc3, 0x1b,
	0xda, 0x1e, 0xcc, 0xf2, 0x87, 0xe1, 0x52, 0x6f, 0x3a, 0x92, 0x8b, 0xeb, 0x1b, 0xa7, 0xa4, 0x48,
	0xa4, 0x21, 0xab, 0xc7, 0x51, 0x80, 0xb6, 0x07, 0x6b, 0xc2, 0xf8, 0x91, 0xad, 0x6e, 0x72, 0x61,
	0x99, 0xe6, 0x12, 0xc9, 0x7d, 0x2d, 0x59, 0xf5, 0x22, 0x6d, 0x4f, 0xdb, 0x82, 0x35, 0x51, 0x28,
	0xb1, 0x65, 0x5b, 0xac, 0x84, 0x3c, 0xb6, 0x56, 0x39, 0xa2, 0xea, 0xf4, 0xdb, 0xf2, 0xb8, 0xa2,
	0x14, 0x65, 0x17, 0xbb, 0x23, 0x98, 0x8b, 0x8b, 0xc4, 0xb2, 0x71, 0xa1, 0x7f, 0x0e, 0xab, 0x73,
	0x7a, 0x6b, 0xf5, 0xb0, 0xbd, 0x30, 0x79, 0xca, 0x35, 0xe0, 0xea, 0x29, 0xd9, 0x89, 0xd1, 0x84,
	0xcc, 0x85, 0x6d, 0x4f, 0x7f, 0x0c, 0xa5, 0x28, 0xc9, 0x79, 0xe9, 0xf9, 0x6b, 0xb0, 0xca, 0xd1,
	0xe1, 0xd4, 0xcc, 0x72, 0x4d, 0x09, 0xc1, 0x41, 0x5e, 0xd6, 0x7b, 0x50, 0x8c, 0x9c, 0xed, 0xcc,
	0x5e, 0x78, 0xf0, 0x72, 0x82, 0x37, 0xd8, 0xba, 0x3b, 0xb5, 0x45, 0x31, 0x51, 0x9a, 0xcb, 0x1d,
	0xb2, 0xff, 0xa1, 0x6d, 0xf9, 0x04, 0xc9, 0xf4, 0x21, 0x5c, 0xed, 0x5a, 0xf6, 0x70, 0x44, 0x3f,
	0x73, 0xdc, 0x41, 0xd9, 0x36, 0x47, 0x27, 0x5f, 0x52, 0x77, 0xb6, 0xb6, 0xbc, 0x0b, 0xa5, 0xbe,
	0xe9, 0x51, 0xc3, 0xa3, 0xb6, 0x67, 0xf9, 0xd6, 0x33, 0x3e, 0x58, 0x96, 0x14, 0x19, 0xb4, 0x2b,
	0x81, 0x2c, 0xf3, 0x0c, 0x28, 0xd6, 0x2d, 0xc6, 0x73, 0xc7, 0x1d, 0x88, 0xc2, 0x28, 0x2f, 0x60,
	0x8c, 0xb5, 0x7e, 0x0f, 0x36, 0xba, 0x93, 0x91, 0xe5, 0x2f, 0x8e, 0xf1, 0x06, 0xe4, 0x04, 0xa1,
	0xa8, 0x79, 0x73, 0x64, 0x06, 0xd0, 0x09, 0x6c, 0xd4, 0xa7, 0x5f, 0x7e, 0x79, 0xb2, 0xd8, 0x4f,
	0x1c, 0x5a, 0xf7, 0x8f, 0x4d, 0xd7, 0x13, 0x36, 0xc8, 0x8e, 0x2d, 0xbb, 0xc2, 0xda, 0xf2, 0xd0,
	0x9a, 0x23, 0x13, 0x02, 0x69, 0xbe, 0x40, 0xa4, 0xfe, 0x9d, 0x34, 0xe4, 0x79, 0x29, 0xdc, 0x3f,
	0xa6, 0x63, 0xf3, 0x3c, 0x17, 0x05, 0x75, 0x35, 0x2e, 0x25, 0x71, 0x3b, 0x36, 0x64, 0xc6, 0x4f,
	0x2a, 0x8f, 0xe4, 0x23, 0xdb, 0x19, 0xf0, 0x74, 0xef, 0x4c, 0xf8, 0x1b, 0x81, 0x64, 0x8c, 0x4b,
	0x1a, 0x8c, 0xa2, 0xcd, 0x09, 0x48, 0xc1, 0x0a, 0xb5, 0xb4, 0x2b, 0x90, 0x35, 0x85, 0xd2, 0x62,
	0x91, 0x0d, 0xda, 0xcc, 0xf7, 0x48, 0x2b, 0xde, 0xbf, 0xf1, 0x86, 0x76, 0x1d, 0x0a, 0xac, 0x6e,
	0x33, 0x4c, 0x7b, 0x60, 0x98, 0xc3, 0x21, 0xce, 0xae, 0x2c, 0x01, 0x06, 0x2b, 0xdb, 0x83, 0xf2,
	0x70, 0x88, 0xc9, 0xc2, 0x67, 0xc9, 0x22, 0xc3, 0xfb, 0x61, 0x43, 0xfb, 0x18, 0x8a, 0x62, 0xe3,
	0x80, 0xf6, 0x60, 0x89, 0x8f, 0x45, 0xfe, 0x66, 0xcc, 0xde, 0x01, 0x09, 0x48, 0xe1, 0x68, 0xd6,
	0xf0, 0xd8, 0x9a, 0xcf, 0x32, 0xb9, 0xeb, 0x9a, 0x27, 0x98, 0x16, 0xb3, 0x24, 0x63, 0x79, 0x65,
	0xd6, 0xd4, 0xbe, 0x09, 0x9a, 0x94, 0x79, 0x56, 0x5d, 0x61, 0xde, 0x2b, 0x90, 0x35, 0x73, 0xc1,
	0xa5, 0x7c, 0x4d, 0x78, 0x66, 0xb9, 0xfe, 0xd4, 0x1c, 0x89, 0xbd, 0x65, 0x5e, 0xae, 0x09, 0x8f,
	0x38, 0x98, 0xcf, 0xaa, 0x9b, 0xa0, 0x79, 0xce, 0xd4, 0xed, 0x53, 0x63, 0xe6, 0x39, 0x6f, 0xb3,
	0x80, 0x33, 0x47, 0xe5, 0x98, 0xba, 0x74, 0xa0, 0x87, 0xf1, 0x69, 0xfa, 0xd4, 0x38, 0x72, 0xdc,
	0xb1, 0xe9, 0x7b, 0x9b, 0x45, 0xbe, 0x9a, 0x33, 0x58, 0x9d, 0x83, 0xb4, 0xf7, 0xe0, 0x02, 0xb5,
	0x71, 0xf1, 0x0e, 0xa6, 0xb4, 0x65, 0x0f, 0x37, 0x4b, 0x38, 0xba, 0xc6, 0x51, 0xfb, 0x21, 0x8c,
	0x56, 0x86, 0x12, 0x3f, 0x79, 0x09, 0xfc, 0xbb, 0x1a, 0x73, 0x1c, 0xcb, 0x8f, 0x60, 0xa4, 0x83,
	0x8b, 0xcf, 0xc2, 0x4d, 0xfd, 0x87, 0x0a, 0x14, 0x23, 0x04, 0xda, 0x87, 0x90, 0x1b, 0x98, 0xbe,
	0x19, 0x2e, 0x5a, 0xae, 0xc6, 0xf0, 0xab, 0x9a, 0xbe, 0x89, 0xe1, 0x96, 0x1d, 0x88, 0x27, 0x9c,
	0x45, 0xd6, 0x98, 0xcd, 0x48, 0x71, 0x30, 0x9f, 0x26, 0x33, 0x00, 0x2b, 0x87, 0xc6, 0xd4, 0x77,
	0xad, 0x7e, 0xf8, 0xd8, 0xfd, 0x5a, 0x0c, 0xe7, 0x26, 0x52, 0xf1, 0x72, 0x68, 0x1c, 0x3c, 0xeb,
	0x7f, 0xa6, 0x40, 0x1e, 0x43, 0x55, 0xcc, 0x98, 0x85, 0x88, 0x51, 0x5e, 0x2a, 0x62, 0x82, 0xa9,
	0xe1, 0x51, 0xdf, 0x97, 0x27, 0xe3, 0xf9, 0xb8, 0xa9, 0xd1, 0xe5, 0x04, 0x62, 0x6a, 0x88, 0x96,
	0xb6, 0x2d, 0x2b, 0xa9, 0xd0, 0x46, 0x33, 0x66, 0x17, 0xc3, 0x8b, 0x2b, 0xdc, 0xfc, 0xfd, 0x96,
	0x02, 0x85, 0x30, 0x43, 0x16, 0x6a, 0xb3, 0xb2, 0xd8, 0x3b, 0x36, 0xdd, 0x81, 0x4c, 0x22, 0x25,
	0x59, 0x13, 0x77, 0x11, 0x1a, 0xae, 0x99, 0xc4, 0xc2, 0xc0, 0x13, 0xb4, 0xac, 0x99, 0x78, 0xe6,
	0xd7, 0xee, 0xc0, 0x86, 0x24, 0x9b, 0x98, 0xae, 0x6f, 0x31, 0x87, 0x86, 0x0b, 0xe8, 0x75, 0x81,
	0xed, 0x48, 0x24, 0x2b, 0xa4, 0xf5, 0xbf, 0x53, 0x60, 0xb3, 0xe2, 0x52, 0xd3, 0xa7, 0x72, 0xc1,
	0x1b, 0xd0, 0x17, 0xa7, 0xd5, 0x93, 0x89, 0xb3, 0xeb, 0xc9, 0x44, 0xb4, 0x9e, 0xdc, 0x86, 0x15,
	0xee, 0x1d, 0x61, 0xa0, 0xcd, 0x18, 0xeb, 0x72, 0xe7, 0x08, 0x3a, 0xb6, 0x44, 0x8b, 0x49, 0x15,
	0xe2, 0xcb, 0x53, 0xcf, 0x2a, 0x47, 0x34, 0x02, 0xee, 0xd7, 0xa1, 0xc0, 0x2a, 0x42, 0x56, 0xaa,
	0x8e, 0xd8, 0xba, 0xc0, 0xdf, 0x2b, 0x03, 0x83, 0xf5, 0x9c, 0x03, 0xeb, 0x19, 0xd5, 0xaf, 0xc2,
	0xe5, 0x18, 0xcd, 0x78, 0xc1, 0xa8, 0xef, 0xc3, 0x2a, 0x56, 0xa4, 0xf5, 0x91, 0xf3, 0xfc, 0x33,
	0xfe, 0x92, 0x2d, 0xaa, 0x8e, 0x32, 0x5f, 0x1e, 0xcf, 0xde, 0xcd, 0x89, 0x03, 0x70, 0xde, 0xd2,
	0x7f, 0xa4, 0xc0, 0xe6, 0xe1, 0x64, 0xb0, 0x9c, 0x05, 0x5f, 0xae, 0x22, 0x67, 0xf6, 0x78, 0x6e,
	0xf9, 0x58, 0xfb, 0x04, 0x54, 0x49, 0x61, 0x0f, 0x44, 0xcc, 0xec, 0xb1, 0x0f, 0x6b, 0xfc, 0x38,
	0xf6, 0x68, 0xe4, 0x3c, 0x37, 0x82, 0xb7, 0x88, 0xc9, 0x85, 0x8a, 0x6b, 0x4e, 0x6d, 0xb2, 0xfa,
	0xc5, 0x9c, 0x1d, 0x96, 0xb2, 0x6c, 0x8c, 0xc6, 0xc2, 0xb2, 0x0d, 0xc8, 0x21, 0xa0, 0x61, 0x1f,
	0x39, 0x3f, 0x9e, 0xfe, 0xfa, 0x07, 0xb0, 0x71, 0x60, 0x79, 0xfe, 0x4b, 0xdb, 0x55, 0x7f, 0x00,
	0x97, 0x16, 0x3a, 0x8a, 0x9d, 0xc2, 0x36, 0x64, 0x2c, 0x7b, 0x60, 0xf5, 0x83, 0xdb, 0x17, 0x1b,
	0x8b, 0x61, 0xc9, 0x44, 0x27, 0x92, 0x4c, 0x7f, 0x0c, 0x9b, 0x55, 0x3a, 0xa2, 0xaf, 0xdf, 0xbf,
	0xcc, 0x8e, 0x31, 0x9c, 0x85, 0x1d, 0x9f, 0x43, 0xb6, 0x7b, 0x62, 0xf7, 0xbb, 0xbe, 0xc9, 0x0f,
	0xb6, 0x4e, 0xec, 0xbe, 0x31, 0x39, 0x36, 0xbd, 0xf8, 0x23, 0x71, 0x46, 0xda, 0x61, 0x58, 0x92,
	0xf3, 0xe4, 0x23, 0x4b, 0x09, 0xfd, 0xa9, 0xeb, 0xe2, 0x4e, 0x9a, 0x75, 0x67, 0x2e, 0xf4, 0x7c,
	0x73, 0x3c, 0x41, 0x51, 0x92, 0x64, 0x5d, 0x60, 0x59, 0xe7, 0x9e, 0xc4, 0xe9, 0xdf, 0x53, 0xa0,
	0xd0, 0x64, 0xcb, 0xa1, 0x65, 0x0f, 0xd1, 0x89, 0x6c, 0x5f, 0xe7, 0x3b, 0xae, 0x39, 0xa4, 0x3c,
	0x9f, 0xf0, 0xed, 0x55, 0x5e, 0xc0, 0x70, 0x3f, 0x7e, 0x15, 0x72, 0xae, 0xf3, 0xdc, 0xe8, 0xe3,
	0x29, 0x0d, 0x67, 0x9e, 0x75, 0x9d, 0xe7, 0xfc, 0x80, 0xe6, 0x06, 0x04, 0x7b, 0x08, 0xc3, 0xa5,
	0xe6, 0xc0, 0xe8, 0x4f, 0x31, 0x8a, 0x93, 0xa4, 0x24, 0xe1, 0x84, 0x9a, 0x83, 0xca, 0x54, 0xee,
	0xfb, 0xb8, 0x8c, 0x29, 0xb1, 0x8b, 0x0b, 0x04, 0xfb, 0x36, 0x5c, 0xa9, 0x52, 0xaf, 0xef, 0x5a,
	0x4f, 0x5e, 0xbf, 0x2b, 0xfe, 0x23, 0x01, 0x57, 0x63, 0x99, 0x07, 0x61, 0x23, 0x93, 0x99, 0xb2,
	0x64, 0x32, 0xdb, 0x01, 0xf4, 0x84, 0xe1, 0xf9, 0xa6, 0x3c, 0xce, 0xbc, 0xb8, 0xe0, 0x32, 0xe6,
	0x5d, 0x92, 0xf5, 0xa4, 0x9f, 0x3f, 0x81, 0xe2, 0x58, 0x58, 0xde, 0xb0, 0xec, 0x23, 0x27, 0x76,
	0x07, 0x1e, 0xf6, 0x0d, 0x29, 0x8c, 0xc3, 0x9e, 0xba, 0x09, 0xda, 0x13, 0xd7, 0xf1, 0x8f, 0xa9,
	0xbb, 0x98, 0x41, 0x55, 0x81, 0x39, 0x27, 0x65, 0xa4, 0x5f, 0x25, 0x65, 0xbc, 0x05, 0xf9, 0x3e,
	0xa6, 0x5a, 0x0c, 0x31, 0xac, 0xfb, 0x92, 0x04, 0x38, 0x88, 0x05, 0xd6, 0x42, 0x4e, 0xc9, 0x2c,
	0xe4, 0x94, 0x21, 0xe4, 0x43, 0xc7, 0x72, 0x6c, 0xbf, 0x15, 0xf2, 0x23, 0x3e, 0x6b, 0xdb, 0xe2,
	0x95, 0x50, 0x22, 0xe6, 0x90, 0x3c, 0xd4, 0x37, 0xf4, 0x62, 0x48, 0x83, 0xd4, 0x13, 0x67, 0x70,
	0x22, 0xae, 0x9a, 0xe1, 0xb3, 0xfe, 0x11, 0x14, 0xc2, 0xe7, 0x7f, 0xda, 0x4d, 0xb1, 0x0b, 0x8f,
	0xab, 0x20, 0x42, 0x84, 0x7c, 0x7f, 0xae, 0x1b, 0x90, 0x11, 0x27, 0x81, 0xb1, 0x22, 0xde, 0x8c,
	0x88, 0xb8, 0x19, 0x77, 0x82, 0x78, 0x8e, 0x78, 0x1f, 0x43, 0x56, 0x1e, 0x35, 0x6a, 0xb7, 0xc3,
	0x87, 0x01, 0x5c, 0xbe, 0xf5, 0x38, 0x96, 0xb3, 0x23, 0x02, 0xbd, 0x01, 0xa5, 0xf2, 0xb3, 0x61,
	0xd8, 0x92, 0xe7, 0x6c, 0x2e, 0x42, 0xf7, 0x33, 0xf8, 0xdb, 0xb3, 0xe0, 0x7e, 0x46, 0x03, 0x4a,
	0x4d, 0xf3, 0xc5, 0x6b, 0x63, 0x65, 0xd9, 0xaf, 0x8b, 0x55, 0x77, 0x3a, 0x7e, 0x2d, 0xac, 0x6e,
	0x83, 0x8a, 0x09, 0x6a, 0x79, 0x66, 0x7a, 0x17, 0x36, 0xab, 0x96, 0xe7, 0x5b, 0x76, 0xdf, 0x7f,
	0xc9, 0xae, 0x67, 0xc8, 0xf1, 0x10, 0xb4, 0x9e, 0x33, 0x21, 0xce, 0x73, 0x2f, 0xcc, 0x2e, 0x38,
	0x96, 0x57, 0xc2, 0xc7, 0xf2, 0xf2, 0xe4, 0x3c, 0x71, 0xe6, 0xc9, 0xb9, 0xee, 0xc1, 0x46, 0x87,
	0xba, 0x7d, 0x6a, 0xfb, 0xd6, 0x88, 0x7a, 0x2f, 0x21, 0xe5, 0x75, 0xc8, 0x4f, 0x66, 0x1d, 0xb1,
	0xd2, 0x54, 0x48, 0x18, 0x14, 0xd6, 0x23, 0x19, 0xd5, 0x63, 0x1b, 0x80, 0x9f, 0x4a, 0x98, 0xf6,
	0x90, 0x6a, 0x2a, 0x24, 0xc7, 0xe2, 0xee, 0x45, 0x81, 0xb0, 0x47, 0x84, 0x98, 0x2f, 0x84, 0xf6,
	0xec, 0x51, 0xff, 0x7e, 0x12, 0xd6, 0x45, 0x0c, 0x57, 0x4d, 0x9f, 0xee, 0x5b, 0x9e, 0xef, 0x0c,
	0x5d, 0x73, 0x7c, 0x9e, 0x94, 0xf7, 0x20, 0x6b, 0xd9, 0x3e, 0x75, 0x9f, 0x99, 0x23, 0x61, 0x89,
	0xb3, 0x2e, 0xa1, 0x04, 0xb4, 0xda, 0x87, 0x90, 0xe7, 0x6c, 0xf1, 0xd2, 0xa9, 0xc8, 0xae, 0x97,
	0x16, 0x37, 0x0d, 0xa8, 0x01, 0xe1, 0x22, 0x70, 0x6d, 0xe6, 0xae, 0x31, 0xcd, 0xb4, 0xd6, 0x74,
	0x28, 0x8e, 0x2d, 0x1b, 0x0f, 0x95, 0xf8, 0xf2, 0x97, 0xe6, 0xcb, 0xe3, 0xd8, 0xb2, 0xab, 0x4e,
	0x9f, 0xaf, 0x80, 0x57, 0xf9, 0xba, 0x66, 0x7c, 0xe9, 0xd8, 0x54, 0xbc, 0xac, 0xcc, 0x32, 0xc0,
	0xb7, 0x1d, 0x1b, 0x73, 0x06, 0xba, 0x34, 0x13, 0xb3, 0xb0, 0x08, 0xe3, 0x84, 0xde, 0x89, 0xdc,
	0x81, 0xac, 0x37, 0x7d, 0x62, 0x60, 0xca, 0xca, 0x9e, 0xf7, 0x6e, 0x23, 0xe3, 0x4d, 0x9f, 0x94,
	0x87, 0x43, 0x4f, 0xdb, 0x85, 0x22, 0xeb, 0x35, 0xcb, 0x26, 0xb9, 0xb3, 0x5e, 0x71, 0xe4, 0xbd,
	0xe9, 0x13, 0xd9, 0xd0, 0xff, 0x39, 0x01, 0xaa, 0x68, 0x2c, 0xed, 0x9f, 0x2b, 0x73, 0xfe, 0x29,
	0x84, 0x7c, 0x70, 0x6a, 0xfc, 0x2c, 0x5a, 0x32, 0xb5, 0x68, 0x49, 0x69, 0xac, 0xf4, 0x52, 0xc6,
	0x9a, 0xf3, 0xf7, 0xca, 0xf2, 0xfe, 0x0e, 0x9b, 0x39, 0xf3, 0xea, 0x66, 0xce, 0x2e, 0x6d, 0xe6,
	0x8f, 0xa0, 0x80, 0xcf, 0xaf, 0xf6, 0x16, 0xf6, 0x23, 0x28, 0x10, 0x51, 0x6e, 0xbd, 0x42, 0xef,
	0xff, 0x07, 0xd0, 0x45, 0x0d, 0xb0, 0xef, 0x75, 0x28, 0x08, 0xd5, 0xc3, 0xde, 0x05, 0xae, 0xe3,
	0xcb, 0xdf, 0x1e, 0xd0, 0xff, 0x4a, 0x81, 0x62, 0xc8, 0x35, 0xd4, 0xd5, 0x3e, 0x85, 0x12, 0x37,
	0xd1, 0x53, 0x7a, 0x12, 0x7e, 0x59, 0x7c, 0x79, 0xd1, 0x4e, 0xf2, 0xad, 0x6b, 0x61, 0x18, 0x36,
	0xce, 0xa7, 0x6c, 0x4b, 0x2c, 0xca, 0xcd, 0xf0, 0xfb, 0xe2, 0x28, 0x83, 0xb0, 0x45, 0x48, 0xc1,
	0x0d, 0xdb, 0x67, 0x77, 0xa6, 0x63, 0x68, 0x0b, 0x1f, 0x8d, 0x8c, 0x99, 0x49, 0xa4, 0xf2, 0xb8,
	0x93, 0xaf, 0x40, 0x3e, 0xa4, 0x8d, 0x76, 0x07, 0x32, 0xfc, 0x6d, 0xac, 0x5c, 0xa1, 0xaf, 0x9c,
	0x16, 0x93, 0xd4, 0x25, 0x92, 0x54, 0xff, 0x95, 0xd9, 0xa4, 0xaa, 0x38, 0xe3, 0x89, 0xe3, 0x59,
	0x3e, 0xd5, 0xde, 0x63, 0xac, 0xd8, 0x2e, 0xd7, 0x13, 0xf6, 0x38, 0x25, 0x6e, 0x24, 0x15, 0xab,
	0x1f, 0xb0, 0x20, 0x17, 0xd7, 0x73, 0xd8, 0x73, 0x24, 0x70, 0x53, 0xaf, 0x1e, 0xb8, 0xe9, 0x65,
	0x03, 0x37, 0xe6, 0x25, 0x47, 0x2e, 0xfc, 0x92, 0xe3, 0x5d, 0x28, 0x79, 0xd3, 0xe1, 0x90, 0x9f,
	0xbc, 0xa3, 0xb4, 0xbc, 0xf6, 0x2b, 0x06, 0x50, 0x3c, 0x87, 0xf8, 0xa5, 0x04, 0x5c, 0x99, 0x37,
	0x08, 0x3f, 0x1a, 0x6f, 0xf8, 0x74, 0xcc, 0x34, 0x7d, 0x4a, 0x45, 0x11, 0x94, 0x23, 0xf8, 0xcc,
	0xe2, 0xd4, 0xf2, 0x0c, 0x7b, 0x3a, 0x1a, 0x19, 0x88, 0x63, 0x95, 0x6b, 0x96, 0x80, 0xe5, 0xb5,
	0xa6, 0xa3, 0xd1, 0x03, 0x46, 0x71, 0xe6, 0xae, 0x64, 0x0f, 0x56, 0xa5, 0xa1, 0xe4, 0x0b, 0x0a,
	0x1e, 0x05, 0x6f, 0x9d, 0x6e, 0x2f, 0xfe, 0x8e, 0xa2, 0x28, 0xac, 0x26, 0x8e, 0xee, 0x0f, 0x60,
	0x3d, 0x62, 0xbb, 0xe8, 0xeb, 0x8e, 0xab, 0xf1, 0x26, 0xe4, 0x9c, 0xd6, 0x42, 0x86, 0xe4, 0x20,
	0xfd, 0xef, 0x15, 0xd8, 0x88, 0x37, 0x84, 0x36, 0x86, 0xb7, 0xe4, 0x20, 0x46, 0x5f, 0xe2, 0xc4,
	0x68, 0x86, 0xe5, 0xd3, 0xb1, 0x0c, 0xc1, 0xaf, 0xc5, 0x8d, 0x19, 0x63, 0x56, 0x72, 0x75, 0x78,
	0x2a, 0x8e, 0x55, 0x9f, 0x17, 0xc5, 0x69, 0x4c, 0x30, 0x6a, 0xf8, 0x5d, 0xa4, 0x38, 0xff, 0x14,
	0xdc, 0xf9, 0x39, 0x67, 0x34, 0x16, 0x92, 0x73, 0xb1, 0xa0, 0xff, 0x93, 0x22, 0x92, 0xdc, 0xfd,
	0x93, 0xa5, 0xde, 0x4d, 0xc4, 0xc5, 0xb7, 0x5c, 0x00, 0x92, 0x2f, 0xbd, 0x5a, 0xfe, 0x24, 0x66,
	0x83, 0xfe, 0x0d, 0x48, 0xf3, 0x05, 0x44, 0x83, 0x14, 0x7e, 0x02, 0xc3, 0xaf, 0xb5, 0xe2, 0xb3,
	0x56, 0x82, 0x84, 0xef, 0x88, 0x6b, 0xa7, 0x09, 0xdf, 0xd1, 0xff, 0x72, 0x66, 0x0f, 0xde, 0xe9,
	0x1c, 0x7b, 0x6c, 0xe1, 0x55, 0xf4, 0xe1, 0x29, 0x5f, 0x7f, 0xf0, 0x45, 0x4c, 0x50, 0x44, 0x34,
	0x4f, 0xbe, 0xba, 0xe6, 0xa9, 0xa5, 0x35, 0xff, 0xc3, 0x59, 0x9a, 0x17, 0x77, 0xb9, 0x6e, 0x42,
	0x86, 0xdf, 0x49, 0x3a, 0xeb, 0x43, 0x17, 0x49, 0x12, 0x11, 0x38, 0xf1, 0xea, 0x02, 0x27, 0x97,
	0x16, 0xf8, 0x16, 0x64, 0xf1, 0x1e, 0xa6, 0x65, 0xfb, 0xac, 0x34, 0x1d, 0x99, 0xbe, 0x70, 0x16,
	0x7b, 0x44, 0x88, 0x38, 0xc9, 0x66, 0x10, 0xc7, 0xd6, 0xff, 0x53, 0x01, 0x4d, 0x74, 0x0e, 0xdd,
	0x44, 0x3a, 0xcf, 0x67, 0xdf, 0x0c, 0x6e, 0x21, 0xc7, 0x9d, 0x01, 0x48, 0x01, 0x82, 0xcb, 0xc9,
	0x33, 0x17, 0x27, 0x5f, 0xca, 0xc5, 0x3f, 0x91, 0xe0, 0xfe, 0x57, 0x05, 0x4a, 0x33, 0x0b, 0xec,
	0xb9, 0xd6, 0xb9, 0x33, 0xf8, 0x7f, 0x43, 0x6e, 0xe2, 0xd2, 0xbe, 0xe5, 0xcd, 0xae, 0xeb, 0x5f,
	0x9b, 0x37, 0xc0, 0xbe, 0xe9, 0x1d, 0x77, 0x24, 0x11, 0x99, 0xd1, 0x07, 0xd3, 0x9f, 0x9f, 0x15,
	0xfd, 0xf7, 0x2c, 0x6f, 0xfa, 0x14, 0x32, 0x52, 0xd7, 0xed, 0xd0, 0x45, 0x63, 0xe5, 0x2c, 0x67,
	0x06, 0xf7, 0x8f, 0x3f, 0x9c, 0xbb, 0x7f, 0x7c, 0x66, 0x08, 0x44, 0xae, 0x25, 0xdf, 0x84, 0xf5,
	0xe8, 0x3e, 0x5e, 0xac, 0x01, 0x91, 0x97, 0xae, 0x8a, 0xfc, 0xca, 0xec, 0x1e, 0xbc, 0x79, 0xda,
	0xb6, 0x34, 0xae, 0x5f, 0x52, 0xf6, 0xbb, 0x09, 0xeb, 0xd1, 0x2d, 0xfe, 0x99, 0xa3, 0x30, 0xea,
	0xc8, 0x2e, 0xfe, 0x3c, 0xea, 0xe8, 0x46, 0xfd, 0x4c, 0xea, 0x5b, 0xb0, 0xf1, 0x52, 0x92, 0xdf,
	0x82, 0xcd, 0xc5, 0x3d, 0xb3, 0xe8, 0x21, 0x6f, 0x7b, 0x28, 0xb3, 0xdb, 0x1e, 0x7a, 0x15, 0xae,
	0xc4, 0x6f, 0x88, 0xb1, 0xbc, 0x50, 0x21, 0xf9, 0x94, 0x9e, 0xc8, 0xe9, 0xff, 0x94, 0x9e, 0x44,
	0xbf, 0xe6, 0x2b, 0xc8, 0x51, 0xbf, 0xab, 0xc0, 0x1b, 0xf1, 0x6c, 0xc4, 0xd0, 0x4f, 0xe1, 0x5a,
	0x68, 0xaf, 0xcc, 0xc2, 0x54, 0x12, 0x9c, 0xb1, 0x40, 0x9f, 0x2e, 0x18, 0xb9, 0x3a, 0x39, 0x15,
	0xe7, 0xe9, 0x2f, 0x60, 0x2d, 0x56, 0xf9, 0xd7, 0x70, 0x70, 0x76, 0x0d, 0x80, 0xd5, 0xc6, 0xa1,
	0xba, 0xa8, 0x40, 0x72, 0xe6, 0x70, 0x28, 0x8a, 0x94, 0x43, 0xd0, 0x16, 0xeb, 0x22, 0xed, 0x53,
	0xc8, 0xcf, 0x3a, 0x49, 0x55, 0xdf, 0x3c, 0xf5, 0x40, 0x8d, 0x97, 0x40, 0x10, 0x70, 0xf5, 0xf4,
	0x7f, 0x98, 0xd5, 0x3e, 0x7c, 0x5b, 0x36, 0x2b, 0x00, 0x43, 0x1e, 0xca, 0x71, 0x0f, 0xfd, 0x2c,
	0x16, 0x77, 0xcf, 0x83, 0x15, 0x24, 0xa4, 0x9f, 0x66, 0xc2, 0xd5, 0xa0, 0xc2, 0x12, 0xdb, 0xd5,
	0xc5, 0x9a, 0xee, 0x9d, 0xb8, 0xa1, 0xe6, 0xac, 0x44, 0x2e, 0x0d, 0x63, 0xe1, 0x9e, 0xfe, 0xa3,
	0x99, 0x65, 0xf9, 0x1a, 0x12, 0x29, 0xad, 0xcf, 0x2b, 0x54, 0xa2, 0xb6, 0x4e, 0x9e, 0x6f, 0xeb,
	0xd4, 0x6b, 0xb5, 0x75, 0xfa, 0xc7, 0xb4, 0x75, 0x48, 0xe3, 0x88, 0xad, 0xf9, 0x97, 0xc8, 0xcb,
	0xda, 0x7a, 0xce, 0x6e, 0x81, 0xad, 0xe7, 0xe0, 0x78, 0x2f, 0xef, 0x8d, 0xc5, 0x3a, 0xe1, 0x7f,
	0x80, 0xc5, 0x7f, 0x4d, 0x81, 0xcd, 0xd3, 0x14, 0xd7, 0x7c, 0xd0, 0x03, 0xc3, 0x47, 0xae, 0x7b,
	0xc7, 0xd8, 0xff, 0xeb, 0x71, 0x03, 0xc7, 0xda, 0x92, 0x5c, 0x1b, 0x9e, 0x81, 0xf5, 0xf4, 0xbf,
	0x56, 0xe0, 0x52, 0xa4, 0x28, 0x0d, 0xb9, 0x21, 0x62, 0x62, 0xe5, 0x7c, 0x13, 0x27, 0x5e, 0xab,
	0x89, 0x93, 0xaf, 0x64, 0xe2, 0x9f, 0x87, 0x0b, 0x31, 0xea, 0x68, 0x03, 0x78, 0x23, 0x94, 0x41,
	0xf0, 0x5b, 0xef, 0x18, 0xb3, 0x7e, 0x35, 0x3e, 0x85, 0x44, 0xcd, 0x42, 0x36, 0x87, 0xf1, 0x08,
	0x4f, 0xff, 0x05, 0x25, 0x38, 0xad, 0x15, 0x25, 0x91, 0x18, 0xfe, 0x18, 0xde, 0x8c, 0xf8, 0x76,
	0x68, 0xb9, 0xb1, 0x39, 0xec, 0xdd, 0x53, 0xfc, 0x3a, 0x63, 0x85, 0x12, 0x5c, 0x9e, 0xf9, 0x74,
	0xcf, 0x72, 0x23, 0x79, 0xec, 0xd7, 0x13, 0xe1, 0x10, 0x8b, 0xf6, 0x8b, 0x59, 0x23, 0xde, 0x83,
	0x2c, 0xca, 0xe3, 0x5a, 0x03, 0xe1, 0xbe, 0xf5, 0xf9, 0xda, 0x0b, 0x79, 0x64, 0x86, 0xa2, 0xc4,
	0xfb, 0x59, 0x9c, 0x76, 0x27, 0xc1, 0xbe, 0xeb, 0x8c, 0x12, 0xe0, 0xe5, 0x5e, 0x4c, 0xfd, 0x2f,
	0x58, 0x9d, 0x65, 0xc9, 0x70, 0x0d, 0x50, 0x1c, 0x86, 0x47, 0xd2, 0x1f, 0x05, 0xfb, 0x01, 0xa9,
	0x5a, 0x15, 0xd4, 0xb9, 0x9e, 0x67, 0x9e, 0x8b, 0x09, 0xad, 0x4a, 0x11, 0xb6, 0x9e, 0xfe, 0xb7,
	0xb3, 0x48, 0x0b, 0xce, 0x9c, 0xe7, 0x5d, 0x5c, 0x88, 0x29, 0xd4, 0x64, 0x79, 0xf8, 0xd3, 0xba,
	0xfe, 0xbb, 0xc1, 0x2a, 0x1c, 0xa8, 0x25, 0xc6, 0x79, 0x0c, 0x97, 0x02, 0xbb, 0x1d, 0x0b, 0x5c,
	0x64, 0xee, 0xbc, 0x1d, 0x37, 0x54, 0xc4, 0x38, 0x64, 0x7d, 0x18, 0x85, 0xf2, 0x29, 0xf3, 0x2f,
	0xb3, 0xac, 0x1c, 0x79, 0xc7, 0x82, 0xf6, 0x8c, 0xbc, 0x70, 0x57, 0xe6, 0x5e, 0xb8, 0xff, 0x4c,
	0x96, 0x58, 0xdf, 0x51, 0x82, 0x83, 0xc4, 0x88, 0xba, 0x62, 0xb0, 0x21, 0x5c, 0x0b, 0xec, 0x8c,
	0x57, 0xf2, 0xa4, 0xb1, 0xc7, 0xe7, 0x67, 0xaa, 0x05, 0xf3, 0x05, 0x99, 0x6a, 0x01, 0xe3, 0xe9,
	0x7f, 0xa3, 0x40, 0xae, 0xdb, 0x37, 0xed, 0x97, 0xfd, 0x0f, 0x87, 0xf8, 0xaf, 0x71, 0x58, 0x3d,
	0x3e, 0xb2, 0x9e, 0x89, 0xf7, 0xeb, 0xfc, 0x42, 0x57, 0x0e, 0x21, 0xf8, 0x7a, 0x3d, 0xf8, 0x04,
	0x26, 0x15, 0xfe, 0x04, 0xe6, 0x16, 0x5c, 0x90, 0xd7, 0x3f, 0x26, 0xa6, 0x6b, 0x8e, 0x46, 0x74,
	0x64, 0x58, 0x03, 0x71, 0x9f, 0x67, 0x4d, 0xa0, 0x3a, 0x02, 0xd3, 0x18, 0x68, 0x6f, 0x43, 0x61,
	0x6c, 0xbe, 0x08, 0x68, 0xc5, 0xe5, 0xe8, 0xfc, 0xd8, 0x7c, 0x21, 0x89, 0x58, 0x1d, 0x79, 0x41,
	0x36, 0x98, 0x76, 0x3f, 0x25, 0x5f, 0x1e, 0x5c, 0x03, 0xf0, 0xa8, 0xe7, 0xe1, 0x36, 0x6b, 0x20,
	0x8c, 0x90, 0x13, 0x90, 0x06, 0x1e, 0x52, 0x78, 0x7d, 0xd3, 0x16, 0x9f, 0x25, 0xa4, 0x05, 0x3a,
	0x70, 0xce, 0xd9, 0x5f, 0x1b, 0x34, 0x60, 0x3d, 0xaa, 0xb1, 0xb8, 0x11, 0x12, 0xb3, 0xcb, 0x9c,
	0x3b, 0xff, 0x4c, 0xcc, 0x5d, 0xf8, 0xdf, 0xfa, 0xc5, 0x24, 0xe4, 0x82, 0x6f, 0x57, 0xb5, 0x55,
	0xc8, 0x37, 0xcb, 0xbd, 0xca, 0xbe, 0xf1, 0xf0, 0xb0, 0x46, 0x3e, 0x57, 0x15, 0x6d, 0x03, 0x34,
	0x0e, 0xe8, 0xec, 0x93, 0x72, 0xb7, 0x26, 0xe0, 0x09, 0xad, 0x04, 0xd0, 0xab, 0x91, 0xa6, 0x68,
	0x27, 0x59, 0x47, 0x52, 0x6e, 0xed, 0x49, 0x82, 0x94, 0xa6, 0x42, 0xa1, 0x43, 0x6a, 0xf5, 0xc6,
	0x63, 0x01, 0x49, 0xb3, 0x2e, 0xf7, 0xdb, 0xed, 0x03, 0xd1, 0x5e, 0xd1, 0x2e, 0xc2, 0x5a, 0xa5,
	0xdd, 0xea, 0xf6, 0x8c, 0x6e, 0xa5, 0x4d, 0x64, 0xc7, 0x8c, 0xb6, 0x09, 0xeb, 0xf5, 0xc3, 0x56,
	0xa5, 0xd7, 0x68, 0xb7, 0x22, 0x98, 0x2c, 0x63, 0xd9, 0xaa, 0x75, 0x7b, 0xb5, 0xaa, 0x80, 0xe4,
	0x34, 0x0d, 0x4a, 0x9f, 0x35, 0x0e, 0xaa, 0x95, 0x32, 0x91, 0x30, 0xd0, 0x2e, 0xc0, 0x2a, 0x97,
	0xb8, 0x7c, 0x20, 0xc7, 0xca, 0x6b, 0x57, 0x60, 0x63, 0xaf, 0xd6, 0x36, 0xee, 0xb7, 0x0f, 0x5b,
	0xd5, 0x46, 0x6b, 0xcf, 0xb8, 0xdf, 0x96, 0x72, 0x15, 0x98, 0x8a, 0x0c, 0x57, 0x6d, 0x74, 0x7b,
	0xe5, 0x56, 0x45, 0x0e, 0x57, 0x64, 0xf2, 0x31, 0x78, 0xa7, 0x7d, 0xf0, 0xf9, 0x5e, 0xbb, 0x25,
	0xc0, 0x25, 0xa6, 0x29, 0xd3, 0xbc, 0x2b, 0x00, 0xab, 0x4c, 0xac, 0xda, 0xe3, 0x46, 0xb7, 0x27,
	0x21, 0xaa, 0xb6, 0x0e, 0xea, 0x83, 0x56, 0xcb, 0x78, 0x54, 0xab, 0xf4, 0xda, 0x44, 0x40, 0xd7,
	0xb4, 0xcb, 0x70, 0x51, 0x2a, 0xd6, 0x8d, 0x68, 0xa6, 0x6d, 0x5d, 0x87, 0x62, 0xe4, 0x5f, 0x9c,
	0xb4, 0x15, 0x48, 0xb4, 0x89, 0xaa, 0x68, 0x19, 0x48, 0x96, 0x5b, 0x55, 0x35, 0xb1, 0xf5, 0x3b,
	0x0a, 0xa8, 0xf3, 0xff, 0x68, 0xa1, 0xe5, 0x21, 0x53, 0x6f, 0x1a, 0xad, 0x76, 0xab, 0xa6, 0x2a,
	0x1a, 0xc0, 0x4a, 0xbd, 0x69, 0x1c, 0xb4, 0xf7, 0xd4, 0x84, 0x56, 0x80, 0x2c, 0x7f, 0xbe, 0xdd,
	0x51, 0x93, 0xb3, 0xd6, 0x4e, 0x47, 0x4d, 0x69, 0x39, 0x48, 0xb3, 0x56, 0x4b, 0x4d, 0x8b, 0xfe,
	0x07, 0xad, 0xdb, 0x1d, 0x75, 0x25, 0x68, 0xec, 0x74, 0xd4, 0x8c, 0x56, 0x84, 0x5c, 0xbd, 0x69,
	0x74, 0x1f, 0x1e, 0x96, 0x49, 0x4d, 0xcd, 0x0a, 0x5c, 0xf7, 0x21, 0xe9, 0xa9, 0x39, 0x6d, 0x0d,
	0x8a, 0xf5, 0xa6, 0x41, 0x6a, 0x95, 0x46, 0x87, 0xb4, 0x2b, 0xe5, 0x03, 0x15, 0xb6, 0xda, 0xa1,
	0x3f, 0x83, 0x08, 0xfe, 0xa1, 0x82, 0x11, 0x56, 0xeb, 0x46, 0xb5, 0xdc, 0xab, 0x19, 0x9d, 0x32,
	0x29, 0x37, 0x55, 0x85, 0x59, 0xa6, 0x5a, 0x37, 0x5a, 0x87, 0xcd, 0x1a, 0x69, 0x54, 0x04, 0x34,
	0xc1, 0x2c, 0x58, 0xad, 0x1b, 0x68, 0x6c, 0x84, 0x24, 0xb7, 0xde, 0x17, 0x7f, 0x9e, 0x10, 0xfe,
	0xd3, 0x0c, 0x26, 0xf9, 0x5e, 0xf9, 0xb0, 0xdb, 0xe5, 0x76, 0xa9, 0x3d, 0xee, 0xa8, 0x09, 0xa6,
	0xf5, 0x41, 0xa3, 0x55, 0x2b, 0x13, 0x35, 0xb9, 0x55, 0x85, 0x52, 0xf4, 0x5f, 0x2b, 0x98, 0xdc,
	0xcd, 0x47, 0x4d, 0xa3, 0x59, 0x7e, 0xac, 0x2a, 0x41, 0xa3, 0xd1, 0x52, 0x13, 0xb2, 0xd1, 0x3d,
	0x6c, 0xaa, 0x49, 0xd9, 0x28, 0x3f, 0xda, 0x53, 0x53, 0x5b, 0xc7, 0xb0, 0xb6, 0xf0, 0xe7, 0x32,
	0x68, 0x80, 0x2e, 0xa7, 0x50, 0x64, 0x83, 0x71, 0x4d, 0xc8, 0x46, 0xc0, 0x08, 0x31, 0x8d, 0x16,
	0x9f, 0x01, 0xd8, 0x38, 0x3c, 0xe8, 0x35, 0x3a, 0x07, 0x6c, 0x06, 0x30, 0xab, 0x76, 0x9b, 0x46,
	0xbd, 0x41, 0xba, 0x3d, 0x75, 0x65, 0x6b, 0x34, 0xfb, 0x6f, 0x9d, 0xd0, 0xbf, 0xd0, 0x60, 0xbf,
	0x4a, 0xa8, 0x1f, 0x1f, 0xb0, 0xc2, 0x47, 0x4f, 0xc8, 0x06, 0x1b, 0x3d, 0x29, 0x1b, 0x6c, 0xf4,
	0x54, 0x80, 0x69, 0x30, 0xdf, 0xae, 0x42, 0x9e, 0x35, 0x48, 0xad, 0x73, 0x50, 0xae, 0xd4, 0xd4,
	0x95, 0x2d, 0x57, 0x7c, 0xc6, 0x8d, 0x63, 0x5c, 0x80, 0x55, 0x1e, 0x81, 0xcd, 0x76, 0xb5, 0x26,
	0x23, 0x48, 0x83, 0x52, 0x08, 0xc8, 0x47, 0x8b, 0xc2, 0xf8, 0xa0, 0xeb, 0xa0, 0x86, 0x60, 0xbd,
	0x76, 0xaf, 0x7c, 0xa0, 0xa6, 0xe6, 0x29, 0x99, 0x10, 0x5b, 0x77, 0x20, 0x17, 0xbc, 0x7a, 0x45,
	0x82, 0x36, 0xe9, 0x19, 0x6d, 0x52, 0xad, 0x11, 0xa3, 0xdc, 0xad, 0xa8, 0x5f, 0x41, 0x39, 0x66,
	0xb0, 0x6a, 0xad, 0x5b, 0x51, 0x95, 0xad, 0x0a, 0x64, 0xe5, 0x37, 0xc9, 0x2c, 0x86, 0x90, 0x20,
	0x60, 0xfa, 0x95, 0x39, 0x10, 0xba, 0x36, 0x02, 0x42, 0xc1, 0xb7, 0x3e, 0x8d, 0x7c, 0x69, 0x2d,
	0xfe, 0x26, 0x45, 0x8d, 0x4c, 0xf4, 0x32, 0x61, 0x22, 0xcc, 0x4f, 0xff, 0xce, 0x41, 0x99, 0x59,
	0x63, 0xeb, 0x1e, 0x6c, 0xc4, 0x7f, 0x76, 0xc7, 0x46, 0x8b, 0x7c, 0x78, 0xa7, 0x2a, 0x2c, 0x34,
	0x51, 0x79, 0x35, 0xb1, 0x75, 0x1b, 0xd4, 0xf9, 0x6f, 0x18, 0x59, 0xea, 0x9b, 0x7d, 0xc5, 0xa8,
	0x2a, 0x2c, 0x10, 0xf6, 0x7b, 0xcd, 0x03, 0xde, 0x4c, 0x6c, 0x0d, 0x40, 0x9d, 0xff, 0xf0, 0x8e,
	0x75, 0x21, 0xb5, 0xde, 0x21, 0x69, 0xb1, 0x3c, 0xc6, 0x67, 0x8e, 0x68, 0x77, 0x3b, 0xb5, 0x4a,
	0xa3, 0xde, 0xa8, 0x55, 0xd5, 0x04, 0xa6, 0x5d, 0x0e, 0x45, 0x1f, 0x26, 0x59, 0x92, 0x99, 0x75,
	0x33, 0xea, 0xa4, 0xdd, 0x34, 0x1a, 0xad, 0x6a, 0xed, 0xb1, 0x9a, 0xda, 0xfa, 0x54, 0xdc, 0xf6,
	0x96, 0xf7, 0xea, 0xb3, 0x90, 0xaa, 0xb6, 0x2b, 0x5d, 0x2e, 0x7d, 0x9d, 0xd4, 0x1e, 0x76, 0xd5,
	0x04, 0x93, 0xac, 0xd3, 0xee, 0x36, 0x30, 0x49, 0xf1, 0xf8, 0x6a, 0xd7, 0xeb, 0xdd, 0x5a, 0xaf,
	0xab, 0xa6, 0xb6, 0x9e, 0x89, 0x8f, 0xf9, 0x51, 0xbe, 0x2c, 0xa4, 0x0e, 0xda, 0xad, 0x3d, 0x9e,
	0x78, 0xaa, 0xed, 0xc3, 0xfb, 0x07, 0x35, 0x1e, 0x9c, 0x2c, 0xc7, 0xd7, 0xca, 0x2d, 0xde, 0xf9,
	0x41, 0xed, 0xf3, 0xcf, 0xda, 0xa4, 0xaa, 0xa6, 0x18, 0x3d, 0x33, 0x9a, 0x9a, 0x66, 0xf4, 0x3c,
	0x8d, 0xab, 0x2b, 0x6c, 0x38, 0x9e, 0x63, 0x1b, 0xad, 0x9e, 0x9a, 0x41, 0x91, 0xca, 0x3d, 0x96,
	0x71, 0x00, 0x56, 0x78, 0xfa, 0x54, 0x73, 0x5b, 0x3f, 0x07, 0x85, 0xf0, 0x57, 0x3a, 0x8c, 0xea,
	0x73, 0x36, 0xe3, 0x15, 0x36, 0x55, 0x58, 0x8a, 0xea, 0xd5, 0x88, 0x81, 0x90, 0x04, 0x53, 0xa5,
	0xd9, 0x6e, 0xf5, 0xf6, 0xd5, 0x24, 0x23, 0xfb, 0xac, 0x56, 0x7b, 0xa0, 0xa6, 0x58, 0xb6, 0xa8,
	0x96, 0xd9, 0x04, 0xcc, 0x42, 0x6a, 0xbf, 0x7d, 0x48, 0xd4, 0x15, 0xc6, 0xbf, 0xd9, 0x68, 0x1d,
	0xf6, 0x6a, 0x6a, 0x86, 0x3d, 0x77, 0x6b, 0x95, 0x76, 0xab, 0xaa, 0x66, 0xb7, 0xde, 0x86, 0x52,
	0xf4, 0x73, 0x02, 0x66, 0xe2, 0x47, 0x55, 0xa3, 0x7e, 0xd0, 0x2e, 0xf7, 0x8c, 0xf7, 0x77, 0xd4,
	0xc4, 0xd6, 0x1e, 0xa8, 0xf3, 0xdf, 0x05, 0x30, 0x41, 0x1e, 0x35, 0x8d, 0xda, 0x61, 0xe5, 0xa0,
	0x51, 0x65, 0xca, 0x7f, 0x85, 0x69, 0xf6, 0xa8, 0x69, 0x54, 0xda, 0xdd, 0x86, 0x9c, 0x5b, 0x8f,
	0x9a, 0x46, 0xb5, 0xdd, 0x33, 0x3a, 0xa4, 0x5d, 0x3d, 0xac, 0xf4, 0xd4, 0xc4, 0xd6, 0x5b, 0x90,
	0x0b, 0xae, 0xc8, 0x32, 0xd1, 0xea, 0x87, 0xe8, 0xe9, 0x2c, 0xa4, 0x1a, 0xad, 0x0a, 0x51, 0x13,
	0x5b, 0xbf, 0xa1, 0xc0, 0xea, 0xdc, 0x59, 0x28, 0x33, 0x6a, 0x79, 0x6f, 0x4f, 0x64, 0xa2, 0x0d,
	0xd0, 0x58, 0x83, 0xc5, 0x6e, 0xa3, 0x55, 0xe9, 0x19, 0x95, 0xf6, 0x61, 0xab, 0xc7, 0x73, 0x39,
	0x83, 0x07, 0x19, 0x0a, 0x1b, 0x0d, 0xe1, 0x13, 0xd6, 0xe0, 0x09, 0xa3, 0x08, 0x39, 0xd6, 0xe0,
	0xbd, 0xd2, 0x4c, 0x09, 0xd6, 0xec, 0xb5, 0x3b, 0x06, 0x69, 0x7f, 0xd6, 0x55, 0x33, 0x6c, 0x7a,
	0x32, 0x48, 0xa7, 0x46, 0x2a, 0xb5, 0x56, 0xaf, 0x71, 0x50, 0xeb, 0xaa, 0xd9, 0xad, 0xbf, 0x50,
	0x82, 0xdb, 0x06, 0x3d, 0x7e, 0x63, 0xb0, 0xb4, 0x47, 0xda, 0x87, 0x1d, 0xe3, 0xfe, 0xe7, 0x46,
	0xbd, 0x51, 0x3b, 0xa8, 0x72, 0x75, 0x03, 0x18, 0xd6, 0x05, 0x6a, 0x82, 0x31, 0x0b, 0xd1, 0x1d,
	0xf4, 0x6a, 0x84, 0xc7, 0x6b, 0x00, 0x0c, 0x4f, 0x43, 0x35, 0x85, 0x13, 0x53, 0xa2, 0xf6, 0x1b,
	0xdd, 0x5e, 0x7b, 0x8f, 0xad, 0x0d, 0x69, 0xed, 0x2a, 0x5c, 0x0a, 0xe0, 0xb8, 0xb8, 0xcc, 0x90,
	0x58, 0x54, 0x44, 0xf8, 0xed, 0x91, 0x46, 0x55, 0xcd, 0x44, 0x78, 0x55, 0xda, 0x4d, 0x0c, 0xf1,
	0x9a, 0x9a, 0xdd, 0xfa, 0x7e, 0x02, 0xff, 0x6a, 0x25, 0xf2, 0xba, 0x47, 0xbb, 0x04, 0x17, 0xf6,
	0xf6, 0x3b, 0xc6, 0xdd, 0xed, 0xed, 0xdd, 0x07, 0x4d, 0xe3, 0xce, 0xee, 0xee, 0xce, 0x83, 0xa6,
	0x71, 0x9b, 0x9b, 0x9b, 0x21, 0x6e, 0xef, 0xdc, 0x65, 0x90, 0x7b, 0x3b, 0x77, 0x1e, 0x34, 0x8d,
	0x1d, 0x35, 0x81, 0x83, 0x32, 0xf8, 0xdd, 0x7b, 0x8c, 0x10, 0x7f, 0xdf, 0x57, 0x93, 0xa8, 0xf0,
	0x7e, 0xc7, 0x78, 0x9f, 0x71, 0xb9, 0x8d, 0xac, 0xd4, 0x94, 0xa4, 0xbd, 0xb3, 0xbb, 0xbd, 0xdd,
	0x14, 0xbf, 0x77, 0xd5, 0x34, 0xe6, 0x26, 0x64, 0xcd, 0x00, 0xf7, 0xb6, 0x77, 0x9b, 0xc6, 0x3d,
	0x75, 0x45, 0x72, 0xb8, 0x7d, 0x77, 0xa7, 0xc9, 0x7f, 0x3e, 0x50, 0x33, 0x2c, 0xfd, 0x20, 0xdb,
	0x0f, 0x19, 0xd7, 0xa6, 0xf1, 0xa1, 0x9a, 0x0d, 0x98, 0x7e, 0xb8, 0x5d, 0x69, 0x8a, 0xdf, 0x5d,
	0x35, 0x37, 0x93, 0x97, 0x01, 0xee, 0xee, 0xde, 0x6d, 0x36, 0x8d, 0xdb, 0xdb, 0x2a, 0x04, 0xf0,
	0x3b, 0xbb, 0x0c, 0xc2, 0x7f, 0x6f, 0xab, 0x79, 0x29, 0xc4, 0xfb, 0x1f, 0x34, 0x91, 0x75, 0xd3,
	0xb8, 0xbd, 0xa3, 0x16, 0xfe, 0x2b, 0x00, 0x00, 0xff, 0xff, 0x40, 0xe3, 0xb2, 0x82, 0x22, 0x53,
	0x00, 0x00,
}
