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

package proto

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

type StorageType_MediumType int32

const (
	StorageType_NOT_SPECIFIED_MEDIUM_TYPE StorageType_MediumType = 0
	StorageType_BLOCK_STORAGE             StorageType_MediumType = 1
	StorageType_OBJECT_STORAGE            StorageType_MediumType = 2
	StorageType_HDD                       StorageType_MediumType = 3
	StorageType_SSD                       StorageType_MediumType = 4
	StorageType_NVDIMM                    StorageType_MediumType = 5
)

var StorageType_MediumType_name = map[int32]string{
	0: "NOT_SPECIFIED_MEDIUM_TYPE",
	1: "BLOCK_STORAGE",
	2: "OBJECT_STORAGE",
	3: "HDD",
	4: "SSD",
	5: "NVDIMM",
}

var StorageType_MediumType_value = map[string]int32{
	"NOT_SPECIFIED_MEDIUM_TYPE": 0,
	"BLOCK_STORAGE":             1,
	"OBJECT_STORAGE":            2,
	"HDD":                       3,
	"SSD":                       4,
	"NVDIMM":                    5,
}

func (x StorageType_MediumType) String() string {
	return proto.EnumName(StorageType_MediumType_name, int32(x))
}

func (StorageType_MediumType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_0c5120591600887d, []int{0, 0}
}

type StorageType_MediumProperty int32

const (
	StorageType_NOT_SPECIFIED_MEDIUM_PROPERTY StorageType_MediumProperty = 0
	StorageType_RANDOM_ACCESS                 StorageType_MediumProperty = 1
	StorageType_REPLICATED                    StorageType_MediumProperty = 2
	StorageType_MERGED                        StorageType_MediumProperty = 3
)

var StorageType_MediumProperty_name = map[int32]string{
	0: "NOT_SPECIFIED_MEDIUM_PROPERTY",
	1: "RANDOM_ACCESS",
	2: "REPLICATED",
	3: "MERGED",
}

var StorageType_MediumProperty_value = map[string]int32{
	"NOT_SPECIFIED_MEDIUM_PROPERTY": 0,
	"RANDOM_ACCESS":                 1,
	"REPLICATED":                    2,
	"MERGED":                        3,
}

func (x StorageType_MediumProperty) String() string {
	return proto.EnumName(StorageType_MediumProperty_name, int32(x))
}

func (StorageType_MediumProperty) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_0c5120591600887d, []int{0, 1}
}

type LabelSelectorRequirement_LabelSelectorOperator int32

const (
	LabelSelectorRequirement_NOT_SPECIFIED_OPERATOR LabelSelectorRequirement_LabelSelectorOperator = 0
	LabelSelectorRequirement_IN                     LabelSelectorRequirement_LabelSelectorOperator = 1
	LabelSelectorRequirement_NOT_INT                LabelSelectorRequirement_LabelSelectorOperator = 2
	LabelSelectorRequirement_EXISTS                 LabelSelectorRequirement_LabelSelectorOperator = 3
	LabelSelectorRequirement_DOES_NOT_EXIST         LabelSelectorRequirement_LabelSelectorOperator = 4
)

var LabelSelectorRequirement_LabelSelectorOperator_name = map[int32]string{
	0: "NOT_SPECIFIED_OPERATOR",
	1: "IN",
	2: "NOT_INT",
	3: "EXISTS",
	4: "DOES_NOT_EXIST",
}

var LabelSelectorRequirement_LabelSelectorOperator_value = map[string]int32{
	"NOT_SPECIFIED_OPERATOR": 0,
	"IN":                     1,
	"NOT_INT":                2,
	"EXISTS":                 3,
	"DOES_NOT_EXIST":         4,
}

func (x LabelSelectorRequirement_LabelSelectorOperator) String() string {
	return proto.EnumName(LabelSelectorRequirement_LabelSelectorOperator_name, int32(x))
}

func (LabelSelectorRequirement_LabelSelectorOperator) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_0c5120591600887d, []int{3, 0}
}

