dashboard.pb.go

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

package otsimopb

import (
	context "context"
	encoding_binary "encoding/binary"
	fmt "fmt"
	proto "github.com/golang/protobuf/proto"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	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.ProtoPackageIsVersion2 // please upgrade the proto package

type ChartType int32

const (
	LINE     ChartType = 0
	BAR      ChartType = 1
	PIE      ChartType = 2
	SCATTER  ChartType = 3
	BUBLE    ChartType = 4
	RADAR    ChartType = 5
	GEO      ChartType = 6
	TIMELINE ChartType = 7
)

var ChartType_name = map[int32]string{
	0: "LINE",
	1: "BAR",
	2: "PIE",
	3: "SCATTER",
	4: "BUBLE",
	5: "RADAR",
	6: "GEO",
	7: "TIMELINE",
}

var ChartType_value = map[string]int32{
	"LINE":     0,
	"BAR":      1,
	"PIE":      2,
	"SCATTER":  3,
	"BUBLE":    4,
	"RADAR":    5,
	"GEO":      6,
	"TIMELINE": 7,
}

func (x ChartType) String() string {
	return proto.EnumName(ChartType_name, int32(x))
}

func (ChartType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_9b97678da3a35dfb, []int{0}
}

type CardDecoration_Size int32

const (
	// Small is 1x1 block on iphone
	SMALL CardDecoration_Size = 0
	// Medium is 2x1 block on iphone
	MEDIUM CardDecoration_Size = 1
	// Large is 2x2 block on iphone
	LARGE CardDecoration_Size = 2
)

var CardDecoration_Size_name = map[int32]string{
	0: "SMALL",
	1: "MEDIUM",
	2: "LARGE",
}

var CardDecoration_Size_value = map[string]int32{
	"SMALL":  0,
	"MEDIUM": 1,
	"LARGE":  2,
}

func (x CardDecoration_Size) String() string {
	return proto.EnumName(CardDecoration_Size_name, int32(x))
}

func (CardDecoration_Size) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_9b97678da3a35dfb, []int{2, 0}
}

type CardDecoration_BackgroundStyle int32

const (
	EMPTY            CardDecoration_BackgroundStyle = 0
	IMAGE            CardDecoration_BackgroundStyle = 1
	CHART_SILHOUETTE CardDecoration_BackgroundStyle = 2
)

var CardDecoration_BackgroundStyle_name = map[int32]string{
	0: "EMPTY",
	1: "IMAGE",
	2: "CHART_SILHOUETTE",
}

var CardDecoration_BackgroundStyle_value = map[string]int32{
	"EMPTY":            0,
	"IMAGE":            1,
	"CHART_SILHOUETTE": 2,
}

func (x CardDecoration_BackgroundStyle) String() string {
	return proto.EnumName(CardDecoration_BackgroundStyle_name, int32(x))
}

func (CardDecoration_BackgroundStyle) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_9b97678da3a35dfb, []int{2, 1}
}

type DashboardItems struct {
	// ProfileId
	ProfileId string `protobuf:"bytes,1,opt,name=profile_id,json=profileId,proto3" json:"profile_id,omitempty"`
	// ChildId
	ChildId string `protobuf:"bytes,2,opt,name=child_id,json=childId,proto3" json:"child_id,omitempty"`
	// Created At
	CreatedAt            int64    `protobuf:"varint,3,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	Items                []*Card  `protobuf:"bytes,8,rep,name=items,proto3" json:"items,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *DashboardItems) Reset()         { *m = DashboardItems{} }
func (m *DashboardItems) String() string { return proto.CompactTextString(m) }
func (*DashboardItems) ProtoMessage()    {}
func (*DashboardItems) Descriptor() ([]byte, []int) {
	return fileDescriptor_9b97678da3a35dfb, []int{0}
}
func (m *DashboardItems) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DashboardItems) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DashboardItems.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DashboardItems) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DashboardItems.Merge(m, src)
}
func (m *DashboardItems) XXX_Size() int {
	return m.Size()
}
func (m *DashboardItems) XXX_DiscardUnknown() {
	xxx_messageInfo_DashboardItems.DiscardUnknown(m)
}

var xxx_messageInfo_DashboardItems proto.InternalMessageInfo

