func (*Auth) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*Auth_Secret)(nil),
		(*Auth_Plain)(nil),
	}
}
XXX_OneofWrappers is for the internal use of the proto package.
package v1alpha1
import (
	fmt "fmt"
	proto "github.com/gogo/protobuf/proto"
	_ "github.com/gogo/protobuf/types"
	io "io"
	v1alpha3 "istio.io/api/networking/v1alpha3"
	_ "istio.io/gogo-genproto/googleapis/google/api"
	math "math"
	math_bits "math/bits"
)
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
const _ = proto.GoGoProtoPackageIsVersion3  
type RedisSettings_Mode int32
const (
	RedisSettings_PROXY   RedisSettings_Mode = 0
	RedisSettings_CLUSTER RedisSettings_Mode = 1
)
var RedisSettings_Mode_name = map[int32]string{
	0: "PROXY",
	1: "CLUSTER",
}
var RedisSettings_Mode_value = map[string]int32{
	"PROXY":   0,
	"CLUSTER": 1,
}
func (x RedisSettings_Mode) String() string {
	return proto.EnumName(RedisSettings_Mode_name, int32(x))
}
func (RedisSettings_Mode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_237e307d114723c1, []int{5, 0}
}
type RedisDestination struct {
	Host                 string         `protobuf:"bytes,1,opt,name=host,proto3" json:"host,omitempty"`
	TrafficPolicy        *TrafficPolicy `protobuf:"bytes,2,opt,name=traffic_policy,json=trafficPolicy,proto3" json:"traffic_policy,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}
func (m *RedisDestination) Reset()         { *m = RedisDestination{} }
func (m *RedisDestination) String() string { return proto.CompactTextString(m) }
func (*RedisDestination) ProtoMessage()    {}
func (*RedisDestination) Descriptor() ([]byte, []int) {
	return fileDescriptor_237e307d114723c1, []int{0}
}
func (m *RedisDestination) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *RedisDestination) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_RedisDestination.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *RedisDestination) XXX_Merge(src proto.Message) {
	xxx_messageInfo_RedisDestination.Merge(m, src)
}
func (m *RedisDestination) XXX_Size() int {
	return m.Size()
}
func (m *RedisDestination) XXX_DiscardUnknown() {
	xxx_messageInfo_RedisDestination.DiscardUnknown(m)
}
var xxx_messageInfo_RedisDestination proto.InternalMessageInfo
func (m *RedisDestination) GetHost() string {
	if m != nil {
		return m.Host
	}
	return ""
}
func (m *RedisDestination) GetTrafficPolicy() *TrafficPolicy {
	if m != nil {
		return m.TrafficPolicy
	}
	return nil
}
type ConnectionPoolSettings struct {
	Tcp                  *v1alpha3.ConnectionPoolSettings_TCPSettings `protobuf:"bytes,1,opt,name=tcp,proto3" json:"tcp,omitempty"`
	Redis                *RedisSettings                               `protobuf:"bytes,2,opt,name=redis,proto3" json:"redis,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                                     `json:"-"`
	XXX_unrecognized     []byte                                       `json:"-"`
	XXX_sizecache        int32                                        `json:"-"`
}
func (m *ConnectionPoolSettings) Reset()         { *m = ConnectionPoolSettings{} }
func (m *ConnectionPoolSettings) String() string { return proto.CompactTextString(m) }
func (*ConnectionPoolSettings) ProtoMessage()    {}
func (*ConnectionPoolSettings) Descriptor() ([]byte, []int) {
	return fileDescriptor_237e307d114723c1, []int{1}
}
func (m *ConnectionPoolSettings) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ConnectionPoolSettings) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ConnectionPoolSettings.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *ConnectionPoolSettings) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ConnectionPoolSettings.Merge(m, src)
}
func (m *ConnectionPoolSettings) XXX_Size() int {
	return m.Size()
}
func (m *ConnectionPoolSettings) XXX_DiscardUnknown() {
	xxx_messageInfo_ConnectionPoolSettings.DiscardUnknown(m)
}
var xxx_messageInfo_ConnectionPoolSettings proto.InternalMessageInfo
func (m *ConnectionPoolSettings) GetTcp() *v1alpha3.ConnectionPoolSettings_TCPSettings {
	if m != nil {
		return m.Tcp
	}
	return nil
}
func (m *ConnectionPoolSettings) GetRedis() *RedisSettings {
	if m != nil {
		return m.Redis
	}
	return nil
}
type Auth struct {
	Auth                 isAuth_Auth `protobuf_oneof:"auth"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}
func (m *Auth) Reset()         { *m = Auth{} }
func (m *Auth) String() string { return proto.CompactTextString(m) }
func (*Auth) ProtoMessage()    {}
func (*Auth) Descriptor() ([]byte, []int) {
	return fileDescriptor_237e307d114723c1, []int{2}
}
func (m *Auth) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Auth) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Auth.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Auth) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Auth.Merge(m, src)
}
func (m *Auth) XXX_Size() int {
	return m.Size()
}
func (m *Auth) XXX_DiscardUnknown() {
	xxx_messageInfo_Auth.DiscardUnknown(m)
}
var xxx_messageInfo_Auth proto.InternalMessageInfo
type isAuth_Auth interface {
	isAuth_Auth()
	MarshalTo([]byte) (int, error)
	Size() int
}
type Auth_Secret struct {
	Secret *SecretReference `protobuf:"bytes,1,opt,name=secret,proto3,oneof" json:"secret,omitempty"`
}
type Auth_Plain struct {
	Plain *PlainAuth `protobuf:"bytes,2,opt,name=plain,proto3,oneof" json:"plain,omitempty"`
}
func (*Auth_Secret) isAuth_Auth() {}
func (*Auth_Plain) isAuth_Auth()  {}
func (m *Auth) GetAuth() isAuth_Auth {
	if m != nil {
		return m.Auth
	}
	return nil
}
func (m *Auth) GetSecret() *SecretReference {
	if x, ok := m.GetAuth().(*Auth_Secret); ok {
		return x.Secret
	}
	return nil
}
func (m *Auth) GetPlain() *PlainAuth {
	if x, ok := m.GetAuth().(*Auth_Plain); ok {
		return x.Plain
	}
	return nil
}