fake.pb.go

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

package gnmi_fake

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import any "github.com/golang/protobuf/ptypes/any"
import gnmi "github.com/openconfig/gnmi/proto/gnmi"

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

type State int32

const (
	State_STOPPED State = 0
	State_INIT    State = 1
	State_RUNNING State = 2
)

var State_name = map[int32]string{
	0: "STOPPED",
	1: "INIT",
	2: "RUNNING",
}
var State_value = map[string]int32{
	"STOPPED": 0,
	"INIT":    1,
	"RUNNING": 2,
}

func (x State) String() string {
	return proto.EnumName(State_name, int32(x))
}
func (State) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_fake_448924c4992cbd6c, []int{0}
}

type Config_ClientType int32

const (
	Config_GRPC           Config_ClientType = 0
	Config_STUBBY         Config_ClientType = 1
	Config_GRPC_GNMI      Config_ClientType = 2
	Config_GRPC_GNMI_PROD Config_ClientType = 3
)

var Config_ClientType_name = map[int32]string{
	0: "GRPC",
	1: "STUBBY",
	2: "GRPC_GNMI",
	3: "GRPC_GNMI_PROD",
}
var Config_ClientType_value = map[string]int32{
	"GRPC":           0,
	"STUBBY":         1,
	"GRPC_GNMI":      2,
	"GRPC_GNMI_PROD": 3,
}

func (x Config_ClientType) String() string {
	return proto.EnumName(Config_ClientType_name, int32(x))
}
func (Config_ClientType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_fake_448924c4992cbd6c, []int{2, 0}
}

