gdr.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: gdr.proto

package gdr

import (
	fmt "fmt"
	proto "github.com/gogo/protobuf/proto"
	types "github.com/gogo/protobuf/types"
	io "io"
	math "math"
	math_bits "math/bits"
)

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

// FlexValueType declares which field should be used parsing the flexvalue
type FlexValueType int32

const (
	FlexValueType_FLEX_VALUE_TYPE_INTEGER FlexValueType = 0
	FlexValueType_FLEX_VALUE_TYPE_STRING  FlexValueType = 1
)

var FlexValueType_name = map[int32]string{
	0: "FLEX_VALUE_TYPE_INTEGER",
	1: "FLEX_VALUE_TYPE_STRING",
}

var FlexValueType_value = map[string]int32{
	"FLEX_VALUE_TYPE_INTEGER": 0,
	"FLEX_VALUE_TYPE_STRING":  1,
}

func (x FlexValueType) String() string {
	return proto.EnumName(FlexValueType_name, int32(x))
}

func (FlexValueType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_f88fa3b9b3f72b96, []int{0}
}

// Unit declares the unit of the flexible value
type Unit int32

const (
	Unit_UNIT_UNKNOWN Unit = 0
	// Electrical values
	Unit_UNIT_AMPERE               Unit = 1
	Unit_UNIT_VOLT                 Unit = 2
	Unit_UNIT_WATT                 Unit = 3
	Unit_UNIT_HERTZ                Unit = 4
	Unit_UNIT_VOLT_AMPERE          Unit = 5
	Unit_UNIT_VOLT_AMPERE_REACTIVE Unit = 6
	Unit_UNIT_WATT_HOUR            Unit = 7
	Unit_UNIT_KILO_WATT_HOUR       Unit = 8
	// Time Values
	Unit_UNIT_SECOND Unit = 9
	Unit_UNIT_MINUTE Unit = 10
	Unit_UNIT_HOUR   Unit = 11
	Unit_UNIT_DAY    Unit = 12
	Unit_UNIT_WEEK   Unit = 13
	Unit_UNIT_MONTH  Unit = 14
	Unit_UNIT_YEAR   Unit = 15
	// Other values
	Unit_UNIT_DEGREE_CELSIUS    Unit = 16
	Unit_UNIT_KELVIN            Unit = 17
	Unit_UNIT_DEGREE_FAHRENHEIT Unit = 18
)

var Unit_name = map[int32]string{
	0:  "UNIT_UNKNOWN",
	1:  "UNIT_AMPERE",
	2:  "UNIT_VOLT",
	3:  "UNIT_WATT",
	4:  "UNIT_HERTZ",
	5:  "UNIT_VOLT_AMPERE",
	6:  "UNIT_VOLT_AMPERE_REACTIVE",
	7:  "UNIT_WATT_HOUR",
	8:  "UNIT_KILO_WATT_HOUR",
	9:  "UNIT_SECOND",
	10: "UNIT_MINUTE",
	11: "UNIT_HOUR",
	12: "UNIT_DAY",
	13: "UNIT_WEEK",
	14: "UNIT_MONTH",
	15: "UNIT_YEAR",
	16: "UNIT_DEGREE_CELSIUS",
	17: "UNIT_KELVIN",
	18: "UNIT_DEGREE_FAHRENHEIT",
}

var Unit_value = map[string]int32{
	"UNIT_UNKNOWN":              0,
	"UNIT_AMPERE":               1,
	"UNIT_VOLT":                 2,
	"UNIT_WATT":                 3,
	"UNIT_HERTZ":                4,
	"UNIT_VOLT_AMPERE":          5,
	"UNIT_VOLT_AMPERE_REACTIVE": 6,
	"UNIT_WATT_HOUR":            7,
	"UNIT_KILO_WATT_HOUR":       8,
	"UNIT_SECOND":               9,
	"UNIT_MINUTE":               10,
	"UNIT_HOUR":                 11,
	"UNIT_DAY":                  12,
	"UNIT_WEEK":                 13,
	"UNIT_MONTH":                14,
	"UNIT_YEAR":                 15,
	"UNIT_DEGREE_CELSIUS":       16,
	"UNIT_KELVIN":               17,
	"UNIT_DEGREE_FAHRENHEIT":    18,
}

func (x Unit) String() string {
	return proto.EnumName(Unit_name, int32(x))
}

func (Unit) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_f88fa3b9b3f72b96, []int{1}
}

// Devicetype - declares which Type of Device the Data Source is
//   - necessary for Sankey-Diagram
type DeviceType int32