type DashboardGetRequest struct {
	ProfileId            string   `protobuf:"bytes,1,opt,name=profile_id,json=profileId,proto3" json:"profile_id,omitempty"`
	ChildId              string   `protobuf:"bytes,2,opt,name=child_id,json=childId,proto3" json:"child_id,omitempty"`
	AppVersion           string   `protobuf:"bytes,3,opt,name=app_version,json=appVersion,proto3" json:"app_version,omitempty"`
	Language             string   `protobuf:"bytes,4,opt,name=language,proto3" json:"language,omitempty"`
	CountryCode          string   `protobuf:"bytes,5,opt,name=country_code,json=countryCode,proto3" json:"country_code,omitempty"`
	LastTimeDataFetched  int64    `protobuf:"varint,6,opt,name=last_time_data_fetched,json=lastTimeDataFetched,proto3" json:"last_time_data_fetched,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *DashboardGetRequest) Reset()         { *m = DashboardGetRequest{} }
func (m *DashboardGetRequest) String() string { return proto.CompactTextString(m) }
func (*DashboardGetRequest) ProtoMessage()    {}
func (*DashboardGetRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_9b97678da3a35dfb, []int{1}
}
func (m *DashboardGetRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *DashboardGetRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_DashboardGetRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *DashboardGetRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_DashboardGetRequest.Merge(m, src)
}
func (m *DashboardGetRequest) XXX_Size() int {
	return m.Size()
}
func (m *DashboardGetRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_DashboardGetRequest.DiscardUnknown(m)
}

var xxx_messageInfo_DashboardGetRequest proto.InternalMessageInfo

type CardDecoration struct {
	Size_                CardDecoration_Size            `protobuf:"varint,1,opt,name=size,proto3,enum=otsimo.CardDecoration_Size" json:"size,omitempty"`
	BackgroundStyle      CardDecoration_BackgroundStyle `protobuf:"varint,2,opt,name=background_style,json=backgroundStyle,proto3,enum=otsimo.CardDecoration_BackgroundStyle" json:"background_style,omitempty"`
	ImageUrl             string                         `protobuf:"bytes,3,opt,name=image_url,json=imageUrl,proto3" json:"image_url,omitempty"`
	LeftIcon             string                         `protobuf:"bytes,4,opt,name=left_icon,json=leftIcon,proto3" json:"left_icon,omitempty"`
	RightIcon            string                         `protobuf:"bytes,5,opt,name=right_icon,json=rightIcon,proto3" json:"right_icon,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                       `json:"-"`
	XXX_sizecache        int32                          `json:"-"`
}

func (m *CardDecoration) Reset()         { *m = CardDecoration{} }
func (m *CardDecoration) String() string { return proto.CompactTextString(m) }
func (*CardDecoration) ProtoMessage()    {}
func (*CardDecoration) Descriptor() ([]byte, []int) {
	return fileDescriptor_9b97678da3a35dfb, []int{2}
}
func (m *CardDecoration) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CardDecoration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CardDecoration.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *CardDecoration) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CardDecoration.Merge(m, src)
}
func (m *CardDecoration) XXX_Size() int {
	return m.Size()
}
func (m *CardDecoration) XXX_DiscardUnknown() {
	xxx_messageInfo_CardDecoration.DiscardUnknown(m)
}

var xxx_messageInfo_CardDecoration proto.InternalMessageInfo

type CardEmpty struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CardEmpty) Reset()         { *m = CardEmpty{} }
func (m *CardEmpty) String() string { return proto.CompactTextString(m) }
func (*CardEmpty) ProtoMessage()    {}
func (*CardEmpty) Descriptor() ([]byte, []int) {
	return fileDescriptor_9b97678da3a35dfb, []int{3}
}
func (m *CardEmpty) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CardEmpty) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CardEmpty.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *CardEmpty) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CardEmpty.Merge(m, src)
}
func (m *CardEmpty) XXX_Size() int {
	return m.Size()
}
func (m *CardEmpty) XXX_DiscardUnknown() {
	xxx_messageInfo_CardEmpty.DiscardUnknown(m)
}

var xxx_messageInfo_CardEmpty proto.InternalMessageInfo

type CardWebpage struct {
	Url                  string   `protobuf:"bytes,1,opt,name=url,proto3" json:"url,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CardWebpage) Reset()         { *m = CardWebpage{} }
func (m *CardWebpage) String() string { return proto.CompactTextString(m) }
func (*CardWebpage) ProtoMessage()    {}
func (*CardWebpage) Descriptor() ([]byte, []int) {
	return fileDescriptor_9b97678da3a35dfb, []int{4}
}
func (m *CardWebpage) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CardWebpage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CardWebpage.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *CardWebpage) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CardWebpage.Merge(m, src)
}
func (m *CardWebpage) XXX_Size() int {
	return m.Size()
}
func (m *CardWebpage) XXX_DiscardUnknown() {
	xxx_messageInfo_CardWebpage.DiscardUnknown(m)
}

var xxx_messageInfo_CardWebpage proto.InternalMessageInfo

type CardApplink struct {
	Applink              string   `protobuf:"bytes,1,opt,name=applink,proto3" json:"applink,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *CardApplink) Reset()         { *m = CardApplink{} }
func (m *CardApplink) String() string { return proto.CompactTextString(m) }
func (*CardApplink) ProtoMessage()    {}
func (*CardApplink) Descriptor() ([]byte, []int) {
	return fileDescriptor_9b97678da3a35dfb, []int{5}
}
func (m *CardApplink) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CardApplink) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CardApplink.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *CardApplink) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CardApplink.Merge(m, src)
}
func (m *CardApplink) XXX_Size() int {
	return m.Size()
}
func (m *CardApplink) XXX_DiscardUnknown() {
	xxx_messageInfo_CardApplink.DiscardUnknown(m)
}

var xxx_messageInfo_CardApplink proto.InternalMessageInfo