// Configuration is used to store all agent configuration for the fake agent
// server.  Each config describes a single agent hosted on the server.
type Configuration struct {
	// Repeated list of targets to emulate.
	Config               []*Config `protobuf:"bytes,1,rep,name=config,proto3" json:"config,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

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

var xxx_messageInfo_Configuration proto.InternalMessageInfo

func (m *Configuration) GetConfig() []*Config {
	if m != nil {
		return m.Config
	}
	return nil
}

type Credentials struct {
	Username             string   `protobuf:"bytes,1,opt,name=username,proto3" json:"username,omitempty"`
	Password             string   `protobuf:"bytes,2,opt,name=password,proto3" json:"password,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_Credentials proto.InternalMessageInfo

func (m *Credentials) GetUsername() string {
	if m != nil {
		return m.Username
	}
	return ""
}

func (m *Credentials) GetPassword() string {
	if m != nil {
		return m.Password
	}
	return ""
}

// Config is a collection of values that together represent the update streams
// for one or more fake devices.
type Config struct {
	// The target for which the fake will publish values for.
	Target string `protobuf:"bytes,1,opt,name=target,proto3" json:"target,omitempty"`
	// Port for the agent to listen on. If 0 or unset the agent will pick a port
	// for this agent.
	Port int64 `protobuf:"varint,2,opt,name=port,proto3" json:"port,omitempty"`
	// A global random seed used in generating subsequent values. Set to have
	// reproducible results.
	Seed int64 `protobuf:"varint,6,opt,name=seed,proto3" json:"seed,omitempty"` // Deprecated: Do not use.
	// The list of values generated.  Each value will contain its corresponding
	// target as the first string in the event.GetValue().path meaning that it is
	// possible to generate streams that will be rejected by the cache for testing
	// purposes.
	Values []*Value `protobuf:"bytes,3,rep,name=values,proto3" json:"values,omitempty"` // Deprecated: Do not use.
	// Setting disable sync will keep the configured client from autogenerating a
	// sync message. This allows negative testing on sync handling.
	DisableSync bool `protobuf:"varint,4,opt,name=disable_sync,json=disableSync,proto3" json:"disable_sync,omitempty"`
	// Type of client to fake either Stubby or GRPC based fake.
	ClientType Config_ClientType `protobuf:"varint,5,opt,name=client_type,json=clientType,proto3,enum=gnmi.fake.Config_ClientType" json:"client_type,omitempty"`
	// Disable EOF will hold open the subscription and not automagically close
	// the stream once the value queue is empty.
	DisableEof bool `protobuf:"varint,7,opt,name=disable_eof,json=disableEof,proto3" json:"disable_eof,omitempty"`
	// Per RPC credentials for the agent. If not set no per RPC auth will be used.
	Credentials *Credentials `protobuf:"bytes,8,opt,name=credentials,proto3" json:"credentials,omitempty"`
	// TLS cert for use on the agent. If not set the transport will not be TLS.
	Cert []byte `protobuf:"bytes,9,opt,name=cert,proto3" json:"cert,omitempty"`
	// Honor the delay between events in the generated value streams. Default will
	// play events as fast as the can be streamed.
	EnableDelay bool `protobuf:"varint,10,opt,name=enable_delay,json=enableDelay,proto3" json:"enable_delay,omitempty"`
	// Generator for value series for the target.
	//
	// Types that are valid to be assigned to Generator:
	//	*Config_Custom
	//	*Config_Random
	//	*Config_Fixed
	Generator            isConfig_Generator `protobuf_oneof:"generator"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

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

var xxx_messageInfo_Config proto.InternalMessageInfo

type isConfig_Generator interface {
	isConfig_Generator()
}

type Config_Custom struct {
	Custom *any.Any `protobuf:"bytes,100,opt,name=custom,proto3,oneof"`
}
type Config_Random struct {
	Random *RandomGenerator `protobuf:"bytes,101,opt,name=random,proto3,oneof"`
}
type Config_Fixed struct {
	Fixed *FixedGenerator `protobuf:"bytes,102,opt,name=fixed,proto3,oneof"`
}

func (*Config_Custom) isConfig_Generator() {}
func (*Config_Random) isConfig_Generator() {}
func (*Config_Fixed) isConfig_Generator()  {}

func (m *Config) GetGenerator() isConfig_Generator {
	if m != nil {
		return m.Generator
	}
	return nil
}

func (m *Config) GetTarget() string {
	if m != nil {
		return m.Target
	}
	return ""
}

func (m *Config) GetPort() int64 {
	if m != nil {
		return m.Port
	}
	return 0
}

// Deprecated: Do not use.
func (m *Config) GetSeed() int64 {
	if m != nil {
		return m.Seed
	}
	return 0
}

// Deprecated: Do not use.
func (m *Config) GetValues() []*Value {
	if m != nil {
		return m.Values
	}
	return nil
}

func (m *Config) GetDisableSync() bool {
	if m != nil {
		return m.DisableSync
	}
	return false
}

func (m *Config) GetClientType() Config_ClientType {
	if m != nil {
		return m.ClientType
	}
	return Config_GRPC
}

func (m *Config) GetDisableEof() bool {
	if m != nil {
		return m.DisableEof
	}
	return false
}

func (m *Config) GetCredentials() *Credentials {
	if m != nil {
		return m.Credentials
	}
	return nil
}

func (m *Config) GetCert() []byte {
	if m != nil {
		return m.Cert
	}
	return nil
}

func (m *Config) GetEnableDelay() bool {
	if m != nil {
		return m.EnableDelay
	}
	return false
}

func (m *Config) GetCustom() *any.Any {
	if x, ok := m.GetGenerator().(*Config_Custom); ok {
		return x.Custom
	}
	return nil
}

func (m *Config) GetRandom() *RandomGenerator {
	if x, ok := m.GetGenerator().(*Config_Random); ok {
		return x.Random
	}
	return nil
}

func (m *Config) GetFixed() *FixedGenerator {
	if x, ok := m.GetGenerator().(*Config_Fixed); ok {
		return x.Fixed
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*Config) 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 _Config_OneofMarshaler, _Config_OneofUnmarshaler, _Config_OneofSizer, []interface{}{
		(*Config_Custom)(nil),
		(*Config_Random)(nil),
		(*Config_Fixed)(nil),
	}
}

func _Config_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*Config)
	// generator
	switch x := m.Generator.(type) {
	case *Config_Custom:
		b.EncodeVarint(100<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Custom); err != nil {
			return err
		}
	case *Config_Random:
		b.EncodeVarint(101<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Random); err != nil {
			return err
		}
	case *Config_Fixed:
		b.EncodeVarint(102<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Fixed); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("Config.Generator has unexpected type %T", x)
	}
	return nil
}

func _Config_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*Config)
	switch tag {
	case 100: // generator.custom
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(any.Any)
		err := b.DecodeMessage(msg)
		m.Generator = &Config_Custom{msg}
		return true, err
	case 101: // generator.random
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(RandomGenerator)
		err := b.DecodeMessage(msg)
		m.Generator = &Config_Random{msg}
		return true, err
	case 102: // generator.fixed
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(FixedGenerator)
		err := b.DecodeMessage(msg)
		m.Generator = &Config_Fixed{msg}
		return true, err
	default:
		return false, nil
	}
}

func _Config_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*Config)
	// generator
	switch x := m.Generator.(type) {
	case *Config_Custom:
		s := proto.Size(x.Custom)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Config_Random:
		s := proto.Size(x.Random)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Config_Fixed:
		s := proto.Size(x.Fixed)
		n += 2 // 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
}

type FixedGenerator struct {
	Responses            []*gnmi.SubscribeResponse `protobuf:"bytes,1,rep,name=responses,proto3" json:"responses,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                  `json:"-"`
	XXX_unrecognized     []byte                    `json:"-"`
	XXX_sizecache        int32                     `json:"-"`
}

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

var xxx_messageInfo_FixedGenerator proto.InternalMessageInfo

func (m *FixedGenerator) GetResponses() []*gnmi.SubscribeResponse {
	if m != nil {
		return m.Responses
	}
	return nil
}

type RandomGenerator struct {
	Seed                 int64    `protobuf:"varint,1,opt,name=seed,proto3" json:"seed,omitempty"`
	Values               []*Value `protobuf:"bytes,2,rep,name=values,proto3" json:"values,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_RandomGenerator proto.InternalMessageInfo

func (m *RandomGenerator) GetSeed() int64 {
	if m != nil {
		return m.Seed
	}
	return 0
}

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

// Delete will cause the value to be deleted at the Value's path.
type DeleteValue struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_DeleteValue proto.InternalMessageInfo

// Value is the main message that will trigger a stream of updates for a given
// path.  A file containing a list of values can be used to simulate a network
// device for integration tests.
type Value struct {
	// The device specific, or OpenConfig path corresponding to a value.
	Path []string `protobuf:"bytes,1,rep,name=path,proto3" json:"path,omitempty"`
	// The initial timestamp and configuration on how the timestamp will change
	// for subsequent values. If timestamp is not set the default will assume to
	// be the current system time.
	Timestamp *Timestamp `protobuf:"bytes,2,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	// If set, repeat indicates that the value should be repeated this many times,
	// otherwise it is repeated indefinitely.
	Repeat int32 `protobuf:"varint,6,opt,name=repeat,proto3" json:"repeat,omitempty"`
	// A local random seed used in generating subsequent values for this path. If
	// not set, will share the global random source with seed defined in Config.
	Seed int64 `protobuf:"varint,7,opt,name=seed,proto3" json:"seed,omitempty"`
	// The initial value of the chosen type including configuration on how the
	// value will mutate for subsequent updates.
	//
	// Types that are valid to be assigned to Value:
	//	*Value_IntValue
	//	*Value_DoubleValue
	//	*Value_StringValue
	//	*Value_Sync
	//	*Value_Delete
	Value                isValue_Value `protobuf_oneof:"value"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_Value proto.InternalMessageInfo

type isValue_Value interface {
	isValue_Value()
}

type Value_IntValue struct {
	IntValue *IntValue `protobuf:"bytes,100,opt,name=int_value,json=intValue,proto3,oneof"`
}
type Value_DoubleValue struct {
	DoubleValue *DoubleValue `protobuf:"bytes,101,opt,name=double_value,json=doubleValue,proto3,oneof"`
}
type Value_StringValue struct {
	StringValue *StringValue `protobuf:"bytes,102,opt,name=string_value,json=stringValue,proto3,oneof"`
}
type Value_Sync struct {
	Sync uint64 `protobuf:"varint,103,opt,name=sync,proto3,oneof"`
}
type Value_Delete struct {
	Delete *DeleteValue `protobuf:"bytes,104,opt,name=delete,proto3,oneof"`
}

func (*Value_IntValue) isValue_Value()    {}
func (*Value_DoubleValue) isValue_Value() {}
func (*Value_StringValue) isValue_Value() {}
func (*Value_Sync) isValue_Value()        {}
func (*Value_Delete) isValue_Value()      {}

func (m *Value) GetValue() isValue_Value {
	if m != nil {
		return m.Value
	}
	return nil
}

func (m *Value) GetPath() []string {
	if m != nil {
		return m.Path
	}
	return nil
}

func (m *Value) GetTimestamp() *Timestamp {
	if m != nil {
		return m.Timestamp
	}
	return nil
}

func (m *Value) GetRepeat() int32 {
	if m != nil {
		return m.Repeat
	}
	return 0
}

func (m *Value) GetSeed() int64 {
	if m != nil {
		return m.Seed
	}
	return 0
}

func (m *Value) GetIntValue() *IntValue {
	if x, ok := m.GetValue().(*Value_IntValue); ok {
		return x.IntValue
	}
	return nil
}

func (m *Value) GetDoubleValue() *DoubleValue {
	if x, ok := m.GetValue().(*Value_DoubleValue); ok {
		return x.DoubleValue
	}
	return nil
}

func (m *Value) GetStringValue() *StringValue {
	if x, ok := m.GetValue().(*Value_StringValue); ok {
		return x.StringValue
	}
	return nil
}

func (m *Value) GetSync() uint64 {
	if x, ok := m.GetValue().(*Value_Sync); ok {
		return x.Sync
	}
	return 0
}

func (m *Value) GetDelete() *DeleteValue {
	if x, ok := m.GetValue().(*Value_Delete); ok {
		return x.Delete
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*Value) 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 _Value_OneofMarshaler, _Value_OneofUnmarshaler, _Value_OneofSizer, []interface{}{
		(*Value_IntValue)(nil),
		(*Value_DoubleValue)(nil),
		(*Value_StringValue)(nil),
		(*Value_Sync)(nil),
		(*Value_Delete)(nil),
	}
}

func _Value_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*Value)
	// value
	switch x := m.Value.(type) {
	case *Value_IntValue:
		b.EncodeVarint(100<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.IntValue); err != nil {
			return err
		}
	case *Value_DoubleValue:
		b.EncodeVarint(101<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.DoubleValue); err != nil {
			return err
		}
	case *Value_StringValue:
		b.EncodeVarint(102<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.StringValue); err != nil {
			return err
		}
	case *Value_Sync:
		b.EncodeVarint(103<<3 | proto.WireVarint)
		b.EncodeVarint(uint64(x.Sync))
	case *Value_Delete:
		b.EncodeVarint(104<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Delete); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("Value.Value has unexpected type %T", x)
	}
	return nil
}

func _Value_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*Value)
	switch tag {
	case 100: // value.int_value
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(IntValue)
		err := b.DecodeMessage(msg)
		m.Value = &Value_IntValue{msg}
		return true, err
	case 101: // value.double_value
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(DoubleValue)
		err := b.DecodeMessage(msg)
		m.Value = &Value_DoubleValue{msg}
		return true, err
	case 102: // value.string_value
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(StringValue)
		err := b.DecodeMessage(msg)
		m.Value = &Value_StringValue{msg}
		return true, err
	case 103: // value.sync
		if wire != proto.WireVarint {
			return true, proto.ErrInternalBadWireType
		}
		x, err := b.DecodeVarint()
		m.Value = &Value_Sync{x}
		return true, err
	case 104: // value.delete
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(DeleteValue)
		err := b.DecodeMessage(msg)
		m.Value = &Value_Delete{msg}
		return true, err
	default:
		return false, nil
	}
}

func _Value_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*Value)
	// value
	switch x := m.Value.(type) {
	case *Value_IntValue:
		s := proto.Size(x.IntValue)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Value_DoubleValue:
		s := proto.Size(x.DoubleValue)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Value_StringValue:
		s := proto.Size(x.StringValue)
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Value_Sync:
		n += 2 // tag and wire
		n += proto.SizeVarint(uint64(x.Sync))
	case *Value_Delete:
		s := proto.Size(x.Delete)
		n += 2 // 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
}

type Timestamp struct {
	// Initial timestamp for the corresponding value, nanoseconds since epoch.
	// This value need have no relation to absolute real-time as the stream of
	// of updates is generated without regard to the real clock and can be run
	// repeatably at any time if the seed is set in the corresponding Value.
	Timestamp int64 `protobuf:"varint,1,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	// These values will vary the change in the timestamp for subsequent outputs
	// by a value between delta_min and delta_max.  Set to the same value to force
	// a set periodic interval.
	DeltaMin             int64    `protobuf:"varint,2,opt,name=delta_min,json=deltaMin,proto3" json:"delta_min,omitempty"`
	DeltaMax             int64    `protobuf:"varint,3,opt,name=delta_max,json=deltaMax,proto3" json:"delta_max,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_Timestamp proto.InternalMessageInfo

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

func (m *Timestamp) GetDeltaMin() int64 {
	if m != nil {
		return m.DeltaMin
	}
	return 0
}

func (m *Timestamp) GetDeltaMax() int64 {
	if m != nil {
		return m.DeltaMax
	}
	return 0
}

type IntValue struct {
	// If distribution is IntRange, value is used as the initial value
	// inside [minimum, maximum] and hold the value as it mutates.
	// If distribution is IntList, value is only used to hold the value as it
	// mutates.
	// If no distribution is set, value is used as it mutates, i.e. constant
	// update.
	Value int64 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
	// Types that are valid to be assigned to Distribution:
	//	*IntValue_Range
	//	*IntValue_List
	Distribution         isIntValue_Distribution `protobuf_oneof:"distribution"`
	XXX_NoUnkeyedLiteral struct{}                `json:"-"`
	XXX_unrecognized     []byte                  `json:"-"`
	XXX_sizecache        int32                   `json:"-"`
}

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

var xxx_messageInfo_IntValue proto.InternalMessageInfo

type isIntValue_Distribution interface {
	isIntValue_Distribution()
}

type IntValue_Range struct {
	Range *IntRange `protobuf:"bytes,2,opt,name=range,proto3,oneof"`
}
type IntValue_List struct {
	List *IntList `protobuf:"bytes,3,opt,name=list,proto3,oneof"`
}

func (*IntValue_Range) isIntValue_Distribution() {}
func (*IntValue_List) isIntValue_Distribution()  {}

func (m *IntValue) GetDistribution() isIntValue_Distribution {
	if m != nil {
		return m.Distribution
	}
	return nil
}

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

func (m *IntValue) GetRange() *IntRange {
	if x, ok := m.GetDistribution().(*IntValue_Range); ok {
		return x.Range
	}
	return nil
}

func (m *IntValue) GetList() *IntList {
	if x, ok := m.GetDistribution().(*IntValue_List); ok {
		return x.List
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*IntValue) 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 _IntValue_OneofMarshaler, _IntValue_OneofUnmarshaler, _IntValue_OneofSizer, []interface{}{
		(*IntValue_Range)(nil),
		(*IntValue_List)(nil),
	}
}

func _IntValue_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*IntValue)
	// distribution
	switch x := m.Distribution.(type) {
	case *IntValue_Range:
		b.EncodeVarint(2<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Range); err != nil {
			return err
		}
	case *IntValue_List:
		b.EncodeVarint(3<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.List); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("IntValue.Distribution has unexpected type %T", x)
	}
	return nil
}

func _IntValue_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*IntValue)
	switch tag {
	case 2: // distribution.range
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(IntRange)
		err := b.DecodeMessage(msg)
		m.Distribution = &IntValue_Range{msg}
		return true, err
	case 3: // distribution.list
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(IntList)
		err := b.DecodeMessage(msg)
		m.Distribution = &IntValue_List{msg}
		return true, err
	default:
		return false, nil
	}
}

func _IntValue_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*IntValue)
	// distribution
	switch x := m.Distribution.(type) {
	case *IntValue_Range:
		s := proto.Size(x.Range)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *IntValue_List:
		s := proto.Size(x.List)
		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
}

type IntRange struct {
	// The range of the value allowed.
	Minimum int64 `protobuf:"varint,1,opt,name=minimum,proto3" json:"minimum,omitempty"`
	Maximum int64 `protobuf:"varint,2,opt,name=maximum,proto3" json:"maximum,omitempty"`
	// If set, the value is cumulative and the subsequent value is value + delta
	// where delta is randomly chosen between delta_min and delta_max.  The range
	// minimum and maximum are still respected and values will saturate at the
	// boundaries if they are exceeded. If not set subsequent value is a value
	// randomly chosen between minimum and maximum.
	DeltaMin             int64    `protobuf:"varint,3,opt,name=delta_min,json=deltaMin,proto3" json:"delta_min,omitempty"`
	DeltaMax             int64    `protobuf:"varint,4,opt,name=delta_max,json=deltaMax,proto3" json:"delta_max,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_IntRange proto.InternalMessageInfo

func (m *IntRange) GetMinimum() int64 {
	if m != nil {
		return m.Minimum
	}
	return 0
}

func (m *IntRange) GetMaximum() int64 {
	if m != nil {
		return m.Maximum
	}
	return 0
}

func (m *IntRange) GetDeltaMin() int64 {
	if m != nil {
		return m.DeltaMin
	}
	return 0
}

func (m *IntRange) GetDeltaMax() int64 {
	if m != nil {
		return m.DeltaMax
	}
	return 0
}

type IntList struct {
	// The set of values which can be used.
	Options []int64 `protobuf:"varint,1,rep,packed,name=options,proto3" json:"options,omitempty"`
	// Set to true to randomize selection of value from options. If false, the
	// values are cycled in order, starting at index 0.
	Random               bool     `protobuf:"varint,2,opt,name=random,proto3" json:"random,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_IntList proto.InternalMessageInfo

func (m *IntList) GetOptions() []int64 {
	if m != nil {
		return m.Options
	}
	return nil
}

func (m *IntList) GetRandom() bool {
	if m != nil {
		return m.Random
	}
	return false
}

type DoubleValue struct {
	// If distribution is DoubleRange, value is used as the initial value
	// inside [minimum, maximum] and hold the value as it mutates.
	// If distribution is DoubleList, value is only used to hold the value as it
	// mutates.
	// If no distribution is set, value is used as it mutates, i.e. constant
	// update.
	Value float64 `protobuf:"fixed64,1,opt,name=value,proto3" json:"value,omitempty"`
	// Types that are valid to be assigned to Distribution:
	//	*DoubleValue_Range
	//	*DoubleValue_List
	Distribution         isDoubleValue_Distribution `protobuf_oneof:"distribution"`
	XXX_NoUnkeyedLiteral struct{}                   `json:"-"`
	XXX_unrecognized     []byte                     `json:"-"`
	XXX_sizecache        int32                      `json:"-"`
}

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

var xxx_messageInfo_DoubleValue proto.InternalMessageInfo

type isDoubleValue_Distribution interface {
	isDoubleValue_Distribution()
}

type DoubleValue_Range struct {
	Range *DoubleRange `protobuf:"bytes,2,opt,name=range,proto3,oneof"`
}
type DoubleValue_List struct {
	List *DoubleList `protobuf:"bytes,3,opt,name=list,proto3,oneof"`
}

func (*DoubleValue_Range) isDoubleValue_Distribution() {}
func (*DoubleValue_List) isDoubleValue_Distribution()  {}

func (m *DoubleValue) GetDistribution() isDoubleValue_Distribution {
	if m != nil {
		return m.Distribution
	}
	return nil
}

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

func (m *DoubleValue) GetRange() *DoubleRange {
	if x, ok := m.GetDistribution().(*DoubleValue_Range); ok {
		return x.Range
	}
	return nil
}

func (m *DoubleValue) GetList() *DoubleList {
	if x, ok := m.GetDistribution().(*DoubleValue_List); ok {
		return x.List
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*DoubleValue) 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 _DoubleValue_OneofMarshaler, _DoubleValue_OneofUnmarshaler, _DoubleValue_OneofSizer, []interface{}{
		(*DoubleValue_Range)(nil),
		(*DoubleValue_List)(nil),
	}
}

func _DoubleValue_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*DoubleValue)
	// distribution
	switch x := m.Distribution.(type) {
	case *DoubleValue_Range:
		b.EncodeVarint(2<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Range); err != nil {
			return err
		}
	case *DoubleValue_List:
		b.EncodeVarint(3<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.List); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("DoubleValue.Distribution has unexpected type %T", x)
	}
	return nil
}

func _DoubleValue_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*DoubleValue)
	switch tag {
	case 2: // distribution.range
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(DoubleRange)
		err := b.DecodeMessage(msg)
		m.Distribution = &DoubleValue_Range{msg}
		return true, err
	case 3: // distribution.list
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(DoubleList)
		err := b.DecodeMessage(msg)
		m.Distribution = &DoubleValue_List{msg}
		return true, err
	default:
		return false, nil
	}
}

func _DoubleValue_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*DoubleValue)
	// distribution
	switch x := m.Distribution.(type) {
	case *DoubleValue_Range:
		s := proto.Size(x.Range)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *DoubleValue_List:
		s := proto.Size(x.List)
		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
}

type DoubleRange struct {
	// The range of the value allowed.
	Minimum float64 `protobuf:"fixed64,1,opt,name=minimum,proto3" json:"minimum,omitempty"`
	Maximum float64 `protobuf:"fixed64,2,opt,name=maximum,proto3" json:"maximum,omitempty"`
	// If set, the value is cumulative and the subsequent value is value + delta
	// where delta is randomly chosen between delta_min and delta_max. The range
	// minimum and maximum are still respected. If not set subsequent value is a
	// value randomly chosen between minimum and maximum.
	DeltaMin             float64  `protobuf:"fixed64,3,opt,name=delta_min,json=deltaMin,proto3" json:"delta_min,omitempty"`
	DeltaMax             float64  `protobuf:"fixed64,4,opt,name=delta_max,json=deltaMax,proto3" json:"delta_max,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_DoubleRange proto.InternalMessageInfo

func (m *DoubleRange) GetMinimum() float64 {
	if m != nil {
		return m.Minimum
	}
	return 0
}

func (m *DoubleRange) GetMaximum() float64 {
	if m != nil {
		return m.Maximum
	}
	return 0
}

func (m *DoubleRange) GetDeltaMin() float64 {
	if m != nil {
		return m.DeltaMin
	}
	return 0
}

func (m *DoubleRange) GetDeltaMax() float64 {
	if m != nil {
		return m.DeltaMax
	}
	return 0
}

type DoubleList struct {
	// The set of values which can be used.
	Options []float64 `protobuf:"fixed64,1,rep,packed,name=options,proto3" json:"options,omitempty"`
	// Set to true to randomize selection of value from options. If false, the
	// values are cycled in order.
	Random               bool     `protobuf:"varint,2,opt,name=random,proto3" json:"random,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_DoubleList proto.InternalMessageInfo

func (m *DoubleList) GetOptions() []float64 {
	if m != nil {
		return m.Options
	}
	return nil
}

func (m *DoubleList) GetRandom() bool {
	if m != nil {
		return m.Random
	}
	return false
}

type StringValue struct {
	// If distribution is StringList, value is used to hold the value as it
	// mutates.
	// If no distribution is set, value is used as it mutates, i.e. constant
	// update.
	Value string `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
	// Types that are valid to be assigned to Distribution:
	//	*StringValue_List
	Distribution         isStringValue_Distribution `protobuf_oneof:"distribution"`
	XXX_NoUnkeyedLiteral struct{}                   `json:"-"`
	XXX_unrecognized     []byte                     `json:"-"`
	XXX_sizecache        int32                      `json:"-"`
}

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

var xxx_messageInfo_StringValue proto.InternalMessageInfo

type isStringValue_Distribution interface {
	isStringValue_Distribution()
}

type StringValue_List struct {
	List *StringList `protobuf:"bytes,2,opt,name=list,proto3,oneof"`
}

func (*StringValue_List) isStringValue_Distribution() {}

func (m *StringValue) GetDistribution() isStringValue_Distribution {
	if m != nil {
		return m.Distribution
	}
	return nil
}

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

func (m *StringValue) GetList() *StringList {
	if x, ok := m.GetDistribution().(*StringValue_List); ok {
		return x.List
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*StringValue) 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 _StringValue_OneofMarshaler, _StringValue_OneofUnmarshaler, _StringValue_OneofSizer, []interface{}{
		(*StringValue_List)(nil),
	}
}

func _StringValue_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*StringValue)
	// distribution
	switch x := m.Distribution.(type) {
	case *StringValue_List:
		b.EncodeVarint(2<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.List); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("StringValue.Distribution has unexpected type %T", x)
	}
	return nil
}

func _StringValue_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*StringValue)
	switch tag {
	case 2: // distribution.list
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(StringList)
		err := b.DecodeMessage(msg)
		m.Distribution = &StringValue_List{msg}
		return true, err
	default:
		return false, nil
	}
}