const (
	DeviceType_DEVICE_TYPE_UNKNOWN               DeviceType = 0
	DeviceType_DEVICE_TYPE_PHOTOVOLTAIC_SYSTEM   DeviceType = 1
	DeviceType_DEVICE_TYPE_ELECTRIC_VEHICLE      DeviceType = 2
	DeviceType_DEVICE_TYPE_BATTERY               DeviceType = 3
	DeviceType_DEVICE_TYPE_OVEN                  DeviceType = 4
	DeviceType_DEVICE_TYPE_FLOW_HEATER           DeviceType = 5
	DeviceType_DEVICE_TYPE_BOILER                DeviceType = 6
	DeviceType_DEVICE_TYPE_IMMERSION_HEATER      DeviceType = 7
	DeviceType_DEVICE_TYPE_STOVE                 DeviceType = 8
	DeviceType_DEVICE_TYPE_COOLER                DeviceType = 9
	DeviceType_DEVICE_TYPE_VENTILATION           DeviceType = 10
	DeviceType_DEVICE_TYPE_DISHWASHER            DeviceType = 11
	DeviceType_DEVICE_TYPE_DRYER                 DeviceType = 12
	DeviceType_DEVICE_TYPE_HEAT_PUMP             DeviceType = 13
	DeviceType_DEVICE_TYPE_WASHING_MACHINE       DeviceType = 14
	DeviceType_DEVICE_TYPE_INVERTER_ONEPHASE     DeviceType = 15
	DeviceType_DEVICE_TYPE_INVERTER_THREEPHASE   DeviceType = 16
	DeviceType_DEVICE_TYPE_CHP                   DeviceType = 17
	DeviceType_DEVICE_TYPE_BUILDING_OFFICE       DeviceType = 18
	DeviceType_DEVICE_TYPE_BUILDING_COMMERCIAL   DeviceType = 19
	DeviceType_DEVICE_TYPE_BUILDING_FACTORY      DeviceType = 20
	DeviceType_DEVICE_TYPE_BUILDING_SINGLE_HOME  DeviceType = 21
	DeviceType_DEVICE_TYPE_BUILDING_HOTEL        DeviceType = 22
	DeviceType_DEVICE_TYPE_BUILDING_APARTMENTS   DeviceType = 23
	DeviceType_DEVICE_TYPE_BUILDING_PARKING      DeviceType = 24
	DeviceType_DEVICE_TYPE_BUILDING_RESIDENTIAL  DeviceType = 25
	DeviceType_DEVICE_TYPE_ROOM_BATH             DeviceType = 26
	DeviceType_DEVICE_TYPE_ROOM_GARAGE           DeviceType = 27
	DeviceType_DEVICE_TYPE_ROOM_BASEMENT         DeviceType = 28
	DeviceType_DEVICE_TYPE_ROOM_CHILD            DeviceType = 29
	DeviceType_DEVICE_TYPE_ROOM_KITCHEN          DeviceType = 30
	DeviceType_DEVICE_TYPE_ROOM_SAUNA            DeviceType = 31
	DeviceType_DEVICE_TYPE_ROOM_BED              DeviceType = 32
	DeviceType_DEVICE_TYPE_ROOM_LIVING           DeviceType = 33
	DeviceType_DEVICE_TYPE_ROOM_GENERIC          DeviceType = 34
	DeviceType_DEVICE_TYPE_CONTROLLABLE_LOAD     DeviceType = 35
	DeviceType_DEVICE_TYPE_LIGHTING              DeviceType = 36
	DeviceType_DEVICE_TYPE_OFFICES               DeviceType = 37
	DeviceType_DEVICE_TYPE_DOMESTIC_APPLIANCES   DeviceType = 38
	DeviceType_DEVICE_TYPE_HEATER_OF_HEAT_PUMP   DeviceType = 39
	DeviceType_DEVICE_TYPE_INDUSTRIAL_ENGINE     DeviceType = 40
	DeviceType_DEVICE_TYPE_AIR_CONDITIONING      DeviceType = 41
	DeviceType_DEVICE_TYPE_COMPRESSOR            DeviceType = 42
	DeviceType_DEVICE_TYPE_PC_DATA_CENTER        DeviceType = 43
	DeviceType_DEVICE_TYPE_FUSES_THREE           DeviceType = 44
	DeviceType_DEVICE_TYPE_FUSES_SIX             DeviceType = 45
	DeviceType_DEVICE_TYPE_FUSES_NINE            DeviceType = 46
	DeviceType_DEVICE_TYPE_FUSES_TWELVE          DeviceType = 47
	DeviceType_DEVICE_TYPE_COMPACTOR             DeviceType = 48
	DeviceType_DEVICE_TYPE_WHITE_GOODS           DeviceType = 49
	DeviceType_DEVICE_TYPE_COLD_STORAGE_ROOM     DeviceType = 50
	DeviceType_DEVICE_TYPE_GARDEN_SHED           DeviceType = 51
	DeviceType_DEVICE_TYPE_COOLING_COMBINATION   DeviceType = 52
	DeviceType_DEVICE_TYPE_FACILITIES            DeviceType = 53
	DeviceType_DEVICE_TYPE_FREEZER               DeviceType = 54
	DeviceType_DEVICE_TYPE_FRIDGE                DeviceType = 55
	DeviceType_DEVICE_TYPE_GRID_CONNECTION_POINT DeviceType = 56
	DeviceType_DEVICE_TYPE_INVERTER_HYBRID       DeviceType = 57
	DeviceType_DEVICE_TYPE_CIRCUIT_PROTECTION    DeviceType = 58
	DeviceType_DEVICE_TYPE_DATA_TRANSCEIVER      DeviceType = 59
)