type CardAnalysis struct {
	Data                 *DataSet  `protobuf:"bytes,1,opt,name=data,proto3" json:"data,omitempty"`
	ChartType            ChartType `protobuf:"varint,2,opt,name=chart_type,json=chartType,proto3,enum=otsimo.ChartType" json:"chart_type,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

func (m *CardAnalysis) Reset()         { *m = CardAnalysis{} }
func (m *CardAnalysis) String() string { return proto.CompactTextString(m) }
func (*CardAnalysis) ProtoMessage()    {}
func (*CardAnalysis) Descriptor() ([]byte, []int) {
	return fileDescriptor_9b97678da3a35dfb, []int{6}
}
func (m *CardAnalysis) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *CardAnalysis) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_CardAnalysis.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *CardAnalysis) XXX_Merge(src proto.Message) {
	xxx_messageInfo_CardAnalysis.Merge(m, src)
}
func (m *CardAnalysis) XXX_Size() int {
	return m.Size()
}
func (m *CardAnalysis) XXX_DiscardUnknown() {
	xxx_messageInfo_CardAnalysis.DiscardUnknown(m)
}

var xxx_messageInfo_CardAnalysis proto.InternalMessageInfo

type Card struct {
	Id         string          `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Text       string          `protobuf:"bytes,2,opt,name=text,proto3" json:"text,omitempty"`
	ExpiresAt  int64           `protobuf:"varint,3,opt,name=expires_at,json=expiresAt,proto3" json:"expires_at,omitempty"`
	CreatedAt  int64           `protobuf:"varint,4,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	Decoration *CardDecoration `protobuf:"bytes,5,opt,name=decoration,proto3" json:"decoration,omitempty"`
	// Score is between 0-500
	ProviderScore int32 `protobuf:"varint,6,opt,name=provider_score,json=providerScore,proto3" json:"provider_score,omitempty"`
	// ProviderWeight is between 0-2
	ProviderWeight float32 `protobuf:"fixed32,7,opt,name=provider_weight,json=providerWeight,proto3" json:"provider_weight,omitempty"`
	ProviderName   string  `protobuf:"bytes,8,opt,name=provider_name,json=providerName,proto3" json:"provider_name,omitempty"`
	Language       string  `protobuf:"bytes,9,opt,name=language,proto3" json:"language,omitempty"`
	// Types that are valid to be assigned to Data:
	//	*Card_Empty
	//	*Card_Webpage
	//	*Card_Applink
	//	*Card_Analysis
	Data isCard_Data `protobuf_oneof:"data"`
	// Title for newer systems
	Title string `protobuf:"bytes,14,opt,name=title,proto3" json:"title,omitempty"`
	// Subtitle for newer systems
	Subtitle string `protobuf:"bytes,15,opt,name=subtitle,proto3" json:"subtitle,omitempty"`
	// Labels of the card
	Labels               map[string]string `protobuf:"bytes,16,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func (m *Card) Reset()         { *m = Card{} }
func (m *Card) String() string { return proto.CompactTextString(m) }
func (*Card) ProtoMessage()    {}
func (*Card) Descriptor() ([]byte, []int) {
	return fileDescriptor_9b97678da3a35dfb, []int{7}
}
func (m *Card) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Card) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Card.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalTo(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *Card) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Card.Merge(m, src)
}
func (m *Card) XXX_Size() int {
	return m.Size()
}
func (m *Card) XXX_DiscardUnknown() {
	xxx_messageInfo_Card.DiscardUnknown(m)
}

var xxx_messageInfo_Card proto.InternalMessageInfo

type isCard_Data interface {
	isCard_Data()
	MarshalTo([]byte) (int, error)
	Size() int
}

type Card_Empty struct {
	Empty *CardEmpty `protobuf:"bytes,10,opt,name=empty,proto3,oneof"`
}
type Card_Webpage struct {
	Webpage *CardWebpage `protobuf:"bytes,11,opt,name=webpage,proto3,oneof"`
}
type Card_Applink struct {
	Applink *CardApplink `protobuf:"bytes,12,opt,name=applink,proto3,oneof"`
}
type Card_Analysis struct {
	Analysis *CardAnalysis `protobuf:"bytes,13,opt,name=analysis,proto3,oneof"`
}

func (*Card_Empty) isCard_Data()    {}
func (*Card_Webpage) isCard_Data()  {}
func (*Card_Applink) isCard_Data()  {}
func (*Card_Analysis) isCard_Data() {}

func (m *Card) GetData() isCard_Data {
	if m != nil {
		return m.Data
	}
	return nil
}

func (m *Card) GetEmpty() *CardEmpty {
	if x, ok := m.GetData().(*Card_Empty); ok {
		return x.Empty
	}
	return nil
}

func (m *Card) GetWebpage() *CardWebpage {
	if x, ok := m.GetData().(*Card_Webpage); ok {
		return x.Webpage
	}
	return nil
}

func (m *Card) GetApplink() *CardApplink {
	if x, ok := m.GetData().(*Card_Applink); ok {
		return x.Applink
	}
	return nil
}

func (m *Card) GetAnalysis() *CardAnalysis {
	if x, ok := m.GetData().(*Card_Analysis); ok {
		return x.Analysis
	}
	return nil
}

// XXX_OneofFuncs is for the internal use of the proto package.
func (*Card) 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 _Card_OneofMarshaler, _Card_OneofUnmarshaler, _Card_OneofSizer, []interface{}{
		(*Card_Empty)(nil),
		(*Card_Webpage)(nil),
		(*Card_Applink)(nil),
		(*Card_Analysis)(nil),
	}
}

func _Card_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
	m := msg.(*Card)
	// data
	switch x := m.Data.(type) {
	case *Card_Empty:
		_ = b.EncodeVarint(10<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Empty); err != nil {
			return err
		}
	case *Card_Webpage:
		_ = b.EncodeVarint(11<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Webpage); err != nil {
			return err
		}
	case *Card_Applink:
		_ = b.EncodeVarint(12<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Applink); err != nil {
			return err
		}
	case *Card_Analysis:
		_ = b.EncodeVarint(13<<3 | proto.WireBytes)
		if err := b.EncodeMessage(x.Analysis); err != nil {
			return err
		}
	case nil:
	default:
		return fmt.Errorf("Card.Data has unexpected type %T", x)
	}
	return nil
}

