// Code generated by protoc-gen-go. DO NOT EDIT.
// source: google/ads/googleads/v1/common/matching_function.proto

package common // import "google.golang.org/genproto/googleapis/ads/googleads/v1/common"

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import wrappers "github.com/golang/protobuf/ptypes/wrappers"
import enums "google.golang.org/genproto/googleapis/ads/googleads/v1/enums"
import _ "google.golang.org/genproto/googleapis/api/annotations"

// 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

// Matching function associated with a
// CustomerFeed, CampaignFeed, or AdGroupFeed. The matching function is used
// to filter the set of feed items selected.
type MatchingFunction struct {
	// String representation of the Function.
	//
	// Examples:
	// 1) IDENTITY(true) or IDENTITY(false). All or none feed items serve.
	// 2) EQUALS(CONTEXT.DEVICE,"Mobile")
	// 3) IN(FEED_ITEM_ID,{1000001,1000002,1000003})
	// 4) CONTAINS_ANY(FeedAttribute[12345678,0],{"Mars cruise","Venus cruise"})
	// 5) AND(IN(FEED_ITEM_ID,{10001,10002}),EQUALS(CONTEXT.DEVICE,"Mobile"))
	// See
	//
	// https:
	// //developers.google.com/adwords/api/docs/guides/feed-matching-functions
	//
	// Note that because multiple strings may represent the same underlying
	// function (whitespace and single versus double quotation marks, for
	// example), the value returned may not be identical to the string sent in a
	// mutate request.
	FunctionString *wrappers.StringValue `protobuf:"bytes,1,opt,name=function_string,json=functionString,proto3" json:"function_string,omitempty"`
	// Operator for a function.
	Operator enums.MatchingFunctionOperatorEnum_MatchingFunctionOperator `protobuf:"varint,4,opt,name=operator,proto3,enum=google.ads.googleads.v1.enums.MatchingFunctionOperatorEnum_MatchingFunctionOperator" json:"operator,omitempty"`
	// The operands on the left hand side of the equation. This is also the
	// operand to be used for single operand expressions such as NOT.
	LeftOperands []*Operand `protobuf:"bytes,2,rep,name=left_operands,json=leftOperands,proto3" json:"left_operands,omitempty"`
	// The operands on the right hand side of the equation.
	RightOperands        []*Operand `protobuf:"bytes,3,rep,name=right_operands,json=rightOperands,proto3" json:"right_operands,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

func (m *MatchingFunction) Reset()         { *m = MatchingFunction{} }
func (m *MatchingFunction) String() string { return proto.CompactTextString(m) }
func (*MatchingFunction) ProtoMessage()    {}
func (*MatchingFunction) Descriptor() ([]byte, []int) {
	return fileDescriptor_matching_function_bb47824ec6458466, []int{0}
}
func (m *MatchingFunction) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_MatchingFunction.Unmarshal(m, b)
}
func (m *MatchingFunction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_MatchingFunction.Marshal(b, m, deterministic)
}
func (dst *MatchingFunction) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MatchingFunction.Merge(dst, src)
}
func (m *MatchingFunction) XXX_Size() int {
	return xxx_messageInfo_MatchingFunction.Size(m)
}
func (m *MatchingFunction) XXX_DiscardUnknown() {
	xxx_messageInfo_MatchingFunction.DiscardUnknown(m)
}

var xxx_messageInfo_MatchingFunction proto.InternalMessageInfo

func (m *MatchingFunction) GetFunctionString() *wrappers.StringValue {
	if m != nil {
		return m.FunctionString
	}
	return nil
}

func (m *MatchingFunction) GetOperator() enums.MatchingFunctionOperatorEnum_MatchingFunctionOperator {
	if m != nil {
		return m.Operator
	}
	return enums.MatchingFunctionOperatorEnum_UNSPECIFIED
}

func (m *MatchingFunction) GetLeftOperands() []*Operand {
	if m != nil {
		return m.LeftOperands
	}
	return nil
}

func (m *MatchingFunction) GetRightOperands() []*Operand {
	if m != nil {
		return m.RightOperands
	}
	return nil
}

// An operand in a matching function.
type Operand struct {
	// Different operands that can be used in a matching function. Required.
	//
	// Types that are valid to be assigned to FunctionArgumentOperand:
	//	*Operand_ConstantOperand_
	//	*Operand_FeedAttributeOperand_
	//	*Operand_FunctionOperand_
	//	*Operand_RequestContextOperand_
	FunctionArgumentOperand isOperand_FunctionArgumentOperand `protobuf_oneof:"function_argument_operand"`
	XXX_NoUnkeyedLiteral    struct{}                          `json:"-"`
	XXX_unrecognized        []byte                            `json:"-"`
	XXX_sizecache           int32                             `json:"-"`
}

func (m *Operand) Reset()         { *m = Operand{} }
func (m *Operand) String() string { return proto.CompactTextString(m) }
func (*Operand) ProtoMessage()    {}
func (*Operand) Descriptor() ([]byte, []int) {
	return fileDescriptor_matching_function_bb47824ec6458466, []int{1}
}
func (m *Operand) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Operand.Unmarshal(m, b)
}
func (m *Operand) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Operand.Marshal(b, m, deterministic)
}
func (dst *Operand) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Operand.Merge(dst, src)
}
func (m *Operand) XXX_Size() int {
	return xxx_messageInfo_Operand.Size(m)
}
func (m *Operand) XXX_DiscardUnknown() {
	xxx_messageInfo_Operand.DiscardUnknown(m)
}

var xxx_messageInfo_Operand proto.InternalMessageInfo

type isOperand_FunctionArgumentOperand interface {
	isOperand_FunctionArgumentOperand()
}

type Operand_ConstantOperand_ struct {
	ConstantOperand *Operand_ConstantOperand `protobuf:"bytes,1,opt,name=constant_operand,json=constantOperand,proto3,oneof"`
}

type Operand_FeedAttributeOperand_ struct {
	FeedAttributeOperand *Operand_FeedAttributeOperand `protobuf:"bytes,2,opt,name=feed_attribute_operand,json=feedAttributeOperand,proto3,oneof"`
}

type Operand_FunctionOperand_ struct {
	FunctionOperand *Operand_FunctionOperand `protobuf:"bytes,3,opt,name=function_operand,json=functionOperand,proto3,oneof"`
}

type Operand_RequestContextOperand_ struct {
	RequestContextOperand *Operand_RequestContextOperand `protobuf:"bytes,4,opt,name=request_context_operand,json=requestContextOperand,proto3,oneof"`
}

func (*Operand_ConstantOperand_) isOperand_FunctionArgumentOperand() {}

func (*Operand_FeedAttributeOperand_) isOperand_FunctionArgumentOperand() {}

func (*Operand_FunctionOperand_) isOperand_FunctionArgumentOperand() {}

func (*Operand_RequestContextOperand_) isOperand_FunctionArgumentOperand() {}

func (m *Operand) GetFunctionArgumentOperand() isOperand_FunctionArgumentOperand {
	if m != nil {
		return m.FunctionArgumentOperand
	}
	return nil
}

func (m *Operand) GetConstantOperand() *Operand_ConstantOperand {
	if x, ok := m.GetFunctionArgumentOperand().(*Operand_ConstantOperand_); ok {
		return x.ConstantOperand
	}
	return nil
}

func (m *Operand) GetFeedAttributeOperand() *Operand_FeedAttributeOperand {
	if x, ok := m.GetFunctionArgumentOperand().(*Operand_FeedAttributeOperand_); ok {
		return x.FeedAttributeOperand
	}
	return nil
}

func (m *Operand) GetFunctionOperand() *Operand_FunctionOperand {
	if x, ok := m.GetFunctionArgumentOperand().(*Operand_FunctionOperand_); ok {
		return x.FunctionOperand
	}
	return nil
}

func (m *Operand) GetRequestContextOperand() *Operand_RequestContextOperand {
	if x, ok := m.GetFunctionArgumentOperand().(*Operand_RequestContextOperand_); ok {
		return x.RequestContextOperand
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*Operand) 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 _Operand_OneofMarshaler, _Operand_OneofUnmarshaler, _Operand_OneofSizer, []interface{}{
		(*Operand_ConstantOperand_)(nil),
		(*Operand_FeedAttributeOperand_)(nil),
		(*Operand_FunctionOperand_)(nil),
		(*Operand_RequestContextOperand_)(nil),
	}
}

func _Operand_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*Operand)
	// function_argument_operand
	switch x := m.FunctionArgumentOperand.(type) {
	case *Operand_ConstantOperand_:
		b.EncodeVarint(1<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.ConstantOperand); err != nil {
			return err
		}
	case *Operand_FeedAttributeOperand_:
		b.EncodeVarint(2<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.FeedAttributeOperand); err != nil {
			return err
		}
	case *Operand_FunctionOperand_:
		b.EncodeVarint(3<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.FunctionOperand); err != nil {
			return err
		}
	case *Operand_RequestContextOperand_:
		b.EncodeVarint(4<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.RequestContextOperand); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("Operand.FunctionArgumentOperand has unexpected type %T", x)
	}
	return nil
}

func _Operand_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*Operand)
	switch tag {
	case 1: // function_argument_operand.constant_operand
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Operand_ConstantOperand)
		err := b.DecodeMessage(msg)
		m.FunctionArgumentOperand = &Operand_ConstantOperand_{msg}
		return true, err
	case 2: // function_argument_operand.feed_attribute_operand
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Operand_FeedAttributeOperand)
		err := b.DecodeMessage(msg)
		m.FunctionArgumentOperand = &Operand_FeedAttributeOperand_{msg}
		return true, err
	case 3: // function_argument_operand.function_operand
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Operand_FunctionOperand)
		err := b.DecodeMessage(msg)
		m.FunctionArgumentOperand = &Operand_FunctionOperand_{msg}
		return true, err
	case 4: // function_argument_operand.request_context_operand
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(Operand_RequestContextOperand)
		err := b.DecodeMessage(msg)
		m.FunctionArgumentOperand = &Operand_RequestContextOperand_{msg}
		return true, err
	default:
		return false, nil
	}
}

func _Operand_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*Operand)
	// function_argument_operand
	switch x := m.FunctionArgumentOperand.(type) {
	case *Operand_ConstantOperand_:
		s := proto.Size(x.ConstantOperand)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Operand_FeedAttributeOperand_:
		s := proto.Size(x.FeedAttributeOperand)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Operand_FunctionOperand_:
		s := proto.Size(x.FunctionOperand)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Operand_RequestContextOperand_:
		s := proto.Size(x.RequestContextOperand)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

// A constant operand in a matching function.
type Operand_ConstantOperand struct {
	// Constant operand values. Required.
	//
	// Types that are valid to be assigned to ConstantOperandValue:
	//	*Operand_ConstantOperand_StringValue
	//	*Operand_ConstantOperand_LongValue
	//	*Operand_ConstantOperand_BooleanValue
	//	*Operand_ConstantOperand_DoubleValue
	ConstantOperandValue isOperand_ConstantOperand_ConstantOperandValue `protobuf_oneof:"constant_operand_value"`
	XXX_NoUnkeyedLiteral struct{}                                       `json:"-"`
	XXX_unrecognized     []byte                                         `json:"-"`
	XXX_sizecache        int32                                          `json:"-"`
}

func (m *Operand_ConstantOperand) Reset()         { *m = Operand_ConstantOperand{} }
func (m *Operand_ConstantOperand) String() string { return proto.CompactTextString(m) }
func (*Operand_ConstantOperand) ProtoMessage()    {}
func (*Operand_ConstantOperand) Descriptor() ([]byte, []int) {
	return fileDescriptor_matching_function_bb47824ec6458466, []int{1, 0}
}
func (m *Operand_ConstantOperand) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Operand_ConstantOperand.Unmarshal(m, b)
}
func (m *Operand_ConstantOperand) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Operand_ConstantOperand.Marshal(b, m, deterministic)
}
func (dst *Operand_ConstantOperand) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Operand_ConstantOperand.Merge(dst, src)
}
func (m *Operand_ConstantOperand) XXX_Size() int {
	return xxx_messageInfo_Operand_ConstantOperand.Size(m)
}
func (m *Operand_ConstantOperand) XXX_DiscardUnknown() {
	xxx_messageInfo_Operand_ConstantOperand.DiscardUnknown(m)
}

var xxx_messageInfo_Operand_ConstantOperand proto.InternalMessageInfo

type isOperand_ConstantOperand_ConstantOperandValue interface {
	isOperand_ConstantOperand_ConstantOperandValue()
}

type Operand_ConstantOperand_StringValue struct {
	StringValue *wrappers.StringValue `protobuf:"bytes,1,opt,name=string_value,json=stringValue,proto3,oneof"`
}

type Operand_ConstantOperand_LongValue struct {
	LongValue *wrappers.Int64Value `protobuf:"bytes,2,opt,name=long_value,json=longValue,proto3,oneof"`
}

type Operand_ConstantOperand_BooleanValue struct {
	BooleanValue *wrappers.BoolValue `protobuf:"bytes,3,opt,name=boolean_value,json=booleanValue,proto3,oneof"`
}

type Operand_ConstantOperand_DoubleValue struct {
	DoubleValue *wrappers.DoubleValue `protobuf:"bytes,4,opt,name=double_value,json=doubleValue,proto3,oneof"`
}

func (*Operand_ConstantOperand_StringValue) isOperand_ConstantOperand_ConstantOperandValue() {}

func (*Operand_ConstantOperand_LongValue) isOperand_ConstantOperand_ConstantOperandValue() {}

func (*Operand_ConstantOperand_BooleanValue) isOperand_ConstantOperand_ConstantOperandValue() {}

func (*Operand_ConstantOperand_DoubleValue) isOperand_ConstantOperand_ConstantOperandValue() {}

func (m *Operand_ConstantOperand) GetConstantOperandValue() isOperand_ConstantOperand_ConstantOperandValue {
	if m != nil {
		return m.ConstantOperandValue
	}
	return nil
}

func (m *Operand_ConstantOperand) GetStringValue() *wrappers.StringValue {
	if x, ok := m.GetConstantOperandValue().(*Operand_ConstantOperand_StringValue); ok {
		return x.StringValue
	}
	return nil
}

func (m *Operand_ConstantOperand) GetLongValue() *wrappers.Int64Value {
	if x, ok := m.GetConstantOperandValue().(*Operand_ConstantOperand_LongValue); ok {
		return x.LongValue
	}
	return nil
}

func (m *Operand_ConstantOperand) GetBooleanValue() *wrappers.BoolValue {
	if x, ok := m.GetConstantOperandValue().(*Operand_ConstantOperand_BooleanValue); ok {
		return x.BooleanValue
	}
	return nil
}

func (m *Operand_ConstantOperand) GetDoubleValue() *wrappers.DoubleValue {
	if x, ok := m.GetConstantOperandValue().(*Operand_ConstantOperand_DoubleValue); ok {
		return x.DoubleValue
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*Operand_ConstantOperand) 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 _Operand_ConstantOperand_OneofMarshaler, _Operand_ConstantOperand_OneofUnmarshaler, _Operand_ConstantOperand_OneofSizer, []interface{}{
		(*Operand_ConstantOperand_StringValue)(nil),
		(*Operand_ConstantOperand_LongValue)(nil),
		(*Operand_ConstantOperand_BooleanValue)(nil),
		(*Operand_ConstantOperand_DoubleValue)(nil),
	}
}

func _Operand_ConstantOperand_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*Operand_ConstantOperand)
	// constant_operand_value
	switch x := m.ConstantOperandValue.(type) {
	case *Operand_ConstantOperand_StringValue:
		b.EncodeVarint(1<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.StringValue); err != nil {
			return err
		}
	case *Operand_ConstantOperand_LongValue:
		b.EncodeVarint(2<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.LongValue); err != nil {
			return err
		}
	case *Operand_ConstantOperand_BooleanValue:
		b.EncodeVarint(3<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.BooleanValue); err != nil {
			return err
		}
	case *Operand_ConstantOperand_DoubleValue:
		b.EncodeVarint(4<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.DoubleValue); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("Operand_ConstantOperand.ConstantOperandValue has unexpected type %T", x)
	}
	return nil
}

func _Operand_ConstantOperand_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*Operand_ConstantOperand)
	switch tag {
	case 1: // constant_operand_value.string_value
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(wrappers.StringValue)
		err := b.DecodeMessage(msg)
		m.ConstantOperandValue = &Operand_ConstantOperand_StringValue{msg}
		return true, err
	case 2: // constant_operand_value.long_value
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(wrappers.Int64Value)
		err := b.DecodeMessage(msg)
		m.ConstantOperandValue = &Operand_ConstantOperand_LongValue{msg}
		return true, err
	case 3: // constant_operand_value.boolean_value
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(wrappers.BoolValue)
		err := b.DecodeMessage(msg)
		m.ConstantOperandValue = &Operand_ConstantOperand_BooleanValue{msg}
		return true, err
	case 4: // constant_operand_value.double_value
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(wrappers.DoubleValue)
		err := b.DecodeMessage(msg)
		m.ConstantOperandValue = &Operand_ConstantOperand_DoubleValue{msg}
		return true, err
	default:
		return false, nil
	}
}

func _Operand_ConstantOperand_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*Operand_ConstantOperand)
	// constant_operand_value
	switch x := m.ConstantOperandValue.(type) {
	case *Operand_ConstantOperand_StringValue:
		s := proto.Size(x.StringValue)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Operand_ConstantOperand_LongValue:
		s := proto.Size(x.LongValue)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Operand_ConstantOperand_BooleanValue:
		s := proto.Size(x.BooleanValue)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Operand_ConstantOperand_DoubleValue:
		s := proto.Size(x.DoubleValue)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case nil:
	default:
		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
	}
	return n
}

// A feed attribute operand in a matching function.
// Used to represent a feed attribute in feed.
type Operand_FeedAttributeOperand struct {
	// The associated feed. Required.
	FeedId *wrappers.Int64Value `protobuf:"bytes,1,opt,name=feed_id,json=feedId,proto3" json:"feed_id,omitempty"`
	// Id of the referenced feed attribute. Required.
	FeedAttributeId      *wrappers.Int64Value `protobuf:"bytes,2,opt,name=feed_attribute_id,json=feedAttributeId,proto3" json:"feed_attribute_id,omitempty"`
	XXX_NoUnkeyedLiteral struct{}             `json:"-"`
	XXX_unrecognized     []byte               `json:"-"`
	XXX_sizecache        int32                `json:"-"`
}

func (m *Operand_FeedAttributeOperand) Reset()         { *m = Operand_FeedAttributeOperand{} }
func (m *Operand_FeedAttributeOperand) String() string { return proto.CompactTextString(m) }
func (*Operand_FeedAttributeOperand) ProtoMessage()    {}
func (*Operand_FeedAttributeOperand) Descriptor() ([]byte, []int) {
	return fileDescriptor_matching_function_bb47824ec6458466, []int{1, 1}
}
func (m *Operand_FeedAttributeOperand) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Operand_FeedAttributeOperand.Unmarshal(m, b)
}
func (m *Operand_FeedAttributeOperand) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Operand_FeedAttributeOperand.Marshal(b, m, deterministic)
}
func (dst *Operand_FeedAttributeOperand) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Operand_FeedAttributeOperand.Merge(dst, src)
}
func (m *Operand_FeedAttributeOperand) XXX_Size() int {
	return xxx_messageInfo_Operand_FeedAttributeOperand.Size(m)
}
func (m *Operand_FeedAttributeOperand) XXX_DiscardUnknown() {
	xxx_messageInfo_Operand_FeedAttributeOperand.DiscardUnknown(m)
}

var xxx_messageInfo_Operand_FeedAttributeOperand proto.InternalMessageInfo

func (m *Operand_FeedAttributeOperand) GetFeedId() *wrappers.Int64Value {
	if m != nil {
		return m.FeedId
	}
	return nil
}

func (m *Operand_FeedAttributeOperand) GetFeedAttributeId() *wrappers.Int64Value {
	if m != nil {
		return m.FeedAttributeId
	}
	return nil
}

// A function operand in a matching function.
// Used to represent nested functions.
type Operand_FunctionOperand struct {
	// The matching function held in this operand.
	MatchingFunction     *MatchingFunction `protobuf:"bytes,1,opt,name=matching_function,json=matchingFunction,proto3" json:"matching_function,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *Operand_FunctionOperand) Reset()         { *m = Operand_FunctionOperand{} }
func (m *Operand_FunctionOperand) String() string { return proto.CompactTextString(m) }
func (*Operand_FunctionOperand) ProtoMessage()    {}
func (*Operand_FunctionOperand) Descriptor() ([]byte, []int) {
	return fileDescriptor_matching_function_bb47824ec6458466, []int{1, 2}
}
func (m *Operand_FunctionOperand) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Operand_FunctionOperand.Unmarshal(m, b)
}
func (m *Operand_FunctionOperand) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Operand_FunctionOperand.Marshal(b, m, deterministic)
}
func (dst *Operand_FunctionOperand) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Operand_FunctionOperand.Merge(dst, src)
}
func (m *Operand_FunctionOperand) XXX_Size() int {
	return xxx_messageInfo_Operand_FunctionOperand.Size(m)
}
func (m *Operand_FunctionOperand) XXX_DiscardUnknown() {
	xxx_messageInfo_Operand_FunctionOperand.DiscardUnknown(m)
}