var DeviceType_name = map[int32]string{
	0:  "DEVICE_TYPE_UNKNOWN",
	1:  "DEVICE_TYPE_PHOTOVOLTAIC_SYSTEM",
	2:  "DEVICE_TYPE_ELECTRIC_VEHICLE",
	3:  "DEVICE_TYPE_BATTERY",
	4:  "DEVICE_TYPE_OVEN",
	5:  "DEVICE_TYPE_FLOW_HEATER",
	6:  "DEVICE_TYPE_BOILER",
	7:  "DEVICE_TYPE_IMMERSION_HEATER",
	8:  "DEVICE_TYPE_STOVE",
	9:  "DEVICE_TYPE_COOLER",
	10: "DEVICE_TYPE_VENTILATION",
	11: "DEVICE_TYPE_DISHWASHER",
	12: "DEVICE_TYPE_DRYER",
	13: "DEVICE_TYPE_HEAT_PUMP",
	14: "DEVICE_TYPE_WASHING_MACHINE",
	15: "DEVICE_TYPE_INVERTER_ONEPHASE",
	16: "DEVICE_TYPE_INVERTER_THREEPHASE",
	17: "DEVICE_TYPE_CHP",
	18: "DEVICE_TYPE_BUILDING_OFFICE",
	19: "DEVICE_TYPE_BUILDING_COMMERCIAL",
	20: "DEVICE_TYPE_BUILDING_FACTORY",
	21: "DEVICE_TYPE_BUILDING_SINGLE_HOME",
	22: "DEVICE_TYPE_BUILDING_HOTEL",
	23: "DEVICE_TYPE_BUILDING_APARTMENTS",
	24: "DEVICE_TYPE_BUILDING_PARKING",
	25: "DEVICE_TYPE_BUILDING_RESIDENTIAL",
	26: "DEVICE_TYPE_ROOM_BATH",
	27: "DEVICE_TYPE_ROOM_GARAGE",
	28: "DEVICE_TYPE_ROOM_BASEMENT",
	29: "DEVICE_TYPE_ROOM_CHILD",
	30: "DEVICE_TYPE_ROOM_KITCHEN",
	31: "DEVICE_TYPE_ROOM_SAUNA",
	32: "DEVICE_TYPE_ROOM_BED",
	33: "DEVICE_TYPE_ROOM_LIVING",
	34: "DEVICE_TYPE_ROOM_GENERIC",
	35: "DEVICE_TYPE_CONTROLLABLE_LOAD",
	36: "DEVICE_TYPE_LIGHTING",
	37: "DEVICE_TYPE_OFFICES",
	38: "DEVICE_TYPE_DOMESTIC_APPLIANCES",
	39: "DEVICE_TYPE_HEATER_OF_HEAT_PUMP",
	40: "DEVICE_TYPE_INDUSTRIAL_ENGINE",
	41: "DEVICE_TYPE_AIR_CONDITIONING",
	42: "DEVICE_TYPE_COMPRESSOR",
	43: "DEVICE_TYPE_PC_DATA_CENTER",
	44: "DEVICE_TYPE_FUSES_THREE",
	45: "DEVICE_TYPE_FUSES_SIX",
	46: "DEVICE_TYPE_FUSES_NINE",
	47: "DEVICE_TYPE_FUSES_TWELVE",
	48: "DEVICE_TYPE_COMPACTOR",
	49: "DEVICE_TYPE_WHITE_GOODS",
	50: "DEVICE_TYPE_COLD_STORAGE_ROOM",
	51: "DEVICE_TYPE_GARDEN_SHED",
	52: "DEVICE_TYPE_COOLING_COMBINATION",
	53: "DEVICE_TYPE_FACILITIES",
	54: "DEVICE_TYPE_FREEZER",
	55: "DEVICE_TYPE_FRIDGE",
	56: "DEVICE_TYPE_GRID_CONNECTION_POINT",
	57: "DEVICE_TYPE_INVERTER_HYBRID",
	58: "DEVICE_TYPE_CIRCUIT_PROTECTION",
	59: "DEVICE_TYPE_DATA_TRANSCEIVER",
}

var DeviceType_value = map[string]int32{
	"DEVICE_TYPE_UNKNOWN":               0,
	"DEVICE_TYPE_PHOTOVOLTAIC_SYSTEM":   1,
	"DEVICE_TYPE_ELECTRIC_VEHICLE":      2,
	"DEVICE_TYPE_BATTERY":               3,
	"DEVICE_TYPE_OVEN":                  4,
	"DEVICE_TYPE_FLOW_HEATER":           5,
	"DEVICE_TYPE_BOILER":                6,
	"DEVICE_TYPE_IMMERSION_HEATER":      7,
	"DEVICE_TYPE_STOVE":                 8,
	"DEVICE_TYPE_COOLER":                9,
	"DEVICE_TYPE_VENTILATION":           10,
	"DEVICE_TYPE_DISHWASHER":            11,
	"DEVICE_TYPE_DRYER":                 12,
	"DEVICE_TYPE_HEAT_PUMP":             13,
	"DEVICE_TYPE_WASHING_MACHINE":       14,
	"DEVICE_TYPE_INVERTER_ONEPHASE":     15,
	"DEVICE_TYPE_INVERTER_THREEPHASE":   16,
	"DEVICE_TYPE_CHP":                   17,
	"DEVICE_TYPE_BUILDING_OFFICE":       18,
	"DEVICE_TYPE_BUILDING_COMMERCIAL":   19,
	"DEVICE_TYPE_BUILDING_FACTORY":      20,
	"DEVICE_TYPE_BUILDING_SINGLE_HOME":  21,
	"DEVICE_TYPE_BUILDING_HOTEL":        22,
	"DEVICE_TYPE_BUILDING_APARTMENTS":   23,
	"DEVICE_TYPE_BUILDING_PARKING":      24,
	"DEVICE_TYPE_BUILDING_RESIDENTIAL":  25,
	"DEVICE_TYPE_ROOM_BATH":             26,
	"DEVICE_TYPE_ROOM_GARAGE":           27,
	"DEVICE_TYPE_ROOM_BASEMENT":         28,
	"DEVICE_TYPE_ROOM_CHILD":            29,
	"DEVICE_TYPE_ROOM_KITCHEN":          30,
	"DEVICE_TYPE_ROOM_SAUNA":            31,
	"DEVICE_TYPE_ROOM_BED":              32,
	"DEVICE_TYPE_ROOM_LIVING":           33,
	"DEVICE_TYPE_ROOM_GENERIC":          34,
	"DEVICE_TYPE_CONTROLLABLE_LOAD":     35,
	"DEVICE_TYPE_LIGHTING":              36,
	"DEVICE_TYPE_OFFICES":               37,
	"DEVICE_TYPE_DOMESTIC_APPLIANCES":   38,
	"DEVICE_TYPE_HEATER_OF_HEAT_PUMP":   39,
	"DEVICE_TYPE_INDUSTRIAL_ENGINE":     40,
	"DEVICE_TYPE_AIR_CONDITIONING":      41,
	"DEVICE_TYPE_COMPRESSOR":            42,
	"DEVICE_TYPE_PC_DATA_CENTER":        43,
	"DEVICE_TYPE_FUSES_THREE":           44,
	"DEVICE_TYPE_FUSES_SIX":             45,
	"DEVICE_TYPE_FUSES_NINE":            46,
	"DEVICE_TYPE_FUSES_TWELVE":          47,
	"DEVICE_TYPE_COMPACTOR":             48,
	"DEVICE_TYPE_WHITE_GOODS":           49,
	"DEVICE_TYPE_COLD_STORAGE_ROOM":     50,
	"DEVICE_TYPE_GARDEN_SHED":           51,
	"DEVICE_TYPE_COOLING_COMBINATION":   52,
	"DEVICE_TYPE_FACILITIES":            53,
	"DEVICE_TYPE_FREEZER":               54,
	"DEVICE_TYPE_FRIDGE":                55,
	"DEVICE_TYPE_GRID_CONNECTION_POINT": 56,
	"DEVICE_TYPE_INVERTER_HYBRID":       57,
	"DEVICE_TYPE_CIRCUIT_PROTECTION":    58,
	"DEVICE_TYPE_DATA_TRANSCEIVER":      59,
}