func _Card_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
	m := msg.(*Card)
	switch tag {
	case 10: // data.empty
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(CardEmpty)
		err := b.DecodeMessage(msg)
		m.Data = &Card_Empty{msg}
		return true, err
	case 11: // data.webpage
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(CardWebpage)
		err := b.DecodeMessage(msg)
		m.Data = &Card_Webpage{msg}
		return true, err
	case 12: // data.applink
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(CardApplink)
		err := b.DecodeMessage(msg)
		m.Data = &Card_Applink{msg}
		return true, err
	case 13: // data.analysis
		if wire != proto.WireBytes {
			return true, proto.ErrInternalBadWireType
		}
		msg := new(CardAnalysis)
		err := b.DecodeMessage(msg)
		m.Data = &Card_Analysis{msg}
		return true, err
	default:
		return false, nil
	}
}

func _Card_OneofSizer(msg proto.Message) (n int) {
	m := msg.(*Card)
	// data
	switch x := m.Data.(type) {
	case *Card_Empty:
		s := proto.Size(x.Empty)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Card_Webpage:
		s := proto.Size(x.Webpage)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Card_Applink:
		s := proto.Size(x.Applink)
		n += 1 // tag and wire
		n += proto.SizeVarint(uint64(s))
		n += s
	case *Card_Analysis:
		s := proto.Size(x.Analysis)
		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
}

func init() {
	proto.RegisterEnum("otsimo.ChartType", ChartType_name, ChartType_value)
	proto.RegisterEnum("otsimo.CardDecoration_Size", CardDecoration_Size_name, CardDecoration_Size_value)
	proto.RegisterEnum("otsimo.CardDecoration_BackgroundStyle", CardDecoration_BackgroundStyle_name, CardDecoration_BackgroundStyle_value)
	proto.RegisterType((*DashboardItems)(nil), "otsimo.DashboardItems")
	proto.RegisterType((*DashboardGetRequest)(nil), "otsimo.DashboardGetRequest")
	proto.RegisterType((*CardDecoration)(nil), "otsimo.CardDecoration")
	proto.RegisterType((*CardEmpty)(nil), "otsimo.CardEmpty")
	proto.RegisterType((*CardWebpage)(nil), "otsimo.CardWebpage")
	proto.RegisterType((*CardApplink)(nil), "otsimo.CardApplink")
	proto.RegisterType((*CardAnalysis)(nil), "otsimo.CardAnalysis")
	proto.RegisterType((*Card)(nil), "otsimo.Card")
	proto.RegisterMapType((map[string]string)(nil), "otsimo.Card.LabelsEntry")
}

func init() { proto.RegisterFile("dashboard.proto", fileDescriptor_9b97678da3a35dfb) }

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

// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
const _ = grpc.SupportPackageIsVersion4

// DashboardServiceClient is the client API for DashboardService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type DashboardServiceClient interface {
	Get(ctx context.Context, in *DashboardGetRequest, opts ...grpc.CallOption) (*DashboardItems, error)
	GetStream(ctx context.Context, in *DashboardGetRequest, opts ...grpc.CallOption) (DashboardService_GetStreamClient, error)
}

type dashboardServiceClient struct {
	cc *grpc.ClientConn
}

func NewDashboardServiceClient(cc *grpc.ClientConn) DashboardServiceClient {
	return &dashboardServiceClient{cc}
}

func (c *dashboardServiceClient) Get(ctx context.Context, in *DashboardGetRequest, opts ...grpc.CallOption) (*DashboardItems, error) {
	out := new(DashboardItems)
	err := c.cc.Invoke(ctx, "/otsimo.DashboardService/Get", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *dashboardServiceClient) GetStream(ctx context.Context, in *DashboardGetRequest, opts ...grpc.CallOption) (DashboardService_GetStreamClient, error) {
	stream, err := c.cc.NewStream(ctx, &_DashboardService_serviceDesc.Streams[0], "/otsimo.DashboardService/GetStream", opts...)
	if err != nil {
		return nil, err
	}
	x := &dashboardServiceGetStreamClient{stream}
	if err := x.ClientStream.SendMsg(in); err != nil {
		return nil, err
	}
	if err := x.ClientStream.CloseSend(); err != nil {
		return nil, err
	}
	return x, nil
}

type DashboardService_GetStreamClient interface {
	Recv() (*Card, error)
	grpc.ClientStream
}

type dashboardServiceGetStreamClient struct {
	grpc.ClientStream
}

func (x *dashboardServiceGetStreamClient) Recv() (*Card, error) {
	m := new(Card)
	if err := x.ClientStream.RecvMsg(m); err != nil {
		return nil, err
	}
	return m, nil
}

// DashboardServiceServer is the server API for DashboardService service.
type DashboardServiceServer interface {
	Get(context.Context, *DashboardGetRequest) (*DashboardItems, error)
	GetStream(*DashboardGetRequest, DashboardService_GetStreamServer) error
}

// UnimplementedDashboardServiceServer can be embedded to have forward compatible implementations.
type UnimplementedDashboardServiceServer struct {
}

func (*UnimplementedDashboardServiceServer) Get(ctx context.Context, req *DashboardGetRequest) (*DashboardItems, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Get not implemented")
}
func (*UnimplementedDashboardServiceServer) GetStream(req *DashboardGetRequest, srv DashboardService_GetStreamServer) error {
	return status.Errorf(codes.Unimplemented, "method GetStream not implemented")
}

func RegisterDashboardServiceServer(s *grpc.Server, srv DashboardServiceServer) {
	s.RegisterService(&_DashboardService_serviceDesc, srv)
}

func _DashboardService_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DashboardGetRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DashboardServiceServer).Get(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/otsimo.DashboardService/Get",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DashboardServiceServer).Get(ctx, req.(*DashboardGetRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _DashboardService_GetStream_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(DashboardGetRequest)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(DashboardServiceServer).GetStream(m, &dashboardServiceGetStreamServer{stream})
}

