cbladybug.pb.go

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

package cbladybug

import (
	context "context"
	fmt "fmt"
	_ "github.com/cloud-barista/poc-cicd-ladybug/src/grpc-api/protobuf/gogoproto"
	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

// Empty 메시지 정의
type Empty struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_Empty proto.InternalMessageInfo

// MessageResponse 응답 메시지 정의
type MessageResponse struct {
	Message              string   `protobuf:"bytes,1,opt,name=message,proto3" json:"message" yaml:"message"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_MessageResponse proto.InternalMessageInfo

func (m *MessageResponse) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

// StatusResponse 응답 메시지 정의
type StatusResponse struct {
	Kind                 string   `protobuf:"bytes,1,opt,name=kind,proto3" json:"kind" yaml:"kind"`
	Code                 int32    `protobuf:"varint,2,opt,name=code,proto3" json:"code" yaml:"code"`
	Message              string   `protobuf:"bytes,3,opt,name=message,proto3" json:"message" yaml:"message"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_StatusResponse proto.InternalMessageInfo

func (m *StatusResponse) GetKind() string {
	if m != nil {
		return m.Kind
	}
	return ""
}

func (m *StatusResponse) GetCode() int32 {
	if m != nil {
		return m.Code
	}
	return 0
}

func (m *StatusResponse) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

type ClusterInfoResponse struct {
	Item                 *ClusterInfo `protobuf:"bytes,1,opt,name=item,proto3" json:"item" yaml:"item"`
	XXX_NoUnkeyedLiteral struct{}     `json:"-"`
	XXX_unrecognized     []byte       `json:"-"`
	XXX_sizecache        int32        `json:"-"`
}

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

var xxx_messageInfo_ClusterInfoResponse proto.InternalMessageInfo

func (m *ClusterInfoResponse) GetItem() *ClusterInfo {
	if m != nil {
		return m.Item
	}
	return nil
}

type ListClusterInfoResponse struct {
	Kind                 string         `protobuf:"bytes,1,opt,name=kind,proto3" json:"kind" yaml:"kind"`
	Items                []*ClusterInfo `protobuf:"bytes,2,rep,name=items,proto3" json:"items" yaml:"items"`
	XXX_NoUnkeyedLiteral struct{}       `json:"-"`
	XXX_unrecognized     []byte         `json:"-"`
	XXX_sizecache        int32          `json:"-"`
}

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

var xxx_messageInfo_ListClusterInfoResponse proto.InternalMessageInfo

func (m *ListClusterInfoResponse) GetKind() string {
	if m != nil {
		return m.Kind
	}
	return ""
}

func (m *ListClusterInfoResponse) GetItems() []*ClusterInfo {
	if m != nil {
		return m.Items
	}
	return nil
}

type ClusterInfo struct {
	Name                 string      `protobuf:"bytes,1,opt,name=name,proto3" json:"name" yaml:"name"`
	Kind                 string      `protobuf:"bytes,2,opt,name=kind,proto3" json:"kind" yaml:"kind"`
	Status               string      `protobuf:"bytes,3,opt,name=status,proto3" json:"status" yaml:"status"`
	Uid                  string      `protobuf:"bytes,4,opt,name=uid,proto3" json:"uid" yaml:"uid"`
	Mcis                 string      `protobuf:"bytes,5,opt,name=mcis,proto3" json:"mcis" yaml:"mcis"`
	Namespace            string      `protobuf:"bytes,6,opt,name=namespace,proto3" json:"namespace" yaml:"namespace"`
	ClusterConfig        string      `protobuf:"bytes,7,opt,name=cluster_config,json=clusterConfig,proto3" json:"clusterConfig" yaml:"clusterConfig"`
	CpLeader             string      `protobuf:"bytes,8,opt,name=cp_leader,json=cpLeader,proto3" json:"cpLeader" yaml:"cpLeader"`
	NetworkCni           string      `protobuf:"bytes,9,opt,name=network_cni,json=networkCni,proto3" json:"networkCni" yaml:"networkCni"`
	Nodes                []*NodeInfo `protobuf:"bytes,10,rep,name=nodes,proto3" json:"nodes" yaml:"nodes"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

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

var xxx_messageInfo_ClusterInfo proto.InternalMessageInfo

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

func (m *ClusterInfo) GetKind() string {
	if m != nil {
		return m.Kind
	}
	return ""
}

func (m *ClusterInfo) GetStatus() string {
	if m != nil {
		return m.Status
	}
	return ""
}

func (m *ClusterInfo) GetUid() string {
	if m != nil {
		return m.Uid
	}
	return ""
}

func (m *ClusterInfo) GetMcis() string {
	if m != nil {
		return m.Mcis
	}
	return ""
}

func (m *ClusterInfo) GetNamespace() string {
	if m != nil {
		return m.Namespace
	}
	return ""
}

func (m *ClusterInfo) GetClusterConfig() string {
	if m != nil {
		return m.ClusterConfig
	}
	return ""
}

func (m *ClusterInfo) GetCpLeader() string {
	if m != nil {
		return m.CpLeader
	}
	return ""
}

func (m *ClusterInfo) GetNetworkCni() string {
	if m != nil {
		return m.NetworkCni
	}
	return ""
}

func (m *ClusterInfo) GetNodes() []*NodeInfo {
	if m != nil {
		return m.Nodes
	}
	return nil
}

type ClusterCreateRequest struct {
	Namespace            string             `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace" yaml:"namespace"`
	Item                 *ClusterCreateInfo `protobuf:"bytes,2,opt,name=item,json=ReqInfo,proto3" json:"ReqInfo" yaml:"ReqInfo"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

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

var xxx_messageInfo_ClusterCreateRequest proto.InternalMessageInfo

func (m *ClusterCreateRequest) GetNamespace() string {
	if m != nil {
		return m.Namespace
	}
	return ""
}

func (m *ClusterCreateRequest) GetItem() *ClusterCreateInfo {
	if m != nil {
		return m.Item
	}
	return nil
}

type ClusterCreateInfo struct {
	Name                 string        `protobuf:"bytes,1,opt,name=name,proto3" json:"name" yaml:"name"`
	ControlPlane         []*NodeConfig `protobuf:"bytes,2,rep,name=control_plane,json=controlPlane,proto3" json:"controlPlane" yaml:"controlPlane"`
	Worker               []*NodeConfig `protobuf:"bytes,3,rep,name=worker,proto3" json:"worker" yaml:"worker"`
	Config               *Config       `protobuf:"bytes,4,opt,name=config,proto3" json:"config" yaml:"config"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_ClusterCreateInfo proto.InternalMessageInfo

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

func (m *ClusterCreateInfo) GetControlPlane() []*NodeConfig {
	if m != nil {
		return m.ControlPlane
	}
	return nil
}

func (m *ClusterCreateInfo) GetWorker() []*NodeConfig {
	if m != nil {
		return m.Worker
	}
	return nil
}

func (m *ClusterCreateInfo) GetConfig() *Config {
	if m != nil {
		return m.Config
	}
	return nil
}

type NodeConfig struct {
	Connection           string   `protobuf:"bytes,1,opt,name=connection,proto3" json:"connection" yaml:"connection"`
	Count                int32    `protobuf:"varint,2,opt,name=count,proto3" json:"count" yaml:"count"`
	Spec                 string   `protobuf:"bytes,3,opt,name=spec,proto3" json:"spec" yaml:"spec"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_NodeConfig proto.InternalMessageInfo

func (m *NodeConfig) GetConnection() string {
	if m != nil {
		return m.Connection
	}
	return ""
}

func (m *NodeConfig) GetCount() int32 {
	if m != nil {
		return m.Count
	}
	return 0
}

func (m *NodeConfig) GetSpec() string {
	if m != nil {
		return m.Spec
	}
	return ""
}

type Config struct {
	Kubernetes           *Kubernetes `protobuf:"bytes,1,opt,name=kubernetes,proto3" json:"kubernetes" yaml:"kubernetes"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

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

var xxx_messageInfo_Config proto.InternalMessageInfo

func (m *Config) GetKubernetes() *Kubernetes {
	if m != nil {
		return m.Kubernetes
	}
	return nil
}

type Kubernetes struct {
	NetworkCni           string   `protobuf:"bytes,1,opt,name=network_cni,json=networkCni,proto3" json:"networkCni" yaml:"networkCni"`
	PodCidr              string   `protobuf:"bytes,2,opt,name=pod_cidr,json=podCidr,proto3" json:"podCidr" yaml:"podCidr"`
	ServiceCidr          string   `protobuf:"bytes,3,opt,name=service_cidr,json=serviceCidr,proto3" json:"serviceCidr" yaml:"serviceCidr"`
	ServicDnsDomain      string   `protobuf:"bytes,4,opt,name=servic_dns_domain,json=serviceDnsDomain,proto3" json:"serviceDnsDomain" yaml:"serviceDnsDomain"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_Kubernetes proto.InternalMessageInfo

func (m *Kubernetes) GetNetworkCni() string {
	if m != nil {
		return m.NetworkCni
	}
	return ""
}

func (m *Kubernetes) GetPodCidr() string {
	if m != nil {
		return m.PodCidr
	}
	return ""
}

func (m *Kubernetes) GetServiceCidr() string {
	if m != nil {
		return m.ServiceCidr
	}
	return ""
}

func (m *Kubernetes) GetServicDnsDomain() string {
	if m != nil {
		return m.ServicDnsDomain
	}
	return ""
}

type ClusterAllQryRequest struct {
	Namespace            string   `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace" yaml:"namespace"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ClusterAllQryRequest proto.InternalMessageInfo

func (m *ClusterAllQryRequest) GetNamespace() string {
	if m != nil {
		return m.Namespace
	}
	return ""
}

type ClusterQryRequest struct {
	Namespace            string   `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace" yaml:"namespace"`
	Cluster              string   `protobuf:"bytes,2,opt,name=cluster,proto3" json:"cluster" yaml:"cluster"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_ClusterQryRequest proto.InternalMessageInfo

func (m *ClusterQryRequest) GetNamespace() string {
	if m != nil {
		return m.Namespace
	}
	return ""
}

func (m *ClusterQryRequest) GetCluster() string {
	if m != nil {
		return m.Cluster
	}
	return ""
}

type NodeInfoResponse struct {
	Item                 *NodeInfo `protobuf:"bytes,1,opt,name=item,proto3" json:"item" yaml:"item"`
	XXX_NoUnkeyedLiteral struct{}  `json:"-"`
	XXX_unrecognized     []byte    `json:"-"`
	XXX_sizecache        int32     `json:"-"`
}

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

var xxx_messageInfo_NodeInfoResponse proto.InternalMessageInfo

func (m *NodeInfoResponse) GetItem() *NodeInfo {
	if m != nil {
		return m.Item
	}
	return nil
}

type ListNodeInfoResponse struct {
	Kind                 string      `protobuf:"bytes,1,opt,name=kind,proto3" json:"kind" yaml:"kind"`
	Items                []*NodeInfo `protobuf:"bytes,2,rep,name=items,proto3" json:"items" yaml:"items"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_unrecognized     []byte      `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

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

var xxx_messageInfo_ListNodeInfoResponse proto.InternalMessageInfo

func (m *ListNodeInfoResponse) GetKind() string {
	if m != nil {
		return m.Kind
	}
	return ""
}

func (m *ListNodeInfoResponse) GetItems() []*NodeInfo {
	if m != nil {
		return m.Items
	}
	return nil
}

type NodeInfo struct {
	Name                 string   `protobuf:"bytes,1,opt,name=name,proto3" json:"name" yaml:"name"`
	Kind                 string   `protobuf:"bytes,2,opt,name=kind,proto3" json:"kind" yaml:"kind"`
	Credential           string   `protobuf:"bytes,3,opt,name=credential,proto3" json:"credential" yaml:"credential"`
	PublicIp             string   `protobuf:"bytes,4,opt,name=public_ip,json=publicIp,proto3" json:"publicIp" yaml:"publicIp"`
	Uid                  string   `protobuf:"bytes,5,opt,name=uid,proto3" json:"uid" yaml:"uid"`
	Role                 string   `protobuf:"bytes,6,opt,name=role,proto3" json:"role" yaml:"role"`
	Spec                 string   `protobuf:"bytes,7,opt,name=spec,proto3" json:"spec" yaml:"spec"`
	Csp                  string   `protobuf:"bytes,8,opt,name=csp,proto3" json:"csp" yaml:"csp"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_NodeInfo proto.InternalMessageInfo

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

func (m *NodeInfo) GetKind() string {
	if m != nil {
		return m.Kind
	}
	return ""
}

func (m *NodeInfo) GetCredential() string {
	if m != nil {
		return m.Credential
	}
	return ""
}

func (m *NodeInfo) GetPublicIp() string {
	if m != nil {
		return m.PublicIp
	}
	return ""
}

func (m *NodeInfo) GetUid() string {
	if m != nil {
		return m.Uid
	}
	return ""
}

func (m *NodeInfo) GetRole() string {
	if m != nil {
		return m.Role
	}
	return ""
}

func (m *NodeInfo) GetSpec() string {
	if m != nil {
		return m.Spec
	}
	return ""
}

func (m *NodeInfo) GetCsp() string {
	if m != nil {
		return m.Csp
	}
	return ""
}

type NodeCreateRequest struct {
	Namespace            string          `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace" yaml:"namespace"`
	Cluster              string          `protobuf:"bytes,2,opt,name=cluster,proto3" json:"cluster" yaml:"cluster"`
	Item                 *NodeCreateInfo `protobuf:"bytes,3,opt,name=item,json=ReqInfo,proto3" json:"ReqInfo" yaml:"ReqInfo"`
	XXX_NoUnkeyedLiteral struct{}        `json:"-"`
	XXX_unrecognized     []byte          `json:"-"`
	XXX_sizecache        int32           `json:"-"`
}

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

var xxx_messageInfo_NodeCreateRequest proto.InternalMessageInfo

func (m *NodeCreateRequest) GetNamespace() string {
	if m != nil {
		return m.Namespace
	}
	return ""
}

func (m *NodeCreateRequest) GetCluster() string {
	if m != nil {
		return m.Cluster
	}
	return ""
}

func (m *NodeCreateRequest) GetItem() *NodeCreateInfo {
	if m != nil {
		return m.Item
	}
	return nil
}

type NodeCreateInfo struct {
	ControlPlane         []*NodeConfig `protobuf:"bytes,1,rep,name=control_plane,json=controlPlane,proto3" json:"controlPlane" yaml:"controlPlane"`
	Worker               []*NodeConfig `protobuf:"bytes,2,rep,name=worker,proto3" json:"worker" yaml:"worker"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

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

var xxx_messageInfo_NodeCreateInfo proto.InternalMessageInfo

func (m *NodeCreateInfo) GetControlPlane() []*NodeConfig {
	if m != nil {
		return m.ControlPlane
	}
	return nil
}

func (m *NodeCreateInfo) GetWorker() []*NodeConfig {
	if m != nil {
		return m.Worker
	}
	return nil
}

type NodeAllQryRequest struct {
	Namespace            string   `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace" yaml:"namespace"`
	Cluster              string   `protobuf:"bytes,2,opt,name=cluster,proto3" json:"cluster" yaml:"cluster"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_NodeAllQryRequest proto.InternalMessageInfo

func (m *NodeAllQryRequest) GetNamespace() string {
	if m != nil {
		return m.Namespace
	}
	return ""
}

func (m *NodeAllQryRequest) GetCluster() string {
	if m != nil {
		return m.Cluster
	}
	return ""
}

type NodeQryRequest struct {
	Namespace            string   `protobuf:"bytes,1,opt,name=namespace,proto3" json:"namespace" yaml:"namespace"`
	Cluster              string   `protobuf:"bytes,2,opt,name=cluster,proto3" json:"cluster" yaml:"cluster"`
	Node                 string   `protobuf:"bytes,3,opt,name=node,proto3" json:"node" yaml:"node"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

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

var xxx_messageInfo_NodeQryRequest proto.InternalMessageInfo

func (m *NodeQryRequest) GetNamespace() string {
	if m != nil {
		return m.Namespace
	}
	return ""
}

func (m *NodeQryRequest) GetCluster() string {
	if m != nil {
		return m.Cluster
	}
	return ""
}

func (m *NodeQryRequest) GetNode() string {
	if m != nil {
		return m.Node
	}
	return ""
}

func init() {
	proto.RegisterType((*Empty)(nil), "cbladybug.Empty")
	proto.RegisterType((*MessageResponse)(nil), "cbladybug.MessageResponse")
	proto.RegisterType((*StatusResponse)(nil), "cbladybug.StatusResponse")
	proto.RegisterType((*ClusterInfoResponse)(nil), "cbladybug.ClusterInfoResponse")
	proto.RegisterType((*ListClusterInfoResponse)(nil), "cbladybug.ListClusterInfoResponse")
	proto.RegisterType((*ClusterInfo)(nil), "cbladybug.ClusterInfo")
	proto.RegisterType((*ClusterCreateRequest)(nil), "cbladybug.ClusterCreateRequest")
	proto.RegisterType((*ClusterCreateInfo)(nil), "cbladybug.ClusterCreateInfo")
	proto.RegisterType((*NodeConfig)(nil), "cbladybug.NodeConfig")
	proto.RegisterType((*Config)(nil), "cbladybug.Config")
	proto.RegisterType((*Kubernetes)(nil), "cbladybug.Kubernetes")
	proto.RegisterType((*ClusterAllQryRequest)(nil), "cbladybug.ClusterAllQryRequest")
	proto.RegisterType((*ClusterQryRequest)(nil), "cbladybug.ClusterQryRequest")
	proto.RegisterType((*NodeInfoResponse)(nil), "cbladybug.NodeInfoResponse")
	proto.RegisterType((*ListNodeInfoResponse)(nil), "cbladybug.ListNodeInfoResponse")
	proto.RegisterType((*NodeInfo)(nil), "cbladybug.NodeInfo")
	proto.RegisterType((*NodeCreateRequest)(nil), "cbladybug.NodeCreateRequest")
	proto.RegisterType((*NodeCreateInfo)(nil), "cbladybug.NodeCreateInfo")
	proto.RegisterType((*NodeAllQryRequest)(nil), "cbladybug.NodeAllQryRequest")
	proto.RegisterType((*NodeQryRequest)(nil), "cbladybug.NodeQryRequest")
}

func init() { proto.RegisterFile("cbladybug/cbladybug.proto", fileDescriptor_fadd82198316be94) }

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

// MCARClient is the client API for MCAR service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type MCARClient interface {
	Healthy(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*MessageResponse, error)
	CreateCluster(ctx context.Context, in *ClusterCreateRequest, opts ...grpc.CallOption) (*ClusterInfoResponse, error)
	ListCluster(ctx context.Context, in *ClusterAllQryRequest, opts ...grpc.CallOption) (*ListClusterInfoResponse, error)
	GetCluster(ctx context.Context, in *ClusterQryRequest, opts ...grpc.CallOption) (*ClusterInfoResponse, error)
	DeleteCluster(ctx context.Context, in *ClusterQryRequest, opts ...grpc.CallOption) (*StatusResponse, error)
	AddNode(ctx context.Context, in *NodeCreateRequest, opts ...grpc.CallOption) (*ListNodeInfoResponse, error)
	ListNode(ctx context.Context, in *NodeAllQryRequest, opts ...grpc.CallOption) (*ListNodeInfoResponse, error)
	GetNode(ctx context.Context, in *NodeQryRequest, opts ...grpc.CallOption) (*NodeInfoResponse, error)
	RemoveNode(ctx context.Context, in *NodeQryRequest, opts ...grpc.CallOption) (*StatusResponse, error)
}

type mCARClient struct {
	cc *grpc.ClientConn
}

func NewMCARClient(cc *grpc.ClientConn) MCARClient {
	return &mCARClient{cc}
}

func (c *mCARClient) Healthy(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*MessageResponse, error) {
	out := new(MessageResponse)
	err := c.cc.Invoke(ctx, "/cbladybug.MCAR/Healthy", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *mCARClient) CreateCluster(ctx context.Context, in *ClusterCreateRequest, opts ...grpc.CallOption) (*ClusterInfoResponse, error) {
	out := new(ClusterInfoResponse)
	err := c.cc.Invoke(ctx, "/cbladybug.MCAR/CreateCluster", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *mCARClient) ListCluster(ctx context.Context, in *ClusterAllQryRequest, opts ...grpc.CallOption) (*ListClusterInfoResponse, error) {
	out := new(ListClusterInfoResponse)
	err := c.cc.Invoke(ctx, "/cbladybug.MCAR/ListCluster", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *mCARClient) GetCluster(ctx context.Context, in *ClusterQryRequest, opts ...grpc.CallOption) (*ClusterInfoResponse, error) {
	out := new(ClusterInfoResponse)
	err := c.cc.Invoke(ctx, "/cbladybug.MCAR/GetCluster", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *mCARClient) DeleteCluster(ctx context.Context, in *ClusterQryRequest, opts ...grpc.CallOption) (*StatusResponse, error) {
	out := new(StatusResponse)
	err := c.cc.Invoke(ctx, "/cbladybug.MCAR/DeleteCluster", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *mCARClient) AddNode(ctx context.Context, in *NodeCreateRequest, opts ...grpc.CallOption) (*ListNodeInfoResponse, error) {
	out := new(ListNodeInfoResponse)
	err := c.cc.Invoke(ctx, "/cbladybug.MCAR/AddNode", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *mCARClient) ListNode(ctx context.Context, in *NodeAllQryRequest, opts ...grpc.CallOption) (*ListNodeInfoResponse, error) {
	out := new(ListNodeInfoResponse)
	err := c.cc.Invoke(ctx, "/cbladybug.MCAR/ListNode", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *mCARClient) GetNode(ctx context.Context, in *NodeQryRequest, opts ...grpc.CallOption) (*NodeInfoResponse, error) {
	out := new(NodeInfoResponse)
	err := c.cc.Invoke(ctx, "/cbladybug.MCAR/GetNode", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *mCARClient) RemoveNode(ctx context.Context, in *NodeQryRequest, opts ...grpc.CallOption) (*StatusResponse, error) {
	out := new(StatusResponse)
	err := c.cc.Invoke(ctx, "/cbladybug.MCAR/RemoveNode", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// MCARServer is the server API for MCAR service.
type MCARServer interface {
	Healthy(context.Context, *Empty) (*MessageResponse, error)
	CreateCluster(context.Context, *ClusterCreateRequest) (*ClusterInfoResponse, error)
	ListCluster(context.Context, *ClusterAllQryRequest) (*ListClusterInfoResponse, error)
	GetCluster(context.Context, *ClusterQryRequest) (*ClusterInfoResponse, error)
	DeleteCluster(context.Context, *ClusterQryRequest) (*StatusResponse, error)
	AddNode(context.Context, *NodeCreateRequest) (*ListNodeInfoResponse, error)
	ListNode(context.Context, *NodeAllQryRequest) (*ListNodeInfoResponse, error)
	GetNode(context.Context, *NodeQryRequest) (*NodeInfoResponse, error)
	RemoveNode(context.Context, *NodeQryRequest) (*StatusResponse, error)
}

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

func (*UnimplementedMCARServer) Healthy(ctx context.Context, req *Empty) (*MessageResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Healthy not implemented")
}
func (*UnimplementedMCARServer) CreateCluster(ctx context.Context, req *ClusterCreateRequest) (*ClusterInfoResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateCluster not implemented")
}
func (*UnimplementedMCARServer) ListCluster(ctx context.Context, req *ClusterAllQryRequest) (*ListClusterInfoResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListCluster not implemented")
}
func (*UnimplementedMCARServer) GetCluster(ctx context.Context, req *ClusterQryRequest) (*ClusterInfoResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetCluster not implemented")
}
func (*UnimplementedMCARServer) DeleteCluster(ctx context.Context, req *ClusterQryRequest) (*StatusResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteCluster not implemented")
}
func (*UnimplementedMCARServer) AddNode(ctx context.Context, req *NodeCreateRequest) (*ListNodeInfoResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method AddNode not implemented")
}
func (*UnimplementedMCARServer) ListNode(ctx context.Context, req *NodeAllQryRequest) (*ListNodeInfoResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListNode not implemented")
}
func (*UnimplementedMCARServer) GetNode(ctx context.Context, req *NodeQryRequest) (*NodeInfoResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetNode not implemented")
}
func (*UnimplementedMCARServer) RemoveNode(ctx context.Context, req *NodeQryRequest) (*StatusResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RemoveNode not implemented")
}

func RegisterMCARServer(s *grpc.Server, srv MCARServer) {
	s.RegisterService(&_MCAR_serviceDesc, srv)
}

func _MCAR_Healthy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MCARServer).Healthy(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/cbladybug.MCAR/Healthy",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MCARServer).Healthy(ctx, req.(*Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _MCAR_CreateCluster_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ClusterCreateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MCARServer).CreateCluster(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/cbladybug.MCAR/CreateCluster",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MCARServer).CreateCluster(ctx, req.(*ClusterCreateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MCAR_ListCluster_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ClusterAllQryRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MCARServer).ListCluster(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/cbladybug.MCAR/ListCluster",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MCARServer).ListCluster(ctx, req.(*ClusterAllQryRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MCAR_GetCluster_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ClusterQryRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MCARServer).GetCluster(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/cbladybug.MCAR/GetCluster",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MCARServer).GetCluster(ctx, req.(*ClusterQryRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MCAR_DeleteCluster_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ClusterQryRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MCARServer).DeleteCluster(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/cbladybug.MCAR/DeleteCluster",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MCARServer).DeleteCluster(ctx, req.(*ClusterQryRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MCAR_AddNode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(NodeCreateRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MCARServer).AddNode(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/cbladybug.MCAR/AddNode",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MCARServer).AddNode(ctx, req.(*NodeCreateRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MCAR_ListNode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(NodeAllQryRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MCARServer).ListNode(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/cbladybug.MCAR/ListNode",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MCARServer).ListNode(ctx, req.(*NodeAllQryRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MCAR_GetNode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(NodeQryRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MCARServer).GetNode(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/cbladybug.MCAR/GetNode",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MCARServer).GetNode(ctx, req.(*NodeQryRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _MCAR_RemoveNode_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(NodeQryRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MCARServer).RemoveNode(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/cbladybug.MCAR/RemoveNode",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MCARServer).RemoveNode(ctx, req.(*NodeQryRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _MCAR_serviceDesc = grpc.ServiceDesc{
	ServiceName: "cbladybug.MCAR",
	HandlerType: (*MCARServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Healthy",
			Handler:    _MCAR_Healthy_Handler,
		},
		{
			MethodName: "CreateCluster",
			Handler:    _MCAR_CreateCluster_Handler,
		},
		{
			MethodName: "ListCluster",
			Handler:    _MCAR_ListCluster_Handler,
		},
		{
			MethodName: "GetCluster",
			Handler:    _MCAR_GetCluster_Handler,
		},
		{
			MethodName: "DeleteCluster",
			Handler:    _MCAR_DeleteCluster_Handler,
		},
		{
			MethodName: "AddNode",
			Handler:    _MCAR_AddNode_Handler,
		},
		{
			MethodName: "ListNode",
			Handler:    _MCAR_ListNode_Handler,
		},
		{
			MethodName: "GetNode",
			Handler:    _MCAR_GetNode_Handler,
		},
		{
			MethodName: "RemoveNode",
			Handler:    _MCAR_RemoveNode_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "cbladybug/cbladybug.proto",
}

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

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

func (m *MessageResponse) 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.Message) > 0 {
		i -= len(m.Message)
		copy(dAtA[i:], m.Message)
		i = encodeVarintCbladybug(dAtA, i, uint64(len(m.Message)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *StatusResponse) 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.Message) > 0 {
		i -= len(m.Message)
		copy(dAtA[i:], m.Message)
		i = encodeVarintCbladybug(dAtA, i, uint64(len(m.Message)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Code != 0 {
		i = encodeVarintCbladybug(dAtA, i, uint64(m.Code))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Kind) > 0 {
		i -= len(m.Kind)
		copy(dAtA[i:], m.Kind)
		i = encodeVarintCbladybug(dAtA, i, uint64(len(m.Kind)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *ClusterInfoResponse) 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.Item != nil {
		{
			size, err := m.Item.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCbladybug(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *ListClusterInfoResponse) 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.Items) > 0 {
		for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintCbladybug(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Kind) > 0 {
		i -= len(m.Kind)
		copy(dAtA[i:], m.Kind)
		i = encodeVarintCbladybug(dAtA, i, uint64(len(m.Kind)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *ClusterInfo) 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.Nodes) > 0 {
		for iNdEx := len(m.Nodes) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Nodes[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintCbladybug(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x52
		}
	}
	if len(m.NetworkCni) > 0 {
		i -= len(m.NetworkCni)
		copy(dAtA[i:], m.NetworkCni)
		i = encodeVarintCbladybug(dAtA, i, uint64(len(m.NetworkCni)))
		i--
		dAtA[i] = 0x4a
	}
	if len(m.CpLeader) > 0 {
		i -= len(m.CpLeader)
		copy(dAtA[i:], m.CpLeader)
		i = encodeVarintCbladybug(dAtA, i, uint64(len(m.CpLeader)))
		i--
		dAtA[i] = 0x42
	}
	if len(m.ClusterConfig) > 0 {
		i -= len(m.ClusterConfig)
		copy(dAtA[i:], m.ClusterConfig)
		i = encodeVarintCbladybug(dAtA, i, uint64(len(m.ClusterConfig)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.Namespace) > 0 {
		i -= len(m.Namespace)
		copy(dAtA[i:], m.Namespace)
		i = encodeVarintCbladybug(dAtA, i, uint64(len(m.Namespace)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.Mcis) > 0 {
		i -= len(m.Mcis)
		copy(dAtA[i:], m.Mcis)
		i = encodeVarintCbladybug(dAtA, i, uint64(len(m.Mcis)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Uid) > 0 {
		i -= len(m.Uid)
		copy(dAtA[i:], m.Uid)
		i = encodeVarintCbladybug(dAtA, i, uint64(len(m.Uid)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Status) > 0 {
		i -= len(m.Status)
		copy(dAtA[i:], m.Status)
		i = encodeVarintCbladybug(dAtA, i, uint64(len(m.Status)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Kind) > 0 {
		i -= len(m.Kind)
		copy(dAtA[i:], m.Kind)
		i = encodeVarintCbladybug(dAtA, i, uint64(len(m.Kind)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintCbladybug(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *ClusterCreateRequest) 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.Item != nil {
		{
			size, err := m.Item.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCbladybug(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Namespace) > 0 {
		i -= len(m.Namespace)
		copy(dAtA[i:], m.Namespace)
		i = encodeVarintCbladybug(dAtA, i, uint64(len(m.Namespace)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *ClusterCreateInfo) 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.Config != nil {
		{
			size, err := m.Config.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCbladybug(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if len(m.Worker) > 0 {
		for iNdEx := len(m.Worker) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Worker[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintCbladybug(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.ControlPlane) > 0 {
		for iNdEx := len(m.ControlPlane) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ControlPlane[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintCbladybug(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintCbladybug(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *NodeConfig) 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.Spec) > 0 {
		i -= len(m.Spec)
		copy(dAtA[i:], m.Spec)
		i = encodeVarintCbladybug(dAtA, i, uint64(len(m.Spec)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Count != 0 {
		i = encodeVarintCbladybug(dAtA, i, uint64(m.Count))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Connection) > 0 {
		i -= len(m.Connection)
		copy(dAtA[i:], m.Connection)
		i = encodeVarintCbladybug(dAtA, i, uint64(len(m.Connection)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *Config) 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.Kubernetes != nil {
		{
			size, err := m.Kubernetes.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCbladybug(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *Kubernetes) 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.ServicDnsDomain) > 0 {
		i -= len(m.ServicDnsDomain)
		copy(dAtA[i:], m.ServicDnsDomain)
		i = encodeVarintCbladybug(dAtA, i, uint64(len(m.ServicDnsDomain)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.ServiceCidr) > 0 {
		i -= len(m.ServiceCidr)
		copy(dAtA[i:], m.ServiceCidr)
		i = encodeVarintCbladybug(dAtA, i, uint64(len(m.ServiceCidr)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.PodCidr) > 0 {
		i -= len(m.PodCidr)
		copy(dAtA[i:], m.PodCidr)
		i = encodeVarintCbladybug(dAtA, i, uint64(len(m.PodCidr)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.NetworkCni) > 0 {
		i -= len(m.NetworkCni)
		copy(dAtA[i:], m.NetworkCni)
		i = encodeVarintCbladybug(dAtA, i, uint64(len(m.NetworkCni)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *ClusterAllQryRequest) 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.Namespace) > 0 {
		i -= len(m.Namespace)
		copy(dAtA[i:], m.Namespace)
		i = encodeVarintCbladybug(dAtA, i, uint64(len(m.Namespace)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *ClusterQryRequest) 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.Cluster) > 0 {
		i -= len(m.Cluster)
		copy(dAtA[i:], m.Cluster)
		i = encodeVarintCbladybug(dAtA, i, uint64(len(m.Cluster)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Namespace) > 0 {
		i -= len(m.Namespace)
		copy(dAtA[i:], m.Namespace)
		i = encodeVarintCbladybug(dAtA, i, uint64(len(m.Namespace)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *NodeInfoResponse) 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.Item != nil {
		{
			size, err := m.Item.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCbladybug(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *ListNodeInfoResponse) 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.Items) > 0 {
		for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Items[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintCbladybug(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Kind) > 0 {
		i -= len(m.Kind)
		copy(dAtA[i:], m.Kind)
		i = encodeVarintCbladybug(dAtA, i, uint64(len(m.Kind)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *NodeInfo) 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.Csp) > 0 {
		i -= len(m.Csp)
		copy(dAtA[i:], m.Csp)
		i = encodeVarintCbladybug(dAtA, i, uint64(len(m.Csp)))
		i--
		dAtA[i] = 0x42
	}
	if len(m.Spec) > 0 {
		i -= len(m.Spec)
		copy(dAtA[i:], m.Spec)
		i = encodeVarintCbladybug(dAtA, i, uint64(len(m.Spec)))
		i--
		dAtA[i] = 0x3a
	}
	if len(m.Role) > 0 {
		i -= len(m.Role)
		copy(dAtA[i:], m.Role)
		i = encodeVarintCbladybug(dAtA, i, uint64(len(m.Role)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.Uid) > 0 {
		i -= len(m.Uid)
		copy(dAtA[i:], m.Uid)
		i = encodeVarintCbladybug(dAtA, i, uint64(len(m.Uid)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.PublicIp) > 0 {
		i -= len(m.PublicIp)
		copy(dAtA[i:], m.PublicIp)
		i = encodeVarintCbladybug(dAtA, i, uint64(len(m.PublicIp)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Credential) > 0 {
		i -= len(m.Credential)
		copy(dAtA[i:], m.Credential)
		i = encodeVarintCbladybug(dAtA, i, uint64(len(m.Credential)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Kind) > 0 {
		i -= len(m.Kind)
		copy(dAtA[i:], m.Kind)
		i = encodeVarintCbladybug(dAtA, i, uint64(len(m.Kind)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintCbladybug(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *NodeCreateRequest) 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.Item != nil {
		{
			size, err := m.Item.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintCbladybug(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Cluster) > 0 {
		i -= len(m.Cluster)
		copy(dAtA[i:], m.Cluster)
		i = encodeVarintCbladybug(dAtA, i, uint64(len(m.Cluster)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Namespace) > 0 {
		i -= len(m.Namespace)
		copy(dAtA[i:], m.Namespace)
		i = encodeVarintCbladybug(dAtA, i, uint64(len(m.Namespace)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *NodeCreateInfo) 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.Worker) > 0 {
		for iNdEx := len(m.Worker) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Worker[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintCbladybug(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.ControlPlane) > 0 {
		for iNdEx := len(m.ControlPlane) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.ControlPlane[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintCbladybug(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *NodeAllQryRequest) 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.Cluster) > 0 {
		i -= len(m.Cluster)
		copy(dAtA[i:], m.Cluster)
		i = encodeVarintCbladybug(dAtA, i, uint64(len(m.Cluster)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Namespace) > 0 {
		i -= len(m.Namespace)
		copy(dAtA[i:], m.Namespace)
		i = encodeVarintCbladybug(dAtA, i, uint64(len(m.Namespace)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *NodeQryRequest) 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.Node) > 0 {
		i -= len(m.Node)
		copy(dAtA[i:], m.Node)
		i = encodeVarintCbladybug(dAtA, i, uint64(len(m.Node)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Cluster) > 0 {
		i -= len(m.Cluster)
		copy(dAtA[i:], m.Cluster)
		i = encodeVarintCbladybug(dAtA, i, uint64(len(m.Cluster)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Namespace) > 0 {
		i -= len(m.Namespace)
		copy(dAtA[i:], m.Namespace)
		i = encodeVarintCbladybug(dAtA, i, uint64(len(m.Namespace)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintCbladybug(dAtA []byte, offset int, v uint64) int {
	offset -= sovCbladybug(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *Empty) 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 *MessageResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovCbladybug(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *StatusResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Kind)
	if l > 0 {
		n += 1 + l + sovCbladybug(uint64(l))
	}
	if m.Code != 0 {
		n += 1 + sovCbladybug(uint64(m.Code))
	}
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovCbladybug(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

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

func (m *ClusterInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovCbladybug(uint64(l))
	}
	l = len(m.Kind)
	if l > 0 {
		n += 1 + l + sovCbladybug(uint64(l))
	}
	l = len(m.Status)
	if l > 0 {
		n += 1 + l + sovCbladybug(uint64(l))
	}
	l = len(m.Uid)
	if l > 0 {
		n += 1 + l + sovCbladybug(uint64(l))
	}
	l = len(m.Mcis)
	if l > 0 {
		n += 1 + l + sovCbladybug(uint64(l))
	}
	l = len(m.Namespace)
	if l > 0 {
		n += 1 + l + sovCbladybug(uint64(l))
	}
	l = len(m.ClusterConfig)
	if l > 0 {
		n += 1 + l + sovCbladybug(uint64(l))
	}
	l = len(m.CpLeader)
	if l > 0 {
		n += 1 + l + sovCbladybug(uint64(l))
	}
	l = len(m.NetworkCni)
	if l > 0 {
		n += 1 + l + sovCbladybug(uint64(l))
	}
	if len(m.Nodes) > 0 {
		for _, e := range m.Nodes {
			l = e.Size()
			n += 1 + l + sovCbladybug(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *ClusterCreateRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Namespace)
	if l > 0 {
		n += 1 + l + sovCbladybug(uint64(l))
	}
	if m.Item != nil {
		l = m.Item.Size()
		n += 1 + l + sovCbladybug(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *NodeConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Connection)
	if l > 0 {
		n += 1 + l + sovCbladybug(uint64(l))
	}
	if m.Count != 0 {
		n += 1 + sovCbladybug(uint64(m.Count))
	}
	l = len(m.Spec)
	if l > 0 {
		n += 1 + l + sovCbladybug(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *Kubernetes) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.NetworkCni)
	if l > 0 {
		n += 1 + l + sovCbladybug(uint64(l))
	}
	l = len(m.PodCidr)
	if l > 0 {
		n += 1 + l + sovCbladybug(uint64(l))
	}
	l = len(m.ServiceCidr)
	if l > 0 {
		n += 1 + l + sovCbladybug(uint64(l))
	}
	l = len(m.ServicDnsDomain)
	if l > 0 {
		n += 1 + l + sovCbladybug(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *ClusterQryRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Namespace)
	if l > 0 {
		n += 1 + l + sovCbladybug(uint64(l))
	}
	l = len(m.Cluster)
	if l > 0 {
		n += 1 + l + sovCbladybug(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

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

func (m *NodeInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovCbladybug(uint64(l))
	}
	l = len(m.Kind)
	if l > 0 {
		n += 1 + l + sovCbladybug(uint64(l))
	}
	l = len(m.Credential)
	if l > 0 {
		n += 1 + l + sovCbladybug(uint64(l))
	}
	l = len(m.PublicIp)
	if l > 0 {
		n += 1 + l + sovCbladybug(uint64(l))
	}
	l = len(m.Uid)
	if l > 0 {
		n += 1 + l + sovCbladybug(uint64(l))
	}
	l = len(m.Role)
	if l > 0 {
		n += 1 + l + sovCbladybug(uint64(l))
	}
	l = len(m.Spec)
	if l > 0 {
		n += 1 + l + sovCbladybug(uint64(l))
	}
	l = len(m.Csp)
	if l > 0 {
		n += 1 + l + sovCbladybug(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *NodeCreateRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Namespace)
	if l > 0 {
		n += 1 + l + sovCbladybug(uint64(l))
	}
	l = len(m.Cluster)
	if l > 0 {
		n += 1 + l + sovCbladybug(uint64(l))
	}
	if m.Item != nil {
		l = m.Item.Size()
		n += 1 + l + sovCbladybug(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

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

func (m *NodeAllQryRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Namespace)
	if l > 0 {
		n += 1 + l + sovCbladybug(uint64(l))
	}
	l = len(m.Cluster)
	if l > 0 {
		n += 1 + l + sovCbladybug(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *NodeQryRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Namespace)
	if l > 0 {
		n += 1 + l + sovCbladybug(uint64(l))
	}
	l = len(m.Cluster)
	if l > 0 {
		n += 1 + l + sovCbladybug(uint64(l))
	}
	l = len(m.Node)
	if l > 0 {
		n += 1 + l + sovCbladybug(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func sovCbladybug(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozCbladybug(x uint64) (n int) {
	return sovCbladybug(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Empty) 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 ErrIntOverflowCbladybug
			}
			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: Empty: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Empty: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipCbladybug(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCbladybug
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCbladybug
			}
			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 *MessageResponse) 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 ErrIntOverflowCbladybug
			}
			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: MessageResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MessageResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCbladybug
				}
				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 ErrInvalidLengthCbladybug
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCbladybug
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Message = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCbladybug(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCbladybug
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCbladybug
			}
			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 *StatusResponse) 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 ErrIntOverflowCbladybug
			}
			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: StatusResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: StatusResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCbladybug
				}
				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 ErrInvalidLengthCbladybug
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCbladybug
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Kind = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Code", wireType)
			}
			m.Code = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCbladybug
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Code |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCbladybug
				}
				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 ErrInvalidLengthCbladybug
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCbladybug
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Message = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCbladybug(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCbladybug
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCbladybug
			}
			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 *ClusterInfoResponse) 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 ErrIntOverflowCbladybug
			}
			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: ClusterInfoResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ClusterInfoResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Item", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCbladybug
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCbladybug
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCbladybug
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Item == nil {
				m.Item = &ClusterInfo{}
			}
			if err := m.Item.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCbladybug(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCbladybug
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCbladybug
			}
			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 *ListClusterInfoResponse) 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 ErrIntOverflowCbladybug
			}
			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: ListClusterInfoResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ListClusterInfoResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCbladybug
				}
				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 ErrInvalidLengthCbladybug
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCbladybug
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Kind = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCbladybug
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCbladybug
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCbladybug
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Items = append(m.Items, &ClusterInfo{})
			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCbladybug(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCbladybug
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCbladybug
			}
			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 *ClusterInfo) 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 ErrIntOverflowCbladybug
			}
			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: ClusterInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ClusterInfo: 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 ErrIntOverflowCbladybug
				}
				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 ErrInvalidLengthCbladybug
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCbladybug
			}
			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 Kind", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCbladybug
				}
				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 ErrInvalidLengthCbladybug
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCbladybug
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Kind = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCbladybug
				}
				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 ErrInvalidLengthCbladybug
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCbladybug
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Status = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Uid", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCbladybug
				}
				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 ErrInvalidLengthCbladybug
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCbladybug
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Uid = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mcis", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCbladybug
				}
				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 ErrInvalidLengthCbladybug
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCbladybug
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Mcis = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCbladybug
				}
				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 ErrInvalidLengthCbladybug
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCbladybug
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Namespace = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ClusterConfig", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCbladybug
				}
				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 ErrInvalidLengthCbladybug
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCbladybug
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ClusterConfig = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CpLeader", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCbladybug
				}
				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 ErrInvalidLengthCbladybug
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCbladybug
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CpLeader = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NetworkCni", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCbladybug
				}
				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 ErrInvalidLengthCbladybug
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCbladybug
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NetworkCni = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Nodes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCbladybug
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCbladybug
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCbladybug
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Nodes = append(m.Nodes, &NodeInfo{})
			if err := m.Nodes[len(m.Nodes)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCbladybug(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCbladybug
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCbladybug
			}
			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 *ClusterCreateRequest) 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 ErrIntOverflowCbladybug
			}
			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: ClusterCreateRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ClusterCreateRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCbladybug
				}
				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 ErrInvalidLengthCbladybug
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCbladybug
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Namespace = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Item", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCbladybug
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCbladybug
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCbladybug
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Item == nil {
				m.Item = &ClusterCreateInfo{}
			}
			if err := m.Item.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCbladybug(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCbladybug
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCbladybug
			}
			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 *ClusterCreateInfo) 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 ErrIntOverflowCbladybug
			}
			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: ClusterCreateInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ClusterCreateInfo: 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 ErrIntOverflowCbladybug
				}
				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 ErrInvalidLengthCbladybug
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCbladybug
			}
			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 ControlPlane", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCbladybug
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCbladybug
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCbladybug
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ControlPlane = append(m.ControlPlane, &NodeConfig{})
			if err := m.ControlPlane[len(m.ControlPlane)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Worker", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCbladybug
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCbladybug
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCbladybug
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Worker = append(m.Worker, &NodeConfig{})
			if err := m.Worker[len(m.Worker)-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 Config", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCbladybug
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCbladybug
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCbladybug
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Config == nil {
				m.Config = &Config{}
			}
			if err := m.Config.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCbladybug(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCbladybug
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCbladybug
			}
			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 *NodeConfig) 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 ErrIntOverflowCbladybug
			}
			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: NodeConfig: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NodeConfig: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Connection", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCbladybug
				}
				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 ErrInvalidLengthCbladybug
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCbladybug
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Connection = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Count", wireType)
			}
			m.Count = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCbladybug
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Count |= int32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCbladybug
				}
				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 ErrInvalidLengthCbladybug
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCbladybug
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Spec = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCbladybug(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCbladybug
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCbladybug
			}
			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 *Config) 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 ErrIntOverflowCbladybug
			}
			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: Config: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Config: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Kubernetes", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCbladybug
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCbladybug
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCbladybug
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Kubernetes == nil {
				m.Kubernetes = &Kubernetes{}
			}
			if err := m.Kubernetes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCbladybug(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCbladybug
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCbladybug
			}
			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 *Kubernetes) 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 ErrIntOverflowCbladybug
			}
			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: Kubernetes: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Kubernetes: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NetworkCni", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCbladybug
				}
				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 ErrInvalidLengthCbladybug
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCbladybug
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NetworkCni = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PodCidr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCbladybug
				}
				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 ErrInvalidLengthCbladybug
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCbladybug
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PodCidr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServiceCidr", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCbladybug
				}
				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 ErrInvalidLengthCbladybug
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCbladybug
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ServiceCidr = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServicDnsDomain", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCbladybug
				}
				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 ErrInvalidLengthCbladybug
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCbladybug
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ServicDnsDomain = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCbladybug(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCbladybug
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCbladybug
			}
			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 *ClusterAllQryRequest) 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 ErrIntOverflowCbladybug
			}
			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: ClusterAllQryRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ClusterAllQryRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCbladybug
				}
				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 ErrInvalidLengthCbladybug
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCbladybug
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Namespace = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCbladybug(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCbladybug
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCbladybug
			}
			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 *ClusterQryRequest) 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 ErrIntOverflowCbladybug
			}
			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: ClusterQryRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ClusterQryRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCbladybug
				}
				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 ErrInvalidLengthCbladybug
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCbladybug
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Namespace = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cluster", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCbladybug
				}
				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 ErrInvalidLengthCbladybug
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCbladybug
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Cluster = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCbladybug(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCbladybug
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCbladybug
			}
			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 *NodeInfoResponse) 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 ErrIntOverflowCbladybug
			}
			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: NodeInfoResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NodeInfoResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Item", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCbladybug
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCbladybug
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCbladybug
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Item == nil {
				m.Item = &NodeInfo{}
			}
			if err := m.Item.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCbladybug(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCbladybug
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCbladybug
			}
			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 *ListNodeInfoResponse) 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 ErrIntOverflowCbladybug
			}
			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: ListNodeInfoResponse: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ListNodeInfoResponse: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Kind", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCbladybug
				}
				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 ErrInvalidLengthCbladybug
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCbladybug
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Kind = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Items", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCbladybug
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCbladybug
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCbladybug
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Items = append(m.Items, &NodeInfo{})
			if err := m.Items[len(m.Items)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCbladybug(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCbladybug
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCbladybug
			}
			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 *NodeInfo) 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 ErrIntOverflowCbladybug
			}
			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: NodeInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NodeInfo: 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 ErrIntOverflowCbladybug
				}
				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 ErrInvalidLengthCbladybug
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCbladybug
			}
			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 Kind", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCbladybug
				}
				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 ErrInvalidLengthCbladybug
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCbladybug
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Kind = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Credential", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCbladybug
				}
				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 ErrInvalidLengthCbladybug
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCbladybug
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Credential = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PublicIp", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCbladybug
				}
				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 ErrInvalidLengthCbladybug
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCbladybug
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PublicIp = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Uid", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCbladybug
				}
				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 ErrInvalidLengthCbladybug
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCbladybug
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Uid = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Role", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCbladybug
				}
				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 ErrInvalidLengthCbladybug
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCbladybug
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Role = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Spec", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCbladybug
				}
				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 ErrInvalidLengthCbladybug
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCbladybug
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Spec = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Csp", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCbladybug
				}
				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 ErrInvalidLengthCbladybug
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCbladybug
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Csp = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCbladybug(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCbladybug
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCbladybug
			}
			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 *NodeCreateRequest) 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 ErrIntOverflowCbladybug
			}
			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: NodeCreateRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NodeCreateRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCbladybug
				}
				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 ErrInvalidLengthCbladybug
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCbladybug
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Namespace = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cluster", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCbladybug
				}
				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 ErrInvalidLengthCbladybug
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCbladybug
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Cluster = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Item", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCbladybug
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCbladybug
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCbladybug
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Item == nil {
				m.Item = &NodeCreateInfo{}
			}
			if err := m.Item.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCbladybug(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCbladybug
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCbladybug
			}
			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 *NodeCreateInfo) 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 ErrIntOverflowCbladybug
			}
			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: NodeCreateInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NodeCreateInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ControlPlane", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCbladybug
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCbladybug
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCbladybug
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ControlPlane = append(m.ControlPlane, &NodeConfig{})
			if err := m.ControlPlane[len(m.ControlPlane)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Worker", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCbladybug
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthCbladybug
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthCbladybug
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Worker = append(m.Worker, &NodeConfig{})
			if err := m.Worker[len(m.Worker)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCbladybug(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCbladybug
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCbladybug
			}
			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 *NodeAllQryRequest) 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 ErrIntOverflowCbladybug
			}
			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: NodeAllQryRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NodeAllQryRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCbladybug
				}
				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 ErrInvalidLengthCbladybug
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCbladybug
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Namespace = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cluster", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCbladybug
				}
				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 ErrInvalidLengthCbladybug
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCbladybug
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Cluster = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCbladybug(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCbladybug
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCbladybug
			}
			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 *NodeQryRequest) 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 ErrIntOverflowCbladybug
			}
			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: NodeQryRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: NodeQryRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Namespace", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCbladybug
				}
				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 ErrInvalidLengthCbladybug
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCbladybug
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Namespace = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cluster", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCbladybug
				}
				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 ErrInvalidLengthCbladybug
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCbladybug
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Cluster = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Node", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowCbladybug
				}
				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 ErrInvalidLengthCbladybug
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthCbladybug
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Node = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipCbladybug(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthCbladybug
			}
			if (iNdEx + skippy) < 0 {
				return ErrInvalidLengthCbladybug
			}
			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 skipCbladybug(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, ErrIntOverflowCbladybug
			}
			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, ErrIntOverflowCbladybug
				}
				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, ErrIntOverflowCbladybug
				}
				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, ErrInvalidLengthCbladybug
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupCbladybug
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthCbladybug
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthCbladybug        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowCbladybug          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupCbladybug = fmt.Errorf("proto: unexpected end of group")
)