func (x DeviceType) String() string {
	return proto.EnumName(DeviceType_name, int32(x))
}

func (DeviceType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_f88fa3b9b3f72b96, []int{2}
}

// Status OK = Datasource updated Data, GDR Updated
// Status WARNING = Datasource updated Data but configuration is needed
// Status Error = Datasource did not updated Data (Maybe broken)
type Status int32

const (
	Status_STATUS_UNKNOWN Status = 0
	Status_STATUS_OK      Status = 1
	Status_STATUS_WARNING Status = 2
	Status_STATUS_ERROR   Status = 3
)

var Status_name = map[int32]string{
	0: "STATUS_UNKNOWN",
	1: "STATUS_OK",
	2: "STATUS_WARNING",
	3: "STATUS_ERROR",
}

var Status_value = map[string]int32{
	"STATUS_UNKNOWN": 0,
	"STATUS_OK":      1,
	"STATUS_WARNING": 2,
	"STATUS_ERROR":   3,
}

func (x Status) String() string {
	return proto.EnumName(Status_name, int32(x))
}

func (Status) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_f88fa3b9b3f72b96, []int{3}
}

// Class Consumer = Consumes Energy, Power, ...
// Class Producer = Produces Energy, Power, ...
// Class Hybrid = Consumes or Produces Energy, Power, ...
type Class int32

const (
	Class_CLASS_UNKNOWN  Class = 0
	Class_CLASS_CONSUMER Class = 1
	Class_CLASS_PRODUCER Class = 2
	Class_CLASS_HYBRID   Class = 3
)

var Class_name = map[int32]string{
	0: "CLASS_UNKNOWN",
	1: "CLASS_CONSUMER",
	2: "CLASS_PRODUCER",
	3: "CLASS_HYBRID",
}

var Class_value = map[string]int32{
	"CLASS_UNKNOWN":  0,
	"CLASS_CONSUMER": 1,
	"CLASS_PRODUCER": 2,
	"CLASS_HYBRID":   3,
}

func (x Class) String() string {
	return proto.EnumName(Class_name, int32(x))
}

func (Class) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_f88fa3b9b3f72b96, []int{4}
}

// GDRs is the message type wich is published to the mqtt Handler for GDR
// config_uuid - unique identification of config at time of measurement (same as associated GCR)
type GDRs struct {
	GDRs       map[string]*GDR `protobuf:"bytes,1,rep,name=GDRs,proto3" json:"GDRs" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	ConfigUuid string          `protobuf:"bytes,2,opt,name=config_uuid,json=configUuid,proto3" json:"config_uuid"`
}

func (m *GDRs) Reset()         { *m = GDRs{} }
func (m *GDRs) String() string { return proto.CompactTextString(m) }
func (*GDRs) ProtoMessage()    {}
func (*GDRs) Descriptor() ([]byte, []int) {
	return fileDescriptor_f88fa3b9b3f72b96, []int{0}
}
func (m *GDRs) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GDRs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GDRs.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 *GDRs) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GDRs.Merge(m, src)
}
func (m *GDRs) XXX_Size() int {
	return m.Size()
}
func (m *GDRs) XXX_DiscardUnknown() {
	xxx_messageInfo_GDRs.DiscardUnknown(m)
}

var xxx_messageInfo_GDRs proto.InternalMessageInfo

func (m *GDRs) GetGDRs() map[string]*GDR {
	if m != nil {
		return m.GDRs
	}
	return nil
}

func (m *GDRs) GetConfigUuid() string {
	if m != nil {
		return m.ConfigUuid
	}
	return ""
}

// GCRs is the message type wich is published to the mqtt Handler for GCR
// config_uuid - unique identification of config in time (i.e. changes on config change)
type GCRs struct {
	GCRs       map[string]*GCR `protobuf:"bytes,1,rep,name=GCRs,proto3" json:"GCRs" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	ConfigUuid string          `protobuf:"bytes,2,opt,name=config_uuid,json=configUuid,proto3" json:"config_uuid"`
}

func (m *GCRs) Reset()         { *m = GCRs{} }
func (m *GCRs) String() string { return proto.CompactTextString(m) }
func (*GCRs) ProtoMessage()    {}
func (*GCRs) Descriptor() ([]byte, []int) {
	return fileDescriptor_f88fa3b9b3f72b96, []int{1}
}
func (m *GCRs) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GCRs) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GCRs.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 *GCRs) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GCRs.Merge(m, src)
}
func (m *GCRs) XXX_Size() int {
	return m.Size()
}
func (m *GCRs) XXX_DiscardUnknown() {
	xxx_messageInfo_GCRs.DiscardUnknown(m)
}

var xxx_messageInfo_GCRs proto.InternalMessageInfo

func (m *GCRs) GetGCRs() map[string]*GCR {
	if m != nil {
		return m.GCRs
	}
	return nil
}

func (m *GCRs) GetConfigUuid() string {
	if m != nil {
		return m.ConfigUuid
	}
	return ""
}