type DashboardService_GetStreamServer interface {
	Send(*Card) error
	grpc.ServerStream
}

type dashboardServiceGetStreamServer struct {
	grpc.ServerStream
}

func (x *dashboardServiceGetStreamServer) Send(m *Card) error {
	return x.ServerStream.SendMsg(m)
}

var _DashboardService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "otsimo.DashboardService",
	HandlerType: (*DashboardServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Get",
			Handler:    _DashboardService_Get_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "GetStream",
			Handler:       _DashboardService_GetStream_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "dashboard.proto",
}

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

func (m *DashboardItems) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.ProfileId) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintDashboard(dAtA, i, uint64(len(m.ProfileId)))
		i += copy(dAtA[i:], m.ProfileId)
	}
	if len(m.ChildId) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintDashboard(dAtA, i, uint64(len(m.ChildId)))
		i += copy(dAtA[i:], m.ChildId)
	}
	if m.CreatedAt != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintDashboard(dAtA, i, uint64(m.CreatedAt))
	}
	if len(m.Items) > 0 {
		for _, msg := range m.Items {
			dAtA[i] = 0x42
			i++
			i = encodeVarintDashboard(dAtA, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(dAtA[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

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

func (m *DashboardGetRequest) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.ProfileId) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintDashboard(dAtA, i, uint64(len(m.ProfileId)))
		i += copy(dAtA[i:], m.ProfileId)
	}
	if len(m.ChildId) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintDashboard(dAtA, i, uint64(len(m.ChildId)))
		i += copy(dAtA[i:], m.ChildId)
	}
	if len(m.AppVersion) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintDashboard(dAtA, i, uint64(len(m.AppVersion)))
		i += copy(dAtA[i:], m.AppVersion)
	}
	if len(m.Language) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintDashboard(dAtA, i, uint64(len(m.Language)))
		i += copy(dAtA[i:], m.Language)
	}
	if len(m.CountryCode) > 0 {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintDashboard(dAtA, i, uint64(len(m.CountryCode)))
		i += copy(dAtA[i:], m.CountryCode)
	}
	if m.LastTimeDataFetched != 0 {
		dAtA[i] = 0x30
		i++
		i = encodeVarintDashboard(dAtA, i, uint64(m.LastTimeDataFetched))
	}
	return i, nil
}

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

func (m *CardDecoration) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Size_ != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintDashboard(dAtA, i, uint64(m.Size_))
	}
	if m.BackgroundStyle != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintDashboard(dAtA, i, uint64(m.BackgroundStyle))
	}
	if len(m.ImageUrl) > 0 {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintDashboard(dAtA, i, uint64(len(m.ImageUrl)))
		i += copy(dAtA[i:], m.ImageUrl)
	}
	if len(m.LeftIcon) > 0 {
		dAtA[i] = 0x22
		i++
		i = encodeVarintDashboard(dAtA, i, uint64(len(m.LeftIcon)))
		i += copy(dAtA[i:], m.LeftIcon)
	}
	if len(m.RightIcon) > 0 {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintDashboard(dAtA, i, uint64(len(m.RightIcon)))
		i += copy(dAtA[i:], m.RightIcon)
	}
	return i, nil
}

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

func (m *CardEmpty) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	return i, nil
}

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

func (m *CardWebpage) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Url) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintDashboard(dAtA, i, uint64(len(m.Url)))
		i += copy(dAtA[i:], m.Url)
	}
	return i, nil
}

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

func (m *CardApplink) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Applink) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintDashboard(dAtA, i, uint64(len(m.Applink)))
		i += copy(dAtA[i:], m.Applink)
	}
	return i, nil
}

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

func (m *CardAnalysis) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Data != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintDashboard(dAtA, i, uint64(m.Data.Size()))
		n1, err1 := m.Data.MarshalTo(dAtA[i:])
		if err1 != nil {
			return 0, err1
		}
		i += n1
	}
	if m.ChartType != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintDashboard(dAtA, i, uint64(m.ChartType))
	}
	return i, nil
}

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

