collection_operators.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// source: github.com/infobloxopen/atlas-app-toolkit/query/collection_operators.proto

/*
Package query is a generated protocol buffer package.

It is generated from these files:
	github.com/infobloxopen/atlas-app-toolkit/query/collection_operators.proto

It has these top-level messages:
	SortCriteria
	Sorting
	FieldSelection
	Field
	Filtering
	LogicalOperator
	StringCondition
	NumberCondition
	NullCondition
	StringArrayCondition
	NumberArrayCondition
	Pagination
	PageInfo
*/
package query

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import _ "github.com/grpc-ecosystem/grpc-gateway/protoc-gen-swagger/options"

// 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.ProtoPackageIsVersion2 // please upgrade the proto package

// Order is a sort order.
type SortCriteria_Order int32

const (
	// ascending sort order
	SortCriteria_ASC SortCriteria_Order = 0
	// descending sort order
	SortCriteria_DESC SortCriteria_Order = 1
)

var SortCriteria_Order_name = map[int32]string{
	0: "ASC",
	1: "DESC",
}
var SortCriteria_Order_value = map[string]int32{
	"ASC":  0,
	"DESC": 1,
}

func (x SortCriteria_Order) String() string {
	return proto.EnumName(SortCriteria_Order_name, int32(x))
}
func (SortCriteria_Order) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0, 0} }

type LogicalOperator_Type int32

const (
	LogicalOperator_AND LogicalOperator_Type = 0
	LogicalOperator_OR  LogicalOperator_Type = 1
)

var LogicalOperator_Type_name = map[int32]string{
	0: "AND",
	1: "OR",
}
var LogicalOperator_Type_value = map[string]int32{
	"AND": 0,
	"OR":  1,
}

func (x LogicalOperator_Type) String() string {
	return proto.EnumName(LogicalOperator_Type_name, int32(x))
}
func (LogicalOperator_Type) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{5, 0} }

type StringCondition_Type int32

const (
	StringCondition_EQ    StringCondition_Type = 0
	StringCondition_MATCH StringCondition_Type = 1
	StringCondition_GT    StringCondition_Type = 2
	StringCondition_GE    StringCondition_Type = 3
	StringCondition_LT    StringCondition_Type = 4
	StringCondition_LE    StringCondition_Type = 5
	StringCondition_IEQ   StringCondition_Type = 6
)

var StringCondition_Type_name = map[int32]string{
	0: "EQ",
	1: "MATCH",
	2: "GT",
	3: "GE",
	4: "LT",
	5: "LE",
	6: "IEQ",
}
var StringCondition_Type_value = map[string]int32{
	"EQ":    0,
	"MATCH": 1,
	"GT":    2,
	"GE":    3,
	"LT":    4,
	"LE":    5,
	"IEQ":   6,
}

func (x StringCondition_Type) String() string {
	return proto.EnumName(StringCondition_Type_name, int32(x))
}
func (StringCondition_Type) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{6, 0} }

type NumberCondition_Type int32

const (
	NumberCondition_EQ NumberCondition_Type = 0
	NumberCondition_GT NumberCondition_Type = 1
	NumberCondition_GE NumberCondition_Type = 2
	NumberCondition_LT NumberCondition_Type = 3
	NumberCondition_LE NumberCondition_Type = 4
)

var NumberCondition_Type_name = map[int32]string{
	0: "EQ",
	1: "GT",
	2: "GE",
	3: "LT",
	4: "LE",
}
var NumberCondition_Type_value = map[string]int32{
	"EQ": 0,
	"GT": 1,
	"GE": 2,
	"LT": 3,
	"LE": 4,
}

func (x NumberCondition_Type) String() string {
	return proto.EnumName(NumberCondition_Type_name, int32(x))
}
func (NumberCondition_Type) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{7, 0} }

type StringArrayCondition_Type int32

const (
	StringArrayCondition_IN StringArrayCondition_Type = 0
)

var StringArrayCondition_Type_name = map[int32]string{
	0: "IN",
}
var StringArrayCondition_Type_value = map[string]int32{
	"IN": 0,
}

func (x StringArrayCondition_Type) String() string {
	return proto.EnumName(StringArrayCondition_Type_name, int32(x))
}
func (StringArrayCondition_Type) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{9, 0} }

type NumberArrayCondition_Type int32

const (
	NumberArrayCondition_IN NumberArrayCondition_Type = 0
)

var NumberArrayCondition_Type_name = map[int32]string{
	0: "IN",
}
var NumberArrayCondition_Type_value = map[string]int32{
	"IN": 0,
}

func (x NumberArrayCondition_Type) String() string {
	return proto.EnumName(NumberArrayCondition_Type_name, int32(x))
}
func (NumberArrayCondition_Type) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor0, []int{10, 0}
}

// SortCriteria represents sort criteria
type SortCriteria struct {
	// Tag is a JSON tag.
	Tag   string             `protobuf:"bytes,1,opt,name=tag" json:"tag,omitempty"`
	Order SortCriteria_Order `protobuf:"varint,2,opt,name=order,enum=infoblox.api.SortCriteria_Order" json:"order,omitempty"`
}

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

func (m *SortCriteria) GetTag() string {
	if m != nil {
		return m.Tag
	}
	return ""
}

func (m *SortCriteria) GetOrder() SortCriteria_Order {
	if m != nil {
		return m.Order
	}
	return SortCriteria_ASC
}

// Sorting represents list of sort criterias.
type Sorting struct {
	Criterias []*SortCriteria `protobuf:"bytes,1,rep,name=criterias" json:"criterias,omitempty"`
}

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

func (m *Sorting) GetCriterias() []*SortCriteria {
	if m != nil {
		return m.Criterias
	}
	return nil
}