// GDR = Generic Data Record
// id - unique identification (Same to associated GCR)
// status - see Status declaration
// timestamp - last time Data was updated
// values - Key = Binary ObisCode, Value = Value of ObisCode
//   - based on ObisCode the basic Data information
//   - in groups here is the comparison of the childs data information
//
// flexValues - Key = string
//
//	Value = FlexValue
type GDR struct {
	Id         string                `protobuf:"bytes,1,opt,name=id,proto3" json:"id"`
	Status     Status                `protobuf:"varint,2,opt,name=status,proto3,enum=Status" json:"status"`
	Timestamp  *types.Timestamp      `protobuf:"bytes,3,opt,name=timestamp,proto3" json:"timestamp"`
	Values     map[uint64]uint64     `protobuf:"bytes,4,rep,name=values,proto3" json:"values" protobuf_key:"varint,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
	FlexValues map[string]*FlexValue `protobuf:"bytes,5,rep,name=flexValues,proto3" json:"flexValues" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

func (m *GDR) Reset()         { *m = GDR{} }
func (m *GDR) String() string { return proto.CompactTextString(m) }
func (*GDR) ProtoMessage()    {}
func (*GDR) Descriptor() ([]byte, []int) {
	return fileDescriptor_f88fa3b9b3f72b96, []int{2}
}
func (m *GDR) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GDR) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GDR.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 *GDR) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GDR.Merge(m, src)
}
func (m *GDR) XXX_Size() int {
	return m.Size()
}
func (m *GDR) XXX_DiscardUnknown() {
	xxx_messageInfo_GDR.DiscardUnknown(m)
}

var xxx_messageInfo_GDR proto.InternalMessageInfo

func (m *GDR) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *GDR) GetStatus() Status {
	if m != nil {
		return m.Status
	}
	return Status_STATUS_UNKNOWN
}

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

func (m *GDR) GetValues() map[uint64]uint64 {
	if m != nil {
		return m.Values
	}
	return nil
}

func (m *GDR) GetFlexValues() map[string]*FlexValue {
	if m != nil {
		return m.FlexValues
	}
	return nil
}

// GCR = Generic Config Record
// id - unique identification (Same to associated GDR)
// label - describes the Datasource
// class - see Class declaration
// sources - points to the childs of the measuring point
//   - references on the GDR ids
//   - structure of groupings
//
// codes  - based on Binary ObisCodes
//   - declares which ObisCodes the associated GDR has
//
// devicetype - see DeviceType declaration
// meta - may include app-dependent meta information
// timestamp - last time the config was updated
// flexDefinitions - definition of flexible values
type GCR struct {
	Id              string                     `protobuf:"bytes,1,opt,name=id,proto3" json:"id"`
	Label           string                     `protobuf:"bytes,2,opt,name=label,proto3" json:"label"`
	Class           Class                      `protobuf:"varint,3,opt,name=class,proto3,enum=Class" json:"class"`
	Sources         []string                   `protobuf:"bytes,4,rep,name=sources,proto3" json:"sources"`
	Codes           []uint64                   `protobuf:"varint,5,rep,packed,name=codes,proto3" json:"codes"`
	Devicetype      DeviceType                 `protobuf:"varint,6,opt,name=devicetype,proto3,enum=DeviceType" json:"devicetype"`
	Meta            map[string]string          `protobuf:"bytes,7,rep,name=meta,proto3" json:"meta" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	Timestamp       *types.Timestamp           `protobuf:"bytes,8,opt,name=timestamp,proto3" json:"timestamp"`
	FlexDefinitions map[string]*FlexDefinition `protobuf:"bytes,9,rep,name=flexDefinitions,proto3" json:"flexDefinitions" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

func (m *GCR) Reset()         { *m = GCR{} }
func (m *GCR) String() string { return proto.CompactTextString(m) }
func (*GCR) ProtoMessage()    {}
func (*GCR) Descriptor() ([]byte, []int) {
	return fileDescriptor_f88fa3b9b3f72b96, []int{3}
}
func (m *GCR) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *GCR) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_GCR.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 *GCR) XXX_Merge(src proto.Message) {
	xxx_messageInfo_GCR.Merge(m, src)
}
func (m *GCR) XXX_Size() int {
	return m.Size()
}
func (m *GCR) XXX_DiscardUnknown() {
	xxx_messageInfo_GCR.DiscardUnknown(m)
}

var xxx_messageInfo_GCR proto.InternalMessageInfo

func (m *GCR) GetId() string {
	if m != nil {
		return m.Id
	}
	return ""
}

func (m *GCR) GetLabel() string {
	if m != nil {
		return m.Label
	}
	return ""
}

func (m *GCR) GetClass() Class {
	if m != nil {
		return m.Class
	}
	return Class_CLASS_UNKNOWN
}

func (m *GCR) GetSources() []string {
	if m != nil {
		return m.Sources
	}
	return nil
}

func (m *GCR) GetCodes() []uint64 {
	if m != nil {
		return m.Codes
	}
	return nil
}

func (m *GCR) GetDevicetype() DeviceType {
	if m != nil {
		return m.Devicetype
	}
	return DeviceType_DEVICE_TYPE_UNKNOWN
}

func (m *GCR) GetMeta() map[string]string {
	if m != nil {
		return m.Meta
	}
	return nil
}

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

func (m *GCR) GetFlexDefinitions() map[string]*FlexDefinition {
	if m != nil {
		return m.FlexDefinitions
	}
	return nil
}

// FlexValue is a message type which handles flexible datapoints inside a GDR
type FlexValue struct {
	IntValue    int64  `protobuf:"varint,1,opt,name=int_value,json=intValue,proto3" json:"int_value"`
	StringValue string `protobuf:"bytes,2,opt,name=string_value,json=stringValue,proto3" json:"string_value"`
}

func (m *FlexValue) Reset()         { *m = FlexValue{} }
func (m *FlexValue) String() string { return proto.CompactTextString(m) }
func (*FlexValue) ProtoMessage()    {}
func (*FlexValue) Descriptor() ([]byte, []int) {
	return fileDescriptor_f88fa3b9b3f72b96, []int{4}
}
func (m *FlexValue) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *FlexValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_FlexValue.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 *FlexValue) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FlexValue.Merge(m, src)
}
func (m *FlexValue) XXX_Size() int {
	return m.Size()
}
func (m *FlexValue) XXX_DiscardUnknown() {
	xxx_messageInfo_FlexValue.DiscardUnknown(m)
}