func (m *Card) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Id) > 0 {
		dAtA[i] = 0xa
		i++
		i = encodeVarintDashboard(dAtA, i, uint64(len(m.Id)))
		i += copy(dAtA[i:], m.Id)
	}
	if len(m.Text) > 0 {
		dAtA[i] = 0x12
		i++
		i = encodeVarintDashboard(dAtA, i, uint64(len(m.Text)))
		i += copy(dAtA[i:], m.Text)
	}
	if m.ExpiresAt != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintDashboard(dAtA, i, uint64(m.ExpiresAt))
	}
	if m.CreatedAt != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintDashboard(dAtA, i, uint64(m.CreatedAt))
	}
	if m.Decoration != nil {
		dAtA[i] = 0x2a
		i++
		i = encodeVarintDashboard(dAtA, i, uint64(m.Decoration.Size()))
		n2, err2 := m.Decoration.MarshalTo(dAtA[i:])
		if err2 != nil {
			return 0, err2
		}
		i += n2
	}
	if m.ProviderScore != 0 {
		dAtA[i] = 0x30
		i++
		i = encodeVarintDashboard(dAtA, i, uint64(m.ProviderScore))
	}
	if m.ProviderWeight != 0 {
		dAtA[i] = 0x3d
		i++
		encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(math.Float32bits(float32(m.ProviderWeight))))
		i += 4
	}
	if len(m.ProviderName) > 0 {
		dAtA[i] = 0x42
		i++
		i = encodeVarintDashboard(dAtA, i, uint64(len(m.ProviderName)))
		i += copy(dAtA[i:], m.ProviderName)
	}
	if len(m.Language) > 0 {
		dAtA[i] = 0x4a
		i++
		i = encodeVarintDashboard(dAtA, i, uint64(len(m.Language)))
		i += copy(dAtA[i:], m.Language)
	}
	if m.Data != nil {
		nn3, err3 := m.Data.MarshalTo(dAtA[i:])
		if err3 != nil {
			return 0, err3
		}
		i += nn3
	}
	if len(m.Title) > 0 {
		dAtA[i] = 0x72
		i++
		i = encodeVarintDashboard(dAtA, i, uint64(len(m.Title)))
		i += copy(dAtA[i:], m.Title)
	}
	if len(m.Subtitle) > 0 {
		dAtA[i] = 0x7a
		i++
		i = encodeVarintDashboard(dAtA, i, uint64(len(m.Subtitle)))
		i += copy(dAtA[i:], m.Subtitle)
	}
	if len(m.Labels) > 0 {
		for k, _ := range m.Labels {
			dAtA[i] = 0x82
			i++
			dAtA[i] = 0x1
			i++
			v := m.Labels[k]
			mapSize := 1 + len(k) + sovDashboard(uint64(len(k))) + 1 + len(v) + sovDashboard(uint64(len(v)))
			i = encodeVarintDashboard(dAtA, i, uint64(mapSize))
			dAtA[i] = 0xa
			i++
			i = encodeVarintDashboard(dAtA, i, uint64(len(k)))
			i += copy(dAtA[i:], k)
			dAtA[i] = 0x12
			i++
			i = encodeVarintDashboard(dAtA, i, uint64(len(v)))
			i += copy(dAtA[i:], v)
		}
	}
	return i, nil
}

func (m *Card_Empty) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Empty != nil {
		dAtA[i] = 0x52
		i++
		i = encodeVarintDashboard(dAtA, i, uint64(m.Empty.Size()))
		n4, err4 := m.Empty.MarshalTo(dAtA[i:])
		if err4 != nil {
			return 0, err4
		}
		i += n4
	}
	return i, nil
}
func (m *Card_Webpage) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Webpage != nil {
		dAtA[i] = 0x5a
		i++
		i = encodeVarintDashboard(dAtA, i, uint64(m.Webpage.Size()))
		n5, err5 := m.Webpage.MarshalTo(dAtA[i:])
		if err5 != nil {
			return 0, err5
		}
		i += n5
	}
	return i, nil
}
func (m *Card_Applink) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Applink != nil {
		dAtA[i] = 0x62
		i++
		i = encodeVarintDashboard(dAtA, i, uint64(m.Applink.Size()))
		n6, err6 := m.Applink.MarshalTo(dAtA[i:])
		if err6 != nil {
			return 0, err6
		}
		i += n6
	}
	return i, nil
}
func (m *Card_Analysis) MarshalTo(dAtA []byte) (int, error) {
	i := 0
	if m.Analysis != nil {
		dAtA[i] = 0x6a
		i++
		i = encodeVarintDashboard(dAtA, i, uint64(m.Analysis.Size()))
		n7, err7 := m.Analysis.MarshalTo(dAtA[i:])
		if err7 != nil {
			return 0, err7
		}
		i += n7
	}
	return i, nil
}
func encodeVarintDashboard(dAtA []byte, offset int, v uint64) int {
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return offset + 1
}
func (m *DashboardItems) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ProfileId)
	if l > 0 {
		n += 1 + l + sovDashboard(uint64(l))
	}
	l = len(m.ChildId)
	if l > 0 {
		n += 1 + l + sovDashboard(uint64(l))
	}
	if m.CreatedAt != 0 {
		n += 1 + sovDashboard(uint64(m.CreatedAt))
	}
	if len(m.Items) > 0 {
		for _, e := range m.Items {
			l = e.Size()
			n += 1 + l + sovDashboard(uint64(l))
		}
	}
	return n
}

func (m *DashboardGetRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ProfileId)
	if l > 0 {
		n += 1 + l + sovDashboard(uint64(l))
	}
	l = len(m.ChildId)
	if l > 0 {
		n += 1 + l + sovDashboard(uint64(l))
	}
	l = len(m.AppVersion)
	if l > 0 {
		n += 1 + l + sovDashboard(uint64(l))
	}
	l = len(m.Language)
	if l > 0 {
		n += 1 + l + sovDashboard(uint64(l))
	}
	l = len(m.CountryCode)
	if l > 0 {
		n += 1 + l + sovDashboard(uint64(l))
	}
	if m.LastTimeDataFetched != 0 {
		n += 1 + sovDashboard(uint64(m.LastTimeDataFetched))
	}
	return n
}