// FieldSelection represents a group of fields for some object.
// Main use case for if is to store information about object fields that
// need to be ratained prior to sending object as a response
type FieldSelection struct {
	Fields map[string]*Field `protobuf:"bytes,1,rep,name=fields" json:"fields,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
}

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

func (m *FieldSelection) GetFields() map[string]*Field {
	if m != nil {
		return m.Fields
	}
	return nil
}

// Field represents a single field for an object.
// It contains fields name and also may contain a group of sub-fields for cases
// when a fields represents some structure.
type Field struct {
	Name string            `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
	Subs map[string]*Field `protobuf:"bytes,2,rep,name=subs" json:"subs,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
}

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

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

func (m *Field) GetSubs() map[string]*Field {
	if m != nil {
		return m.Subs
	}
	return nil
}

// Filtering represents filtering expression.
// root could be either LogicalOperator or one of the supported conditions.
type Filtering struct {
	// Types that are valid to be assigned to Root:
	//	*Filtering_Operator
	//	*Filtering_StringCondition
	//	*Filtering_NumberCondition
	//	*Filtering_NullCondition
	//	*Filtering_StringArrayCondition
	//	*Filtering_NumberArrayCondition
	Root isFiltering_Root `protobuf_oneof:"root"`
}

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

type isFiltering_Root interface {
	isFiltering_Root()
}

type Filtering_Operator struct {
	Operator *LogicalOperator `protobuf:"bytes,1,opt,name=operator,oneof"`
}
type Filtering_StringCondition struct {
	StringCondition *StringCondition `protobuf:"bytes,2,opt,name=string_condition,json=stringCondition,oneof"`
}
type Filtering_NumberCondition struct {
	NumberCondition *NumberCondition `protobuf:"bytes,3,opt,name=number_condition,json=numberCondition,oneof"`
}
type Filtering_NullCondition struct {
	NullCondition *NullCondition `protobuf:"bytes,4,opt,name=null_condition,json=nullCondition,oneof"`
}
type Filtering_StringArrayCondition struct {
	StringArrayCondition *StringArrayCondition `protobuf:"bytes,5,opt,name=string_array_condition,json=stringArrayCondition,oneof"`
}
type Filtering_NumberArrayCondition struct {
	NumberArrayCondition *NumberArrayCondition `protobuf:"bytes,6,opt,name=number_array_condition,json=numberArrayCondition,oneof"`
}

func (*Filtering_Operator) isFiltering_Root()             {}
func (*Filtering_StringCondition) isFiltering_Root()      {}
func (*Filtering_NumberCondition) isFiltering_Root()      {}
func (*Filtering_NullCondition) isFiltering_Root()        {}
func (*Filtering_StringArrayCondition) isFiltering_Root() {}
func (*Filtering_NumberArrayCondition) isFiltering_Root() {}

func (m *Filtering) GetRoot() isFiltering_Root {
	if m != nil {
		return m.Root
	}
	return nil
}

func (m *Filtering) GetOperator() *LogicalOperator {
	if x, ok := m.GetRoot().(*Filtering_Operator); ok {
		return x.Operator
	}
	return nil
}

func (m *Filtering) GetStringCondition() *StringCondition {
	if x, ok := m.GetRoot().(*Filtering_StringCondition); ok {
		return x.StringCondition
	}
	return nil
}

func (m *Filtering) GetNumberCondition() *NumberCondition {
	if x, ok := m.GetRoot().(*Filtering_NumberCondition); ok {
		return x.NumberCondition
	}
	return nil
}

func (m *Filtering) GetNullCondition() *NullCondition {
	if x, ok := m.GetRoot().(*Filtering_NullCondition); ok {
		return x.NullCondition
	}
	return nil
}

func (m *Filtering) GetStringArrayCondition() *StringArrayCondition {
	if x, ok := m.GetRoot().(*Filtering_StringArrayCondition); ok {
		return x.StringArrayCondition
	}
	return nil
}

func (m *Filtering) GetNumberArrayCondition() *NumberArrayCondition {
	if x, ok := m.GetRoot().(*Filtering_NumberArrayCondition); ok {
		return x.NumberArrayCondition
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*Filtering) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _Filtering_OneofMarshaler, _Filtering_OneofUnmarshaler, _Filtering_OneofSizer, []interface{}{
		(*Filtering_Operator)(nil),
		(*Filtering_StringCondition)(nil),
		(*Filtering_NumberCondition)(nil),
		(*Filtering_NullCondition)(nil),
		(*Filtering_StringArrayCondition)(nil),
		(*Filtering_NumberArrayCondition)(nil),
	}
}

func _Filtering_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*Filtering)
	// root
	switch x := m.Root.(type) {
	case *Filtering_Operator:
		b.EncodeVarint(1<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Operator); err != nil {
			return err
		}
	case *Filtering_StringCondition:
		b.EncodeVarint(2<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.StringCondition); err != nil {
			return err
		}
	case *Filtering_NumberCondition:
		b.EncodeVarint(3<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.NumberCondition); err != nil {
			return err
		}
	case *Filtering_NullCondition:
		b.EncodeVarint(4<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.NullCondition); err != nil {
			return err
		}
	case *Filtering_StringArrayCondition:
		b.EncodeVarint(5<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.StringArrayCondition); err != nil {
			return err
		}
	case *Filtering_NumberArrayCondition:
		b.EncodeVarint(6<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.NumberArrayCondition); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("Filtering.Root has unexpected type %T", x)
	}
	return nil
}

func _Filtering_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*Filtering)
	switch tag {
	case 1: // root.operator
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(LogicalOperator)
		err := b.DecodeMessage(msg)
		m.Root = &Filtering_Operator{msg}
		return true, err
	case 2: // root.string_condition
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(StringCondition)
		err := b.DecodeMessage(msg)
		m.Root = &Filtering_StringCondition{msg}
		return true, err
	case 3: // root.number_condition
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(NumberCondition)
		err := b.DecodeMessage(msg)
		m.Root = &Filtering_NumberCondition{msg}
		return true, err
	case 4: // root.null_condition
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(NullCondition)
		err := b.DecodeMessage(msg)
		m.Root = &Filtering_NullCondition{msg}
		return true, err
	case 5: // root.string_array_condition
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(StringArrayCondition)
		err := b.DecodeMessage(msg)
		m.Root = &Filtering_StringArrayCondition{msg}
		return true, err
	case 6: // root.number_array_condition
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(NumberArrayCondition)
		err := b.DecodeMessage(msg)
		m.Root = &Filtering_NumberArrayCondition{msg}
		return true, err
	default:
		return false, nil
	}
}

func _Filtering_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*Filtering)
	// root
	switch x := m.Root.(type) {
	case *Filtering_Operator:
		s := proto.Size(x.Operator)
		n += proto.SizeVarint(1<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Filtering_StringCondition:
		s := proto.Size(x.StringCondition)
		n += proto.SizeVarint(2<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Filtering_NumberCondition:
		s := proto.Size(x.NumberCondition)
		n += proto.SizeVarint(3<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Filtering_NullCondition:
		s := proto.Size(x.NullCondition)
		n += proto.SizeVarint(4<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Filtering_StringArrayCondition:
		s := proto.Size(x.StringArrayCondition)
		n += proto.SizeVarint(5<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Filtering_NumberArrayCondition:
		s := proto.Size(x.NumberArrayCondition)
		n += proto.SizeVarint(6<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

// LogicalOperator represents binary logical operator, either AND or OR depending on type.
// left and right are respectively left and right operands of the operator, could be
// either LogicalOperator or one of the supported conditions.
// is_negative is set to true if the operator is negated.
type LogicalOperator struct {
	// Types that are valid to be assigned to Left:
	//	*LogicalOperator_LeftOperator
	//	*LogicalOperator_LeftStringCondition
	//	*LogicalOperator_LeftNumberCondition
	//	*LogicalOperator_LeftNullCondition
	//	*LogicalOperator_LeftStringArrayCondition
	//	*LogicalOperator_LeftNumberArrayCondition
	Left isLogicalOperator_Left `protobuf_oneof:"left"`
	// Types that are valid to be assigned to Right:
	//	*LogicalOperator_RightOperator
	//	*LogicalOperator_RightStringCondition
	//	*LogicalOperator_RightNumberCondition
	//	*LogicalOperator_RightNullCondition
	//	*LogicalOperator_RightStringArrayCondition
	//	*LogicalOperator_RightNumberArrayCondition
	Right      isLogicalOperator_Right `protobuf_oneof:"right"`
	Type       LogicalOperator_Type    `protobuf:"varint,9,opt,name=type,enum=infoblox.api.LogicalOperator_Type" json:"type,omitempty"`
	IsNegative bool                    `protobuf:"varint,10,opt,name=is_negative,json=isNegative" json:"is_negative,omitempty"`
}

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

type isLogicalOperator_Left interface {
	isLogicalOperator_Left()
}
type isLogicalOperator_Right interface {
	isLogicalOperator_Right()
}

type LogicalOperator_LeftOperator struct {
	LeftOperator *LogicalOperator `protobuf:"bytes,1,opt,name=left_operator,json=leftOperator,oneof"`
}
type LogicalOperator_LeftStringCondition struct {
	LeftStringCondition *StringCondition `protobuf:"bytes,2,opt,name=left_string_condition,json=leftStringCondition,oneof"`
}
type LogicalOperator_LeftNumberCondition struct {
	LeftNumberCondition *NumberCondition `protobuf:"bytes,3,opt,name=left_number_condition,json=leftNumberCondition,oneof"`
}
type LogicalOperator_LeftNullCondition struct {
	LeftNullCondition *NullCondition `protobuf:"bytes,4,opt,name=left_null_condition,json=leftNullCondition,oneof"`
}
type LogicalOperator_LeftStringArrayCondition struct {
	LeftStringArrayCondition *StringArrayCondition `protobuf:"bytes,11,opt,name=left_string_array_condition,json=leftStringArrayCondition,oneof"`
}
type LogicalOperator_LeftNumberArrayCondition struct {
	LeftNumberArrayCondition *NumberArrayCondition `protobuf:"bytes,12,opt,name=left_number_array_condition,json=leftNumberArrayCondition,oneof"`
}
type LogicalOperator_RightOperator struct {
	RightOperator *LogicalOperator `protobuf:"bytes,5,opt,name=right_operator,json=rightOperator,oneof"`
}
type LogicalOperator_RightStringCondition struct {
	RightStringCondition *StringCondition `protobuf:"bytes,6,opt,name=right_string_condition,json=rightStringCondition,oneof"`
}
type LogicalOperator_RightNumberCondition struct {
	RightNumberCondition *NumberCondition `protobuf:"bytes,7,opt,name=right_number_condition,json=rightNumberCondition,oneof"`
}
type LogicalOperator_RightNullCondition struct {
	RightNullCondition *NullCondition `protobuf:"bytes,8,opt,name=right_null_condition,json=rightNullCondition,oneof"`
}
type LogicalOperator_RightStringArrayCondition struct {
	RightStringArrayCondition *StringArrayCondition `protobuf:"bytes,13,opt,name=right_string_array_condition,json=rightStringArrayCondition,oneof"`
}
type LogicalOperator_RightNumberArrayCondition struct {
	RightNumberArrayCondition *NumberArrayCondition `protobuf:"bytes,14,opt,name=right_number_array_condition,json=rightNumberArrayCondition,oneof"`
}

func (*LogicalOperator_LeftOperator) isLogicalOperator_Left()               {}
func (*LogicalOperator_LeftStringCondition) isLogicalOperator_Left()        {}
func (*LogicalOperator_LeftNumberCondition) isLogicalOperator_Left()        {}
func (*LogicalOperator_LeftNullCondition) isLogicalOperator_Left()          {}
func (*LogicalOperator_LeftStringArrayCondition) isLogicalOperator_Left()   {}
func (*LogicalOperator_LeftNumberArrayCondition) isLogicalOperator_Left()   {}
func (*LogicalOperator_RightOperator) isLogicalOperator_Right()             {}
func (*LogicalOperator_RightStringCondition) isLogicalOperator_Right()      {}
func (*LogicalOperator_RightNumberCondition) isLogicalOperator_Right()      {}
func (*LogicalOperator_RightNullCondition) isLogicalOperator_Right()        {}
func (*LogicalOperator_RightStringArrayCondition) isLogicalOperator_Right() {}
func (*LogicalOperator_RightNumberArrayCondition) isLogicalOperator_Right() {}

func (m *LogicalOperator) GetLeft() isLogicalOperator_Left {
	if m != nil {
		return m.Left
	}
	return nil
}
func (m *LogicalOperator) GetRight() isLogicalOperator_Right {
	if m != nil {
		return m.Right
	}
	return nil
}

func (m *LogicalOperator) GetLeftOperator() *LogicalOperator {
	if x, ok := m.GetLeft().(*LogicalOperator_LeftOperator); ok {
		return x.LeftOperator
	}
	return nil
}

func (m *LogicalOperator) GetLeftStringCondition() *StringCondition {
	if x, ok := m.GetLeft().(*LogicalOperator_LeftStringCondition); ok {
		return x.LeftStringCondition
	}
	return nil
}

func (m *LogicalOperator) GetLeftNumberCondition() *NumberCondition {
	if x, ok := m.GetLeft().(*LogicalOperator_LeftNumberCondition); ok {
		return x.LeftNumberCondition
	}
	return nil
}

func (m *LogicalOperator) GetLeftNullCondition() *NullCondition {
	if x, ok := m.GetLeft().(*LogicalOperator_LeftNullCondition); ok {
		return x.LeftNullCondition
	}
	return nil
}

func (m *LogicalOperator) GetLeftStringArrayCondition() *StringArrayCondition {
	if x, ok := m.GetLeft().(*LogicalOperator_LeftStringArrayCondition); ok {
		return x.LeftStringArrayCondition
	}
	return nil
}

func (m *LogicalOperator) GetLeftNumberArrayCondition() *NumberArrayCondition {
	if x, ok := m.GetLeft().(*LogicalOperator_LeftNumberArrayCondition); ok {
		return x.LeftNumberArrayCondition
	}
	return nil
}

func (m *LogicalOperator) GetRightOperator() *LogicalOperator {
	if x, ok := m.GetRight().(*LogicalOperator_RightOperator); ok {
		return x.RightOperator
	}
	return nil
}

func (m *LogicalOperator) GetRightStringCondition() *StringCondition {
	if x, ok := m.GetRight().(*LogicalOperator_RightStringCondition); ok {
		return x.RightStringCondition
	}
	return nil
}

func (m *LogicalOperator) GetRightNumberCondition() *NumberCondition {
	if x, ok := m.GetRight().(*LogicalOperator_RightNumberCondition); ok {
		return x.RightNumberCondition
	}
	return nil
}

func (m *LogicalOperator) GetRightNullCondition() *NullCondition {
	if x, ok := m.GetRight().(*LogicalOperator_RightNullCondition); ok {
		return x.RightNullCondition
	}
	return nil
}

func (m *LogicalOperator) GetRightStringArrayCondition() *StringArrayCondition {
	if x, ok := m.GetRight().(*LogicalOperator_RightStringArrayCondition); ok {
		return x.RightStringArrayCondition
	}
	return nil
}

func (m *LogicalOperator) GetRightNumberArrayCondition() *NumberArrayCondition {
	if x, ok := m.GetRight().(*LogicalOperator_RightNumberArrayCondition); ok {
		return x.RightNumberArrayCondition
	}
	return nil
}

func (m *LogicalOperator) GetType() LogicalOperator_Type {
	if m != nil {
		return m.Type
	}
	return LogicalOperator_AND
}

func (m *LogicalOperator) GetIsNegative() bool {
	if m != nil {
		return m.IsNegative
	}
	return false
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*LogicalOperator) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
	return _LogicalOperator_OneofMarshaler, _LogicalOperator_OneofUnmarshaler, _LogicalOperator_OneofSizer, []interface{}{
		(*LogicalOperator_LeftOperator)(nil),
		(*LogicalOperator_LeftStringCondition)(nil),
		(*LogicalOperator_LeftNumberCondition)(nil),
		(*LogicalOperator_LeftNullCondition)(nil),
		(*LogicalOperator_LeftStringArrayCondition)(nil),
		(*LogicalOperator_LeftNumberArrayCondition)(nil),
		(*LogicalOperator_RightOperator)(nil),
		(*LogicalOperator_RightStringCondition)(nil),
		(*LogicalOperator_RightNumberCondition)(nil),
		(*LogicalOperator_RightNullCondition)(nil),
		(*LogicalOperator_RightStringArrayCondition)(nil),
		(*LogicalOperator_RightNumberArrayCondition)(nil),
	}
}

func _LogicalOperator_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*LogicalOperator)
	// left
	switch x := m.Left.(type) {
	case *LogicalOperator_LeftOperator:
		b.EncodeVarint(1<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.LeftOperator); err != nil {
			return err
		}
	case *LogicalOperator_LeftStringCondition:
		b.EncodeVarint(2<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.LeftStringCondition); err != nil {
			return err
		}
	case *LogicalOperator_LeftNumberCondition:
		b.EncodeVarint(3<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.LeftNumberCondition); err != nil {
			return err
		}
	case *LogicalOperator_LeftNullCondition:
		b.EncodeVarint(4<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.LeftNullCondition); err != nil {
			return err
		}
	case *LogicalOperator_LeftStringArrayCondition:
		b.EncodeVarint(11<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.LeftStringArrayCondition); err != nil {
			return err
		}
	case *LogicalOperator_LeftNumberArrayCondition:
		b.EncodeVarint(12<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.LeftNumberArrayCondition); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("LogicalOperator.Left has unexpected type %T", x)
	}
	// right
	switch x := m.Right.(type) {
	case *LogicalOperator_RightOperator:
		b.EncodeVarint(5<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.RightOperator); err != nil {
			return err
		}
	case *LogicalOperator_RightStringCondition:
		b.EncodeVarint(6<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.RightStringCondition); err != nil {
			return err
		}
	case *LogicalOperator_RightNumberCondition:
		b.EncodeVarint(7<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.RightNumberCondition); err != nil {
			return err
		}
	case *LogicalOperator_RightNullCondition:
		b.EncodeVarint(8<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.RightNullCondition); err != nil {
			return err
		}
	case *LogicalOperator_RightStringArrayCondition:
		b.EncodeVarint(13<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.RightStringArrayCondition); err != nil {
			return err
		}
	case *LogicalOperator_RightNumberArrayCondition:
		b.EncodeVarint(14<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.RightNumberArrayCondition); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("LogicalOperator.Right has unexpected type %T", x)
	}
	return nil
}

func _LogicalOperator_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*LogicalOperator)
	switch tag {
	case 1: // left.left_operator
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(LogicalOperator)
		err := b.DecodeMessage(msg)
		m.Left = &LogicalOperator_LeftOperator{msg}
		return true, err
	case 2: // left.left_string_condition
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(StringCondition)
		err := b.DecodeMessage(msg)
		m.Left = &LogicalOperator_LeftStringCondition{msg}
		return true, err
	case 3: // left.left_number_condition
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(NumberCondition)
		err := b.DecodeMessage(msg)
		m.Left = &LogicalOperator_LeftNumberCondition{msg}
		return true, err
	case 4: // left.left_null_condition
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(NullCondition)
		err := b.DecodeMessage(msg)
		m.Left = &LogicalOperator_LeftNullCondition{msg}
		return true, err
	case 11: // left.left_string_array_condition
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(StringArrayCondition)
		err := b.DecodeMessage(msg)
		m.Left = &LogicalOperator_LeftStringArrayCondition{msg}
		return true, err
	case 12: // left.left_number_array_condition
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(NumberArrayCondition)
		err := b.DecodeMessage(msg)
		m.Left = &LogicalOperator_LeftNumberArrayCondition{msg}
		return true, err
	case 5: // right.right_operator
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(LogicalOperator)
		err := b.DecodeMessage(msg)
		m.Right = &LogicalOperator_RightOperator{msg}
		return true, err
	case 6: // right.right_string_condition
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(StringCondition)
		err := b.DecodeMessage(msg)
		m.Right = &LogicalOperator_RightStringCondition{msg}
		return true, err
	case 7: // right.right_number_condition
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(NumberCondition)
		err := b.DecodeMessage(msg)
		m.Right = &LogicalOperator_RightNumberCondition{msg}
		return true, err
	case 8: // right.right_null_condition
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(NullCondition)
		err := b.DecodeMessage(msg)
		m.Right = &LogicalOperator_RightNullCondition{msg}
		return true, err
	case 13: // right.right_string_array_condition
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(StringArrayCondition)
		err := b.DecodeMessage(msg)
		m.Right = &LogicalOperator_RightStringArrayCondition{msg}
		return true, err
	case 14: // right.right_number_array_condition
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(NumberArrayCondition)
		err := b.DecodeMessage(msg)
		m.Right = &LogicalOperator_RightNumberArrayCondition{msg}
		return true, err
	default:
		return false, nil
	}
}

func _LogicalOperator_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*LogicalOperator)
	// left
	switch x := m.Left.(type) {
	case *LogicalOperator_LeftOperator:
		s := proto.Size(x.LeftOperator)
		n += proto.SizeVarint(1<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *LogicalOperator_LeftStringCondition:
		s := proto.Size(x.LeftStringCondition)
		n += proto.SizeVarint(2<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *LogicalOperator_LeftNumberCondition:
		s := proto.Size(x.LeftNumberCondition)
		n += proto.SizeVarint(3<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *LogicalOperator_LeftNullCondition:
		s := proto.Size(x.LeftNullCondition)
		n += proto.SizeVarint(4<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *LogicalOperator_LeftStringArrayCondition:
		s := proto.Size(x.LeftStringArrayCondition)
		n += proto.SizeVarint(11<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *LogicalOperator_LeftNumberArrayCondition:
		s := proto.Size(x.LeftNumberArrayCondition)
		n += proto.SizeVarint(12<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	// right
	switch x := m.Right.(type) {
	case *LogicalOperator_RightOperator:
		s := proto.Size(x.RightOperator)
		n += proto.SizeVarint(5<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *LogicalOperator_RightStringCondition:
		s := proto.Size(x.RightStringCondition)
		n += proto.SizeVarint(6<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *LogicalOperator_RightNumberCondition:
		s := proto.Size(x.RightNumberCondition)
		n += proto.SizeVarint(7<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *LogicalOperator_RightNullCondition:
		s := proto.Size(x.RightNullCondition)
		n += proto.SizeVarint(8<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *LogicalOperator_RightStringArrayCondition:
		s := proto.Size(x.RightStringArrayCondition)
		n += proto.SizeVarint(13<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case *LogicalOperator_RightNumberArrayCondition:
		s := proto.Size(x.RightNumberArrayCondition)
		n += proto.SizeVarint(14<<3 | proto.WireBytes)
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

// StringCondition represents a condition with a string literal, e.g. field == 'string'.
// field_path is a reference to a value of a resource.
// value is the string literal.
// type is a type of the condition.
// is_negative is set to true if the condition is negated.
type StringCondition struct {
	FieldPath  []string             `protobuf:"bytes,1,rep,name=field_path,json=fieldPath" json:"field_path,omitempty"`
	Value      string               `protobuf:"bytes,2,opt,name=value" json:"value,omitempty"`
	Type       StringCondition_Type `protobuf:"varint,3,opt,name=type,enum=infoblox.api.StringCondition_Type" json:"type,omitempty"`
	IsNegative bool                 `protobuf:"varint,4,opt,name=is_negative,json=isNegative" json:"is_negative,omitempty"`
}

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

func (m *StringCondition) GetFieldPath() []string {
	if m != nil {
		return m.FieldPath
	}
	return nil
}

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

func (m *StringCondition) GetType() StringCondition_Type {
	if m != nil {
		return m.Type
	}
	return StringCondition_EQ
}

func (m *StringCondition) GetIsNegative() bool {
	if m != nil {
		return m.IsNegative
	}
	return false
}

// NumberCondition represents a condition with a number literal, e.g. field > 3.
// field_path is a reference to a value of a resource.
// value is the number literal.
// type is a type of the condition.
// is_negative is set to true if the condition is negated.
type NumberCondition struct {
	FieldPath  []string             `protobuf:"bytes,1,rep,name=field_path,json=fieldPath" json:"field_path,omitempty"`
	Value      float64              `protobuf:"fixed64,2,opt,name=value" json:"value,omitempty"`
	Type       NumberCondition_Type `protobuf:"varint,3,opt,name=type,enum=infoblox.api.NumberCondition_Type" json:"type,omitempty"`
	IsNegative bool                 `protobuf:"varint,4,opt,name=is_negative,json=isNegative" json:"is_negative,omitempty"`
}

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

func (m *NumberCondition) GetFieldPath() []string {
	if m != nil {
		return m.FieldPath
	}
	return nil
}

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

func (m *NumberCondition) GetType() NumberCondition_Type {
	if m != nil {
		return m.Type
	}
	return NumberCondition_EQ
}

func (m *NumberCondition) GetIsNegative() bool {
	if m != nil {
		return m.IsNegative
	}
	return false
}

// NullCondition represents a condition with a null literal, e.g. field == null.
// field_path is a reference to a value of a resource.
// is_negative is set to true if the condition is negated.
type NullCondition struct {
	FieldPath  []string `protobuf:"bytes,1,rep,name=field_path,json=fieldPath" json:"field_path,omitempty"`
	IsNegative bool     `protobuf:"varint,2,opt,name=is_negative,json=isNegative" json:"is_negative,omitempty"`
}

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

func (m *NullCondition) GetFieldPath() []string {
	if m != nil {
		return m.FieldPath
	}
	return nil
}

func (m *NullCondition) GetIsNegative() bool {
	if m != nil {
		return m.IsNegative
	}
	return false
}

// StringArrayCondition represents a condition with string arrays, e.g. field in ['hello','world']
// field_path is a reference to a value of a resource.
// is_negative is set to true if the condition is negated
type StringArrayCondition struct {
	FieldPath  []string                  `protobuf:"bytes,1,rep,name=field_path,json=fieldPath" json:"field_path,omitempty"`
	Values     []string                  `protobuf:"bytes,2,rep,name=values" json:"values,omitempty"`
	Type       StringArrayCondition_Type `protobuf:"varint,3,opt,name=type,enum=infoblox.api.StringArrayCondition_Type" json:"type,omitempty"`
	IsNegative bool                      `protobuf:"varint,4,opt,name=is_negative,json=isNegative" json:"is_negative,omitempty"`
}

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

func (m *StringArrayCondition) GetFieldPath() []string {
	if m != nil {
		return m.FieldPath
	}
	return nil
}

func (m *StringArrayCondition) GetValues() []string {
	if m != nil {
		return m.Values
	}
	return nil
}

func (m *StringArrayCondition) GetType() StringArrayCondition_Type {
	if m != nil {
		return m.Type
	}
	return StringArrayCondition_IN
}

func (m *StringArrayCondition) GetIsNegative() bool {
	if m != nil {
		return m.IsNegative
	}
	return false
}

// NumberArrayCondition represents a condition with string arrays, e.g. field in [1, 5, 7]
// field_path is a reference to a value of a resource.
// is_negative is set to true if the condition is negated
type NumberArrayCondition struct {
	FieldPath  []string                  `protobuf:"bytes,1,rep,name=field_path,json=fieldPath" json:"field_path,omitempty"`
	Values     []float64                 `protobuf:"fixed64,2,rep,packed,name=values" json:"values,omitempty"`
	Type       NumberArrayCondition_Type `protobuf:"varint,3,opt,name=type,enum=infoblox.api.NumberArrayCondition_Type" json:"type,omitempty"`
	IsNegative bool                      `protobuf:"varint,4,opt,name=is_negative,json=isNegative" json:"is_negative,omitempty"`
}

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

func (m *NumberArrayCondition) GetFieldPath() []string {
	if m != nil {
		return m.FieldPath
	}
	return nil
}

func (m *NumberArrayCondition) GetValues() []float64 {
	if m != nil {
		return m.Values
	}
	return nil
}

func (m *NumberArrayCondition) GetType() NumberArrayCondition_Type {
	if m != nil {
		return m.Type
	}
	return NumberArrayCondition_IN
}

func (m *NumberArrayCondition) GetIsNegative() bool {
	if m != nil {
		return m.IsNegative
	}
	return false
}

// Pagination represents both server-driven and client-driven pagination request.
// Server-driven pagination is a model in which the server returns some
// amount of data along with an token indicating there is more data
// and where subsequent queries can get the next page of data.
// Client-driven pagination is a model in which rows are addressable by
// offset and page size (limit).
type Pagination struct {
	// The service-defined string used to identify a page of resources.
	// A null value indicates the first page.
	PageToken string `protobuf:"bytes,1,opt,name=page_token,json=pageToken" json:"page_token,omitempty"`
	// The integer index of the offset into a collection of resources.
	// If omitted or null the value is assumed to be "0".
	Offset int32 `protobuf:"varint,2,opt,name=offset" json:"offset,omitempty"`
	// The integer number of resources to be returned in the response.
	// The service may impose maximum value.
	// If omitted the service may impose a default value.
	Limit int32 `protobuf:"varint,3,opt,name=limit" json:"limit,omitempty"`
}

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

func (m *Pagination) GetPageToken() string {
	if m != nil {
		return m.PageToken
	}
	return ""
}

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

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

// PageInfo represents both server-driven and client-driven pagination response.
// Server-driven pagination is a model in which the server returns some
// amount of data along with an token indicating there is more data
// and where subsequent queries can get the next page of data.
// Client-driven pagination is a model in which rows are addressable by
// offset and page size (limit).
type PageInfo struct {
	// The service response should contain a string to indicate
	// the next page of resources.
	// A null value indicates no more pages.
	PageToken string `protobuf:"bytes,1,opt,name=page_token,json=pageToken" json:"page_token,omitempty"`
	// The service may optionally include the total number of resources being paged.
	Size int32 `protobuf:"varint,2,opt,name=size" json:"size,omitempty"`
	// The service may optionally include the offset of the next page of resources.
	// A null value indicates no more pages.
	Offset int32 `protobuf:"varint,3,opt,name=offset" json:"offset,omitempty"`
}

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

func (m *PageInfo) GetPageToken() string {
	if m != nil {
		return m.PageToken
	}
	return ""
}

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

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

func init() {
	proto.RegisterType((*SortCriteria)(nil), "infoblox.api.SortCriteria")
	proto.RegisterType((*Sorting)(nil), "infoblox.api.Sorting")
	proto.RegisterType((*FieldSelection)(nil), "infoblox.api.FieldSelection")
	proto.RegisterType((*Field)(nil), "infoblox.api.Field")
	proto.RegisterType((*Filtering)(nil), "infoblox.api.Filtering")
	proto.RegisterType((*LogicalOperator)(nil), "infoblox.api.LogicalOperator")
	proto.RegisterType((*StringCondition)(nil), "infoblox.api.StringCondition")
	proto.RegisterType((*NumberCondition)(nil), "infoblox.api.NumberCondition")
	proto.RegisterType((*NullCondition)(nil), "infoblox.api.NullCondition")
	proto.RegisterType((*StringArrayCondition)(nil), "infoblox.api.StringArrayCondition")
	proto.RegisterType((*NumberArrayCondition)(nil), "infoblox.api.NumberArrayCondition")
	proto.RegisterType((*Pagination)(nil), "infoblox.api.Pagination")
	proto.RegisterType((*PageInfo)(nil), "infoblox.api.PageInfo")
	proto.RegisterEnum("infoblox.api.SortCriteria_Order", SortCriteria_Order_name, SortCriteria_Order_value)
	proto.RegisterEnum("infoblox.api.LogicalOperator_Type", LogicalOperator_Type_name, LogicalOperator_Type_value)
	proto.RegisterEnum("infoblox.api.StringCondition_Type", StringCondition_Type_name, StringCondition_Type_value)
	proto.RegisterEnum("infoblox.api.NumberCondition_Type", NumberCondition_Type_name, NumberCondition_Type_value)
	proto.RegisterEnum("infoblox.api.StringArrayCondition_Type", StringArrayCondition_Type_name, StringArrayCondition_Type_value)
	proto.RegisterEnum("infoblox.api.NumberArrayCondition_Type", NumberArrayCondition_Type_name, NumberArrayCondition_Type_value)
}

func init() {
	proto.RegisterFile("github.com/infobloxopen/atlas-app-toolkit/query/collection_operators.proto", fileDescriptor0)
}

var fileDescriptor0 = []byte{
	// 1120 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x57, 0xd1, 0x52, 0xdb, 0x46,
	0x14, 0xf5, 0xda, 0xb2, 0x41, 0x17, 0x30, 0xca, 0x42, 0x89, 0x81, 0xa4, 0xa1, 0x9a, 0xce, 0x94,
	0xce, 0x14, 0x7b, 0xea, 0x4e, 0xd3, 0x0c, 0xbc, 0xd4, 0x80, 0x29, 0x64, 0x08, 0x10, 0x99, 0xbc,
	0xe4, 0xc5, 0xb3, 0x36, 0x6b, 0xa1, 0x41, 0x68, 0x55, 0x69, 0x4d, 0xeb, 0x7e, 0x40, 0x3f, 0x80,
	0xc7, 0x4e, 0xbf, 0xa2, 0xaf, 0xfd, 0x81, 0xbe, 0xf5, 0x23, 0xfa, 0x23, 0x9d, 0x5d, 0xad, 0x6c,
	0x59, 0x16, 0xc1, 0x4e, 0x5e, 0x2c, 0xed, 0x9d, 0x7b, 0xcf, 0xb9, 0xe7, 0xee, 0x91, 0xb5, 0x82,
	0xd7, 0xb6, 0xc3, 0xaf, 0xfb, 0x9d, 0x6a, 0x97, 0xdd, 0xd6, 0x1c, 0xaf, 0xc7, 0x3a, 0x2e, 0xfb,
	0x95, 0xf9, 0xd4, 0xab, 0x11, 0xee, 0x92, 0x70, 0x87, 0xf8, 0xfe, 0x0e, 0x67, 0xcc, 0xbd, 0x71,
	0x78, 0xed, 0xe7, 0x3e, 0x0d, 0x06, 0xb5, 0x2e, 0x73, 0x5d, 0xda, 0xe5, 0x0e, 0xf3, 0xda, 0xcc,
	0xa7, 0x01, 0xe1, 0x2c, 0x08, 0xab, 0x7e, 0xc0, 0x38, 0xc3, 0x8b, 0x31, 0x40, 0x95, 0xf8, 0xce,
	0xc6, 0x37, 0x32, 0xd8, 0xdd, 0xb1, 0xa9, 0xb7, 0x13, 0xfe, 0x42, 0x6c, 0x9b, 0x06, 0x35, 0xe6,
	0x8b, 0xc2, 0xb0, 0x46, 0x3c, 0x8f, 0x71, 0x22, 0xef, 0xa3, 0x5a, 0x93, 0xc3, 0x62, 0x8b, 0x05,
	0xfc, 0x20, 0x70, 0x38, 0x0d, 0x1c, 0x82, 0x0d, 0x28, 0x70, 0x62, 0x57, 0xd0, 0x16, 0xda, 0xd6,
	0x2d, 0x71, 0x8b, 0x5f, 0x42, 0x91, 0x05, 0x57, 0x34, 0xa8, 0xe4, 0xb7, 0xd0, 0x76, 0xb9, 0xbe,
	0x55, 0x4d, 0xb2, 0x55, 0x93, 0xc5, 0xd5, 0x73, 0x91, 0x67, 0x45, 0xe9, 0xe6, 0x06, 0x14, 0xe5,
	0x1a, 0xcf, 0x41, 0xa1, 0xd1, 0x3a, 0x30, 0x72, 0x78, 0x1e, 0xb4, 0xc3, 0x66, 0xeb, 0xc0, 0x40,
	0x26, 0x81, 0x39, 0x51, 0xe8, 0x78, 0x36, 0x7e, 0x05, 0x7a, 0x57, 0xd5, 0x87, 0x15, 0xb4, 0x55,
	0xd8, 0x5e, 0xa8, 0x6f, 0x3c, 0x4c, 0x61, 0x8d, 0x92, 0x77, 0x9f, 0xdd, 0x37, 0xd6, 0xe1, 0x69,
	0xfd, 0x89, 0x9c, 0x98, 0xcc, 0x0c, 0x23, 0xcc, 0x3f, 0xf2, 0x68, 0xce, 0xfc, 0x07, 0x41, 0xf9,
	0xc8, 0xa1, 0xee, 0x55, 0x8b, 0xaa, 0xb9, 0xe1, 0x1f, 0xa1, 0xd4, 0x13, 0x91, 0x98, 0x67, 0x7b,
	0x9c, 0x67, 0x3c, 0x3b, 0x5a, 0x86, 0x4d, 0x8f, 0x07, 0x03, 0x4b, 0xd5, 0x6d, 0x9c, 0xc1, 0x42,
	0x22, 0x2c, 0x86, 0x75, 0x43, 0x07, 0xf1, 0xb0, 0x6e, 0xe8, 0x00, 0x7f, 0x0d, 0xc5, 0x3b, 0xe2,
	0xf6, 0xa9, 0x1c, 0xd6, 0x42, 0x7d, 0x25, 0x83, 0xc1, 0x8a, 0x32, 0x76, 0xf3, 0xaf, 0xd0, 0xee,
	0x97, 0xf7, 0x8d, 0x2f, 0xe0, 0x45, 0x7d, 0x7d, 0x24, 0x41, 0x12, 0xb5, 0xc3, 0xb8, 0x0b, 0x29,
	0xe5, 0x4f, 0x04, 0x45, 0x59, 0x8a, 0x31, 0x68, 0x1e, 0xb9, 0xa5, 0x8a, 0x51, 0xde, 0xe3, 0x6f,
	0x41, 0x0b, 0xfb, 0x9d, 0xb0, 0x92, 0x97, 0x9a, 0x9e, 0x67, 0x30, 0x56, 0x5b, 0xfd, 0x8e, 0x12,
	0x22, 0x53, 0x37, 0x4e, 0x41, 0x1f, 0x86, 0x3e, 0x59, 0x84, 0xf9, 0xbb, 0x06, 0xfa, 0x91, 0xe3,
	0x8a, 0x5d, 0xf1, 0x6c, 0xbc, 0x07, 0xf3, 0xb1, 0x3f, 0x25, 0xe6, 0x44, 0x4b, 0xa7, 0xcc, 0x76,
	0xba, 0xc4, 0x3d, 0x57, 0x49, 0xc7, 0x39, 0x6b, 0x58, 0x80, 0x5f, 0x83, 0x11, 0x72, 0x01, 0xd3,
	0xee, 0x32, 0xef, 0xca, 0x11, 0x13, 0x50, 0x4d, 0xa4, 0x40, 0x5a, 0x32, 0xeb, 0x20, 0x4e, 0x3a,
	0xce, 0x59, 0xcb, 0xe1, 0x78, 0x48, 0x60, 0x79, 0xfd, 0xdb, 0x0e, 0x0d, 0x12, 0x58, 0x85, 0x2c,
	0xac, 0x33, 0x99, 0x35, 0x86, 0xe5, 0x8d, 0x87, 0xf0, 0x21, 0x94, 0xbd, 0xbe, 0xeb, 0x26, 0x90,
	0x34, 0x89, 0xb4, 0x99, 0x46, 0x72, 0xdd, 0x24, 0xce, 0x92, 0x97, 0x0c, 0xe0, 0xf7, 0xb0, 0xa6,
	0xd4, 0x91, 0x20, 0x20, 0x83, 0x04, 0x5a, 0x51, 0xa2, 0x99, 0x59, 0x1a, 0x1b, 0x22, 0x35, 0x09,
	0xba, 0x1a, 0x66, 0xc4, 0x05, 0xb6, 0x52, 0x9b, 0xc6, 0x2e, 0x65, 0x61, 0x47, 0x9a, 0x27, 0xb1,
	0xbd, 0x8c, 0xf8, 0xee, 0xe7, 0xf7, 0x8d, 0x4d, 0x58, 0xaf, 0xaf, 0x24, 0x5d, 0xaa, 0xb6, 0x5b,
	0xf8, 0x73, 0xbf, 0x04, 0x5a, 0xc0, 0x18, 0x37, 0xff, 0xd2, 0x61, 0x39, 0xb5, 0xbb, 0xf8, 0x10,
	0x96, 0x5c, 0xda, 0xe3, 0xed, 0x59, 0x3d, 0xb1, 0x28, 0xaa, 0x86, 0x28, 0x2d, 0xf8, 0x4c, 0xa2,
	0x7c, 0xac, 0x39, 0x56, 0x44, 0x75, 0x2a, 0x3c, 0x04, 0xfd, 0x58, 0x97, 0x48, 0xd0, 0x54, 0x18,
	0xbf, 0x81, 0x15, 0x05, 0x3a, 0xbb, 0x5d, 0x9e, 0x44, 0x80, 0x49, 0xcb, 0x74, 0x61, 0x33, 0x29,
	0x3c, 0xbd, 0xb7, 0x0b, 0x33, 0xf8, 0xa6, 0x32, 0x9a, 0x41, 0xca, 0x3b, 0x31, 0xc9, 0x03, 0x06,
	0x5a, 0x9c, 0xc1, 0x40, 0x95, 0xd1, 0x4c, 0x52, 0x24, 0x47, 0x50, 0x0e, 0x1c, 0xfb, 0x3a, 0xe1,
	0x84, 0xe2, 0x34, 0x4e, 0x40, 0xd6, 0x92, 0x2c, 0x1b, 0x5a, 0xe1, 0x1d, 0xac, 0x45, 0x38, 0x13,
	0x5e, 0x28, 0x4d, 0xe3, 0x05, 0x64, 0xad, 0xca, 0xf2, 0xb4, 0x19, 0x86, 0xb0, 0x13, 0x6e, 0x98,
	0x9b, 0xc6, 0x0d, 0x31, 0x6c, 0xda, 0x0e, 0xe7, 0xb0, 0x1a, 0xc3, 0x8e, 0xf9, 0x61, 0xfe, 0x71,
	0x3f, 0x20, 0x0b, 0x2b, 0xc8, 0xa4, 0x21, 0x28, 0x3c, 0x1b, 0x93, 0x9f, 0xde, 0xac, 0xa5, 0xa9,
	0x1d, 0x81, 0xac, 0xf5, 0xc4, 0x24, 0x52, 0xbb, 0x35, 0xa4, 0x79, 0xc0, 0x13, 0xe5, 0xa9, 0x3d,
	0x11, 0xd3, 0x64, 0x9a, 0xe2, 0x25, 0x68, 0x7c, 0xe0, 0xd3, 0x8a, 0x2e, 0x8f, 0x16, 0xe6, 0x07,
	0xad, 0x50, 0xbd, 0x1c, 0xf8, 0xd4, 0x92, 0xf9, 0xf8, 0x05, 0x2c, 0x38, 0x61, 0xdb, 0xa3, 0x36,
	0xe1, 0xce, 0x1d, 0xad, 0xc0, 0x16, 0xda, 0x9e, 0xb7, 0xc0, 0x09, 0xcf, 0x54, 0xc4, 0x7c, 0x0a,
	0x9a, 0x48, 0x97, 0x67, 0x8f, 0xb3, 0x43, 0x23, 0x87, 0x4b, 0x90, 0x3f, 0xb7, 0x0c, 0x24, 0xfe,
	0xab, 0x84, 0x45, 0xf7, 0xe7, 0xa0, 0x28, 0xdb, 0x32, 0xff, 0x43, 0xb0, 0x9c, 0x36, 0xc3, 0x73,
	0x80, 0xe8, 0x3d, 0xec, 0x13, 0x7e, 0x2d, 0x0f, 0x0b, 0xba, 0xa5, 0xcb, 0xc8, 0x05, 0xe1, 0xd7,
	0x78, 0x35, 0xf9, 0x7e, 0xd4, 0xd5, 0xab, 0x70, 0xa8, 0xa5, 0x90, 0xa5, 0x25, 0xc5, 0xf0, 0x01,
	0x2d, 0xda, 0x84, 0x96, 0x7d, 0xa5, 0xa5, 0x04, 0xf9, 0xe6, 0x5b, 0x23, 0x87, 0x75, 0x28, 0xbe,
	0x69, 0x5c, 0x1e, 0x1c, 0x1b, 0x48, 0x84, 0x7e, 0xba, 0x34, 0xf2, 0xf2, 0xda, 0x34, 0x0a, 0xe2,
	0x7a, 0x7a, 0x69, 0x68, 0xf2, 0xda, 0x34, 0x8a, 0x42, 0xfe, 0x49, 0xf3, 0xad, 0x51, 0x32, 0xff,
	0x45, 0xb0, 0x9c, 0xf6, 0xe6, 0x2c, 0x2a, 0xd1, 0x54, 0x2a, 0x53, 0x0c, 0x33, 0xa9, 0xac, 0xa6,
	0x54, 0x46, 0xd2, 0x90, 0x92, 0x96, 0x57, 0xd2, 0x0a, 0x4a, 0x9a, 0x66, 0x9e, 0xc3, 0xd2, 0xf8,
	0x93, 0xf1, 0x88, 0x9c, 0x54, 0x03, 0xf9, 0x89, 0x06, 0xfe, 0x46, 0xb0, 0x9a, 0xf9, 0x2c, 0x3c,
	0x02, 0xbc, 0x06, 0x25, 0x39, 0x9a, 0xe8, 0x04, 0xa6, 0x5b, 0x6a, 0x85, 0xf7, 0xc6, 0x26, 0xf5,
	0xd5, 0xe3, 0x4f, 0xe4, 0x4c, 0xe3, 0x2a, 0x8f, 0xc6, 0x75, 0x72, 0x66, 0xe4, 0x64, 0xf7, 0x99,
	0x8f, 0xd8, 0x4c, 0xdd, 0xa3, 0xe9, 0xba, 0xcf, 0x22, 0xfa, 0xa4, 0xee, 0xef, 0x00, 0x2e, 0x88,
	0xed, 0x78, 0x24, 0x6e, 0xd9, 0x27, 0x36, 0x6d, 0x73, 0x76, 0x43, 0x3d, 0x75, 0x30, 0xd5, 0x45,
	0xe4, 0x52, 0x04, 0x44, 0xcb, 0xac, 0xd7, 0x0b, 0x29, 0x97, 0x9b, 0x58, 0xb4, 0xd4, 0x4a, 0x18,
	0xd6, 0x75, 0x6e, 0x1d, 0x2e, 0x7b, 0x2e, 0x5a, 0xd1, 0x62, 0x77, 0xf3, 0xbe, 0x51, 0x81, 0xb5,
	0xba, 0x31, 0x3a, 0xbc, 0xf8, 0x82, 0x29, 0xfa, 0x48, 0x78, 0x07, 0xf3, 0x17, 0xc4, 0xa6, 0x27,
	0x5e, 0x8f, 0x3d, 0xc6, 0x8a, 0x41, 0x0b, 0x9d, 0xdf, 0xa8, 0xe2, 0x94, 0xf7, 0x89, 0x4e, 0x0a,
	0xc9, 0x4e, 0xf6, 0x7f, 0x78, 0xff, 0xfd, 0x8c, 0x9f, 0x77, 0x7b, 0xf2, 0xb7, 0x53, 0x92, 0x1f,
	0x65, 0xdf, 0xfd, 0x1f, 0x00, 0x00, 0xff, 0xff, 0x3e, 0xc6, 0x6c, 0x28, 0x1e, 0x0e, 0x00, 0x00,
}