var xxx_messageInfo_FlexValue proto.InternalMessageInfo

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

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

// FlexDefinition describes the content of the flexible values
type FlexDefinition struct {
	Label        string        `protobuf:"bytes,1,opt,name=label,proto3" json:"label"`
	Type         FlexValueType `protobuf:"varint,2,opt,name=type,proto3,enum=FlexValueType" json:"type"`
	Unit         Unit          `protobuf:"varint,3,opt,name=unit,proto3,enum=Unit" json:"unit"`
	Decimalpower int32         `protobuf:"zigzag32,4,opt,name=decimalpower,proto3" json:"decimalpower"`
}

func (m *FlexDefinition) Reset()         { *m = FlexDefinition{} }
func (m *FlexDefinition) String() string { return proto.CompactTextString(m) }
func (*FlexDefinition) ProtoMessage()    {}
func (*FlexDefinition) Descriptor() ([]byte, []int) {
	return fileDescriptor_f88fa3b9b3f72b96, []int{5}
}
func (m *FlexDefinition) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *FlexDefinition) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_FlexDefinition.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 *FlexDefinition) XXX_Merge(src proto.Message) {
	xxx_messageInfo_FlexDefinition.Merge(m, src)
}
func (m *FlexDefinition) XXX_Size() int {
	return m.Size()
}
func (m *FlexDefinition) XXX_DiscardUnknown() {
	xxx_messageInfo_FlexDefinition.DiscardUnknown(m)
}

var xxx_messageInfo_FlexDefinition proto.InternalMessageInfo

func (m *FlexDefinition) GetLabel() string {
	if m != nil {
		return m.Label
	}
	return ""
}

func (m *FlexDefinition) GetType() FlexValueType {
	if m != nil {
		return m.Type
	}
	return FlexValueType_FLEX_VALUE_TYPE_INTEGER
}

func (m *FlexDefinition) GetUnit() Unit {
	if m != nil {
		return m.Unit
	}
	return Unit_UNIT_UNKNOWN
}

func (m *FlexDefinition) GetDecimalpower() int32 {
	if m != nil {
		return m.Decimalpower
	}
	return 0
}

func init() {
	proto.RegisterEnum("FlexValueType", FlexValueType_name, FlexValueType_value)
	proto.RegisterEnum("Unit", Unit_name, Unit_value)
	proto.RegisterEnum("DeviceType", DeviceType_name, DeviceType_value)
	proto.RegisterEnum("Status", Status_name, Status_value)
	proto.RegisterEnum("Class", Class_name, Class_value)
	proto.RegisterType((*GDRs)(nil), "GDRs")
	proto.RegisterMapType((map[string]*GDR)(nil), "GDRs.GDRsEntry")
	proto.RegisterType((*GCRs)(nil), "GCRs")
	proto.RegisterMapType((map[string]*GCR)(nil), "GCRs.GCRsEntry")
	proto.RegisterType((*GDR)(nil), "GDR")
	proto.RegisterMapType((map[string]*FlexValue)(nil), "GDR.FlexValuesEntry")
	proto.RegisterMapType((map[uint64]uint64)(nil), "GDR.ValuesEntry")
	proto.RegisterType((*GCR)(nil), "GCR")
	proto.RegisterMapType((map[string]*FlexDefinition)(nil), "GCR.FlexDefinitionsEntry")
	proto.RegisterMapType((map[string]string)(nil), "GCR.MetaEntry")
	proto.RegisterType((*FlexValue)(nil), "FlexValue")
	proto.RegisterType((*FlexDefinition)(nil), "FlexDefinition")
}

func init() { proto.RegisterFile("gdr.proto", fileDescriptor_f88fa3b9b3f72b96) }

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