func (m *CardDecoration) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Size_ != 0 {
		n += 1 + sovDashboard(uint64(m.Size_))
	}
	if m.BackgroundStyle != 0 {
		n += 1 + sovDashboard(uint64(m.BackgroundStyle))
	}
	l = len(m.ImageUrl)
	if l > 0 {
		n += 1 + l + sovDashboard(uint64(l))
	}
	l = len(m.LeftIcon)
	if l > 0 {
		n += 1 + l + sovDashboard(uint64(l))
	}
	l = len(m.RightIcon)
	if l > 0 {
		n += 1 + l + sovDashboard(uint64(l))
	}
	return n
}

func (m *CardEmpty) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	return n
}

func (m *CardWebpage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Url)
	if l > 0 {
		n += 1 + l + sovDashboard(uint64(l))
	}
	return n
}

func (m *CardApplink) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Applink)
	if l > 0 {
		n += 1 + l + sovDashboard(uint64(l))
	}
	return n
}

func (m *CardAnalysis) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Data != nil {
		l = m.Data.Size()
		n += 1 + l + sovDashboard(uint64(l))
	}
	if m.ChartType != 0 {
		n += 1 + sovDashboard(uint64(m.ChartType))
	}
	return n
}

func (m *Card) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Id)
	if l > 0 {
		n += 1 + l + sovDashboard(uint64(l))
	}
	l = len(m.Text)
	if l > 0 {
		n += 1 + l + sovDashboard(uint64(l))
	}
	if m.ExpiresAt != 0 {
		n += 1 + sovDashboard(uint64(m.ExpiresAt))
	}
	if m.CreatedAt != 0 {
		n += 1 + sovDashboard(uint64(m.CreatedAt))
	}
	if m.Decoration != nil {
		l = m.Decoration.Size()
		n += 1 + l + sovDashboard(uint64(l))
	}
	if m.ProviderScore != 0 {
		n += 1 + sovDashboard(uint64(m.ProviderScore))
	}
	if m.ProviderWeight != 0 {
		n += 5
	}
	l = len(m.ProviderName)
	if l > 0 {
		n += 1 + l + sovDashboard(uint64(l))
	}
	l = len(m.Language)
	if l > 0 {
		n += 1 + l + sovDashboard(uint64(l))
	}
	if m.Data != nil {
		n += m.Data.Size()
	}
	l = len(m.Title)
	if l > 0 {
		n += 1 + l + sovDashboard(uint64(l))
	}
	l = len(m.Subtitle)
	if l > 0 {
		n += 1 + l + sovDashboard(uint64(l))
	}
	if len(m.Labels) > 0 {
		for k, v := range m.Labels {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovDashboard(uint64(len(k))) + 1 + len(v) + sovDashboard(uint64(len(v)))
			n += mapEntrySize + 2 + sovDashboard(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *Card_Empty) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Empty != nil {
		l = m.Empty.Size()
		n += 1 + l + sovDashboard(uint64(l))
	}
	return n
}
func (m *Card_Webpage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Webpage != nil {
		l = m.Webpage.Size()
		n += 1 + l + sovDashboard(uint64(l))
	}
	return n
}
func (m *Card_Applink) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Applink != nil {
		l = m.Applink.Size()
		n += 1 + l + sovDashboard(uint64(l))
	}
	return n
}
func (m *Card_Analysis) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Analysis != nil {
		l = m.Analysis.Size()
		n += 1 + l + sovDashboard(uint64(l))
	}
	return n
}