// models
type StorageType struct {
	Type                 StorageType_MediumType       `protobuf:"varint,1,opt,name=type,proto3,enum=control.StorageType_MediumType" json:"type,omitempty"`
	Properties           []StorageType_MediumProperty `protobuf:"varint,2,rep,packed,name=properties,proto3,enum=control.StorageType_MediumProperty" json:"properties,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                     `json:"-"`
	XXX_unrecognized     []byte                       `json:"-"`
	XXX_sizecache        int32                        `json:"-"`
}

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

var xxx_messageInfo_StorageType proto.InternalMessageInfo

func (m *StorageType) GetType() StorageType_MediumType {
	if m != nil {
		return m.Type
	}
	return StorageType_NOT_SPECIFIED_MEDIUM_TYPE
}

func (m *StorageType) GetProperties() []StorageType_MediumProperty {
	if m != nil {
		return m.Properties
	}
	return nil
}

type StoragePolicy struct {
	Name                 string         `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	StackedTypes         []*StorageType `protobuf:"bytes,2,rep,name=stacked_types,json=stackedTypes,proto3" json:"stacked_types,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

var xxx_messageInfo_StoragePolicy proto.InternalMessageInfo

func (m *StoragePolicy) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *StoragePolicy) GetStackedTypes() []*StorageType {
	if m != nil {
		return m.StackedTypes
	}
	return nil
}

type Quota struct {
	ReadIops             int64    `protobuf:"varint,1,opt,name=read_iops,json=readIops,proto3" json:"read_iops,omitempty"`
	ReadBps              int64    `protobuf:"varint,2,opt,name=read_bps,json=readBps,proto3" json:"read_bps,omitempty"`
	WriteIops            int64    `protobuf:"varint,3,opt,name=write_iops,json=writeIops,proto3" json:"write_iops,omitempty"`
	WriteBps             int64    `protobuf:"varint,4,opt,name=write_bps,json=writeBps,proto3" json:"write_bps,omitempty"`
	Space                int64    `protobuf:"varint,5,opt,name=space,proto3" json:"space,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_Quota proto.InternalMessageInfo

func (m *Quota) GetReadIops() int64 {
	if m != nil {
		return m.ReadIops
	}
	return 0
}

func (m *Quota) GetReadBps() int64 {
	if m != nil {
		return m.ReadBps
	}
	return 0
}

func (m *Quota) GetWriteIops() int64 {
	if m != nil {
		return m.WriteIops
	}
	return 0
}

func (m *Quota) GetWriteBps() int64 {
	if m != nil {
		return m.WriteBps
	}
	return 0
}

func (m *Quota) GetSpace() int64 {
	if m != nil {
		return m.Space
	}
	return 0
}

type LabelSelectorRequirement struct {
	Key                  string                                         `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Operator             LabelSelectorRequirement_LabelSelectorOperator `protobuf:"varint,2,opt,name=operator,proto3,enum=control.LabelSelectorRequirement_LabelSelectorOperator" json:"operator,omitempty"`
	Values               []string                                       `protobuf:"bytes,3,rep,name=values,proto3" json:"values,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                                       `json:"-"`
	XXX_unrecognized     []byte                                         `json:"-"`
	XXX_sizecache        int32                                          `json:"-"`
}

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

var xxx_messageInfo_LabelSelectorRequirement proto.InternalMessageInfo

func (m *LabelSelectorRequirement) GetKey() string {
	if m != nil {
		return m.Key
	}
	return ""
}

func (m *LabelSelectorRequirement) GetOperator() LabelSelectorRequirement_LabelSelectorOperator {
	if m != nil {
		return m.Operator
	}
	return LabelSelectorRequirement_NOT_SPECIFIED_OPERATOR
}

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

type LabelSelector struct {
	MatchLabels          map[string]string           `protobuf:"bytes,1,rep,name=match_labels,json=matchLabels,proto3" json:"match_labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	MatchExpressions     []*LabelSelectorRequirement `protobuf:"bytes,2,rep,name=match_expressions,json=matchExpressions,proto3" json:"match_expressions,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                    `json:"-"`
	XXX_unrecognized     []byte                      `json:"-"`
	XXX_sizecache        int32                       `json:"-"`
}

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

var xxx_messageInfo_LabelSelector proto.InternalMessageInfo

func (m *LabelSelector) GetMatchLabels() map[string]string {
	if m != nil {
		return m.MatchLabels
	}
	return nil
}

func (m *LabelSelector) GetMatchExpressions() []*LabelSelectorRequirement {
	if m != nil {
		return m.MatchExpressions
	}
	return nil
}

type KeyValuePair struct {
	Key                  string   `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
	Value                string   `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_KeyValuePair proto.InternalMessageInfo

func (m *KeyValuePair) GetKey() string {
	if m != nil {
		return m.Key
	}
	return ""
}

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

type Tenant struct {
	Name                 string          `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Selector             *LabelSelector  `protobuf:"bytes,2,opt,name=selector,proto3" json:"selector,omitempty"`
	Tolerations          []*KeyValuePair `protobuf:"bytes,3,rep,name=tolerations,proto3" json:"tolerations,omitempty"`
	Quota                *Quota          `protobuf:"bytes,4,opt,name=quota,proto3" json:"quota,omitempty"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

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

var xxx_messageInfo_Tenant proto.InternalMessageInfo

func (m *Tenant) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *Tenant) GetSelector() *LabelSelector {
	if m != nil {
		return m.Selector
	}
	return nil
}

func (m *Tenant) GetTolerations() []*KeyValuePair {
	if m != nil {
		return m.Tolerations
	}
	return nil
}

func (m *Tenant) GetQuota() *Quota {
	if m != nil {
		return m.Quota
	}
	return nil
}

type Zone struct {
	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Endpoints            []string `protobuf:"bytes,2,rep,name=endpoints,proto3" json:"endpoints,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_Zone proto.InternalMessageInfo

func (m *Zone) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *Zone) GetEndpoints() []string {
	if m != nil {
		return m.Endpoints
	}
	return nil
}

type ZonesList struct {
	Zones                []*Zone  `protobuf:"bytes,1,rep,name=zones,proto3" json:"zones,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ZonesList proto.InternalMessageInfo

func (m *ZonesList) GetZones() []*Zone {
	if m != nil {
		return m.Zones
	}
	return nil
}

type ThrottlerRuntimeInfo struct {
	Cpu                  int32     `protobuf:"varint,1,opt,name=cpu,proto3" json:"cpu,omitempty"`
	Loadavg              []float32 `protobuf:"fixed32,2,rep,packed,name=loadavg,proto3" json:"loadavg,omitempty"`
	TenantCounts         int32     `protobuf:"varint,3,opt,name=tenant_counts,json=tenantCounts,proto3" json:"tenant_counts,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

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

var xxx_messageInfo_ThrottlerRuntimeInfo proto.InternalMessageInfo

func (m *ThrottlerRuntimeInfo) GetCpu() int32 {
	if m != nil {
		return m.Cpu
	}
	return 0
}

func (m *ThrottlerRuntimeInfo) GetLoadavg() []float32 {
	if m != nil {
		return m.Loadavg
	}
	return nil
}

func (m *ThrottlerRuntimeInfo) GetTenantCounts() int32 {
	if m != nil {
		return m.TenantCounts
	}
	return 0
}

type Throttler struct {
	Address              string                `protobuf:"bytes,1,opt,name=address,proto3" json:"address,omitempty"`
	RuntimeInfo          *ThrottlerRuntimeInfo `protobuf:"bytes,2,opt,name=runtime_info,json=runtimeInfo,proto3" json:"runtime_info,omitempty"`
	XXX_NoUnkeyedLiteral struct{}              `json:"-"`
	XXX_unrecognized     []byte                `json:"-"`
	XXX_sizecache        int32                 `json:"-"`
}

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

var xxx_messageInfo_Throttler proto.InternalMessageInfo

func (m *Throttler) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

func (m *Throttler) GetRuntimeInfo() *ThrottlerRuntimeInfo {
	if m != nil {
		return m.RuntimeInfo
	}
	return nil
}

type MountPoint struct {
	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Realms               []*Realm `protobuf:"bytes,2,rep,name=realms,proto3" json:"realms,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_MountPoint proto.InternalMessageInfo

func (m *MountPoint) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *MountPoint) GetRealms() []*Realm {
	if m != nil {
		return m.Realms
	}
	return nil
}

type RealmRuntimeInfo struct {
	Capacity             int64    `protobuf:"varint,1,opt,name=capacity,proto3" json:"capacity,omitempty"`
	Used                 int64    `protobuf:"varint,2,opt,name=used,proto3" json:"used,omitempty"`
	LastUpdate           int64    `protobuf:"varint,3,opt,name=last_update,json=lastUpdate,proto3" json:"last_update,omitempty"`
	SoftwareVersion      string   `protobuf:"bytes,4,opt,name=software_version,json=softwareVersion,proto3" json:"software_version,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_RealmRuntimeInfo proto.InternalMessageInfo

func (m *RealmRuntimeInfo) GetCapacity() int64 {
	if m != nil {
		return m.Capacity
	}
	return 0
}

func (m *RealmRuntimeInfo) GetUsed() int64 {
	if m != nil {
		return m.Used
	}
	return 0
}

func (m *RealmRuntimeInfo) GetLastUpdate() int64 {
	if m != nil {
		return m.LastUpdate
	}
	return 0
}

func (m *RealmRuntimeInfo) GetSoftwareVersion() string {
	if m != nil {
		return m.SoftwareVersion
	}
	return ""
}

type Realm struct {
	Name                 string            `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Address              string            `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
	Policy               *StoragePolicy    `protobuf:"bytes,3,opt,name=policy,proto3" json:"policy,omitempty"`
	RuntimeInfo          *RealmRuntimeInfo `protobuf:"bytes,4,opt,name=runtime_info,json=runtimeInfo,proto3" json:"runtime_info,omitempty"`
	Labels               map[string]string `protobuf:"bytes,5,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	Taints               []*KeyValuePair   `protobuf:"bytes,6,rep,name=taints,proto3" json:"taints,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_unrecognized     []byte            `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

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

var xxx_messageInfo_Realm proto.InternalMessageInfo

func (m *Realm) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *Realm) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

func (m *Realm) GetPolicy() *StoragePolicy {
	if m != nil {
		return m.Policy
	}
	return nil
}

func (m *Realm) GetRuntimeInfo() *RealmRuntimeInfo {
	if m != nil {
		return m.RuntimeInfo
	}
	return nil
}

func (m *Realm) GetLabels() map[string]string {
	if m != nil {
		return m.Labels
	}
	return nil
}

func (m *Realm) GetTaints() []*KeyValuePair {
	if m != nil {
		return m.Taints
	}
	return nil
}

type RealmsList struct {
	Realms               []*Realm `protobuf:"bytes,1,rep,name=realms,proto3" json:"realms,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_RealmsList proto.InternalMessageInfo

func (m *RealmsList) GetRealms() []*Realm {
	if m != nil {
		return m.Realms
	}
	return nil
}

// universe req / resp messages
type ZoneHeartbeatReq struct {
	Zone                 *Zone    `protobuf:"bytes,1,opt,name=zone,proto3" json:"zone,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ZoneHeartbeatReq proto.InternalMessageInfo

func (m *ZoneHeartbeatReq) GetZone() *Zone {
	if m != nil {
		return m.Zone
	}
	return nil
}

type GetZoneReq struct {
	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_GetZoneReq proto.InternalMessageInfo

func (m *GetZoneReq) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

type DeleteZoneReq struct {
	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_DeleteZoneReq proto.InternalMessageInfo

func (m *DeleteZoneReq) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

type EmptyMessage struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_EmptyMessage proto.InternalMessageInfo

type GlobZonesReq struct {
	Pattern              string   `protobuf:"bytes,1,opt,name=pattern,proto3" json:"pattern,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_GlobZonesReq proto.InternalMessageInfo

func (m *GlobZonesReq) GetPattern() string {
	if m != nil {
		return m.Pattern
	}
	return ""
}

type CreateTenantReq struct {
	Tenant               *Tenant  `protobuf:"bytes,1,opt,name=tenant,proto3" json:"tenant,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_CreateTenantReq proto.InternalMessageInfo

func (m *CreateTenantReq) GetTenant() *Tenant {
	if m != nil {
		return m.Tenant
	}
	return nil
}

type GetTenantReq struct {
	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_GetTenantReq proto.InternalMessageInfo

func (m *GetTenantReq) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

type DeleteTenantReq struct {
	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_DeleteTenantReq proto.InternalMessageInfo

func (m *DeleteTenantReq) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

type TenantsList struct {
	Tenants              []*Tenant `protobuf:"bytes,1,rep,name=tenants,proto3" json:"tenants,omitempty"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

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

var xxx_messageInfo_TenantsList proto.InternalMessageInfo

func (m *TenantsList) GetTenants() []*Tenant {
	if m != nil {
		return m.Tenants
	}
	return nil
}

type GlobTenantsReq struct {
	Pattern              string   `protobuf:"bytes,1,opt,name=pattern,proto3" json:"pattern,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_GlobTenantsReq proto.InternalMessageInfo

func (m *GlobTenantsReq) GetPattern() string {
	if m != nil {
		return m.Pattern
	}
	return ""
}

type WatchZonesReq struct {
	Pattern              string   `protobuf:"bytes,1,opt,name=pattern,proto3" json:"pattern,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_WatchZonesReq proto.InternalMessageInfo

func (m *WatchZonesReq) GetPattern() string {
	if m != nil {
		return m.Pattern
	}
	return ""
}

type WatchTenantsReq struct {
	Pattern              string   `protobuf:"bytes,1,opt,name=pattern,proto3" json:"pattern,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_WatchTenantsReq proto.InternalMessageInfo

func (m *WatchTenantsReq) GetPattern() string {
	if m != nil {
		return m.Pattern
	}
	return ""
}

// zone req / resp messages
type LocateReq struct {
	MountPoint           string         `protobuf:"bytes,1,opt,name=mount_point,json=mountPoint,proto3" json:"mount_point,omitempty"`
	Tenant               string         `protobuf:"bytes,2,opt,name=tenant,proto3" json:"tenant,omitempty"`
	Policy               *StoragePolicy `protobuf:"bytes,3,opt,name=policy,proto3" json:"policy,omitempty"`
	Create               bool           `protobuf:"varint,4,opt,name=create,proto3" json:"create,omitempty"`
	Merged               bool           `protobuf:"varint,5,opt,name=merged,proto3" json:"merged,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

var xxx_messageInfo_LocateReq proto.InternalMessageInfo

func (m *LocateReq) GetMountPoint() string {
	if m != nil {
		return m.MountPoint
	}
	return ""
}

func (m *LocateReq) GetTenant() string {
	if m != nil {
		return m.Tenant
	}
	return ""
}

func (m *LocateReq) GetPolicy() *StoragePolicy {
	if m != nil {
		return m.Policy
	}
	return nil
}

func (m *LocateReq) GetCreate() bool {
	if m != nil {
		return m.Create
	}
	return false
}

func (m *LocateReq) GetMerged() bool {
	if m != nil {
		return m.Merged
	}
	return false
}

type LocateResp struct {
	MountPoint           *MountPoint `protobuf:"bytes,1,opt,name=mount_point,json=mountPoint,proto3" json:"mount_point,omitempty"`
	Throttler            *Throttler  `protobuf:"bytes,2,opt,name=throttler,proto3" json:"throttler,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

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

var xxx_messageInfo_LocateResp proto.InternalMessageInfo

func (m *LocateResp) GetMountPoint() *MountPoint {
	if m != nil {
		return m.MountPoint
	}
	return nil
}

func (m *LocateResp) GetThrottler() *Throttler {
	if m != nil {
		return m.Throttler
	}
	return nil
}

type RemoveMountReq struct {
	MountPoint           string   `protobuf:"bytes,1,opt,name=mount_point,json=mountPoint,proto3" json:"mount_point,omitempty"`
	Tenant               string   `protobuf:"bytes,2,opt,name=tenant,proto3" json:"tenant,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_RemoveMountReq proto.InternalMessageInfo

func (m *RemoveMountReq) GetMountPoint() string {
	if m != nil {
		return m.MountPoint
	}
	return ""
}

func (m *RemoveMountReq) GetTenant() string {
	if m != nil {
		return m.Tenant
	}
	return ""
}

type GetRealmReq struct {
	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_GetRealmReq proto.InternalMessageInfo

func (m *GetRealmReq) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

type GlobRealmsReq struct {
	Pattern              string   `protobuf:"bytes,1,opt,name=pattern,proto3" json:"pattern,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_GlobRealmsReq proto.InternalMessageInfo

func (m *GlobRealmsReq) GetPattern() string {
	if m != nil {
		return m.Pattern
	}
	return ""
}

type RealmHeartbeatReq struct {
	Realm                *Realm   `protobuf:"bytes,1,opt,name=realm,proto3" json:"realm,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_RealmHeartbeatReq proto.InternalMessageInfo

func (m *RealmHeartbeatReq) GetRealm() *Realm {
	if m != nil {
		return m.Realm
	}
	return nil
}

type RealmHeartbeatResp struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_RealmHeartbeatResp proto.InternalMessageInfo

type ThrottlerHeartbeatReq struct {
	Throttler            *Throttler `protobuf:"bytes,1,opt,name=throttler,proto3" json:"throttler,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

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

var xxx_messageInfo_ThrottlerHeartbeatReq proto.InternalMessageInfo

func (m *ThrottlerHeartbeatReq) GetThrottler() *Throttler {
	if m != nil {
		return m.Throttler
	}
	return nil
}

type ThrottlerHeartbeatResp struct {
	TransferTarget       *Throttler `protobuf:"bytes,1,opt,name=transfer_target,json=transferTarget,proto3" json:"transfer_target,omitempty"`
	XXX_NoUnkeyedLiteral struct{}   `json:"-"`
	XXX_unrecognized     []byte     `json:"-"`
	XXX_sizecache        int32      `json:"-"`
}

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

var xxx_messageInfo_ThrottlerHeartbeatResp proto.InternalMessageInfo

func (m *ThrottlerHeartbeatResp) GetTransferTarget() *Throttler {
	if m != nil {
		return m.TransferTarget
	}
	return nil
}

type WatchRealmsReq struct {
	Pattern              string   `protobuf:"bytes,1,opt,name=pattern,proto3" json:"pattern,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_WatchRealmsReq proto.InternalMessageInfo

func (m *WatchRealmsReq) GetPattern() string {
	if m != nil {
		return m.Pattern
	}
	return ""
}

// realm req / resp messages
type MountReq struct {
	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Tenant               string   `protobuf:"bytes,2,opt,name=tenant,proto3" json:"tenant,omitempty"`
	Merged               bool     `protobuf:"varint,3,opt,name=merged,proto3" json:"merged,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_MountReq proto.InternalMessageInfo

func (m *MountReq) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *MountReq) GetTenant() string {
	if m != nil {
		return m.Tenant
	}
	return ""
}

func (m *MountReq) GetMerged() bool {
	if m != nil {
		return m.Merged
	}
	return false
}

type MountResp struct {
	MountPoint           *MountPoint `protobuf:"bytes,1,opt,name=mount_point,json=mountPoint,proto3" json:"mount_point,omitempty"`
	Token                string      `protobuf:"bytes,2,opt,name=token,proto3" json:"token,omitempty"`
	Entries              []*DirEntry `protobuf:"bytes,3,rep,name=entries,proto3" json:"entries,omitempty"`
	Errno                int64       `protobuf:"varint,4,opt,name=errno,proto3" json:"errno,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

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

var xxx_messageInfo_MountResp proto.InternalMessageInfo

func (m *MountResp) GetMountPoint() *MountPoint {
	if m != nil {
		return m.MountPoint
	}
	return nil
}

func (m *MountResp) GetToken() string {
	if m != nil {
		return m.Token
	}
	return ""
}

func (m *MountResp) GetEntries() []*DirEntry {
	if m != nil {
		return m.Entries
	}
	return nil
}

func (m *MountResp) GetErrno() int64 {
	if m != nil {
		return m.Errno
	}
	return 0
}

type UmountReq struct {
	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Tenant               string   `protobuf:"bytes,2,opt,name=tenant,proto3" json:"tenant,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_UmountReq proto.InternalMessageInfo

func (m *UmountReq) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *UmountReq) GetTenant() string {
	if m != nil {
		return m.Tenant
	}
	return ""
}

type CleanupReq struct {
	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Tenant               string   `protobuf:"bytes,2,opt,name=tenant,proto3" json:"tenant,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_CleanupReq proto.InternalMessageInfo

func (m *CleanupReq) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *CleanupReq) GetTenant() string {
	if m != nil {
		return m.Tenant
	}
	return ""
}

type MountPointHeartbeatReq struct {
	Token                string   `protobuf:"bytes,1,opt,name=token,proto3" json:"token,omitempty"`
	OpenFiles            []string `protobuf:"bytes,2,rep,name=open_files,json=openFiles,proto3" json:"open_files,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_MountPointHeartbeatReq proto.InternalMessageInfo

func (m *MountPointHeartbeatReq) GetToken() string {
	if m != nil {
		return m.Token
	}
	return ""
}

func (m *MountPointHeartbeatReq) GetOpenFiles() []string {
	if m != nil {
		return m.OpenFiles
	}
	return nil
}

type MountPointHeartbeatResp struct {
	// expired files since last heartbeat
	ExpiredFiles []string `protobuf:"bytes,2,rep,name=expired_files,json=expiredFiles,proto3" json:"expired_files,omitempty"`
	// lease valid time in ms
	LeaseTime            int64    `protobuf:"varint,3,opt,name=lease_time,json=leaseTime,proto3" json:"lease_time,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_MountPointHeartbeatResp proto.InternalMessageInfo

func (m *MountPointHeartbeatResp) GetExpiredFiles() []string {
	if m != nil {
		return m.ExpiredFiles
	}
	return nil
}

func (m *MountPointHeartbeatResp) GetLeaseTime() int64 {
	if m != nil {
		return m.LeaseTime
	}
	return 0
}

// throttler req / resp messages
type ThrottleReq struct {
	Tenant               string   `protobuf:"bytes,1,opt,name=tenant,proto3" json:"tenant,omitempty"`
	ReadBytes            int64    `protobuf:"varint,2,opt,name=read_bytes,json=readBytes,proto3" json:"read_bytes,omitempty"`
	ReadIo               int64    `protobuf:"varint,3,opt,name=read_io,json=readIo,proto3" json:"read_io,omitempty"`
	WriteBytes           int64    `protobuf:"varint,4,opt,name=write_bytes,json=writeBytes,proto3" json:"write_bytes,omitempty"`
	WriteIo              int64    `protobuf:"varint,5,opt,name=write_io,json=writeIo,proto3" json:"write_io,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ThrottleReq proto.InternalMessageInfo

func (m *ThrottleReq) GetTenant() string {
	if m != nil {
		return m.Tenant
	}
	return ""
}

func (m *ThrottleReq) GetReadBytes() int64 {
	if m != nil {
		return m.ReadBytes
	}
	return 0
}

func (m *ThrottleReq) GetReadIo() int64 {
	if m != nil {
		return m.ReadIo
	}
	return 0
}

func (m *ThrottleReq) GetWriteBytes() int64 {
	if m != nil {
		return m.WriteBytes
	}
	return 0
}

func (m *ThrottleReq) GetWriteIo() int64 {
	if m != nil {
		return m.WriteIo
	}
	return 0
}

type ThrottleResp struct {
	ReadBytes            int64    `protobuf:"varint,1,opt,name=read_bytes,json=readBytes,proto3" json:"read_bytes,omitempty"`
	ReadIo               int64    `protobuf:"varint,2,opt,name=read_io,json=readIo,proto3" json:"read_io,omitempty"`
	WriteBytes           int64    `protobuf:"varint,3,opt,name=write_bytes,json=writeBytes,proto3" json:"write_bytes,omitempty"`
	WriteIo              int64    `protobuf:"varint,4,opt,name=write_io,json=writeIo,proto3" json:"write_io,omitempty"`
	LeaseTime            int64    `protobuf:"varint,5,opt,name=lease_time,json=leaseTime,proto3" json:"lease_time,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ThrottleResp proto.InternalMessageInfo

func (m *ThrottleResp) GetReadBytes() int64 {
	if m != nil {
		return m.ReadBytes
	}
	return 0
}

func (m *ThrottleResp) GetReadIo() int64 {
	if m != nil {
		return m.ReadIo
	}
	return 0
}

func (m *ThrottleResp) GetWriteBytes() int64 {
	if m != nil {
		return m.WriteBytes
	}
	return 0
}

func (m *ThrottleResp) GetWriteIo() int64 {
	if m != nil {
		return m.WriteIo
	}
	return 0
}

func (m *ThrottleResp) GetLeaseTime() int64 {
	if m != nil {
		return m.LeaseTime
	}
	return 0
}

type HandoverReq struct {
	Tenants              []*ThrottleReq `protobuf:"bytes,1,rep,name=tenants,proto3" json:"tenants,omitempty"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

var xxx_messageInfo_HandoverReq proto.InternalMessageInfo

func (m *HandoverReq) GetTenants() []*ThrottleReq {
	if m != nil {
		return m.Tenants
	}
	return nil
}

func init() {
	proto.RegisterEnum("control.StorageType_MediumType", StorageType_MediumType_name, StorageType_MediumType_value)
	proto.RegisterEnum("control.StorageType_MediumProperty", StorageType_MediumProperty_name, StorageType_MediumProperty_value)
	proto.RegisterEnum("control.LabelSelectorRequirement_LabelSelectorOperator", LabelSelectorRequirement_LabelSelectorOperator_name, LabelSelectorRequirement_LabelSelectorOperator_value)
	proto.RegisterType((*StorageType)(nil), "control.StorageType")
	proto.RegisterType((*StoragePolicy)(nil), "control.StoragePolicy")
	proto.RegisterType((*Quota)(nil), "control.Quota")
	proto.RegisterType((*LabelSelectorRequirement)(nil), "control.LabelSelectorRequirement")
	proto.RegisterType((*LabelSelector)(nil), "control.LabelSelector")
	proto.RegisterMapType((map[string]string)(nil), "control.LabelSelector.MatchLabelsEntry")
	proto.RegisterType((*KeyValuePair)(nil), "control.KeyValuePair")
	proto.RegisterType((*Tenant)(nil), "control.Tenant")
	proto.RegisterType((*Zone)(nil), "control.Zone")
	proto.RegisterType((*ZonesList)(nil), "control.ZonesList")
	proto.RegisterType((*ThrottlerRuntimeInfo)(nil), "control.ThrottlerRuntimeInfo")
	proto.RegisterType((*Throttler)(nil), "control.Throttler")
	proto.RegisterType((*MountPoint)(nil), "control.MountPoint")
	proto.RegisterType((*RealmRuntimeInfo)(nil), "control.RealmRuntimeInfo")
	proto.RegisterType((*Realm)(nil), "control.Realm")
	proto.RegisterMapType((map[string]string)(nil), "control.Realm.LabelsEntry")
	proto.RegisterType((*RealmsList)(nil), "control.RealmsList")
	proto.RegisterType((*ZoneHeartbeatReq)(nil), "control.ZoneHeartbeatReq")
	proto.RegisterType((*GetZoneReq)(nil), "control.GetZoneReq")
	proto.RegisterType((*DeleteZoneReq)(nil), "control.DeleteZoneReq")
	proto.RegisterType((*EmptyMessage)(nil), "control.EmptyMessage")
	proto.RegisterType((*GlobZonesReq)(nil), "control.GlobZonesReq")
	proto.RegisterType((*CreateTenantReq)(nil), "control.CreateTenantReq")
	proto.RegisterType((*GetTenantReq)(nil), "control.GetTenantReq")
	proto.RegisterType((*DeleteTenantReq)(nil), "control.DeleteTenantReq")
	proto.RegisterType((*TenantsList)(nil), "control.TenantsList")
	proto.RegisterType((*GlobTenantsReq)(nil), "control.GlobTenantsReq")
	proto.RegisterType((*WatchZonesReq)(nil), "control.WatchZonesReq")
	proto.RegisterType((*WatchTenantsReq)(nil), "control.WatchTenantsReq")
	proto.RegisterType((*LocateReq)(nil), "control.LocateReq")
	proto.RegisterType((*LocateResp)(nil), "control.LocateResp")
	proto.RegisterType((*RemoveMountReq)(nil), "control.RemoveMountReq")
	proto.RegisterType((*GetRealmReq)(nil), "control.GetRealmReq")
	proto.RegisterType((*GlobRealmsReq)(nil), "control.GlobRealmsReq")
	proto.RegisterType((*RealmHeartbeatReq)(nil), "control.RealmHeartbeatReq")
	proto.RegisterType((*RealmHeartbeatResp)(nil), "control.RealmHeartbeatResp")
	proto.RegisterType((*ThrottlerHeartbeatReq)(nil), "control.ThrottlerHeartbeatReq")
	proto.RegisterType((*ThrottlerHeartbeatResp)(nil), "control.ThrottlerHeartbeatResp")
	proto.RegisterType((*WatchRealmsReq)(nil), "control.WatchRealmsReq")
	proto.RegisterType((*MountReq)(nil), "control.MountReq")
	proto.RegisterType((*MountResp)(nil), "control.MountResp")
	proto.RegisterType((*UmountReq)(nil), "control.UmountReq")
	proto.RegisterType((*CleanupReq)(nil), "control.CleanupReq")
	proto.RegisterType((*MountPointHeartbeatReq)(nil), "control.MountPointHeartbeatReq")
	proto.RegisterType((*MountPointHeartbeatResp)(nil), "control.MountPointHeartbeatResp")
	proto.RegisterType((*ThrottleReq)(nil), "control.ThrottleReq")
	proto.RegisterType((*ThrottleResp)(nil), "control.ThrottleResp")
	proto.RegisterType((*HandoverReq)(nil), "control.HandoverReq")
}

func init() { proto.RegisterFile("control.proto", fileDescriptor_0c5120591600887d) }

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

// UniverseServiceClient is the client API for UniverseService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type UniverseServiceClient interface {
	GetZone(ctx context.Context, in *GetZoneReq, opts ...grpc.CallOption) (*Zone, error)
	DeleteZone(ctx context.Context, in *DeleteZoneReq, opts ...grpc.CallOption) (*EmptyMessage, error)
	GetAllZones(ctx context.Context, in *EmptyMessage, opts ...grpc.CallOption) (*ZonesList, error)
	GlobZones(ctx context.Context, in *GlobZonesReq, opts ...grpc.CallOption) (*ZonesList, error)
	WatchZones(ctx context.Context, in *WatchZonesReq, opts ...grpc.CallOption) (UniverseService_WatchZonesClient, error)
	ZoneHeartbeat(ctx context.Context, in *ZoneHeartbeatReq, opts ...grpc.CallOption) (*Zone, error)
	CreateTenant(ctx context.Context, in *CreateTenantReq, opts ...grpc.CallOption) (*Tenant, error)
	GetTenant(ctx context.Context, in *GetTenantReq, opts ...grpc.CallOption) (*Tenant, error)
	DeleteTenant(ctx context.Context, in *DeleteTenantReq, opts ...grpc.CallOption) (*EmptyMessage, error)
	GetAllTenants(ctx context.Context, in *EmptyMessage, opts ...grpc.CallOption) (*TenantsList, error)
	GlobTenants(ctx context.Context, in *GlobTenantsReq, opts ...grpc.CallOption) (*TenantsList, error)
	WatchTenants(ctx context.Context, in *WatchTenantsReq, opts ...grpc.CallOption) (UniverseService_WatchTenantsClient, error)
}

type universeServiceClient struct {
	cc *grpc.ClientConn
}

func NewUniverseServiceClient(cc *grpc.ClientConn) UniverseServiceClient {
	return &universeServiceClient{cc}
}

func (c *universeServiceClient) GetZone(ctx context.Context, in *GetZoneReq, opts ...grpc.CallOption) (*Zone, error) {
	out := new(Zone)
	err := c.cc.Invoke(ctx, "/control.UniverseService/GetZone", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *universeServiceClient) DeleteZone(ctx context.Context, in *DeleteZoneReq, opts ...grpc.CallOption) (*EmptyMessage, error) {
	out := new(EmptyMessage)
	err := c.cc.Invoke(ctx, "/control.UniverseService/DeleteZone", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *universeServiceClient) GetAllZones(ctx context.Context, in *EmptyMessage, opts ...grpc.CallOption) (*ZonesList, error) {
	out := new(ZonesList)
	err := c.cc.Invoke(ctx, "/control.UniverseService/GetAllZones", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *universeServiceClient) GlobZones(ctx context.Context, in *GlobZonesReq, opts ...grpc.CallOption) (*ZonesList, error) {
	out := new(ZonesList)
	err := c.cc.Invoke(ctx, "/control.UniverseService/GlobZones", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *universeServiceClient) WatchZones(ctx context.Context, in *WatchZonesReq, opts ...grpc.CallOption) (UniverseService_WatchZonesClient, error) {
	stream, err := c.cc.NewStream(ctx, &_UniverseService_serviceDesc.Streams[0], "/control.UniverseService/WatchZones", opts...)
	if err != nil {
		return nil, err
	}
	x := &universeServiceWatchZonesClient{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 UniverseService_WatchZonesClient interface {
	Recv() (*ZonesList, error)
	grpc.ClientStream
}

type universeServiceWatchZonesClient struct {
	grpc.ClientStream
}

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

func (c *universeServiceClient) ZoneHeartbeat(ctx context.Context, in *ZoneHeartbeatReq, opts ...grpc.CallOption) (*Zone, error) {
	out := new(Zone)
	err := c.cc.Invoke(ctx, "/control.UniverseService/ZoneHeartbeat", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *universeServiceClient) CreateTenant(ctx context.Context, in *CreateTenantReq, opts ...grpc.CallOption) (*Tenant, error) {
	out := new(Tenant)
	err := c.cc.Invoke(ctx, "/control.UniverseService/CreateTenant", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *universeServiceClient) GetTenant(ctx context.Context, in *GetTenantReq, opts ...grpc.CallOption) (*Tenant, error) {
	out := new(Tenant)
	err := c.cc.Invoke(ctx, "/control.UniverseService/GetTenant", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *universeServiceClient) DeleteTenant(ctx context.Context, in *DeleteTenantReq, opts ...grpc.CallOption) (*EmptyMessage, error) {
	out := new(EmptyMessage)
	err := c.cc.Invoke(ctx, "/control.UniverseService/DeleteTenant", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *universeServiceClient) GetAllTenants(ctx context.Context, in *EmptyMessage, opts ...grpc.CallOption) (*TenantsList, error) {
	out := new(TenantsList)
	err := c.cc.Invoke(ctx, "/control.UniverseService/GetAllTenants", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *universeServiceClient) GlobTenants(ctx context.Context, in *GlobTenantsReq, opts ...grpc.CallOption) (*TenantsList, error) {
	out := new(TenantsList)
	err := c.cc.Invoke(ctx, "/control.UniverseService/GlobTenants", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *universeServiceClient) WatchTenants(ctx context.Context, in *WatchTenantsReq, opts ...grpc.CallOption) (UniverseService_WatchTenantsClient, error) {
	stream, err := c.cc.NewStream(ctx, &_UniverseService_serviceDesc.Streams[1], "/control.UniverseService/WatchTenants", opts...)
	if err != nil {
		return nil, err
	}
	x := &universeServiceWatchTenantsClient{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 UniverseService_WatchTenantsClient interface {
	Recv() (*TenantsList, error)
	grpc.ClientStream
}

type universeServiceWatchTenantsClient struct {
	grpc.ClientStream
}

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

// UniverseServiceServer is the server API for UniverseService service.
type UniverseServiceServer interface {
	GetZone(context.Context, *GetZoneReq) (*Zone, error)
	DeleteZone(context.Context, *DeleteZoneReq) (*EmptyMessage, error)
	GetAllZones(context.Context, *EmptyMessage) (*ZonesList, error)
	GlobZones(context.Context, *GlobZonesReq) (*ZonesList, error)
	WatchZones(*WatchZonesReq, UniverseService_WatchZonesServer) error
	ZoneHeartbeat(context.Context, *ZoneHeartbeatReq) (*Zone, error)
	CreateTenant(context.Context, *CreateTenantReq) (*Tenant, error)
	GetTenant(context.Context, *GetTenantReq) (*Tenant, error)
	DeleteTenant(context.Context, *DeleteTenantReq) (*EmptyMessage, error)
	GetAllTenants(context.Context, *EmptyMessage) (*TenantsList, error)
	GlobTenants(context.Context, *GlobTenantsReq) (*TenantsList, error)
	WatchTenants(*WatchTenantsReq, UniverseService_WatchTenantsServer) error
}

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

func (*UnimplementedUniverseServiceServer) GetZone(ctx context.Context, req *GetZoneReq) (*Zone, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetZone not implemented")
}
func (*UnimplementedUniverseServiceServer) DeleteZone(ctx context.Context, req *DeleteZoneReq) (*EmptyMessage, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteZone not implemented")
}
func (*UnimplementedUniverseServiceServer) GetAllZones(ctx context.Context, req *EmptyMessage) (*ZonesList, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetAllZones not implemented")
}
func (*UnimplementedUniverseServiceServer) GlobZones(ctx context.Context, req *GlobZonesReq) (*ZonesList, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GlobZones not implemented")
}
func (*UnimplementedUniverseServiceServer) WatchZones(req *WatchZonesReq, srv UniverseService_WatchZonesServer) error {
	return status.Errorf(codes.Unimplemented, "method WatchZones not implemented")
}
func (*UnimplementedUniverseServiceServer) ZoneHeartbeat(ctx context.Context, req *ZoneHeartbeatReq) (*Zone, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ZoneHeartbeat not implemented")
}
func (*UnimplementedUniverseServiceServer) CreateTenant(ctx context.Context, req *CreateTenantReq) (*Tenant, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateTenant not implemented")
}
func (*UnimplementedUniverseServiceServer) GetTenant(ctx context.Context, req *GetTenantReq) (*Tenant, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetTenant not implemented")
}
func (*UnimplementedUniverseServiceServer) DeleteTenant(ctx context.Context, req *DeleteTenantReq) (*EmptyMessage, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteTenant not implemented")
}
func (*UnimplementedUniverseServiceServer) GetAllTenants(ctx context.Context, req *EmptyMessage) (*TenantsList, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetAllTenants not implemented")
}
func (*UnimplementedUniverseServiceServer) GlobTenants(ctx context.Context, req *GlobTenantsReq) (*TenantsList, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GlobTenants not implemented")
}
func (*UnimplementedUniverseServiceServer) WatchTenants(req *WatchTenantsReq, srv UniverseService_WatchTenantsServer) error {
	return status.Errorf(codes.Unimplemented, "method WatchTenants not implemented")
}

func RegisterUniverseServiceServer(s *grpc.Server, srv UniverseServiceServer) {
	s.RegisterService(&_UniverseService_serviceDesc, srv)
}

func _UniverseService_GetZone_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetZoneReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(UniverseServiceServer).GetZone(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/control.UniverseService/GetZone",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(UniverseServiceServer).GetZone(ctx, req.(*GetZoneReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _UniverseService_DeleteZone_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteZoneReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(UniverseServiceServer).DeleteZone(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/control.UniverseService/DeleteZone",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(UniverseServiceServer).DeleteZone(ctx, req.(*DeleteZoneReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _UniverseService_GetAllZones_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(EmptyMessage)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(UniverseServiceServer).GetAllZones(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/control.UniverseService/GetAllZones",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(UniverseServiceServer).GetAllZones(ctx, req.(*EmptyMessage))
	}
	return interceptor(ctx, in, info, handler)
}

func _UniverseService_GlobZones_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GlobZonesReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(UniverseServiceServer).GlobZones(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/control.UniverseService/GlobZones",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(UniverseServiceServer).GlobZones(ctx, req.(*GlobZonesReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _UniverseService_WatchZones_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(WatchZonesReq)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(UniverseServiceServer).WatchZones(m, &universeServiceWatchZonesServer{stream})
}

type UniverseService_WatchZonesServer interface {
	Send(*ZonesList) error
	grpc.ServerStream
}

type universeServiceWatchZonesServer struct {
	grpc.ServerStream
}

func (x *universeServiceWatchZonesServer) Send(m *ZonesList) error {
	return x.ServerStream.SendMsg(m)
}

func _UniverseService_ZoneHeartbeat_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ZoneHeartbeatReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(UniverseServiceServer).ZoneHeartbeat(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/control.UniverseService/ZoneHeartbeat",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(UniverseServiceServer).ZoneHeartbeat(ctx, req.(*ZoneHeartbeatReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _UniverseService_CreateTenant_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateTenantReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(UniverseServiceServer).CreateTenant(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/control.UniverseService/CreateTenant",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(UniverseServiceServer).CreateTenant(ctx, req.(*CreateTenantReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _UniverseService_GetTenant_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetTenantReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(UniverseServiceServer).GetTenant(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/control.UniverseService/GetTenant",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(UniverseServiceServer).GetTenant(ctx, req.(*GetTenantReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _UniverseService_DeleteTenant_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteTenantReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(UniverseServiceServer).DeleteTenant(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/control.UniverseService/DeleteTenant",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(UniverseServiceServer).DeleteTenant(ctx, req.(*DeleteTenantReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _UniverseService_GetAllTenants_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(EmptyMessage)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(UniverseServiceServer).GetAllTenants(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/control.UniverseService/GetAllTenants",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(UniverseServiceServer).GetAllTenants(ctx, req.(*EmptyMessage))
	}
	return interceptor(ctx, in, info, handler)
}

func _UniverseService_GlobTenants_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GlobTenantsReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(UniverseServiceServer).GlobTenants(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/control.UniverseService/GlobTenants",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(UniverseServiceServer).GlobTenants(ctx, req.(*GlobTenantsReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _UniverseService_WatchTenants_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(WatchTenantsReq)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(UniverseServiceServer).WatchTenants(m, &universeServiceWatchTenantsServer{stream})
}

type UniverseService_WatchTenantsServer interface {
	Send(*TenantsList) error
	grpc.ServerStream
}

type universeServiceWatchTenantsServer struct {
	grpc.ServerStream
}

func (x *universeServiceWatchTenantsServer) Send(m *TenantsList) error {
	return x.ServerStream.SendMsg(m)
}

var _UniverseService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "control.UniverseService",
	HandlerType: (*UniverseServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetZone",
			Handler:    _UniverseService_GetZone_Handler,
		},
		{
			MethodName: "DeleteZone",
			Handler:    _UniverseService_DeleteZone_Handler,
		},
		{
			MethodName: "GetAllZones",
			Handler:    _UniverseService_GetAllZones_Handler,
		},
		{
			MethodName: "GlobZones",
			Handler:    _UniverseService_GlobZones_Handler,
		},
		{
			MethodName: "ZoneHeartbeat",
			Handler:    _UniverseService_ZoneHeartbeat_Handler,
		},
		{
			MethodName: "CreateTenant",
			Handler:    _UniverseService_CreateTenant_Handler,
		},
		{
			MethodName: "GetTenant",
			Handler:    _UniverseService_GetTenant_Handler,
		},
		{
			MethodName: "DeleteTenant",
			Handler:    _UniverseService_DeleteTenant_Handler,
		},
		{
			MethodName: "GetAllTenants",
			Handler:    _UniverseService_GetAllTenants_Handler,
		},
		{
			MethodName: "GlobTenants",
			Handler:    _UniverseService_GlobTenants_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "WatchZones",
			Handler:       _UniverseService_WatchZones_Handler,
			ServerStreams: true,
		},
		{
			StreamName:    "WatchTenants",
			Handler:       _UniverseService_WatchTenants_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "control.proto",
}

// ZoneServiceClient is the client API for ZoneService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ZoneServiceClient interface {
	Locate(ctx context.Context, in *LocateReq, opts ...grpc.CallOption) (*MountPoint, error)
	RemoveMount(ctx context.Context, in *RemoveMountReq, opts ...grpc.CallOption) (*EmptyMessage, error)
	GetRealm(ctx context.Context, in *GetRealmReq, opts ...grpc.CallOption) (*Realm, error)
	GetAllRealms(ctx context.Context, in *EmptyMessage, opts ...grpc.CallOption) (*RealmsList, error)
	GlobRealms(ctx context.Context, in *GlobRealmsReq, opts ...grpc.CallOption) (*RealmsList, error)
	WatchRealms(ctx context.Context, in *WatchRealmsReq, opts ...grpc.CallOption) (ZoneService_WatchRealmsClient, error)
	RealmHeartbeat(ctx context.Context, in *RealmHeartbeatReq, opts ...grpc.CallOption) (*RealmHeartbeatResp, error)
	ThrottlerHeartbeat(ctx context.Context, in *ThrottlerHeartbeatReq, opts ...grpc.CallOption) (*ThrottlerHeartbeatResp, error)
}

type zoneServiceClient struct {
	cc *grpc.ClientConn
}

func NewZoneServiceClient(cc *grpc.ClientConn) ZoneServiceClient {
	return &zoneServiceClient{cc}
}

func (c *zoneServiceClient) Locate(ctx context.Context, in *LocateReq, opts ...grpc.CallOption) (*MountPoint, error) {
	out := new(MountPoint)
	err := c.cc.Invoke(ctx, "/control.ZoneService/Locate", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *zoneServiceClient) RemoveMount(ctx context.Context, in *RemoveMountReq, opts ...grpc.CallOption) (*EmptyMessage, error) {
	out := new(EmptyMessage)
	err := c.cc.Invoke(ctx, "/control.ZoneService/RemoveMount", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *zoneServiceClient) GetRealm(ctx context.Context, in *GetRealmReq, opts ...grpc.CallOption) (*Realm, error) {
	out := new(Realm)
	err := c.cc.Invoke(ctx, "/control.ZoneService/GetRealm", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *zoneServiceClient) GetAllRealms(ctx context.Context, in *EmptyMessage, opts ...grpc.CallOption) (*RealmsList, error) {
	out := new(RealmsList)
	err := c.cc.Invoke(ctx, "/control.ZoneService/GetAllRealms", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *zoneServiceClient) GlobRealms(ctx context.Context, in *GlobRealmsReq, opts ...grpc.CallOption) (*RealmsList, error) {
	out := new(RealmsList)
	err := c.cc.Invoke(ctx, "/control.ZoneService/GlobRealms", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *zoneServiceClient) WatchRealms(ctx context.Context, in *WatchRealmsReq, opts ...grpc.CallOption) (ZoneService_WatchRealmsClient, error) {
	stream, err := c.cc.NewStream(ctx, &_ZoneService_serviceDesc.Streams[0], "/control.ZoneService/WatchRealms", opts...)
	if err != nil {
		return nil, err
	}
	x := &zoneServiceWatchRealmsClient{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 ZoneService_WatchRealmsClient interface {
	Recv() (*RealmsList, error)
	grpc.ClientStream
}

type zoneServiceWatchRealmsClient struct {
	grpc.ClientStream
}

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

func (c *zoneServiceClient) RealmHeartbeat(ctx context.Context, in *RealmHeartbeatReq, opts ...grpc.CallOption) (*RealmHeartbeatResp, error) {
	out := new(RealmHeartbeatResp)
	err := c.cc.Invoke(ctx, "/control.ZoneService/RealmHeartbeat", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *zoneServiceClient) ThrottlerHeartbeat(ctx context.Context, in *ThrottlerHeartbeatReq, opts ...grpc.CallOption) (*ThrottlerHeartbeatResp, error) {
	out := new(ThrottlerHeartbeatResp)
	err := c.cc.Invoke(ctx, "/control.ZoneService/ThrottlerHeartbeat", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ZoneServiceServer is the server API for ZoneService service.
type ZoneServiceServer interface {
	Locate(context.Context, *LocateReq) (*MountPoint, error)
	RemoveMount(context.Context, *RemoveMountReq) (*EmptyMessage, error)
	GetRealm(context.Context, *GetRealmReq) (*Realm, error)
	GetAllRealms(context.Context, *EmptyMessage) (*RealmsList, error)
	GlobRealms(context.Context, *GlobRealmsReq) (*RealmsList, error)
	WatchRealms(*WatchRealmsReq, ZoneService_WatchRealmsServer) error
	RealmHeartbeat(context.Context, *RealmHeartbeatReq) (*RealmHeartbeatResp, error)
	ThrottlerHeartbeat(context.Context, *ThrottlerHeartbeatReq) (*ThrottlerHeartbeatResp, error)
}

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

func (*UnimplementedZoneServiceServer) Locate(ctx context.Context, req *LocateReq) (*MountPoint, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Locate not implemented")
}
func (*UnimplementedZoneServiceServer) RemoveMount(ctx context.Context, req *RemoveMountReq) (*EmptyMessage, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RemoveMount not implemented")
}
func (*UnimplementedZoneServiceServer) GetRealm(ctx context.Context, req *GetRealmReq) (*Realm, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetRealm not implemented")
}
func (*UnimplementedZoneServiceServer) GetAllRealms(ctx context.Context, req *EmptyMessage) (*RealmsList, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetAllRealms not implemented")
}
func (*UnimplementedZoneServiceServer) GlobRealms(ctx context.Context, req *GlobRealmsReq) (*RealmsList, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GlobRealms not implemented")
}
func (*UnimplementedZoneServiceServer) WatchRealms(req *WatchRealmsReq, srv ZoneService_WatchRealmsServer) error {
	return status.Errorf(codes.Unimplemented, "method WatchRealms not implemented")
}
func (*UnimplementedZoneServiceServer) RealmHeartbeat(ctx context.Context, req *RealmHeartbeatReq) (*RealmHeartbeatResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RealmHeartbeat not implemented")
}
func (*UnimplementedZoneServiceServer) ThrottlerHeartbeat(ctx context.Context, req *ThrottlerHeartbeatReq) (*ThrottlerHeartbeatResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ThrottlerHeartbeat not implemented")
}

func RegisterZoneServiceServer(s *grpc.Server, srv ZoneServiceServer) {
	s.RegisterService(&_ZoneService_serviceDesc, srv)
}

func _ZoneService_Locate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LocateReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ZoneServiceServer).Locate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/control.ZoneService/Locate",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ZoneServiceServer).Locate(ctx, req.(*LocateReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ZoneService_RemoveMount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RemoveMountReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ZoneServiceServer).RemoveMount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/control.ZoneService/RemoveMount",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ZoneServiceServer).RemoveMount(ctx, req.(*RemoveMountReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ZoneService_GetRealm_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetRealmReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ZoneServiceServer).GetRealm(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/control.ZoneService/GetRealm",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ZoneServiceServer).GetRealm(ctx, req.(*GetRealmReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ZoneService_GetAllRealms_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(EmptyMessage)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ZoneServiceServer).GetAllRealms(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/control.ZoneService/GetAllRealms",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ZoneServiceServer).GetAllRealms(ctx, req.(*EmptyMessage))
	}
	return interceptor(ctx, in, info, handler)
}

func _ZoneService_GlobRealms_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GlobRealmsReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ZoneServiceServer).GlobRealms(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/control.ZoneService/GlobRealms",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ZoneServiceServer).GlobRealms(ctx, req.(*GlobRealmsReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ZoneService_WatchRealms_Handler(srv interface{}, stream grpc.ServerStream) error {
	m := new(WatchRealmsReq)
	if err := stream.RecvMsg(m); err != nil {
		return err
	}
	return srv.(ZoneServiceServer).WatchRealms(m, &zoneServiceWatchRealmsServer{stream})
}

type ZoneService_WatchRealmsServer interface {
	Send(*RealmsList) error
	grpc.ServerStream
}

type zoneServiceWatchRealmsServer struct {
	grpc.ServerStream
}

func (x *zoneServiceWatchRealmsServer) Send(m *RealmsList) error {
	return x.ServerStream.SendMsg(m)
}

func _ZoneService_RealmHeartbeat_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RealmHeartbeatReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ZoneServiceServer).RealmHeartbeat(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/control.ZoneService/RealmHeartbeat",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ZoneServiceServer).RealmHeartbeat(ctx, req.(*RealmHeartbeatReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ZoneService_ThrottlerHeartbeat_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ThrottlerHeartbeatReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ZoneServiceServer).ThrottlerHeartbeat(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/control.ZoneService/ThrottlerHeartbeat",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ZoneServiceServer).ThrottlerHeartbeat(ctx, req.(*ThrottlerHeartbeatReq))
	}
	return interceptor(ctx, in, info, handler)
}

var _ZoneService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "control.ZoneService",
	HandlerType: (*ZoneServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Locate",
			Handler:    _ZoneService_Locate_Handler,
		},
		{
			MethodName: "RemoveMount",
			Handler:    _ZoneService_RemoveMount_Handler,
		},
		{
			MethodName: "GetRealm",
			Handler:    _ZoneService_GetRealm_Handler,
		},
		{
			MethodName: "GetAllRealms",
			Handler:    _ZoneService_GetAllRealms_Handler,
		},
		{
			MethodName: "GlobRealms",
			Handler:    _ZoneService_GlobRealms_Handler,
		},
		{
			MethodName: "RealmHeartbeat",
			Handler:    _ZoneService_RealmHeartbeat_Handler,
		},
		{
			MethodName: "ThrottlerHeartbeat",
			Handler:    _ZoneService_ThrottlerHeartbeat_Handler,
		},
	},
	Streams: []grpc.StreamDesc{
		{
			StreamName:    "WatchRealms",
			Handler:       _ZoneService_WatchRealms_Handler,
			ServerStreams: true,
		},
	},
	Metadata: "control.proto",
}

// RealmControlServiceClient is the client API for RealmControlService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type RealmControlServiceClient interface {
	Mount(ctx context.Context, in *MountReq, opts ...grpc.CallOption) (*MountResp, error)
	Umount(ctx context.Context, in *UmountReq, opts ...grpc.CallOption) (*EmptyMessage, error)
	Cleanup(ctx context.Context, in *CleanupReq, opts ...grpc.CallOption) (*EmptyMessage, error)
	Heartbeat(ctx context.Context, in *MountPointHeartbeatReq, opts ...grpc.CallOption) (*MountPointHeartbeatResp, error)
}

type realmControlServiceClient struct {
	cc *grpc.ClientConn
}

func NewRealmControlServiceClient(cc *grpc.ClientConn) RealmControlServiceClient {
	return &realmControlServiceClient{cc}
}

func (c *realmControlServiceClient) Mount(ctx context.Context, in *MountReq, opts ...grpc.CallOption) (*MountResp, error) {
	out := new(MountResp)
	err := c.cc.Invoke(ctx, "/control.RealmControlService/Mount", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *realmControlServiceClient) Umount(ctx context.Context, in *UmountReq, opts ...grpc.CallOption) (*EmptyMessage, error) {
	out := new(EmptyMessage)
	err := c.cc.Invoke(ctx, "/control.RealmControlService/Umount", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *realmControlServiceClient) Cleanup(ctx context.Context, in *CleanupReq, opts ...grpc.CallOption) (*EmptyMessage, error) {
	out := new(EmptyMessage)
	err := c.cc.Invoke(ctx, "/control.RealmControlService/Cleanup", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *realmControlServiceClient) Heartbeat(ctx context.Context, in *MountPointHeartbeatReq, opts ...grpc.CallOption) (*MountPointHeartbeatResp, error) {
	out := new(MountPointHeartbeatResp)
	err := c.cc.Invoke(ctx, "/control.RealmControlService/Heartbeat", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// RealmControlServiceServer is the server API for RealmControlService service.
type RealmControlServiceServer interface {
	Mount(context.Context, *MountReq) (*MountResp, error)
	Umount(context.Context, *UmountReq) (*EmptyMessage, error)
	Cleanup(context.Context, *CleanupReq) (*EmptyMessage, error)
	Heartbeat(context.Context, *MountPointHeartbeatReq) (*MountPointHeartbeatResp, error)
}

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

func (*UnimplementedRealmControlServiceServer) Mount(ctx context.Context, req *MountReq) (*MountResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Mount not implemented")
}
func (*UnimplementedRealmControlServiceServer) Umount(ctx context.Context, req *UmountReq) (*EmptyMessage, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Umount not implemented")
}
func (*UnimplementedRealmControlServiceServer) Cleanup(ctx context.Context, req *CleanupReq) (*EmptyMessage, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Cleanup not implemented")
}
func (*UnimplementedRealmControlServiceServer) Heartbeat(ctx context.Context, req *MountPointHeartbeatReq) (*MountPointHeartbeatResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Heartbeat not implemented")
}

func RegisterRealmControlServiceServer(s *grpc.Server, srv RealmControlServiceServer) {
	s.RegisterService(&_RealmControlService_serviceDesc, srv)
}

func _RealmControlService_Mount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MountReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RealmControlServiceServer).Mount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/control.RealmControlService/Mount",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RealmControlServiceServer).Mount(ctx, req.(*MountReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _RealmControlService_Umount_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UmountReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RealmControlServiceServer).Umount(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/control.RealmControlService/Umount",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RealmControlServiceServer).Umount(ctx, req.(*UmountReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _RealmControlService_Cleanup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CleanupReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RealmControlServiceServer).Cleanup(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/control.RealmControlService/Cleanup",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RealmControlServiceServer).Cleanup(ctx, req.(*CleanupReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _RealmControlService_Heartbeat_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MountPointHeartbeatReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(RealmControlServiceServer).Heartbeat(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/control.RealmControlService/Heartbeat",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(RealmControlServiceServer).Heartbeat(ctx, req.(*MountPointHeartbeatReq))
	}
	return interceptor(ctx, in, info, handler)
}

var _RealmControlService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "control.RealmControlService",
	HandlerType: (*RealmControlServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Mount",
			Handler:    _RealmControlService_Mount_Handler,
		},
		{
			MethodName: "Umount",
			Handler:    _RealmControlService_Umount_Handler,
		},
		{
			MethodName: "Cleanup",
			Handler:    _RealmControlService_Cleanup_Handler,
		},
		{
			MethodName: "Heartbeat",
			Handler:    _RealmControlService_Heartbeat_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "control.proto",
}

// ThrottlingServiceClient is the client API for ThrottlingService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type ThrottlingServiceClient interface {
	Throttle(ctx context.Context, in *ThrottleReq, opts ...grpc.CallOption) (*ThrottleResp, error)
	Handover(ctx context.Context, in *HandoverReq, opts ...grpc.CallOption) (*EmptyMessage, error)
}

type throttlingServiceClient struct {
	cc *grpc.ClientConn
}

func NewThrottlingServiceClient(cc *grpc.ClientConn) ThrottlingServiceClient {
	return &throttlingServiceClient{cc}
}

func (c *throttlingServiceClient) Throttle(ctx context.Context, in *ThrottleReq, opts ...grpc.CallOption) (*ThrottleResp, error) {
	out := new(ThrottleResp)
	err := c.cc.Invoke(ctx, "/control.ThrottlingService/Throttle", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *throttlingServiceClient) Handover(ctx context.Context, in *HandoverReq, opts ...grpc.CallOption) (*EmptyMessage, error) {
	out := new(EmptyMessage)
	err := c.cc.Invoke(ctx, "/control.ThrottlingService/Handover", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ThrottlingServiceServer is the server API for ThrottlingService service.
type ThrottlingServiceServer interface {
	Throttle(context.Context, *ThrottleReq) (*ThrottleResp, error)
	Handover(context.Context, *HandoverReq) (*EmptyMessage, error)
}

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

func (*UnimplementedThrottlingServiceServer) Throttle(ctx context.Context, req *ThrottleReq) (*ThrottleResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Throttle not implemented")
}
func (*UnimplementedThrottlingServiceServer) Handover(ctx context.Context, req *HandoverReq) (*EmptyMessage, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Handover not implemented")
}

func RegisterThrottlingServiceServer(s *grpc.Server, srv ThrottlingServiceServer) {
	s.RegisterService(&_ThrottlingService_serviceDesc, srv)
}

func _ThrottlingService_Throttle_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ThrottleReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ThrottlingServiceServer).Throttle(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/control.ThrottlingService/Throttle",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ThrottlingServiceServer).Throttle(ctx, req.(*ThrottleReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ThrottlingService_Handover_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(HandoverReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ThrottlingServiceServer).Handover(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/control.ThrottlingService/Handover",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ThrottlingServiceServer).Handover(ctx, req.(*HandoverReq))
	}
	return interceptor(ctx, in, info, handler)
}

var _ThrottlingService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "control.ThrottlingService",
	HandlerType: (*ThrottlingServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Throttle",
			Handler:    _ThrottlingService_Throttle_Handler,
		},
		{
			MethodName: "Handover",
			Handler:    _ThrottlingService_Handover_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "control.proto",
}

func (m *StorageType) 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 *StorageType) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *StorageType) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Properties) > 0 {
		dAtA2 := make([]byte, len(m.Properties)*10)
		var j1 int
		for _, num := range m.Properties {
			for num >= 1<<7 {
				dAtA2[j1] = uint8(uint64(num)&0x7f | 0x80)
				num >>= 7
				j1++
			}
			dAtA2[j1] = uint8(num)
			j1++
		}
		i -= j1
		copy(dAtA[i:], dAtA2[:j1])
		i = encodeVarintControl(dAtA, i, uint64(j1))
		i--
		dAtA[i] = 0x12
	}
	if m.Type != 0 {
		i = encodeVarintControl(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *StoragePolicy) 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 *StoragePolicy) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *StoragePolicy) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.StackedTypes) > 0 {
		for iNdEx := len(m.StackedTypes) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.StackedTypes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintControl(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintControl(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Quota) 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 *Quota) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Quota) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Space != 0 {
		i = encodeVarintControl(dAtA, i, uint64(m.Space))
		i--
		dAtA[i] = 0x28
	}
	if m.WriteBps != 0 {
		i = encodeVarintControl(dAtA, i, uint64(m.WriteBps))
		i--
		dAtA[i] = 0x20
	}
	if m.WriteIops != 0 {
		i = encodeVarintControl(dAtA, i, uint64(m.WriteIops))
		i--
		dAtA[i] = 0x18
	}
	if m.ReadBps != 0 {
		i = encodeVarintControl(dAtA, i, uint64(m.ReadBps))
		i--
		dAtA[i] = 0x10
	}
	if m.ReadIops != 0 {
		i = encodeVarintControl(dAtA, i, uint64(m.ReadIops))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *LabelSelectorRequirement) 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 *LabelSelectorRequirement) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *LabelSelectorRequirement) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Values) > 0 {
		for iNdEx := len(m.Values) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Values[iNdEx])
			copy(dAtA[i:], m.Values[iNdEx])
			i = encodeVarintControl(dAtA, i, uint64(len(m.Values[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.Operator != 0 {
		i = encodeVarintControl(dAtA, i, uint64(m.Operator))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Key) > 0 {
		i -= len(m.Key)
		copy(dAtA[i:], m.Key)
		i = encodeVarintControl(dAtA, i, uint64(len(m.Key)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *LabelSelector) 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 *LabelSelector) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *LabelSelector) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.MatchExpressions) > 0 {
		for iNdEx := len(m.MatchExpressions) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.MatchExpressions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintControl(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.MatchLabels) > 0 {
		for k := range m.MatchLabels {
			v := m.MatchLabels[k]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintControl(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintControl(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintControl(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *KeyValuePair) 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 *KeyValuePair) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *KeyValuePair) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Value) > 0 {
		i -= len(m.Value)
		copy(dAtA[i:], m.Value)
		i = encodeVarintControl(dAtA, i, uint64(len(m.Value)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Key) > 0 {
		i -= len(m.Key)
		copy(dAtA[i:], m.Key)
		i = encodeVarintControl(dAtA, i, uint64(len(m.Key)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Tenant) 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 *Tenant) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Tenant) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Quota != nil {
		{
			size, err := m.Quota.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintControl(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if len(m.Tolerations) > 0 {
		for iNdEx := len(m.Tolerations) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Tolerations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintControl(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.Selector != nil {
		{
			size, err := m.Selector.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintControl(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintControl(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Zone) 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 *Zone) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Zone) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Endpoints) > 0 {
		for iNdEx := len(m.Endpoints) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Endpoints[iNdEx])
			copy(dAtA[i:], m.Endpoints[iNdEx])
			i = encodeVarintControl(dAtA, i, uint64(len(m.Endpoints[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintControl(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ZonesList) 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 *ZonesList) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ZonesList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Zones) > 0 {
		for iNdEx := len(m.Zones) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Zones[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintControl(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *ThrottlerRuntimeInfo) 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 *ThrottlerRuntimeInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ThrottlerRuntimeInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.TenantCounts != 0 {
		i = encodeVarintControl(dAtA, i, uint64(m.TenantCounts))
		i--
		dAtA[i] = 0x18
	}
	if len(m.Loadavg) > 0 {
		for iNdEx := len(m.Loadavg) - 1; iNdEx >= 0; iNdEx-- {
			f5 := math.Float32bits(float32(m.Loadavg[iNdEx]))
			i -= 4
			encoding_binary.LittleEndian.PutUint32(dAtA[i:], uint32(f5))
		}
		i = encodeVarintControl(dAtA, i, uint64(len(m.Loadavg)*4))
		i--
		dAtA[i] = 0x12
	}
	if m.Cpu != 0 {
		i = encodeVarintControl(dAtA, i, uint64(m.Cpu))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *Throttler) 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 *Throttler) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Throttler) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.RuntimeInfo != nil {
		{
			size, err := m.RuntimeInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintControl(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Address) > 0 {
		i -= len(m.Address)
		copy(dAtA[i:], m.Address)
		i = encodeVarintControl(dAtA, i, uint64(len(m.Address)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *MountPoint) 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 *MountPoint) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MountPoint) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Realms) > 0 {
		for iNdEx := len(m.Realms) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Realms[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintControl(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintControl(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RealmRuntimeInfo) 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 *RealmRuntimeInfo) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RealmRuntimeInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.SoftwareVersion) > 0 {
		i -= len(m.SoftwareVersion)
		copy(dAtA[i:], m.SoftwareVersion)
		i = encodeVarintControl(dAtA, i, uint64(len(m.SoftwareVersion)))
		i--
		dAtA[i] = 0x22
	}
	if m.LastUpdate != 0 {
		i = encodeVarintControl(dAtA, i, uint64(m.LastUpdate))
		i--
		dAtA[i] = 0x18
	}
	if m.Used != 0 {
		i = encodeVarintControl(dAtA, i, uint64(m.Used))
		i--
		dAtA[i] = 0x10
	}
	if m.Capacity != 0 {
		i = encodeVarintControl(dAtA, i, uint64(m.Capacity))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *Realm) 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 *Realm) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Realm) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Taints) > 0 {
		for iNdEx := len(m.Taints) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Taints[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintControl(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x32
		}
	}
	if len(m.Labels) > 0 {
		for k := range m.Labels {
			v := m.Labels[k]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintControl(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintControl(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintControl(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x2a
		}
	}
	if m.RuntimeInfo != nil {
		{
			size, err := m.RuntimeInfo.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintControl(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.Policy != nil {
		{
			size, err := m.Policy.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintControl(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Address) > 0 {
		i -= len(m.Address)
		copy(dAtA[i:], m.Address)
		i = encodeVarintControl(dAtA, i, uint64(len(m.Address)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintControl(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RealmsList) 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 *RealmsList) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RealmsList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Realms) > 0 {
		for iNdEx := len(m.Realms) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Realms[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintControl(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *ZoneHeartbeatReq) 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 *ZoneHeartbeatReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ZoneHeartbeatReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Zone != nil {
		{
			size, err := m.Zone.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintControl(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *GetZoneReq) 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 *GetZoneReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetZoneReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintControl(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *DeleteZoneReq) 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 *DeleteZoneReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DeleteZoneReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintControl(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *EmptyMessage) 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 *EmptyMessage) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *EmptyMessage) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	return len(dAtA) - i, nil
}

func (m *GlobZonesReq) 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 *GlobZonesReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GlobZonesReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Pattern) > 0 {
		i -= len(m.Pattern)
		copy(dAtA[i:], m.Pattern)
		i = encodeVarintControl(dAtA, i, uint64(len(m.Pattern)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *CreateTenantReq) 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 *CreateTenantReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CreateTenantReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Tenant != nil {
		{
			size, err := m.Tenant.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintControl(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *GetTenantReq) 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 *GetTenantReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetTenantReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintControl(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *DeleteTenantReq) 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 *DeleteTenantReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *DeleteTenantReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintControl(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *TenantsList) 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 *TenantsList) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TenantsList) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Tenants) > 0 {
		for iNdEx := len(m.Tenants) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Tenants[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintControl(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *GlobTenantsReq) 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 *GlobTenantsReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GlobTenantsReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Pattern) > 0 {
		i -= len(m.Pattern)
		copy(dAtA[i:], m.Pattern)
		i = encodeVarintControl(dAtA, i, uint64(len(m.Pattern)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *WatchZonesReq) 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 *WatchZonesReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *WatchZonesReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Pattern) > 0 {
		i -= len(m.Pattern)
		copy(dAtA[i:], m.Pattern)
		i = encodeVarintControl(dAtA, i, uint64(len(m.Pattern)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *WatchTenantsReq) 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 *WatchTenantsReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *WatchTenantsReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Pattern) > 0 {
		i -= len(m.Pattern)
		copy(dAtA[i:], m.Pattern)
		i = encodeVarintControl(dAtA, i, uint64(len(m.Pattern)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *LocateReq) 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 *LocateReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *LocateReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Merged {
		i--
		if m.Merged {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x28
	}
	if m.Create {
		i--
		if m.Create {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x20
	}
	if m.Policy != nil {
		{
			size, err := m.Policy.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintControl(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Tenant) > 0 {
		i -= len(m.Tenant)
		copy(dAtA[i:], m.Tenant)
		i = encodeVarintControl(dAtA, i, uint64(len(m.Tenant)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.MountPoint) > 0 {
		i -= len(m.MountPoint)
		copy(dAtA[i:], m.MountPoint)
		i = encodeVarintControl(dAtA, i, uint64(len(m.MountPoint)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *LocateResp) 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 *LocateResp) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *LocateResp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Throttler != nil {
		{
			size, err := m.Throttler.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintControl(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.MountPoint != nil {
		{
			size, err := m.MountPoint.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintControl(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RemoveMountReq) 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 *RemoveMountReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RemoveMountReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Tenant) > 0 {
		i -= len(m.Tenant)
		copy(dAtA[i:], m.Tenant)
		i = encodeVarintControl(dAtA, i, uint64(len(m.Tenant)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.MountPoint) > 0 {
		i -= len(m.MountPoint)
		copy(dAtA[i:], m.MountPoint)
		i = encodeVarintControl(dAtA, i, uint64(len(m.MountPoint)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *GetRealmReq) 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 *GetRealmReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GetRealmReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintControl(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *GlobRealmsReq) 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 *GlobRealmsReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *GlobRealmsReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Pattern) > 0 {
		i -= len(m.Pattern)
		copy(dAtA[i:], m.Pattern)
		i = encodeVarintControl(dAtA, i, uint64(len(m.Pattern)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RealmHeartbeatReq) 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 *RealmHeartbeatReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RealmHeartbeatReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Realm != nil {
		{
			size, err := m.Realm.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintControl(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *RealmHeartbeatResp) 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 *RealmHeartbeatResp) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *RealmHeartbeatResp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	return len(dAtA) - i, nil
}

func (m *ThrottlerHeartbeatReq) 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 *ThrottlerHeartbeatReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ThrottlerHeartbeatReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Throttler != nil {
		{
			size, err := m.Throttler.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintControl(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ThrottlerHeartbeatResp) 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 *ThrottlerHeartbeatResp) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ThrottlerHeartbeatResp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.TransferTarget != nil {
		{
			size, err := m.TransferTarget.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintControl(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *WatchRealmsReq) 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 *WatchRealmsReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *WatchRealmsReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Pattern) > 0 {
		i -= len(m.Pattern)
		copy(dAtA[i:], m.Pattern)
		i = encodeVarintControl(dAtA, i, uint64(len(m.Pattern)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *MountReq) 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 *MountReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MountReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Merged {
		i--
		if m.Merged {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x18
	}
	if len(m.Tenant) > 0 {
		i -= len(m.Tenant)
		copy(dAtA[i:], m.Tenant)
		i = encodeVarintControl(dAtA, i, uint64(len(m.Tenant)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintControl(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *MountResp) 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 *MountResp) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MountResp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Errno != 0 {
		i = encodeVarintControl(dAtA, i, uint64(m.Errno))
		i--
		dAtA[i] = 0x20
	}
	if len(m.Entries) > 0 {
		for iNdEx := len(m.Entries) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Entries[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintControl(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Token) > 0 {
		i -= len(m.Token)
		copy(dAtA[i:], m.Token)
		i = encodeVarintControl(dAtA, i, uint64(len(m.Token)))
		i--
		dAtA[i] = 0x12
	}
	if m.MountPoint != nil {
		{
			size, err := m.MountPoint.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintControl(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *UmountReq) 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 *UmountReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *UmountReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Tenant) > 0 {
		i -= len(m.Tenant)
		copy(dAtA[i:], m.Tenant)
		i = encodeVarintControl(dAtA, i, uint64(len(m.Tenant)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintControl(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *CleanupReq) 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 *CleanupReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *CleanupReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Tenant) > 0 {
		i -= len(m.Tenant)
		copy(dAtA[i:], m.Tenant)
		i = encodeVarintControl(dAtA, i, uint64(len(m.Tenant)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintControl(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *MountPointHeartbeatReq) 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 *MountPointHeartbeatReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MountPointHeartbeatReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.OpenFiles) > 0 {
		for iNdEx := len(m.OpenFiles) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.OpenFiles[iNdEx])
			copy(dAtA[i:], m.OpenFiles[iNdEx])
			i = encodeVarintControl(dAtA, i, uint64(len(m.OpenFiles[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Token) > 0 {
		i -= len(m.Token)
		copy(dAtA[i:], m.Token)
		i = encodeVarintControl(dAtA, i, uint64(len(m.Token)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *MountPointHeartbeatResp) 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 *MountPointHeartbeatResp) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MountPointHeartbeatResp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.LeaseTime != 0 {
		i = encodeVarintControl(dAtA, i, uint64(m.LeaseTime))
		i--
		dAtA[i] = 0x18
	}
	if len(m.ExpiredFiles) > 0 {
		for iNdEx := len(m.ExpiredFiles) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.ExpiredFiles[iNdEx])
			copy(dAtA[i:], m.ExpiredFiles[iNdEx])
			i = encodeVarintControl(dAtA, i, uint64(len(m.ExpiredFiles[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	return len(dAtA) - i, nil
}

func (m *ThrottleReq) 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 *ThrottleReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ThrottleReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.WriteIo != 0 {
		i = encodeVarintControl(dAtA, i, uint64(m.WriteIo))
		i--
		dAtA[i] = 0x28
	}
	if m.WriteBytes != 0 {
		i = encodeVarintControl(dAtA, i, uint64(m.WriteBytes))
		i--
		dAtA[i] = 0x20
	}
	if m.ReadIo != 0 {
		i = encodeVarintControl(dAtA, i, uint64(m.ReadIo))
		i--
		dAtA[i] = 0x18
	}
	if m.ReadBytes != 0 {
		i = encodeVarintControl(dAtA, i, uint64(m.ReadBytes))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Tenant) > 0 {
		i -= len(m.Tenant)
		copy(dAtA[i:], m.Tenant)
		i = encodeVarintControl(dAtA, i, uint64(len(m.Tenant)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *ThrottleResp) 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 *ThrottleResp) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ThrottleResp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.LeaseTime != 0 {
		i = encodeVarintControl(dAtA, i, uint64(m.LeaseTime))
		i--
		dAtA[i] = 0x28
	}
	if m.WriteIo != 0 {
		i = encodeVarintControl(dAtA, i, uint64(m.WriteIo))
		i--
		dAtA[i] = 0x20
	}
	if m.WriteBytes != 0 {
		i = encodeVarintControl(dAtA, i, uint64(m.WriteBytes))
		i--
		dAtA[i] = 0x18
	}
	if m.ReadIo != 0 {
		i = encodeVarintControl(dAtA, i, uint64(m.ReadIo))
		i--
		dAtA[i] = 0x10
	}
	if m.ReadBytes != 0 {
		i = encodeVarintControl(dAtA, i, uint64(m.ReadBytes))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *HandoverReq) 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 *HandoverReq) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *HandoverReq) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Tenants) > 0 {
		for iNdEx := len(m.Tenants) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Tenants[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintControl(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func encodeVarintControl(dAtA []byte, offset int, v uint64) int {
	offset -= sovControl(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *StorageType) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Type != 0 {
		n += 1 + sovControl(uint64(m.Type))
	}
	if len(m.Properties) > 0 {
		l = 0
		for _, e := range m.Properties {
			l += sovControl(uint64(e))
		}
		n += 1 + sovControl(uint64(l)) + l
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *StoragePolicy) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovControl(uint64(l))
	}
	if len(m.StackedTypes) > 0 {
		for _, e := range m.StackedTypes {
			l = e.Size()
			n += 1 + l + sovControl(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Quota) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ReadIops != 0 {
		n += 1 + sovControl(uint64(m.ReadIops))
	}
	if m.ReadBps != 0 {
		n += 1 + sovControl(uint64(m.ReadBps))
	}
	if m.WriteIops != 0 {
		n += 1 + sovControl(uint64(m.WriteIops))
	}
	if m.WriteBps != 0 {
		n += 1 + sovControl(uint64(m.WriteBps))
	}
	if m.Space != 0 {
		n += 1 + sovControl(uint64(m.Space))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *LabelSelectorRequirement) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovControl(uint64(l))
	}
	if m.Operator != 0 {
		n += 1 + sovControl(uint64(m.Operator))
	}
	if len(m.Values) > 0 {
		for _, s := range m.Values {
			l = len(s)
			n += 1 + l + sovControl(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *LabelSelector) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.MatchLabels) > 0 {
		for k, v := range m.MatchLabels {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovControl(uint64(len(k))) + 1 + len(v) + sovControl(uint64(len(v)))
			n += mapEntrySize + 1 + sovControl(uint64(mapEntrySize))
		}
	}
	if len(m.MatchExpressions) > 0 {
		for _, e := range m.MatchExpressions {
			l = e.Size()
			n += 1 + l + sovControl(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *KeyValuePair) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovControl(uint64(l))
	}
	l = len(m.Value)
	if l > 0 {
		n += 1 + l + sovControl(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Tenant) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovControl(uint64(l))
	}
	if m.Selector != nil {
		l = m.Selector.Size()
		n += 1 + l + sovControl(uint64(l))
	}
	if len(m.Tolerations) > 0 {
		for _, e := range m.Tolerations {
			l = e.Size()
			n += 1 + l + sovControl(uint64(l))
		}
	}
	if m.Quota != nil {
		l = m.Quota.Size()
		n += 1 + l + sovControl(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Zone) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovControl(uint64(l))
	}
	if len(m.Endpoints) > 0 {
		for _, s := range m.Endpoints {
			l = len(s)
			n += 1 + l + sovControl(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ZonesList) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Zones) > 0 {
		for _, e := range m.Zones {
			l = e.Size()
			n += 1 + l + sovControl(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ThrottlerRuntimeInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Cpu != 0 {
		n += 1 + sovControl(uint64(m.Cpu))
	}
	if len(m.Loadavg) > 0 {
		n += 1 + sovControl(uint64(len(m.Loadavg)*4)) + len(m.Loadavg)*4
	}
	if m.TenantCounts != 0 {
		n += 1 + sovControl(uint64(m.TenantCounts))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Throttler) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Address)
	if l > 0 {
		n += 1 + l + sovControl(uint64(l))
	}
	if m.RuntimeInfo != nil {
		l = m.RuntimeInfo.Size()
		n += 1 + l + sovControl(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *MountPoint) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovControl(uint64(l))
	}
	if len(m.Realms) > 0 {
		for _, e := range m.Realms {
			l = e.Size()
			n += 1 + l + sovControl(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *RealmRuntimeInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Capacity != 0 {
		n += 1 + sovControl(uint64(m.Capacity))
	}
	if m.Used != 0 {
		n += 1 + sovControl(uint64(m.Used))
	}
	if m.LastUpdate != 0 {
		n += 1 + sovControl(uint64(m.LastUpdate))
	}
	l = len(m.SoftwareVersion)
	if l > 0 {
		n += 1 + l + sovControl(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *Realm) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovControl(uint64(l))
	}
	l = len(m.Address)
	if l > 0 {
		n += 1 + l + sovControl(uint64(l))
	}
	if m.Policy != nil {
		l = m.Policy.Size()
		n += 1 + l + sovControl(uint64(l))
	}
	if m.RuntimeInfo != nil {
		l = m.RuntimeInfo.Size()
		n += 1 + l + sovControl(uint64(l))
	}
	if len(m.Labels) > 0 {
		for k, v := range m.Labels {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovControl(uint64(len(k))) + 1 + len(v) + sovControl(uint64(len(v)))
			n += mapEntrySize + 1 + sovControl(uint64(mapEntrySize))
		}
	}
	if len(m.Taints) > 0 {
		for _, e := range m.Taints {
			l = e.Size()
			n += 1 + l + sovControl(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *RealmsList) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Realms) > 0 {
		for _, e := range m.Realms {
			l = e.Size()
			n += 1 + l + sovControl(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ZoneHeartbeatReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Zone != nil {
		l = m.Zone.Size()
		n += 1 + l + sovControl(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GetZoneReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovControl(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *DeleteZoneReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovControl(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *EmptyMessage) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GlobZonesReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Pattern)
	if l > 0 {
		n += 1 + l + sovControl(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CreateTenantReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Tenant != nil {
		l = m.Tenant.Size()
		n += 1 + l + sovControl(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GetTenantReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovControl(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *DeleteTenantReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovControl(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *TenantsList) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Tenants) > 0 {
		for _, e := range m.Tenants {
			l = e.Size()
			n += 1 + l + sovControl(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GlobTenantsReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Pattern)
	if l > 0 {
		n += 1 + l + sovControl(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *WatchZonesReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Pattern)
	if l > 0 {
		n += 1 + l + sovControl(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *WatchTenantsReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Pattern)
	if l > 0 {
		n += 1 + l + sovControl(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *LocateReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.MountPoint)
	if l > 0 {
		n += 1 + l + sovControl(uint64(l))
	}
	l = len(m.Tenant)
	if l > 0 {
		n += 1 + l + sovControl(uint64(l))
	}
	if m.Policy != nil {
		l = m.Policy.Size()
		n += 1 + l + sovControl(uint64(l))
	}
	if m.Create {
		n += 2
	}
	if m.Merged {
		n += 2
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *LocateResp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MountPoint != nil {
		l = m.MountPoint.Size()
		n += 1 + l + sovControl(uint64(l))
	}
	if m.Throttler != nil {
		l = m.Throttler.Size()
		n += 1 + l + sovControl(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *RemoveMountReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.MountPoint)
	if l > 0 {
		n += 1 + l + sovControl(uint64(l))
	}
	l = len(m.Tenant)
	if l > 0 {
		n += 1 + l + sovControl(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GetRealmReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovControl(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *GlobRealmsReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Pattern)
	if l > 0 {
		n += 1 + l + sovControl(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *RealmHeartbeatReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Realm != nil {
		l = m.Realm.Size()
		n += 1 + l + sovControl(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *RealmHeartbeatResp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ThrottlerHeartbeatReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Throttler != nil {
		l = m.Throttler.Size()
		n += 1 + l + sovControl(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ThrottlerHeartbeatResp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.TransferTarget != nil {
		l = m.TransferTarget.Size()
		n += 1 + l + sovControl(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *WatchRealmsReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Pattern)
	if l > 0 {
		n += 1 + l + sovControl(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *MountReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovControl(uint64(l))
	}
	l = len(m.Tenant)
	if l > 0 {
		n += 1 + l + sovControl(uint64(l))
	}
	if m.Merged {
		n += 2
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *MountResp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.MountPoint != nil {
		l = m.MountPoint.Size()
		n += 1 + l + sovControl(uint64(l))
	}
	l = len(m.Token)
	if l > 0 {
		n += 1 + l + sovControl(uint64(l))
	}
	if len(m.Entries) > 0 {
		for _, e := range m.Entries {
			l = e.Size()
			n += 1 + l + sovControl(uint64(l))
		}
	}
	if m.Errno != 0 {
		n += 1 + sovControl(uint64(m.Errno))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *UmountReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovControl(uint64(l))
	}
	l = len(m.Tenant)
	if l > 0 {
		n += 1 + l + sovControl(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *CleanupReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovControl(uint64(l))
	}
	l = len(m.Tenant)
	if l > 0 {
		n += 1 + l + sovControl(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *MountPointHeartbeatReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Token)
	if l > 0 {
		n += 1 + l + sovControl(uint64(l))
	}
	if len(m.OpenFiles) > 0 {
		for _, s := range m.OpenFiles {
			l = len(s)
			n += 1 + l + sovControl(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *MountPointHeartbeatResp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.ExpiredFiles) > 0 {
		for _, s := range m.ExpiredFiles {
			l = len(s)
			n += 1 + l + sovControl(uint64(l))
		}
	}
	if m.LeaseTime != 0 {
		n += 1 + sovControl(uint64(m.LeaseTime))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ThrottleReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Tenant)
	if l > 0 {
		n += 1 + l + sovControl(uint64(l))
	}
	if m.ReadBytes != 0 {
		n += 1 + sovControl(uint64(m.ReadBytes))
	}
	if m.ReadIo != 0 {
		n += 1 + sovControl(uint64(m.ReadIo))
	}
	if m.WriteBytes != 0 {
		n += 1 + sovControl(uint64(m.WriteBytes))
	}
	if m.WriteIo != 0 {
		n += 1 + sovControl(uint64(m.WriteIo))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ThrottleResp) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ReadBytes != 0 {
		n += 1 + sovControl(uint64(m.ReadBytes))
	}
	if m.ReadIo != 0 {
		n += 1 + sovControl(uint64(m.ReadIo))
	}
	if m.WriteBytes != 0 {
		n += 1 + sovControl(uint64(m.WriteBytes))
	}
	if m.WriteIo != 0 {
		n += 1 + sovControl(uint64(m.WriteIo))
	}
	if m.LeaseTime != 0 {
		n += 1 + sovControl(uint64(m.LeaseTime))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *HandoverReq) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Tenants) > 0 {
		for _, e := range m.Tenants {
			l = e.Size()
			n += 1 + l + sovControl(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func sovControl(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozControl(x uint64) (n int) {
	return sovControl(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *StorageType) 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 ErrIntOverflowControl
			}
			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: StorageType: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StorageType: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 ErrIntOverflowControl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= StorageType_MediumType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType == 0 {
				var v StorageType_MediumProperty
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowControl
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					v |= StorageType_MediumProperty(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				m.Properties = append(m.Properties, v)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowControl
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthControl
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthControl
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				if elementCount != 0 && len(m.Properties) == 0 {
					m.Properties = make([]StorageType_MediumProperty, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v StorageType_MediumProperty
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowControl
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						v |= StorageType_MediumProperty(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					m.Properties = append(m.Properties, v)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Properties", wireType)
			}
		default:
			iNdEx = preIndex
			skippy, err := skipControl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthControl
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *StoragePolicy) 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 ErrIntOverflowControl
			}
			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: StoragePolicy: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StoragePolicy: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowControl
				}
				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 ErrInvalidLengthControl
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthControl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field StackedTypes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowControl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthControl
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthControl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.StackedTypes = append(m.StackedTypes, &StorageType{})
			if err := m.StackedTypes[len(m.StackedTypes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipControl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthControl
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Quota) 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 ErrIntOverflowControl
			}
			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: Quota: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Quota: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReadIops", wireType)
			}
			m.ReadIops = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowControl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ReadIops |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReadBps", wireType)
			}
			m.ReadBps = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowControl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ReadBps |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field WriteIops", wireType)
			}
			m.WriteIops = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowControl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.WriteIops |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field WriteBps", wireType)
			}
			m.WriteBps = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowControl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.WriteBps |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Space", wireType)
			}
			m.Space = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowControl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Space |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipControl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthControl
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *LabelSelectorRequirement) 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 ErrIntOverflowControl
			}
			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: LabelSelectorRequirement: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LabelSelectorRequirement: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowControl
				}
				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 ErrInvalidLengthControl
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthControl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Key = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Operator", wireType)
			}
			m.Operator = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowControl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Operator |= LabelSelectorRequirement_LabelSelectorOperator(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowControl
				}
				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 ErrInvalidLengthControl
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthControl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Values = append(m.Values, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipControl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthControl
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *LabelSelector) 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 ErrIntOverflowControl
			}
			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: LabelSelector: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LabelSelector: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MatchLabels", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowControl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthControl
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthControl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MatchLabels == nil {
				m.MatchLabels = 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 ErrIntOverflowControl
					}
					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 ErrIntOverflowControl
						}
						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 ErrInvalidLengthControl
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthControl
					}
					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 ErrIntOverflowControl
						}
						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 ErrInvalidLengthControl
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthControl
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipControl(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthControl
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.MatchLabels[mapkey] = mapvalue
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MatchExpressions", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowControl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthControl
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthControl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MatchExpressions = append(m.MatchExpressions, &LabelSelectorRequirement{})
			if err := m.MatchExpressions[len(m.MatchExpressions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipControl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthControl
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Tenant) 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 ErrIntOverflowControl
			}
			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: Tenant: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Tenant: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowControl
				}
				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 ErrInvalidLengthControl
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthControl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowControl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthControl
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthControl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Selector == nil {
				m.Selector = &LabelSelector{}
			}
			if err := m.Selector.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tolerations", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowControl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthControl
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthControl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Tolerations = append(m.Tolerations, &KeyValuePair{})
			if err := m.Tolerations[len(m.Tolerations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Quota", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowControl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthControl
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthControl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Quota == nil {
				m.Quota = &Quota{}
			}
			if err := m.Quota.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipControl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthControl
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ThrottlerRuntimeInfo) 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 ErrIntOverflowControl
			}
			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: ThrottlerRuntimeInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ThrottlerRuntimeInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cpu", wireType)
			}
			m.Cpu = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowControl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Cpu |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType == 5 {
				var v uint32
				if (iNdEx + 4) > l {
					return io.ErrUnexpectedEOF
				}
				v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
				iNdEx += 4
				v2 := float32(math.Float32frombits(v))
				m.Loadavg = append(m.Loadavg, v2)
			} else if wireType == 2 {
				var packedLen int
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowControl
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					packedLen |= int(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				if packedLen < 0 {
					return ErrInvalidLengthControl
				}
				postIndex := iNdEx + packedLen
				if postIndex < 0 {
					return ErrInvalidLengthControl
				}
				if postIndex > l {
					return io.ErrUnexpectedEOF
				}
				var elementCount int
				elementCount = packedLen / 4
				if elementCount != 0 && len(m.Loadavg) == 0 {
					m.Loadavg = make([]float32, 0, elementCount)
				}
				for iNdEx < postIndex {
					var v uint32
					if (iNdEx + 4) > l {
						return io.ErrUnexpectedEOF
					}
					v = uint32(encoding_binary.LittleEndian.Uint32(dAtA[iNdEx:]))
					iNdEx += 4
					v2 := float32(math.Float32frombits(v))
					m.Loadavg = append(m.Loadavg, v2)
				}
			} else {
				return fmt.Errorf("proto: wrong wireType = %d for field Loadavg", wireType)
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field TenantCounts", wireType)
			}
			m.TenantCounts = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowControl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.TenantCounts |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipControl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthControl
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Throttler) 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 ErrIntOverflowControl
			}
			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: Throttler: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Throttler: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowControl
				}
				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 ErrInvalidLengthControl
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthControl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Address = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RuntimeInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowControl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthControl
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthControl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RuntimeInfo == nil {
				m.RuntimeInfo = &ThrottlerRuntimeInfo{}
			}
			if err := m.RuntimeInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipControl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthControl
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MountPoint) 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 ErrIntOverflowControl
			}
			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: MountPoint: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MountPoint: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowControl
				}
				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 ErrInvalidLengthControl
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthControl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Realms", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowControl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthControl
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthControl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Realms = append(m.Realms, &Realm{})
			if err := m.Realms[len(m.Realms)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipControl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthControl
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *RealmRuntimeInfo) 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 ErrIntOverflowControl
			}
			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: RealmRuntimeInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RealmRuntimeInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Capacity", wireType)
			}
			m.Capacity = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowControl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Capacity |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Used", wireType)
			}
			m.Used = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowControl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Used |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LastUpdate", wireType)
			}
			m.LastUpdate = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowControl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LastUpdate |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SoftwareVersion", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowControl
				}
				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 ErrInvalidLengthControl
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthControl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SoftwareVersion = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipControl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthControl
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Realm) 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 ErrIntOverflowControl
			}
			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: Realm: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Realm: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowControl
				}
				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 ErrInvalidLengthControl
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthControl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowControl
				}
				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 ErrInvalidLengthControl
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthControl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Address = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Policy", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowControl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthControl
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthControl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Policy == nil {
				m.Policy = &StoragePolicy{}
			}
			if err := m.Policy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field RuntimeInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowControl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthControl
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthControl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.RuntimeInfo == nil {
				m.RuntimeInfo = &RealmRuntimeInfo{}
			}
			if err := m.RuntimeInfo.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			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 ErrIntOverflowControl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthControl
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthControl
			}
			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 ErrIntOverflowControl
					}
					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 ErrIntOverflowControl
						}
						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 ErrInvalidLengthControl
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthControl
					}
					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 ErrIntOverflowControl
						}
						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 ErrInvalidLengthControl
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthControl
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipControl(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthControl
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Labels[mapkey] = mapvalue
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Taints", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowControl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthControl
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthControl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Taints = append(m.Taints, &KeyValuePair{})
			if err := m.Taints[len(m.Taints)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipControl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthControl
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

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

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

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

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

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

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

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

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

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

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *LocateReq) 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 ErrIntOverflowControl
			}
			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: LocateReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LocateReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MountPoint", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowControl
				}
				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 ErrInvalidLengthControl
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthControl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.MountPoint = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tenant", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowControl
				}
				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 ErrInvalidLengthControl
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthControl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Tenant = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Policy", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowControl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthControl
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthControl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Policy == nil {
				m.Policy = &StoragePolicy{}
			}
			if err := m.Policy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Create", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowControl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Create = bool(v != 0)
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Merged", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowControl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Merged = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipControl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthControl
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

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

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

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

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

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

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MountReq) 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 ErrIntOverflowControl
			}
			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: MountReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MountReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowControl
				}
				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 ErrInvalidLengthControl
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthControl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tenant", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowControl
				}
				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 ErrInvalidLengthControl
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthControl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Tenant = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Merged", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowControl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Merged = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipControl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthControl
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MountResp) 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 ErrIntOverflowControl
			}
			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: MountResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MountResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field MountPoint", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowControl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthControl
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthControl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.MountPoint == nil {
				m.MountPoint = &MountPoint{}
			}
			if err := m.MountPoint.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Token", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowControl
				}
				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 ErrInvalidLengthControl
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthControl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Token = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Entries", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowControl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthControl
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthControl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Entries = append(m.Entries, &DirEntry{})
			if err := m.Entries[len(m.Entries)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Errno", wireType)
			}
			m.Errno = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowControl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Errno |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipControl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthControl
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MountPointHeartbeatResp) 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 ErrIntOverflowControl
			}
			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: MountPointHeartbeatResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MountPointHeartbeatResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExpiredFiles", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowControl
				}
				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 ErrInvalidLengthControl
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthControl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ExpiredFiles = append(m.ExpiredFiles, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LeaseTime", wireType)
			}
			m.LeaseTime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowControl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LeaseTime |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipControl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthControl
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ThrottleReq) 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 ErrIntOverflowControl
			}
			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: ThrottleReq: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ThrottleReq: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tenant", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowControl
				}
				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 ErrInvalidLengthControl
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthControl
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Tenant = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReadBytes", wireType)
			}
			m.ReadBytes = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowControl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ReadBytes |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReadIo", wireType)
			}
			m.ReadIo = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowControl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ReadIo |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field WriteBytes", wireType)
			}
			m.WriteBytes = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowControl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.WriteBytes |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field WriteIo", wireType)
			}
			m.WriteIo = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowControl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.WriteIo |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipControl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthControl
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ThrottleResp) 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 ErrIntOverflowControl
			}
			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: ThrottleResp: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ThrottleResp: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReadBytes", wireType)
			}
			m.ReadBytes = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowControl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ReadBytes |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReadIo", wireType)
			}
			m.ReadIo = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowControl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ReadIo |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field WriteBytes", wireType)
			}
			m.WriteBytes = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowControl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.WriteBytes |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field WriteIo", wireType)
			}
			m.WriteIo = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowControl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.WriteIo |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field LeaseTime", wireType)
			}
			m.LeaseTime = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowControl
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.LeaseTime |= int64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipControl(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthControl
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipControl(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, ErrIntOverflowControl
			}
			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, ErrIntOverflowControl
				}
				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, ErrIntOverflowControl
				}
				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, ErrInvalidLengthControl
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupControl
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthControl
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthControl        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowControl          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupControl = fmt.Errorf("proto: unexpected end of group")
)