var xxx_messageInfo_Operand_FunctionOperand proto.InternalMessageInfo

func (m *Operand_FunctionOperand) GetMatchingFunction() *MatchingFunction {
	if m != nil {
		return m.MatchingFunction
	}
	return nil
}

// An operand in a function referring to a value in the request context.
type Operand_RequestContextOperand struct {
	// Type of value to be referred in the request context.
	ContextType          enums.MatchingFunctionContextTypeEnum_MatchingFunctionContextType `protobuf:"varint,1,opt,name=context_type,json=contextType,proto3,enum=google.ads.googleads.v1.enums.MatchingFunctionContextTypeEnum_MatchingFunctionContextType" json:"context_type,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                                                          `json:"-"`
	XXX_unrecognized     []byte                                                            `json:"-"`
	XXX_sizecache        int32                                                             `json:"-"`
}

func (m *Operand_RequestContextOperand) Reset()         { *m = Operand_RequestContextOperand{} }
func (m *Operand_RequestContextOperand) String() string { return proto.CompactTextString(m) }
func (*Operand_RequestContextOperand) ProtoMessage()    {}
func (*Operand_RequestContextOperand) Descriptor() ([]byte, []int) {
	return fileDescriptor_matching_function_bb47824ec6458466, []int{1, 3}
}
func (m *Operand_RequestContextOperand) XXX_Unmarshal(b []byte) error {
	return xxx_messageInfo_Operand_RequestContextOperand.Unmarshal(m, b)
}
func (m *Operand_RequestContextOperand) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	return xxx_messageInfo_Operand_RequestContextOperand.Marshal(b, m, deterministic)
}
func (dst *Operand_RequestContextOperand) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Operand_RequestContextOperand.Merge(dst, src)
}
func (m *Operand_RequestContextOperand) XXX_Size() int {
	return xxx_messageInfo_Operand_RequestContextOperand.Size(m)
}
func (m *Operand_RequestContextOperand) XXX_DiscardUnknown() {
	xxx_messageInfo_Operand_RequestContextOperand.DiscardUnknown(m)
}

var xxx_messageInfo_Operand_RequestContextOperand proto.InternalMessageInfo

func (m *Operand_RequestContextOperand) GetContextType() enums.MatchingFunctionContextTypeEnum_MatchingFunctionContextType {
	if m != nil {
		return m.ContextType
	}
	return enums.MatchingFunctionContextTypeEnum_UNSPECIFIED
}

func init() {
	proto.RegisterType((*MatchingFunction)(nil), "google.ads.googleads.v1.common.MatchingFunction")
	proto.RegisterType((*Operand)(nil), "google.ads.googleads.v1.common.Operand")
	proto.RegisterType((*Operand_ConstantOperand)(nil), "google.ads.googleads.v1.common.Operand.ConstantOperand")
	proto.RegisterType((*Operand_FeedAttributeOperand)(nil), "google.ads.googleads.v1.common.Operand.FeedAttributeOperand")
	proto.RegisterType((*Operand_FunctionOperand)(nil), "google.ads.googleads.v1.common.Operand.FunctionOperand")
	proto.RegisterType((*Operand_RequestContextOperand)(nil), "google.ads.googleads.v1.common.Operand.RequestContextOperand")
}

func init() {
	proto.RegisterFile("google/ads/googleads/v1/common/matching_function.proto", fileDescriptor_matching_function_bb47824ec6458466)
}

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