func _StringValue_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*StringValue)
	// distribution
	switch x := m.Distribution.(type) {
	case *StringValue_List:
		s := proto.Size(x.List)
		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
}

type StringList struct {
	// The set of strings which can be used.
	Options []string `protobuf:"bytes,1,rep,name=options,proto3" json:"options,omitempty"`
	// Set to true to randomize selection of value from options. If false, the
	// values are cycled in order, starting at index 0.
	Random               bool     `protobuf:"varint,2,opt,name=random,proto3" json:"random,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_StringList proto.InternalMessageInfo

func (m *StringList) GetOptions() []string {
	if m != nil {
		return m.Options
	}
	return nil
}

func (m *StringList) GetRandom() bool {
	if m != nil {
		return m.Random
	}
	return false
}

func init() {
	proto.RegisterType((*Configuration)(nil), "gnmi.fake.Configuration")
	proto.RegisterType((*Credentials)(nil), "gnmi.fake.Credentials")
	proto.RegisterType((*Config)(nil), "gnmi.fake.Config")
	proto.RegisterType((*FixedGenerator)(nil), "gnmi.fake.FixedGenerator")
	proto.RegisterType((*RandomGenerator)(nil), "gnmi.fake.RandomGenerator")
	proto.RegisterType((*DeleteValue)(nil), "gnmi.fake.DeleteValue")
	proto.RegisterType((*Value)(nil), "gnmi.fake.Value")
	proto.RegisterType((*Timestamp)(nil), "gnmi.fake.Timestamp")
	proto.RegisterType((*IntValue)(nil), "gnmi.fake.IntValue")
	proto.RegisterType((*IntRange)(nil), "gnmi.fake.IntRange")
	proto.RegisterType((*IntList)(nil), "gnmi.fake.IntList")
	proto.RegisterType((*DoubleValue)(nil), "gnmi.fake.DoubleValue")
	proto.RegisterType((*DoubleRange)(nil), "gnmi.fake.DoubleRange")
	proto.RegisterType((*DoubleList)(nil), "gnmi.fake.DoubleList")
	proto.RegisterType((*StringValue)(nil), "gnmi.fake.StringValue")
	proto.RegisterType((*StringList)(nil), "gnmi.fake.StringList")
	proto.RegisterEnum("gnmi.fake.State", State_name, State_value)
	proto.RegisterEnum("gnmi.fake.Config_ClientType", Config_ClientType_name, Config_ClientType_value)
}

func init() { proto.RegisterFile("testing/fake/proto/fake.proto", fileDescriptor_fake_448924c4992cbd6c) }

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