func (m *GDRs) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GDRs) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GDRs) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ConfigUuid) > 0 {
		i -= len(m.ConfigUuid)
		copy(dAtA[i:], m.ConfigUuid)
		i = encodeVarintGdr(dAtA, i, uint64(len(m.ConfigUuid)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.GDRs) > 0 {
		for k := range m.GDRs {
			v := m.GDRs[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintGdr(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintGdr(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintGdr(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *GCRs) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GCRs) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GCRs) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ConfigUuid) > 0 {
		i -= len(m.ConfigUuid)
		copy(dAtA[i:], m.ConfigUuid)
		i = encodeVarintGdr(dAtA, i, uint64(len(m.ConfigUuid)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.GCRs) > 0 {
		for k := range m.GCRs {
			v := m.GCRs[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintGdr(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintGdr(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintGdr(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *GDR) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GDR) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GDR) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.FlexValues) > 0 {
		for k := range m.FlexValues {
			v := m.FlexValues[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintGdr(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintGdr(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintGdr(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x2a
		}
	}
	if len(m.Values) > 0 {
		for k := range m.Values {
			v := m.Values[k]
			baseI := i
			i = encodeVarintGdr(dAtA, i, uint64(v))
			i--
			dAtA[i] = 0x10
			i = encodeVarintGdr(dAtA, i, uint64(k))
			i--
			dAtA[i] = 0x8
			i = encodeVarintGdr(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x22
		}
	}
	if m.Timestamp != nil {
		{
			size, err := m.Timestamp.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGdr(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Status != 0 {
		i = encodeVarintGdr(dAtA, i, uint64(m.Status))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintGdr(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *GCR) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *GCR) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GCR) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.FlexDefinitions) > 0 {
		for k := range m.FlexDefinitions {
			v := m.FlexDefinitions[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintGdr(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintGdr(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintGdr(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x4a
		}
	}
	if m.Timestamp != nil {
		{
			size, err := m.Timestamp.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintGdr(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x42
	}
	if len(m.Meta) > 0 {
		for k := range m.Meta {
			v := m.Meta[k]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintGdr(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintGdr(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintGdr(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x3a
		}
	}
	if m.Devicetype != 0 {
		i = encodeVarintGdr(dAtA, i, uint64(m.Devicetype))
		i--
		dAtA[i] = 0x30
	}
	if len(m.Codes) > 0 {
		dAtA8 := make([]byte, len(m.Codes)*10)
		var j7 int
		for _, num := range m.Codes {
			for num >= 1<<7 {
				dAtA8[j7] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j7++
			}
			dAtA8[j7] = uint8(num)
			j7++
		}
		i -= j7
		copy(dAtA[i:], dAtA8[:j7])
		i = encodeVarintGdr(dAtA, i, uint64(j7))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Sources) > 0 {
		for iNdEx := len(m.Sources) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Sources[iNdEx])
			copy(dAtA[i:], m.Sources[iNdEx])
			i = encodeVarintGdr(dAtA, i, uint64(len(m.Sources[iNdEx])))
			i--
			dAtA[i] = 0x22
		}
	}
	if m.Class != 0 {
		i = encodeVarintGdr(dAtA, i, uint64(m.Class))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Label) > 0 {
		i -= len(m.Label)
		copy(dAtA[i:], m.Label)
		i = encodeVarintGdr(dAtA, i, uint64(len(m.Label)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Id) > 0 {
		i -= len(m.Id)
		copy(dAtA[i:], m.Id)
		i = encodeVarintGdr(dAtA, i, uint64(len(m.Id)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *FlexValue) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *FlexValue) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FlexValue) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.StringValue) > 0 {
		i -= len(m.StringValue)
		copy(dAtA[i:], m.StringValue)
		i = encodeVarintGdr(dAtA, i, uint64(len(m.StringValue)))
		i--
		dAtA[i] = 0x12
	}
	if m.IntValue != 0 {
		i = encodeVarintGdr(dAtA, i, uint64(m.IntValue))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *FlexDefinition) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *FlexDefinition) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *FlexDefinition) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Decimalpower != 0 {
		i = encodeVarintGdr(dAtA, i, uint64((uint32(m.Decimalpower)<<1)^uint32((m.Decimalpower>>31))))
		i--
		dAtA[i] = 0x20
	}
	if m.Unit != 0 {
		i = encodeVarintGdr(dAtA, i, uint64(m.Unit))
		i--
		dAtA[i] = 0x18
	}
	if m.Type != 0 {
		i = encodeVarintGdr(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Label) > 0 {
		i -= len(m.Label)
		copy(dAtA[i:], m.Label)
		i = encodeVarintGdr(dAtA, i, uint64(len(m.Label)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintGdr(dAtA []byte, offset int, v uint64) int {
	offset -= sovGdr(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *GDRs) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.GDRs) > 0 {
		for k, v := range m.GDRs {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovGdr(uint64(l))
			}
			mapEntrySize := 1 + len(k) + sovGdr(uint64(len(k))) + l
			n += mapEntrySize + 1 + sovGdr(uint64(mapEntrySize))
		}
	}
	l = len(m.ConfigUuid)
	if l > 0 {
		n += 1 + l + sovGdr(uint64(l))
	}
	return n
}

func (m *GCRs) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.GCRs) > 0 {
		for k, v := range m.GCRs {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovGdr(uint64(l))
			}
			mapEntrySize := 1 + len(k) + sovGdr(uint64(len(k))) + l
			n += mapEntrySize + 1 + sovGdr(uint64(mapEntrySize))
		}
	}
	l = len(m.ConfigUuid)
	if l > 0 {
		n += 1 + l + sovGdr(uint64(l))
	}
	return n
}

func (m *GDR) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovGdr(uint64(l))
	}
	if m.Status != 0 {
		n += 1 + sovGdr(uint64(m.Status))
	}
	if m.Timestamp != nil {
		l = m.Timestamp.Size()
		n += 1 + l + sovGdr(uint64(l))
	}
	if len(m.Values) > 0 {
		for k, v := range m.Values {
			_ = k
			_ = v
			mapEntrySize := 1 + sovGdr(uint64(k)) + 1 + sovGdr(uint64(v))
			n += mapEntrySize + 1 + sovGdr(uint64(mapEntrySize))
		}
	}
	if len(m.FlexValues) > 0 {
		for k, v := range m.FlexValues {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovGdr(uint64(l))
			}
			mapEntrySize := 1 + len(k) + sovGdr(uint64(len(k))) + l
			n += mapEntrySize + 1 + sovGdr(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *GCR) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovGdr(uint64(l))
	}
	l = len(m.Label)
	if l > 0 {
		n += 1 + l + sovGdr(uint64(l))
	}
	if m.Class != 0 {
		n += 1 + sovGdr(uint64(m.Class))
	}
	if len(m.Sources) > 0 {
		for _, s := range m.Sources {
			l = len(s)
			n += 1 + l + sovGdr(uint64(l))
		}
	}
	if len(m.Codes) > 0 {
		l = 0
		for _, e := range m.Codes {
			l += sovGdr(uint64(e))
		}
		n += 1 + sovGdr(uint64(l)) + l
	}
	if m.Devicetype != 0 {
		n += 1 + sovGdr(uint64(m.Devicetype))
	}
	if len(m.Meta) > 0 {
		for k, v := range m.Meta {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovGdr(uint64(len(k))) + 1 + len(v) + sovGdr(uint64(len(v)))
			n += mapEntrySize + 1 + sovGdr(uint64(mapEntrySize))
		}
	}
	if m.Timestamp != nil {
		l = m.Timestamp.Size()
		n += 1 + l + sovGdr(uint64(l))
	}
	if len(m.FlexDefinitions) > 0 {
		for k, v := range m.FlexDefinitions {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovGdr(uint64(l))
			}
			mapEntrySize := 1 + len(k) + sovGdr(uint64(len(k))) + l
			n += mapEntrySize + 1 + sovGdr(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *FlexValue) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.IntValue != 0 {
		n += 1 + sovGdr(uint64(m.IntValue))
	}
	l = len(m.StringValue)
	if l > 0 {
		n += 1 + l + sovGdr(uint64(l))
	}
	return n
}

func (m *FlexDefinition) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Label)
	if l > 0 {
		n += 1 + l + sovGdr(uint64(l))
	}
	if m.Type != 0 {
		n += 1 + sovGdr(uint64(m.Type))
	}
	if m.Unit != 0 {
		n += 1 + sovGdr(uint64(m.Unit))
	}
	if m.Decimalpower != 0 {
		n += 1 + sozGdr(uint64(m.Decimalpower))
	}
	return n
}

func sovGdr(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozGdr(x uint64) (n int) {
	return sovGdr(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *GDRs) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowGdr
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GDRs: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GDRs: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GDRs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGdr
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGdr
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGdr
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.GDRs == nil {
				m.GDRs = make(map[string]*GDR)
			}
			var mapkey string
			var mapvalue *GDR
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowGdr
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowGdr
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthGdr
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthGdr
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowGdr
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthGdr
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthGdr
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &GDR{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipGdr(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthGdr
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.GDRs[mapkey] = mapvalue
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConfigUuid", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGdr
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthGdr
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGdr
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ConfigUuid = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGdr(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGdr
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GCRs) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowGdr
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GCRs: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GCRs: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GCRs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGdr
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGdr
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGdr
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.GCRs == nil {
				m.GCRs = make(map[string]*GCR)
			}
			var mapkey string
			var mapvalue *GCR
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowGdr
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowGdr
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthGdr
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthGdr
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowGdr
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthGdr
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthGdr
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &GCR{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipGdr(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthGdr
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.GCRs[mapkey] = mapvalue
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConfigUuid", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGdr
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthGdr
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGdr
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ConfigUuid = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGdr(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGdr
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GDR) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowGdr
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GDR: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GDR: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGdr
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthGdr
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGdr
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			m.Status = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGdr
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Status |= Status(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGdr
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGdr
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGdr
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Timestamp == nil {
				m.Timestamp = &types.Timestamp{}
			}
			if err := m.Timestamp.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGdr
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGdr
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGdr
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Values == nil {
				m.Values = make(map[uint64]uint64)
			}
			var mapkey uint64
			var mapvalue uint64
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowGdr
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowGdr
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else if fieldNum == 2 {
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowGdr
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapvalue |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipGdr(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthGdr
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Values[mapkey] = mapvalue
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FlexValues", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGdr
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGdr
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGdr
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.FlexValues == nil {
				m.FlexValues = make(map[string]*FlexValue)
			}
			var mapkey string
			var mapvalue *FlexValue
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowGdr
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowGdr
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthGdr
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthGdr
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowGdr
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthGdr
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthGdr
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &FlexValue{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipGdr(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthGdr
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.FlexValues[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGdr(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGdr
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GCR) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowGdr
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GCR: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GCR: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Id", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGdr
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthGdr
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGdr
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Id = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Label", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGdr
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthGdr
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGdr
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Label = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Class", wireType)
			}
			m.Class = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGdr
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Class |= Class(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Sources", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGdr
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthGdr
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGdr
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Sources = append(m.Sources, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 5:
			if wireType == 0 {
				var v uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowGdr
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Codes = append(m.Codes, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowGdr
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthGdr
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthGdr
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				var count int
				for _, integer := range dAtA[iNdEx:postIndex] {
					if integer < 128 {
						count++
					}
				}
				elementCount = count
				if elementCount != 0 && len(m.Codes) == 0 {
					m.Codes = make([]uint64, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowGdr
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Codes = append(m.Codes, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Codes", wireType)
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Devicetype", wireType)
			}
			m.Devicetype = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGdr
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Devicetype |= DeviceType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Meta", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGdr
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGdr
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGdr
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Meta == nil {
				m.Meta = make(map[string]string)
			}
			var mapkey string
			var mapvalue string
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowGdr
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowGdr
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthGdr
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthGdr
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowGdr
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapvalue |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapvalue := int(stringLenmapvalue)
					if intStringLenmapvalue < 0 {
						return ErrInvalidLengthGdr
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthGdr
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipGdr(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthGdr
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Meta[mapkey] = mapvalue
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGdr
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGdr
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGdr
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Timestamp == nil {
				m.Timestamp = &types.Timestamp{}
			}
			if err := m.Timestamp.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FlexDefinitions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGdr
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthGdr
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthGdr
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.FlexDefinitions == nil {
				m.FlexDefinitions = make(map[string]*FlexDefinition)
			}
			var mapkey string
			var mapvalue *FlexDefinition
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowGdr
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowGdr
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthGdr
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthGdr
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowGdr
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthGdr
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthGdr
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &FlexDefinition{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipGdr(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthGdr
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.FlexDefinitions[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGdr(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGdr
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *FlexValue) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowGdr
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: FlexValue: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FlexValue: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field IntValue", wireType)
			}
			m.IntValue = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGdr
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.IntValue |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StringValue", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGdr
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthGdr
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGdr
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StringValue = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipGdr(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGdr
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *FlexDefinition) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowGdr
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: FlexDefinition: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: FlexDefinition: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Label", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGdr
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthGdr
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthGdr
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Label = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			m.Type = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGdr
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= FlexValueType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Unit", wireType)
			}
			m.Unit = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGdr
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Unit |= Unit(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Decimalpower", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowGdr
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			v = int32((uint32(v) >> 1) ^ uint32(((v&1)<<31)>>31))
			m.Decimalpower = v
		default:
			iNdEx = preIndex
			skippy, err := skipGdr(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthGdr
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipGdr(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	depth := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowGdr
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowGdr
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
		case 1:
			iNdEx += 8
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowGdr
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if length < 0 {
				return 0, ErrInvalidLengthGdr
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupGdr
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthGdr
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthGdr        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowGdr          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupGdr = fmt.Errorf("proto: unexpected end of group")
)