func sovDashboard(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozDashboard(x uint64) (n int) {
	return sovDashboard(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *DashboardItems) 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 ErrIntOverflowDashboard
			}
			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: DashboardItems: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DashboardItems: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProfileId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDashboard
				}
				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 ErrInvalidLengthDashboard
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDashboard
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ProfileId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChildId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDashboard
				}
				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 ErrInvalidLengthDashboard
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDashboard
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ChildId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreatedAt", wireType)
			}
			m.CreatedAt = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDashboard
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CreatedAt |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDashboard
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDashboard
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDashboard
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Items = append(m.Items, &Card{})
			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDashboard(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDashboard
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDashboard
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DashboardGetRequest) 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 ErrIntOverflowDashboard
			}
			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: DashboardGetRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DashboardGetRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProfileId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDashboard
				}
				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 ErrInvalidLengthDashboard
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDashboard
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ProfileId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChildId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDashboard
				}
				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 ErrInvalidLengthDashboard
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDashboard
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ChildId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AppVersion", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDashboard
				}
				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 ErrInvalidLengthDashboard
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDashboard
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.AppVersion = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Language", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDashboard
				}
				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 ErrInvalidLengthDashboard
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDashboard
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Language = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CountryCode", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDashboard
				}
				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 ErrInvalidLengthDashboard
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDashboard
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CountryCode = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastTimeDataFetched", wireType)
			}
			m.LastTimeDataFetched = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDashboard
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LastTimeDataFetched |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipDashboard(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDashboard
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDashboard
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CardDecoration) 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 ErrIntOverflowDashboard
			}
			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: CardDecoration: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CardDecoration: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Size_", wireType)
			}
			m.Size_ = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDashboard
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Size_ |= CardDecoration_Size(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field BackgroundStyle", wireType)
			}
			m.BackgroundStyle = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDashboard
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.BackgroundStyle |= CardDecoration_BackgroundStyle(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ImageUrl", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDashboard
				}
				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 ErrInvalidLengthDashboard
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDashboard
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ImageUrl = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LeftIcon", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDashboard
				}
				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 ErrInvalidLengthDashboard
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDashboard
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LeftIcon = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RightIcon", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDashboard
				}
				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 ErrInvalidLengthDashboard
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDashboard
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.RightIcon = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDashboard(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDashboard
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDashboard
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CardEmpty) 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 ErrIntOverflowDashboard
			}
			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: CardEmpty: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CardEmpty: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipDashboard(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDashboard
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDashboard
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CardWebpage) 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 ErrIntOverflowDashboard
			}
			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: CardWebpage: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CardWebpage: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Url", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDashboard
				}
				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 ErrInvalidLengthDashboard
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDashboard
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Url = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDashboard(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDashboard
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDashboard
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CardApplink) 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 ErrIntOverflowDashboard
			}
			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: CardApplink: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CardApplink: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Applink", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDashboard
				}
				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 ErrInvalidLengthDashboard
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDashboard
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Applink = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDashboard(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDashboard
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDashboard
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *CardAnalysis) 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 ErrIntOverflowDashboard
			}
			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: CardAnalysis: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CardAnalysis: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDashboard
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDashboard
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDashboard
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Data == nil {
				m.Data = &DataSet{}
			}
			if err := m.Data.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChartType", wireType)
			}
			m.ChartType = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDashboard
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ChartType |= ChartType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipDashboard(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDashboard
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDashboard
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Card) 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 ErrIntOverflowDashboard
			}
			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: Card: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Card: 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 ErrIntOverflowDashboard
				}
				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 ErrInvalidLengthDashboard
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDashboard
			}
			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 Text", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDashboard
				}
				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 ErrInvalidLengthDashboard
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDashboard
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Text = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExpiresAt", wireType)
			}
			m.ExpiresAt = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDashboard
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ExpiresAt |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreatedAt", wireType)
			}
			m.CreatedAt = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDashboard
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.CreatedAt |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Decoration", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDashboard
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDashboard
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDashboard
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Decoration == nil {
				m.Decoration = &CardDecoration{}
			}
			if err := m.Decoration.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProviderScore", wireType)
			}
			m.ProviderScore = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDashboard
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ProviderScore |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProviderWeight", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
			iNdEx += 4
			m.ProviderWeight = float32(math.Float32frombits(v))
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProviderName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDashboard
				}
				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 ErrInvalidLengthDashboard
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDashboard
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ProviderName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Language", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDashboard
				}
				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 ErrInvalidLengthDashboard
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDashboard
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Language = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Empty", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDashboard
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDashboard
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDashboard
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &CardEmpty{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Data = &Card_Empty{v}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Webpage", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDashboard
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDashboard
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDashboard
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &CardWebpage{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Data = &Card_Webpage{v}
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Applink", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDashboard
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDashboard
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDashboard
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &CardApplink{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Data = &Card_Applink{v}
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Analysis", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDashboard
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDashboard
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDashboard
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			v := &CardAnalysis{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Data = &Card_Analysis{v}
			iNdEx = postIndex
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Title", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDashboard
				}
				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 ErrInvalidLengthDashboard
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDashboard
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Title = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 15:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Subtitle", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDashboard
				}
				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 ErrInvalidLengthDashboard
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthDashboard
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Subtitle = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 16:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Labels", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowDashboard
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthDashboard
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthDashboard
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Labels == nil {
				m.Labels = 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 ErrIntOverflowDashboard
					}
					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 ErrIntOverflowDashboard
						}
						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 ErrInvalidLengthDashboard
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthDashboard
					}
					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 ErrIntOverflowDashboard
						}
						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 ErrInvalidLengthDashboard
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthDashboard
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipDashboard(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if skippy < 0 {
						return ErrInvalidLengthDashboard
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Labels[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipDashboard(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthDashboard
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthDashboard
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipDashboard(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowDashboard
			}
			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, ErrIntOverflowDashboard
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
			return iNdEx, nil
		case 1:
			iNdEx += 8
			return iNdEx, nil
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowDashboard
				}
				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, ErrInvalidLengthDashboard
			}
			iNdEx += length
			if iNdEx < 0 {
				return 0, ErrInvalidLengthDashboard
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowDashboard
					}
					if iNdEx >= l {
						return 0, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					innerWire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				innerWireType := int(innerWire & 0x7)
				if innerWireType == 4 {
					break
				}
				next, err := skipDashboard(dAtA[start:])
				if err != nil {
					return 0, err
				}
				iNdEx = start + next
				if iNdEx < 0 {
					return 0, ErrInvalidLengthDashboard
				}
			}
			return iNdEx, nil
		case 4:
			return iNdEx, nil
		case 5:
			iNdEx += 4
			return iNdEx, nil
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
	}
	panic("unreachable")
}

var (
	ErrInvalidLengthDashboard = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowDashboard   = fmt.Errorf("proto: integer overflow")
)