service.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: src/cloud/vzmgr/vzmgrpb/service.proto

package vzmgrpb

import (
	context "context"
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	types "github.com/gogo/protobuf/types"
	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"
	uuidpb "px.dev/pixie/src/api/proto/uuidpb"
	cvmsgspb "px.dev/pixie/src/shared/cvmsgspb"
	reflect "reflect"
	strings "strings"
)

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package

type CreateVizierClusterRequest struct {
	OrgID       *uuidpb.UUID `protobuf:"bytes,1,opt,name=org_id,json=orgId,proto3" json:"org_id,omitempty"`
	ProjectName string       `protobuf:"bytes,2,opt,name=project_name,json=projectName,proto3" json:"project_name,omitempty"`
}

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

var xxx_messageInfo_CreateVizierClusterRequest proto.InternalMessageInfo

func (m *CreateVizierClusterRequest) GetOrgID() *uuidpb.UUID {
	if m != nil {
		return m.OrgID
	}
	return nil
}

func (m *CreateVizierClusterRequest) GetProjectName() string {
	if m != nil {
		return m.ProjectName
	}
	return ""
}

type GetViziersByOrgResponse struct {
	VizierIDs []*uuidpb.UUID `protobuf:"bytes,1,rep,name=vizier_ids,json=vizierIds,proto3" json:"vizier_ids,omitempty"`
}

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

var xxx_messageInfo_GetViziersByOrgResponse proto.InternalMessageInfo

func (m *GetViziersByOrgResponse) GetVizierIDs() []*uuidpb.UUID {
	if m != nil {
		return m.VizierIDs
	}
	return nil
}

type GetViziersByShardRequest struct {
	FromShardID string `protobuf:"bytes,1,opt,name=from_shard_id,json=fromShardId,proto3" json:"from_shard_id,omitempty"`
	ToShardID   string `protobuf:"bytes,2,opt,name=to_shard_id,json=toShardId,proto3" json:"to_shard_id,omitempty"`
}

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

var xxx_messageInfo_GetViziersByShardRequest proto.InternalMessageInfo

func (m *GetViziersByShardRequest) GetFromShardID() string {
	if m != nil {
		return m.FromShardID
	}
	return ""
}

func (m *GetViziersByShardRequest) GetToShardID() string {
	if m != nil {
		return m.ToShardID
	}
	return ""
}

type GetViziersByShardResponse struct {
	Viziers []*GetViziersByShardResponse_VizierInfo `protobuf:"bytes,1,rep,name=viziers,proto3" json:"viziers,omitempty"`
}

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

var xxx_messageInfo_GetViziersByShardResponse proto.InternalMessageInfo

func (m *GetViziersByShardResponse) GetViziers() []*GetViziersByShardResponse_VizierInfo {
	if m != nil {
		return m.Viziers
	}
	return nil
}

type GetViziersByShardResponse_VizierInfo struct {
	VizierID *uuidpb.UUID `protobuf:"bytes,1,opt,name=vizier_id,json=vizierId,proto3" json:"vizier_id,omitempty"`
	OrgID    *uuidpb.UUID `protobuf:"bytes,2,opt,name=org_id,json=orgId,proto3" json:"org_id,omitempty"`
	K8sUID   string       `protobuf:"bytes,4,opt,name=k8s_uid,json=k8sUid,proto3" json:"k8s_uid,omitempty"`
}

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

var xxx_messageInfo_GetViziersByShardResponse_VizierInfo proto.InternalMessageInfo

func (m *GetViziersByShardResponse_VizierInfo) GetVizierID() *uuidpb.UUID {
	if m != nil {
		return m.VizierID
	}
	return nil
}

func (m *GetViziersByShardResponse_VizierInfo) GetOrgID() *uuidpb.UUID {
	if m != nil {
		return m.OrgID
	}
	return nil
}

func (m *GetViziersByShardResponse_VizierInfo) GetK8sUID() string {
	if m != nil {
		return m.K8sUID
	}
	return ""
}

type GetVizierInfosRequest struct {
	VizierIDs []*uuidpb.UUID `protobuf:"bytes,1,rep,name=vizier_ids,json=vizierIds,proto3" json:"vizier_ids,omitempty"`
}

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

var xxx_messageInfo_GetVizierInfosRequest proto.InternalMessageInfo

func (m *GetVizierInfosRequest) GetVizierIDs() []*uuidpb.UUID {
	if m != nil {
		return m.VizierIDs
	}
	return nil
}

type GetVizierInfosResponse struct {
	VizierInfos []*cvmsgspb.VizierInfo `protobuf:"bytes,1,rep,name=vizier_infos,json=vizierInfos,proto3" json:"vizier_infos,omitempty"`
}

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

var xxx_messageInfo_GetVizierInfosResponse proto.InternalMessageInfo

func (m *GetVizierInfosResponse) GetVizierInfos() []*cvmsgspb.VizierInfo {
	if m != nil {
		return m.VizierInfos
	}
	return nil
}

type DeploymentKeyMetadata struct {
	ID        *uuidpb.UUID     `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	CreatedAt *types.Timestamp `protobuf:"bytes,3,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	Desc      string           `protobuf:"bytes,4,opt,name=desc,proto3" json:"desc,omitempty"`
	OrgID     *uuidpb.UUID     `protobuf:"bytes,5,opt,name=org_id,json=orgId,proto3" json:"org_id,omitempty"`
	UserID    *uuidpb.UUID     `protobuf:"bytes,6,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"`
}

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

var xxx_messageInfo_DeploymentKeyMetadata proto.InternalMessageInfo

func (m *DeploymentKeyMetadata) GetID() *uuidpb.UUID {
	if m != nil {
		return m.ID
	}
	return nil
}

func (m *DeploymentKeyMetadata) GetCreatedAt() *types.Timestamp {
	if m != nil {
		return m.CreatedAt
	}
	return nil
}

func (m *DeploymentKeyMetadata) GetDesc() string {
	if m != nil {
		return m.Desc
	}
	return ""
}

func (m *DeploymentKeyMetadata) GetOrgID() *uuidpb.UUID {
	if m != nil {
		return m.OrgID
	}
	return nil
}

func (m *DeploymentKeyMetadata) GetUserID() *uuidpb.UUID {
	if m != nil {
		return m.UserID
	}
	return nil
}

type DeploymentKey struct {
	ID        *uuidpb.UUID     `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Key       string           `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"`
	CreatedAt *types.Timestamp `protobuf:"bytes,3,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	Desc      string           `protobuf:"bytes,4,opt,name=desc,proto3" json:"desc,omitempty"`
	OrgID     *uuidpb.UUID     `protobuf:"bytes,5,opt,name=org_id,json=orgId,proto3" json:"org_id,omitempty"`
	UserID    *uuidpb.UUID     `protobuf:"bytes,6,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"`
}

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

var xxx_messageInfo_DeploymentKey proto.InternalMessageInfo

func (m *DeploymentKey) GetID() *uuidpb.UUID {
	if m != nil {
		return m.ID
	}
	return nil
}

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

func (m *DeploymentKey) GetCreatedAt() *types.Timestamp {
	if m != nil {
		return m.CreatedAt
	}
	return nil
}

func (m *DeploymentKey) GetDesc() string {
	if m != nil {
		return m.Desc
	}
	return ""
}

func (m *DeploymentKey) GetOrgID() *uuidpb.UUID {
	if m != nil {
		return m.OrgID
	}
	return nil
}

func (m *DeploymentKey) GetUserID() *uuidpb.UUID {
	if m != nil {
		return m.UserID
	}
	return nil
}

type CreateDeploymentKeyRequest struct {
	Desc   string       `protobuf:"bytes,1,opt,name=desc,proto3" json:"desc,omitempty"`
	OrgID  *uuidpb.UUID `protobuf:"bytes,2,opt,name=org_id,json=orgId,proto3" json:"org_id,omitempty"`
	UserID *uuidpb.UUID `protobuf:"bytes,3,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"`
}

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

var xxx_messageInfo_CreateDeploymentKeyRequest proto.InternalMessageInfo

func (m *CreateDeploymentKeyRequest) GetDesc() string {
	if m != nil {
		return m.Desc
	}
	return ""
}

func (m *CreateDeploymentKeyRequest) GetOrgID() *uuidpb.UUID {
	if m != nil {
		return m.OrgID
	}
	return nil
}

func (m *CreateDeploymentKeyRequest) GetUserID() *uuidpb.UUID {
	if m != nil {
		return m.UserID
	}
	return nil
}

type ListDeploymentKeyRequest struct {
	OrgID *uuidpb.UUID `protobuf:"bytes,1,opt,name=org_id,json=orgId,proto3" json:"org_id,omitempty"`
}

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

var xxx_messageInfo_ListDeploymentKeyRequest proto.InternalMessageInfo

func (m *ListDeploymentKeyRequest) GetOrgID() *uuidpb.UUID {
	if m != nil {
		return m.OrgID
	}
	return nil
}

type ListDeploymentKeyResponse struct {
	Keys []*DeploymentKeyMetadata `protobuf:"bytes,1,rep,name=keys,proto3" json:"keys,omitempty"`
}

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

var xxx_messageInfo_ListDeploymentKeyResponse proto.InternalMessageInfo

func (m *ListDeploymentKeyResponse) GetKeys() []*DeploymentKeyMetadata {
	if m != nil {
		return m.Keys
	}
	return nil
}

type GetDeploymentKeyRequest struct {
	ID    *uuidpb.UUID `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	OrgID *uuidpb.UUID `protobuf:"bytes,2,opt,name=org_id,json=orgId,proto3" json:"org_id,omitempty"`
}

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

var xxx_messageInfo_GetDeploymentKeyRequest proto.InternalMessageInfo

func (m *GetDeploymentKeyRequest) GetID() *uuidpb.UUID {
	if m != nil {
		return m.ID
	}
	return nil
}

func (m *GetDeploymentKeyRequest) GetOrgID() *uuidpb.UUID {
	if m != nil {
		return m.OrgID
	}
	return nil
}

type GetDeploymentKeyResponse struct {
	Key *DeploymentKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
}

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

var xxx_messageInfo_GetDeploymentKeyResponse proto.InternalMessageInfo

func (m *GetDeploymentKeyResponse) GetKey() *DeploymentKey {
	if m != nil {
		return m.Key
	}
	return nil
}

type DeleteDeploymentKeyRequest struct {
	ID    *uuidpb.UUID `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	OrgID *uuidpb.UUID `protobuf:"bytes,2,opt,name=org_id,json=orgId,proto3" json:"org_id,omitempty"`
}

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

var xxx_messageInfo_DeleteDeploymentKeyRequest proto.InternalMessageInfo

func (m *DeleteDeploymentKeyRequest) GetID() *uuidpb.UUID {
	if m != nil {
		return m.ID
	}
	return nil
}

func (m *DeleteDeploymentKeyRequest) GetOrgID() *uuidpb.UUID {
	if m != nil {
		return m.OrgID
	}
	return nil
}

type LookupDeploymentKeyRequest struct {
	Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
}

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

var xxx_messageInfo_LookupDeploymentKeyRequest proto.InternalMessageInfo

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

type LookupDeploymentKeyResponse struct {
	Key *DeploymentKey `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
}

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

var xxx_messageInfo_LookupDeploymentKeyResponse proto.InternalMessageInfo

func (m *LookupDeploymentKeyResponse) GetKey() *DeploymentKey {
	if m != nil {
		return m.Key
	}
	return nil
}

type RegisterVizierDeploymentRequest struct {
	K8sClusterUID  string `protobuf:"bytes,1,opt,name=k8s_cluster_uid,json=k8sClusterUid,proto3" json:"k8s_cluster_uid,omitempty"`
	DeploymentKey  string `protobuf:"bytes,2,opt,name=deployment_key,json=deploymentKey,proto3" json:"deployment_key,omitempty"`
	K8sClusterName string `protobuf:"bytes,3,opt,name=k8s_cluster_name,json=k8sClusterName,proto3" json:"k8s_cluster_name,omitempty"`
}

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

var xxx_messageInfo_RegisterVizierDeploymentRequest proto.InternalMessageInfo

func (m *RegisterVizierDeploymentRequest) GetK8sClusterUID() string {
	if m != nil {
		return m.K8sClusterUID
	}
	return ""
}

func (m *RegisterVizierDeploymentRequest) GetDeploymentKey() string {
	if m != nil {
		return m.DeploymentKey
	}
	return ""
}

func (m *RegisterVizierDeploymentRequest) GetK8sClusterName() string {
	if m != nil {
		return m.K8sClusterName
	}
	return ""
}

type RegisterVizierDeploymentResponse struct {
	VizierID   *uuidpb.UUID `protobuf:"bytes,1,opt,name=vizier_id,json=vizierId,proto3" json:"vizier_id,omitempty"`
	VizierName string       `protobuf:"bytes,2,opt,name=vizier_name,json=vizierName,proto3" json:"vizier_name,omitempty"`
}

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

var xxx_messageInfo_RegisterVizierDeploymentResponse proto.InternalMessageInfo

func (m *RegisterVizierDeploymentResponse) GetVizierID() *uuidpb.UUID {
	if m != nil {
		return m.VizierID
	}
	return nil
}

func (m *RegisterVizierDeploymentResponse) GetVizierName() string {
	if m != nil {
		return m.VizierName
	}
	return ""
}

type GetOrgFromVizierResponse struct {
	OrgID *uuidpb.UUID `protobuf:"bytes,1,opt,name=org_id,json=orgId,proto3" json:"org_id,omitempty"`
}

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

var xxx_messageInfo_GetOrgFromVizierResponse proto.InternalMessageInfo

func (m *GetOrgFromVizierResponse) GetOrgID() *uuidpb.UUID {
	if m != nil {
		return m.OrgID
	}
	return nil
}

func init() {
	proto.RegisterType((*CreateVizierClusterRequest)(nil), "px.services.internal.CreateVizierClusterRequest")
	proto.RegisterType((*GetViziersByOrgResponse)(nil), "px.services.internal.GetViziersByOrgResponse")
	proto.RegisterType((*GetViziersByShardRequest)(nil), "px.services.internal.GetViziersByShardRequest")
	proto.RegisterType((*GetViziersByShardResponse)(nil), "px.services.internal.GetViziersByShardResponse")
	proto.RegisterType((*GetViziersByShardResponse_VizierInfo)(nil), "px.services.internal.GetViziersByShardResponse.VizierInfo")
	proto.RegisterType((*GetVizierInfosRequest)(nil), "px.services.internal.GetVizierInfosRequest")
	proto.RegisterType((*GetVizierInfosResponse)(nil), "px.services.internal.GetVizierInfosResponse")
	proto.RegisterType((*DeploymentKeyMetadata)(nil), "px.services.internal.DeploymentKeyMetadata")
	proto.RegisterType((*DeploymentKey)(nil), "px.services.internal.DeploymentKey")
	proto.RegisterType((*CreateDeploymentKeyRequest)(nil), "px.services.internal.CreateDeploymentKeyRequest")
	proto.RegisterType((*ListDeploymentKeyRequest)(nil), "px.services.internal.ListDeploymentKeyRequest")
	proto.RegisterType((*ListDeploymentKeyResponse)(nil), "px.services.internal.ListDeploymentKeyResponse")
	proto.RegisterType((*GetDeploymentKeyRequest)(nil), "px.services.internal.GetDeploymentKeyRequest")
	proto.RegisterType((*GetDeploymentKeyResponse)(nil), "px.services.internal.GetDeploymentKeyResponse")
	proto.RegisterType((*DeleteDeploymentKeyRequest)(nil), "px.services.internal.DeleteDeploymentKeyRequest")
	proto.RegisterType((*LookupDeploymentKeyRequest)(nil), "px.services.internal.LookupDeploymentKeyRequest")
	proto.RegisterType((*LookupDeploymentKeyResponse)(nil), "px.services.internal.LookupDeploymentKeyResponse")
	proto.RegisterType((*RegisterVizierDeploymentRequest)(nil), "px.services.internal.RegisterVizierDeploymentRequest")
	proto.RegisterType((*RegisterVizierDeploymentResponse)(nil), "px.services.internal.RegisterVizierDeploymentResponse")
	proto.RegisterType((*GetOrgFromVizierResponse)(nil), "px.services.internal.GetOrgFromVizierResponse")
}

func init() {
	proto.RegisterFile("src/cloud/vzmgr/vzmgrpb/service.proto", fileDescriptor_7b112f5a7e47f58f)
}

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

func (this *CreateVizierClusterRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*CreateVizierClusterRequest)
	if !ok {
		that2, ok := that.(CreateVizierClusterRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.OrgID.Equal(that1.OrgID) {
		return false
	}
	if this.ProjectName != that1.ProjectName {
		return false
	}
	return true
}
func (this *GetViziersByOrgResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GetViziersByOrgResponse)
	if !ok {
		that2, ok := that.(GetViziersByOrgResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.VizierIDs) != len(that1.VizierIDs) {
		return false
	}
	for i := range this.VizierIDs {
		if !this.VizierIDs[i].Equal(that1.VizierIDs[i]) {
			return false
		}
	}
	return true
}
func (this *GetViziersByShardRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GetViziersByShardRequest)
	if !ok {
		that2, ok := that.(GetViziersByShardRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.FromShardID != that1.FromShardID {
		return false
	}
	if this.ToShardID != that1.ToShardID {
		return false
	}
	return true
}
func (this *GetViziersByShardResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GetViziersByShardResponse)
	if !ok {
		that2, ok := that.(GetViziersByShardResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Viziers) != len(that1.Viziers) {
		return false
	}
	for i := range this.Viziers {
		if !this.Viziers[i].Equal(that1.Viziers[i]) {
			return false
		}
	}
	return true
}
func (this *GetViziersByShardResponse_VizierInfo) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GetViziersByShardResponse_VizierInfo)
	if !ok {
		that2, ok := that.(GetViziersByShardResponse_VizierInfo)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.VizierID.Equal(that1.VizierID) {
		return false
	}
	if !this.OrgID.Equal(that1.OrgID) {
		return false
	}
	if this.K8sUID != that1.K8sUID {
		return false
	}
	return true
}
func (this *GetVizierInfosRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GetVizierInfosRequest)
	if !ok {
		that2, ok := that.(GetVizierInfosRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.VizierIDs) != len(that1.VizierIDs) {
		return false
	}
	for i := range this.VizierIDs {
		if !this.VizierIDs[i].Equal(that1.VizierIDs[i]) {
			return false
		}
	}
	return true
}
func (this *GetVizierInfosResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GetVizierInfosResponse)
	if !ok {
		that2, ok := that.(GetVizierInfosResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.VizierInfos) != len(that1.VizierInfos) {
		return false
	}
	for i := range this.VizierInfos {
		if !this.VizierInfos[i].Equal(that1.VizierInfos[i]) {
			return false
		}
	}
	return true
}
func (this *DeploymentKeyMetadata) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DeploymentKeyMetadata)
	if !ok {
		that2, ok := that.(DeploymentKeyMetadata)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.ID.Equal(that1.ID) {
		return false
	}
	if !this.CreatedAt.Equal(that1.CreatedAt) {
		return false
	}
	if this.Desc != that1.Desc {
		return false
	}
	if !this.OrgID.Equal(that1.OrgID) {
		return false
	}
	if !this.UserID.Equal(that1.UserID) {
		return false
	}
	return true
}
func (this *DeploymentKey) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DeploymentKey)
	if !ok {
		that2, ok := that.(DeploymentKey)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.ID.Equal(that1.ID) {
		return false
	}
	if this.Key != that1.Key {
		return false
	}
	if !this.CreatedAt.Equal(that1.CreatedAt) {
		return false
	}
	if this.Desc != that1.Desc {
		return false
	}
	if !this.OrgID.Equal(that1.OrgID) {
		return false
	}
	if !this.UserID.Equal(that1.UserID) {
		return false
	}
	return true
}
func (this *CreateDeploymentKeyRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*CreateDeploymentKeyRequest)
	if !ok {
		that2, ok := that.(CreateDeploymentKeyRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Desc != that1.Desc {
		return false
	}
	if !this.OrgID.Equal(that1.OrgID) {
		return false
	}
	if !this.UserID.Equal(that1.UserID) {
		return false
	}
	return true
}
func (this *ListDeploymentKeyRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ListDeploymentKeyRequest)
	if !ok {
		that2, ok := that.(ListDeploymentKeyRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.OrgID.Equal(that1.OrgID) {
		return false
	}
	return true
}
func (this *ListDeploymentKeyResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*ListDeploymentKeyResponse)
	if !ok {
		that2, ok := that.(ListDeploymentKeyResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if len(this.Keys) != len(that1.Keys) {
		return false
	}
	for i := range this.Keys {
		if !this.Keys[i].Equal(that1.Keys[i]) {
			return false
		}
	}
	return true
}
func (this *GetDeploymentKeyRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GetDeploymentKeyRequest)
	if !ok {
		that2, ok := that.(GetDeploymentKeyRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.ID.Equal(that1.ID) {
		return false
	}
	if !this.OrgID.Equal(that1.OrgID) {
		return false
	}
	return true
}
func (this *GetDeploymentKeyResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GetDeploymentKeyResponse)
	if !ok {
		that2, ok := that.(GetDeploymentKeyResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Key.Equal(that1.Key) {
		return false
	}
	return true
}
func (this *DeleteDeploymentKeyRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*DeleteDeploymentKeyRequest)
	if !ok {
		that2, ok := that.(DeleteDeploymentKeyRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.ID.Equal(that1.ID) {
		return false
	}
	if !this.OrgID.Equal(that1.OrgID) {
		return false
	}
	return true
}
func (this *LookupDeploymentKeyRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*LookupDeploymentKeyRequest)
	if !ok {
		that2, ok := that.(LookupDeploymentKeyRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.Key != that1.Key {
		return false
	}
	return true
}
func (this *LookupDeploymentKeyResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*LookupDeploymentKeyResponse)
	if !ok {
		that2, ok := that.(LookupDeploymentKeyResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.Key.Equal(that1.Key) {
		return false
	}
	return true
}
func (this *RegisterVizierDeploymentRequest) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RegisterVizierDeploymentRequest)
	if !ok {
		that2, ok := that.(RegisterVizierDeploymentRequest)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if this.K8sClusterUID != that1.K8sClusterUID {
		return false
	}
	if this.DeploymentKey != that1.DeploymentKey {
		return false
	}
	if this.K8sClusterName != that1.K8sClusterName {
		return false
	}
	return true
}
func (this *RegisterVizierDeploymentResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*RegisterVizierDeploymentResponse)
	if !ok {
		that2, ok := that.(RegisterVizierDeploymentResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.VizierID.Equal(that1.VizierID) {
		return false
	}
	if this.VizierName != that1.VizierName {
		return false
	}
	return true
}
func (this *GetOrgFromVizierResponse) Equal(that interface{}) bool {
	if that == nil {
		return this == nil
	}

	that1, ok := that.(*GetOrgFromVizierResponse)
	if !ok {
		that2, ok := that.(GetOrgFromVizierResponse)
		if ok {
			that1 = &that2
		} else {
			return false
		}
	}
	if that1 == nil {
		return this == nil
	} else if this == nil {
		return false
	}
	if !this.OrgID.Equal(that1.OrgID) {
		return false
	}
	return true
}
func (this *CreateVizierClusterRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&vzmgrpb.CreateVizierClusterRequest{")
	if this.OrgID != nil {
		s = append(s, "OrgID: "+fmt.Sprintf("%#v", this.OrgID)+",\n")
	}
	s = append(s, "ProjectName: "+fmt.Sprintf("%#v", this.ProjectName)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *GetViziersByOrgResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&vzmgrpb.GetViziersByOrgResponse{")
	if this.VizierIDs != nil {
		s = append(s, "VizierIDs: "+fmt.Sprintf("%#v", this.VizierIDs)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *GetViziersByShardRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&vzmgrpb.GetViziersByShardRequest{")
	s = append(s, "FromShardID: "+fmt.Sprintf("%#v", this.FromShardID)+",\n")
	s = append(s, "ToShardID: "+fmt.Sprintf("%#v", this.ToShardID)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *GetViziersByShardResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&vzmgrpb.GetViziersByShardResponse{")
	if this.Viziers != nil {
		s = append(s, "Viziers: "+fmt.Sprintf("%#v", this.Viziers)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *GetViziersByShardResponse_VizierInfo) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&vzmgrpb.GetViziersByShardResponse_VizierInfo{")
	if this.VizierID != nil {
		s = append(s, "VizierID: "+fmt.Sprintf("%#v", this.VizierID)+",\n")
	}
	if this.OrgID != nil {
		s = append(s, "OrgID: "+fmt.Sprintf("%#v", this.OrgID)+",\n")
	}
	s = append(s, "K8sUID: "+fmt.Sprintf("%#v", this.K8sUID)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *GetVizierInfosRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&vzmgrpb.GetVizierInfosRequest{")
	if this.VizierIDs != nil {
		s = append(s, "VizierIDs: "+fmt.Sprintf("%#v", this.VizierIDs)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *GetVizierInfosResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&vzmgrpb.GetVizierInfosResponse{")
	if this.VizierInfos != nil {
		s = append(s, "VizierInfos: "+fmt.Sprintf("%#v", this.VizierInfos)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *DeploymentKeyMetadata) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 9)
	s = append(s, "&vzmgrpb.DeploymentKeyMetadata{")
	if this.ID != nil {
		s = append(s, "ID: "+fmt.Sprintf("%#v", this.ID)+",\n")
	}
	if this.CreatedAt != nil {
		s = append(s, "CreatedAt: "+fmt.Sprintf("%#v", this.CreatedAt)+",\n")
	}
	s = append(s, "Desc: "+fmt.Sprintf("%#v", this.Desc)+",\n")
	if this.OrgID != nil {
		s = append(s, "OrgID: "+fmt.Sprintf("%#v", this.OrgID)+",\n")
	}
	if this.UserID != nil {
		s = append(s, "UserID: "+fmt.Sprintf("%#v", this.UserID)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *DeploymentKey) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 10)
	s = append(s, "&vzmgrpb.DeploymentKey{")
	if this.ID != nil {
		s = append(s, "ID: "+fmt.Sprintf("%#v", this.ID)+",\n")
	}
	s = append(s, "Key: "+fmt.Sprintf("%#v", this.Key)+",\n")
	if this.CreatedAt != nil {
		s = append(s, "CreatedAt: "+fmt.Sprintf("%#v", this.CreatedAt)+",\n")
	}
	s = append(s, "Desc: "+fmt.Sprintf("%#v", this.Desc)+",\n")
	if this.OrgID != nil {
		s = append(s, "OrgID: "+fmt.Sprintf("%#v", this.OrgID)+",\n")
	}
	if this.UserID != nil {
		s = append(s, "UserID: "+fmt.Sprintf("%#v", this.UserID)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *CreateDeploymentKeyRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&vzmgrpb.CreateDeploymentKeyRequest{")
	s = append(s, "Desc: "+fmt.Sprintf("%#v", this.Desc)+",\n")
	if this.OrgID != nil {
		s = append(s, "OrgID: "+fmt.Sprintf("%#v", this.OrgID)+",\n")
	}
	if this.UserID != nil {
		s = append(s, "UserID: "+fmt.Sprintf("%#v", this.UserID)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ListDeploymentKeyRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&vzmgrpb.ListDeploymentKeyRequest{")
	if this.OrgID != nil {
		s = append(s, "OrgID: "+fmt.Sprintf("%#v", this.OrgID)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ListDeploymentKeyResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&vzmgrpb.ListDeploymentKeyResponse{")
	if this.Keys != nil {
		s = append(s, "Keys: "+fmt.Sprintf("%#v", this.Keys)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *GetDeploymentKeyRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&vzmgrpb.GetDeploymentKeyRequest{")
	if this.ID != nil {
		s = append(s, "ID: "+fmt.Sprintf("%#v", this.ID)+",\n")
	}
	if this.OrgID != nil {
		s = append(s, "OrgID: "+fmt.Sprintf("%#v", this.OrgID)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *GetDeploymentKeyResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&vzmgrpb.GetDeploymentKeyResponse{")
	if this.Key != nil {
		s = append(s, "Key: "+fmt.Sprintf("%#v", this.Key)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *DeleteDeploymentKeyRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&vzmgrpb.DeleteDeploymentKeyRequest{")
	if this.ID != nil {
		s = append(s, "ID: "+fmt.Sprintf("%#v", this.ID)+",\n")
	}
	if this.OrgID != nil {
		s = append(s, "OrgID: "+fmt.Sprintf("%#v", this.OrgID)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *LookupDeploymentKeyRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&vzmgrpb.LookupDeploymentKeyRequest{")
	s = append(s, "Key: "+fmt.Sprintf("%#v", this.Key)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *LookupDeploymentKeyResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&vzmgrpb.LookupDeploymentKeyResponse{")
	if this.Key != nil {
		s = append(s, "Key: "+fmt.Sprintf("%#v", this.Key)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *RegisterVizierDeploymentRequest) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&vzmgrpb.RegisterVizierDeploymentRequest{")
	s = append(s, "K8sClusterUID: "+fmt.Sprintf("%#v", this.K8sClusterUID)+",\n")
	s = append(s, "DeploymentKey: "+fmt.Sprintf("%#v", this.DeploymentKey)+",\n")
	s = append(s, "K8sClusterName: "+fmt.Sprintf("%#v", this.K8sClusterName)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *RegisterVizierDeploymentResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&vzmgrpb.RegisterVizierDeploymentResponse{")
	if this.VizierID != nil {
		s = append(s, "VizierID: "+fmt.Sprintf("%#v", this.VizierID)+",\n")
	}
	s = append(s, "VizierName: "+fmt.Sprintf("%#v", this.VizierName)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *GetOrgFromVizierResponse) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&vzmgrpb.GetOrgFromVizierResponse{")
	if this.OrgID != nil {
		s = append(s, "OrgID: "+fmt.Sprintf("%#v", this.OrgID)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func valueToGoStringService(v interface{}, typ string) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
}

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

// VZMgrServiceClient is the client API for VZMgrService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type VZMgrServiceClient interface {
	CreateVizierCluster(ctx context.Context, in *CreateVizierClusterRequest, opts ...grpc.CallOption) (*uuidpb.UUID, error)
	GetViziersByOrg(ctx context.Context, in *uuidpb.UUID, opts ...grpc.CallOption) (*GetViziersByOrgResponse, error)
	GetVizierInfo(ctx context.Context, in *uuidpb.UUID, opts ...grpc.CallOption) (*cvmsgspb.VizierInfo, error)
	GetViziersByShard(ctx context.Context, in *GetViziersByShardRequest, opts ...grpc.CallOption) (*GetViziersByShardResponse, error)
	GetVizierConnectionInfo(ctx context.Context, in *uuidpb.UUID, opts ...grpc.CallOption) (*cvmsgspb.VizierConnectionInfo, error)
	GetVizierInfos(ctx context.Context, in *GetVizierInfosRequest, opts ...grpc.CallOption) (*GetVizierInfosResponse, error)
	VizierConnected(ctx context.Context, in *cvmsgspb.RegisterVizierRequest, opts ...grpc.CallOption) (*cvmsgspb.RegisterVizierAck, error)
	UpdateVizierConfig(ctx context.Context, in *cvmsgspb.UpdateVizierConfigRequest, opts ...grpc.CallOption) (*cvmsgspb.UpdateVizierConfigResponse, error)
	UpdateOrInstallVizier(ctx context.Context, in *cvmsgspb.UpdateOrInstallVizierRequest, opts ...grpc.CallOption) (*cvmsgspb.UpdateOrInstallVizierResponse, error)
	GetOrgFromVizier(ctx context.Context, in *uuidpb.UUID, opts ...grpc.CallOption) (*GetOrgFromVizierResponse, error)
}

type vZMgrServiceClient struct {
	cc *grpc.ClientConn
}

func NewVZMgrServiceClient(cc *grpc.ClientConn) VZMgrServiceClient {
	return &vZMgrServiceClient{cc}
}

func (c *vZMgrServiceClient) CreateVizierCluster(ctx context.Context, in *CreateVizierClusterRequest, opts ...grpc.CallOption) (*uuidpb.UUID, error) {
	out := new(uuidpb.UUID)
	err := c.cc.Invoke(ctx, "/px.services.internal.VZMgrService/CreateVizierCluster", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *vZMgrServiceClient) GetViziersByOrg(ctx context.Context, in *uuidpb.UUID, opts ...grpc.CallOption) (*GetViziersByOrgResponse, error) {
	out := new(GetViziersByOrgResponse)
	err := c.cc.Invoke(ctx, "/px.services.internal.VZMgrService/GetViziersByOrg", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *vZMgrServiceClient) GetVizierInfo(ctx context.Context, in *uuidpb.UUID, opts ...grpc.CallOption) (*cvmsgspb.VizierInfo, error) {
	out := new(cvmsgspb.VizierInfo)
	err := c.cc.Invoke(ctx, "/px.services.internal.VZMgrService/GetVizierInfo", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *vZMgrServiceClient) GetViziersByShard(ctx context.Context, in *GetViziersByShardRequest, opts ...grpc.CallOption) (*GetViziersByShardResponse, error) {
	out := new(GetViziersByShardResponse)
	err := c.cc.Invoke(ctx, "/px.services.internal.VZMgrService/GetViziersByShard", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *vZMgrServiceClient) GetVizierConnectionInfo(ctx context.Context, in *uuidpb.UUID, opts ...grpc.CallOption) (*cvmsgspb.VizierConnectionInfo, error) {
	out := new(cvmsgspb.VizierConnectionInfo)
	err := c.cc.Invoke(ctx, "/px.services.internal.VZMgrService/GetVizierConnectionInfo", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *vZMgrServiceClient) GetVizierInfos(ctx context.Context, in *GetVizierInfosRequest, opts ...grpc.CallOption) (*GetVizierInfosResponse, error) {
	out := new(GetVizierInfosResponse)
	err := c.cc.Invoke(ctx, "/px.services.internal.VZMgrService/GetVizierInfos", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *vZMgrServiceClient) VizierConnected(ctx context.Context, in *cvmsgspb.RegisterVizierRequest, opts ...grpc.CallOption) (*cvmsgspb.RegisterVizierAck, error) {
	out := new(cvmsgspb.RegisterVizierAck)
	err := c.cc.Invoke(ctx, "/px.services.internal.VZMgrService/VizierConnected", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *vZMgrServiceClient) UpdateVizierConfig(ctx context.Context, in *cvmsgspb.UpdateVizierConfigRequest, opts ...grpc.CallOption) (*cvmsgspb.UpdateVizierConfigResponse, error) {
	out := new(cvmsgspb.UpdateVizierConfigResponse)
	err := c.cc.Invoke(ctx, "/px.services.internal.VZMgrService/UpdateVizierConfig", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *vZMgrServiceClient) UpdateOrInstallVizier(ctx context.Context, in *cvmsgspb.UpdateOrInstallVizierRequest, opts ...grpc.CallOption) (*cvmsgspb.UpdateOrInstallVizierResponse, error) {
	out := new(cvmsgspb.UpdateOrInstallVizierResponse)
	err := c.cc.Invoke(ctx, "/px.services.internal.VZMgrService/UpdateOrInstallVizier", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *vZMgrServiceClient) GetOrgFromVizier(ctx context.Context, in *uuidpb.UUID, opts ...grpc.CallOption) (*GetOrgFromVizierResponse, error) {
	out := new(GetOrgFromVizierResponse)
	err := c.cc.Invoke(ctx, "/px.services.internal.VZMgrService/GetOrgFromVizier", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// VZMgrServiceServer is the server API for VZMgrService service.
type VZMgrServiceServer interface {
	CreateVizierCluster(context.Context, *CreateVizierClusterRequest) (*uuidpb.UUID, error)
	GetViziersByOrg(context.Context, *uuidpb.UUID) (*GetViziersByOrgResponse, error)
	GetVizierInfo(context.Context, *uuidpb.UUID) (*cvmsgspb.VizierInfo, error)
	GetViziersByShard(context.Context, *GetViziersByShardRequest) (*GetViziersByShardResponse, error)
	GetVizierConnectionInfo(context.Context, *uuidpb.UUID) (*cvmsgspb.VizierConnectionInfo, error)
	GetVizierInfos(context.Context, *GetVizierInfosRequest) (*GetVizierInfosResponse, error)
	VizierConnected(context.Context, *cvmsgspb.RegisterVizierRequest) (*cvmsgspb.RegisterVizierAck, error)
	UpdateVizierConfig(context.Context, *cvmsgspb.UpdateVizierConfigRequest) (*cvmsgspb.UpdateVizierConfigResponse, error)
	UpdateOrInstallVizier(context.Context, *cvmsgspb.UpdateOrInstallVizierRequest) (*cvmsgspb.UpdateOrInstallVizierResponse, error)
	GetOrgFromVizier(context.Context, *uuidpb.UUID) (*GetOrgFromVizierResponse, error)
}

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

func (*UnimplementedVZMgrServiceServer) CreateVizierCluster(ctx context.Context, req *CreateVizierClusterRequest) (*uuidpb.UUID, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateVizierCluster not implemented")
}
func (*UnimplementedVZMgrServiceServer) GetViziersByOrg(ctx context.Context, req *uuidpb.UUID) (*GetViziersByOrgResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetViziersByOrg not implemented")
}
func (*UnimplementedVZMgrServiceServer) GetVizierInfo(ctx context.Context, req *uuidpb.UUID) (*cvmsgspb.VizierInfo, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetVizierInfo not implemented")
}
func (*UnimplementedVZMgrServiceServer) GetViziersByShard(ctx context.Context, req *GetViziersByShardRequest) (*GetViziersByShardResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetViziersByShard not implemented")
}
func (*UnimplementedVZMgrServiceServer) GetVizierConnectionInfo(ctx context.Context, req *uuidpb.UUID) (*cvmsgspb.VizierConnectionInfo, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetVizierConnectionInfo not implemented")
}
func (*UnimplementedVZMgrServiceServer) GetVizierInfos(ctx context.Context, req *GetVizierInfosRequest) (*GetVizierInfosResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetVizierInfos not implemented")
}
func (*UnimplementedVZMgrServiceServer) VizierConnected(ctx context.Context, req *cvmsgspb.RegisterVizierRequest) (*cvmsgspb.RegisterVizierAck, error) {
	return nil, status.Errorf(codes.Unimplemented, "method VizierConnected not implemented")
}
func (*UnimplementedVZMgrServiceServer) UpdateVizierConfig(ctx context.Context, req *cvmsgspb.UpdateVizierConfigRequest) (*cvmsgspb.UpdateVizierConfigResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateVizierConfig not implemented")
}
func (*UnimplementedVZMgrServiceServer) UpdateOrInstallVizier(ctx context.Context, req *cvmsgspb.UpdateOrInstallVizierRequest) (*cvmsgspb.UpdateOrInstallVizierResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateOrInstallVizier not implemented")
}
func (*UnimplementedVZMgrServiceServer) GetOrgFromVizier(ctx context.Context, req *uuidpb.UUID) (*GetOrgFromVizierResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetOrgFromVizier not implemented")
}

func RegisterVZMgrServiceServer(s *grpc.Server, srv VZMgrServiceServer) {
	s.RegisterService(&_VZMgrService_serviceDesc, srv)
}

func _VZMgrService_CreateVizierCluster_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateVizierClusterRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VZMgrServiceServer).CreateVizierCluster(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/px.services.internal.VZMgrService/CreateVizierCluster",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VZMgrServiceServer).CreateVizierCluster(ctx, req.(*CreateVizierClusterRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _VZMgrService_GetViziersByOrg_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(uuidpb.UUID)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VZMgrServiceServer).GetViziersByOrg(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/px.services.internal.VZMgrService/GetViziersByOrg",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VZMgrServiceServer).GetViziersByOrg(ctx, req.(*uuidpb.UUID))
	}
	return interceptor(ctx, in, info, handler)
}

func _VZMgrService_GetVizierInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(uuidpb.UUID)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VZMgrServiceServer).GetVizierInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/px.services.internal.VZMgrService/GetVizierInfo",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VZMgrServiceServer).GetVizierInfo(ctx, req.(*uuidpb.UUID))
	}
	return interceptor(ctx, in, info, handler)
}

func _VZMgrService_GetViziersByShard_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetViziersByShardRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VZMgrServiceServer).GetViziersByShard(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/px.services.internal.VZMgrService/GetViziersByShard",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VZMgrServiceServer).GetViziersByShard(ctx, req.(*GetViziersByShardRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _VZMgrService_GetVizierConnectionInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(uuidpb.UUID)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VZMgrServiceServer).GetVizierConnectionInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/px.services.internal.VZMgrService/GetVizierConnectionInfo",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VZMgrServiceServer).GetVizierConnectionInfo(ctx, req.(*uuidpb.UUID))
	}
	return interceptor(ctx, in, info, handler)
}

func _VZMgrService_GetVizierInfos_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetVizierInfosRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VZMgrServiceServer).GetVizierInfos(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/px.services.internal.VZMgrService/GetVizierInfos",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VZMgrServiceServer).GetVizierInfos(ctx, req.(*GetVizierInfosRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _VZMgrService_VizierConnected_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(cvmsgspb.RegisterVizierRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VZMgrServiceServer).VizierConnected(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/px.services.internal.VZMgrService/VizierConnected",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VZMgrServiceServer).VizierConnected(ctx, req.(*cvmsgspb.RegisterVizierRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _VZMgrService_UpdateVizierConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(cvmsgspb.UpdateVizierConfigRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VZMgrServiceServer).UpdateVizierConfig(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/px.services.internal.VZMgrService/UpdateVizierConfig",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VZMgrServiceServer).UpdateVizierConfig(ctx, req.(*cvmsgspb.UpdateVizierConfigRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _VZMgrService_UpdateOrInstallVizier_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(cvmsgspb.UpdateOrInstallVizierRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VZMgrServiceServer).UpdateOrInstallVizier(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/px.services.internal.VZMgrService/UpdateOrInstallVizier",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VZMgrServiceServer).UpdateOrInstallVizier(ctx, req.(*cvmsgspb.UpdateOrInstallVizierRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _VZMgrService_GetOrgFromVizier_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(uuidpb.UUID)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VZMgrServiceServer).GetOrgFromVizier(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/px.services.internal.VZMgrService/GetOrgFromVizier",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VZMgrServiceServer).GetOrgFromVizier(ctx, req.(*uuidpb.UUID))
	}
	return interceptor(ctx, in, info, handler)
}

var _VZMgrService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "px.services.internal.VZMgrService",
	HandlerType: (*VZMgrServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateVizierCluster",
			Handler:    _VZMgrService_CreateVizierCluster_Handler,
		},
		{
			MethodName: "GetViziersByOrg",
			Handler:    _VZMgrService_GetViziersByOrg_Handler,
		},
		{
			MethodName: "GetVizierInfo",
			Handler:    _VZMgrService_GetVizierInfo_Handler,
		},
		{
			MethodName: "GetViziersByShard",
			Handler:    _VZMgrService_GetViziersByShard_Handler,
		},
		{
			MethodName: "GetVizierConnectionInfo",
			Handler:    _VZMgrService_GetVizierConnectionInfo_Handler,
		},
		{
			MethodName: "GetVizierInfos",
			Handler:    _VZMgrService_GetVizierInfos_Handler,
		},
		{
			MethodName: "VizierConnected",
			Handler:    _VZMgrService_VizierConnected_Handler,
		},
		{
			MethodName: "UpdateVizierConfig",
			Handler:    _VZMgrService_UpdateVizierConfig_Handler,
		},
		{
			MethodName: "UpdateOrInstallVizier",
			Handler:    _VZMgrService_UpdateOrInstallVizier_Handler,
		},
		{
			MethodName: "GetOrgFromVizier",
			Handler:    _VZMgrService_GetOrgFromVizier_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "src/cloud/vzmgr/vzmgrpb/service.proto",
}

// VZDeploymentKeyServiceClient is the client API for VZDeploymentKeyService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type VZDeploymentKeyServiceClient interface {
	Create(ctx context.Context, in *CreateDeploymentKeyRequest, opts ...grpc.CallOption) (*DeploymentKey, error)
	List(ctx context.Context, in *ListDeploymentKeyRequest, opts ...grpc.CallOption) (*ListDeploymentKeyResponse, error)
	Get(ctx context.Context, in *GetDeploymentKeyRequest, opts ...grpc.CallOption) (*GetDeploymentKeyResponse, error)
	Delete(ctx context.Context, in *DeleteDeploymentKeyRequest, opts ...grpc.CallOption) (*types.Empty, error)
	LookupDeploymentKey(ctx context.Context, in *LookupDeploymentKeyRequest, opts ...grpc.CallOption) (*LookupDeploymentKeyResponse, error)
}

type vZDeploymentKeyServiceClient struct {
	cc *grpc.ClientConn
}

func NewVZDeploymentKeyServiceClient(cc *grpc.ClientConn) VZDeploymentKeyServiceClient {
	return &vZDeploymentKeyServiceClient{cc}
}

func (c *vZDeploymentKeyServiceClient) Create(ctx context.Context, in *CreateDeploymentKeyRequest, opts ...grpc.CallOption) (*DeploymentKey, error) {
	out := new(DeploymentKey)
	err := c.cc.Invoke(ctx, "/px.services.internal.VZDeploymentKeyService/Create", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *vZDeploymentKeyServiceClient) List(ctx context.Context, in *ListDeploymentKeyRequest, opts ...grpc.CallOption) (*ListDeploymentKeyResponse, error) {
	out := new(ListDeploymentKeyResponse)
	err := c.cc.Invoke(ctx, "/px.services.internal.VZDeploymentKeyService/List", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *vZDeploymentKeyServiceClient) Get(ctx context.Context, in *GetDeploymentKeyRequest, opts ...grpc.CallOption) (*GetDeploymentKeyResponse, error) {
	out := new(GetDeploymentKeyResponse)
	err := c.cc.Invoke(ctx, "/px.services.internal.VZDeploymentKeyService/Get", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *vZDeploymentKeyServiceClient) Delete(ctx context.Context, in *DeleteDeploymentKeyRequest, opts ...grpc.CallOption) (*types.Empty, error) {
	out := new(types.Empty)
	err := c.cc.Invoke(ctx, "/px.services.internal.VZDeploymentKeyService/Delete", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *vZDeploymentKeyServiceClient) LookupDeploymentKey(ctx context.Context, in *LookupDeploymentKeyRequest, opts ...grpc.CallOption) (*LookupDeploymentKeyResponse, error) {
	out := new(LookupDeploymentKeyResponse)
	err := c.cc.Invoke(ctx, "/px.services.internal.VZDeploymentKeyService/LookupDeploymentKey", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// VZDeploymentKeyServiceServer is the server API for VZDeploymentKeyService service.
type VZDeploymentKeyServiceServer interface {
	Create(context.Context, *CreateDeploymentKeyRequest) (*DeploymentKey, error)
	List(context.Context, *ListDeploymentKeyRequest) (*ListDeploymentKeyResponse, error)
	Get(context.Context, *GetDeploymentKeyRequest) (*GetDeploymentKeyResponse, error)
	Delete(context.Context, *DeleteDeploymentKeyRequest) (*types.Empty, error)
	LookupDeploymentKey(context.Context, *LookupDeploymentKeyRequest) (*LookupDeploymentKeyResponse, error)
}

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

func (*UnimplementedVZDeploymentKeyServiceServer) Create(ctx context.Context, req *CreateDeploymentKeyRequest) (*DeploymentKey, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Create not implemented")
}
func (*UnimplementedVZDeploymentKeyServiceServer) List(ctx context.Context, req *ListDeploymentKeyRequest) (*ListDeploymentKeyResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method List not implemented")
}
func (*UnimplementedVZDeploymentKeyServiceServer) Get(ctx context.Context, req *GetDeploymentKeyRequest) (*GetDeploymentKeyResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Get not implemented")
}
func (*UnimplementedVZDeploymentKeyServiceServer) Delete(ctx context.Context, req *DeleteDeploymentKeyRequest) (*types.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Delete not implemented")
}
func (*UnimplementedVZDeploymentKeyServiceServer) LookupDeploymentKey(ctx context.Context, req *LookupDeploymentKeyRequest) (*LookupDeploymentKeyResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method LookupDeploymentKey not implemented")
}

func RegisterVZDeploymentKeyServiceServer(s *grpc.Server, srv VZDeploymentKeyServiceServer) {
	s.RegisterService(&_VZDeploymentKeyService_serviceDesc, srv)
}

func _VZDeploymentKeyService_Create_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateDeploymentKeyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VZDeploymentKeyServiceServer).Create(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/px.services.internal.VZDeploymentKeyService/Create",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VZDeploymentKeyServiceServer).Create(ctx, req.(*CreateDeploymentKeyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _VZDeploymentKeyService_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListDeploymentKeyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VZDeploymentKeyServiceServer).List(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/px.services.internal.VZDeploymentKeyService/List",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VZDeploymentKeyServiceServer).List(ctx, req.(*ListDeploymentKeyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _VZDeploymentKeyService_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetDeploymentKeyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VZDeploymentKeyServiceServer).Get(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/px.services.internal.VZDeploymentKeyService/Get",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VZDeploymentKeyServiceServer).Get(ctx, req.(*GetDeploymentKeyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _VZDeploymentKeyService_Delete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteDeploymentKeyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VZDeploymentKeyServiceServer).Delete(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/px.services.internal.VZDeploymentKeyService/Delete",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VZDeploymentKeyServiceServer).Delete(ctx, req.(*DeleteDeploymentKeyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _VZDeploymentKeyService_LookupDeploymentKey_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LookupDeploymentKeyRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VZDeploymentKeyServiceServer).LookupDeploymentKey(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/px.services.internal.VZDeploymentKeyService/LookupDeploymentKey",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VZDeploymentKeyServiceServer).LookupDeploymentKey(ctx, req.(*LookupDeploymentKeyRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _VZDeploymentKeyService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "px.services.internal.VZDeploymentKeyService",
	HandlerType: (*VZDeploymentKeyServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Create",
			Handler:    _VZDeploymentKeyService_Create_Handler,
		},
		{
			MethodName: "List",
			Handler:    _VZDeploymentKeyService_List_Handler,
		},
		{
			MethodName: "Get",
			Handler:    _VZDeploymentKeyService_Get_Handler,
		},
		{
			MethodName: "Delete",
			Handler:    _VZDeploymentKeyService_Delete_Handler,
		},
		{
			MethodName: "LookupDeploymentKey",
			Handler:    _VZDeploymentKeyService_LookupDeploymentKey_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "src/cloud/vzmgr/vzmgrpb/service.proto",
}

// VZDeploymentServiceClient is the client API for VZDeploymentService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
type VZDeploymentServiceClient interface {
	RegisterVizierDeployment(ctx context.Context, in *RegisterVizierDeploymentRequest, opts ...grpc.CallOption) (*RegisterVizierDeploymentResponse, error)
}

type vZDeploymentServiceClient struct {
	cc *grpc.ClientConn
}

func NewVZDeploymentServiceClient(cc *grpc.ClientConn) VZDeploymentServiceClient {
	return &vZDeploymentServiceClient{cc}
}

func (c *vZDeploymentServiceClient) RegisterVizierDeployment(ctx context.Context, in *RegisterVizierDeploymentRequest, opts ...grpc.CallOption) (*RegisterVizierDeploymentResponse, error) {
	out := new(RegisterVizierDeploymentResponse)
	err := c.cc.Invoke(ctx, "/px.services.internal.VZDeploymentService/RegisterVizierDeployment", in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// VZDeploymentServiceServer is the server API for VZDeploymentService service.
type VZDeploymentServiceServer interface {
	RegisterVizierDeployment(context.Context, *RegisterVizierDeploymentRequest) (*RegisterVizierDeploymentResponse, error)
}

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

func (*UnimplementedVZDeploymentServiceServer) RegisterVizierDeployment(ctx context.Context, req *RegisterVizierDeploymentRequest) (*RegisterVizierDeploymentResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RegisterVizierDeployment not implemented")
}

func RegisterVZDeploymentServiceServer(s *grpc.Server, srv VZDeploymentServiceServer) {
	s.RegisterService(&_VZDeploymentService_serviceDesc, srv)
}

func _VZDeploymentService_RegisterVizierDeployment_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RegisterVizierDeploymentRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(VZDeploymentServiceServer).RegisterVizierDeployment(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: "/px.services.internal.VZDeploymentService/RegisterVizierDeployment",
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(VZDeploymentServiceServer).RegisterVizierDeployment(ctx, req.(*RegisterVizierDeploymentRequest))
	}
	return interceptor(ctx, in, info, handler)
}

var _VZDeploymentService_serviceDesc = grpc.ServiceDesc{
	ServiceName: "px.services.internal.VZDeploymentService",
	HandlerType: (*VZDeploymentServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "RegisterVizierDeployment",
			Handler:    _VZDeploymentService_RegisterVizierDeployment_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "src/cloud/vzmgr/vzmgrpb/service.proto",
}

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

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

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

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

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

func (m *GetViziersByShardRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.ToShardID) > 0 {
		i -= len(m.ToShardID)
		copy(dAtA[i:], m.ToShardID)
		i = encodeVarintService(dAtA, i, uint64(len(m.ToShardID)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.FromShardID) > 0 {
		i -= len(m.FromShardID)
		copy(dAtA[i:], m.FromShardID)
		i = encodeVarintService(dAtA, i, uint64(len(m.FromShardID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *GetViziersByShardResponse_VizierInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.K8sUID) > 0 {
		i -= len(m.K8sUID)
		copy(dAtA[i:], m.K8sUID)
		i = encodeVarintService(dAtA, i, uint64(len(m.K8sUID)))
		i--
		dAtA[i] = 0x22
	}
	if m.OrgID != nil {
		{
			size, err := m.OrgID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.VizierID != nil {
		{
			size, err := m.VizierID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *DeploymentKeyMetadata) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.UserID != nil {
		{
			size, err := m.UserID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if m.OrgID != nil {
		{
			size, err := m.OrgID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Desc) > 0 {
		i -= len(m.Desc)
		copy(dAtA[i:], m.Desc)
		i = encodeVarintService(dAtA, i, uint64(len(m.Desc)))
		i--
		dAtA[i] = 0x22
	}
	if m.CreatedAt != nil {
		{
			size, err := m.CreatedAt.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.ID != nil {
		{
			size, err := m.ID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *DeploymentKey) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.UserID != nil {
		{
			size, err := m.UserID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if m.OrgID != nil {
		{
			size, err := m.OrgID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Desc) > 0 {
		i -= len(m.Desc)
		copy(dAtA[i:], m.Desc)
		i = encodeVarintService(dAtA, i, uint64(len(m.Desc)))
		i--
		dAtA[i] = 0x22
	}
	if m.CreatedAt != nil {
		{
			size, err := m.CreatedAt.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Key) > 0 {
		i -= len(m.Key)
		copy(dAtA[i:], m.Key)
		i = encodeVarintService(dAtA, i, uint64(len(m.Key)))
		i--
		dAtA[i] = 0x12
	}
	if m.ID != nil {
		{
			size, err := m.ID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *CreateDeploymentKeyRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.UserID != nil {
		{
			size, err := m.UserID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.OrgID != nil {
		{
			size, err := m.OrgID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if len(m.Desc) > 0 {
		i -= len(m.Desc)
		copy(dAtA[i:], m.Desc)
		i = encodeVarintService(dAtA, i, uint64(len(m.Desc)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *GetDeploymentKeyRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.OrgID != nil {
		{
			size, err := m.OrgID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.ID != nil {
		{
			size, err := m.ID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

func (m *DeleteDeploymentKeyRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.OrgID != nil {
		{
			size, err := m.OrgID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.ID != nil {
		{
			size, err := m.ID.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintService(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

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

func (m *RegisterVizierDeploymentRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.K8sClusterName) > 0 {
		i -= len(m.K8sClusterName)
		copy(dAtA[i:], m.K8sClusterName)
		i = encodeVarintService(dAtA, i, uint64(len(m.K8sClusterName)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.DeploymentKey) > 0 {
		i -= len(m.DeploymentKey)
		copy(dAtA[i:], m.DeploymentKey)
		i = encodeVarintService(dAtA, i, uint64(len(m.DeploymentKey)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.K8sClusterUID) > 0 {
		i -= len(m.K8sClusterUID)
		copy(dAtA[i:], m.K8sClusterUID)
		i = encodeVarintService(dAtA, i, uint64(len(m.K8sClusterUID)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

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

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

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

func encodeVarintService(dAtA []byte, offset int, v uint64) int {
	offset -= sovService(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *CreateVizierClusterRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.OrgID != nil {
		l = m.OrgID.Size()
		n += 1 + l + sovService(uint64(l))
	}
	l = len(m.ProjectName)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	return n
}

func (m *GetViziersByOrgResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.VizierIDs) > 0 {
		for _, e := range m.VizierIDs {
			l = e.Size()
			n += 1 + l + sovService(uint64(l))
		}
	}
	return n
}

func (m *GetViziersByShardRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.FromShardID)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	l = len(m.ToShardID)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	return n
}

func (m *GetViziersByShardResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Viziers) > 0 {
		for _, e := range m.Viziers {
			l = e.Size()
			n += 1 + l + sovService(uint64(l))
		}
	}
	return n
}

func (m *GetViziersByShardResponse_VizierInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.VizierID != nil {
		l = m.VizierID.Size()
		n += 1 + l + sovService(uint64(l))
	}
	if m.OrgID != nil {
		l = m.OrgID.Size()
		n += 1 + l + sovService(uint64(l))
	}
	l = len(m.K8sUID)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	return n
}

func (m *GetVizierInfosRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.VizierIDs) > 0 {
		for _, e := range m.VizierIDs {
			l = e.Size()
			n += 1 + l + sovService(uint64(l))
		}
	}
	return n
}

func (m *GetVizierInfosResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.VizierInfos) > 0 {
		for _, e := range m.VizierInfos {
			l = e.Size()
			n += 1 + l + sovService(uint64(l))
		}
	}
	return n
}

func (m *DeploymentKeyMetadata) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ID != nil {
		l = m.ID.Size()
		n += 1 + l + sovService(uint64(l))
	}
	if m.CreatedAt != nil {
		l = m.CreatedAt.Size()
		n += 1 + l + sovService(uint64(l))
	}
	l = len(m.Desc)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	if m.OrgID != nil {
		l = m.OrgID.Size()
		n += 1 + l + sovService(uint64(l))
	}
	if m.UserID != nil {
		l = m.UserID.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}

func (m *DeploymentKey) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ID != nil {
		l = m.ID.Size()
		n += 1 + l + sovService(uint64(l))
	}
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	if m.CreatedAt != nil {
		l = m.CreatedAt.Size()
		n += 1 + l + sovService(uint64(l))
	}
	l = len(m.Desc)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	if m.OrgID != nil {
		l = m.OrgID.Size()
		n += 1 + l + sovService(uint64(l))
	}
	if m.UserID != nil {
		l = m.UserID.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}

func (m *CreateDeploymentKeyRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Desc)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	if m.OrgID != nil {
		l = m.OrgID.Size()
		n += 1 + l + sovService(uint64(l))
	}
	if m.UserID != nil {
		l = m.UserID.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}

func (m *ListDeploymentKeyRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.OrgID != nil {
		l = m.OrgID.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}

func (m *ListDeploymentKeyResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Keys) > 0 {
		for _, e := range m.Keys {
			l = e.Size()
			n += 1 + l + sovService(uint64(l))
		}
	}
	return n
}

func (m *GetDeploymentKeyRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ID != nil {
		l = m.ID.Size()
		n += 1 + l + sovService(uint64(l))
	}
	if m.OrgID != nil {
		l = m.OrgID.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}

func (m *GetDeploymentKeyResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Key != nil {
		l = m.Key.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}

func (m *DeleteDeploymentKeyRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.ID != nil {
		l = m.ID.Size()
		n += 1 + l + sovService(uint64(l))
	}
	if m.OrgID != nil {
		l = m.OrgID.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}

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

func (m *LookupDeploymentKeyResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Key != nil {
		l = m.Key.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}

func (m *RegisterVizierDeploymentRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.K8sClusterUID)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	l = len(m.DeploymentKey)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	l = len(m.K8sClusterName)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	return n
}

func (m *RegisterVizierDeploymentResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.VizierID != nil {
		l = m.VizierID.Size()
		n += 1 + l + sovService(uint64(l))
	}
	l = len(m.VizierName)
	if l > 0 {
		n += 1 + l + sovService(uint64(l))
	}
	return n
}

func (m *GetOrgFromVizierResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.OrgID != nil {
		l = m.OrgID.Size()
		n += 1 + l + sovService(uint64(l))
	}
	return n
}

func sovService(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozService(x uint64) (n int) {
	return sovService(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *CreateVizierClusterRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&CreateVizierClusterRequest{`,
		`OrgID:` + strings.Replace(fmt.Sprintf("%v", this.OrgID), "UUID", "uuidpb.UUID", 1) + `,`,
		`ProjectName:` + fmt.Sprintf("%v", this.ProjectName) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GetViziersByOrgResponse) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForVizierIDs := "[]*UUID{"
	for _, f := range this.VizierIDs {
		repeatedStringForVizierIDs += strings.Replace(fmt.Sprintf("%v", f), "UUID", "uuidpb.UUID", 1) + ","
	}
	repeatedStringForVizierIDs += "}"
	s := strings.Join([]string{`&GetViziersByOrgResponse{`,
		`VizierIDs:` + repeatedStringForVizierIDs + `,`,
		`}`,
	}, "")
	return s
}
func (this *GetViziersByShardRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GetViziersByShardRequest{`,
		`FromShardID:` + fmt.Sprintf("%v", this.FromShardID) + `,`,
		`ToShardID:` + fmt.Sprintf("%v", this.ToShardID) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GetViziersByShardResponse) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForViziers := "[]*GetViziersByShardResponse_VizierInfo{"
	for _, f := range this.Viziers {
		repeatedStringForViziers += strings.Replace(fmt.Sprintf("%v", f), "GetViziersByShardResponse_VizierInfo", "GetViziersByShardResponse_VizierInfo", 1) + ","
	}
	repeatedStringForViziers += "}"
	s := strings.Join([]string{`&GetViziersByShardResponse{`,
		`Viziers:` + repeatedStringForViziers + `,`,
		`}`,
	}, "")
	return s
}
func (this *GetViziersByShardResponse_VizierInfo) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GetViziersByShardResponse_VizierInfo{`,
		`VizierID:` + strings.Replace(fmt.Sprintf("%v", this.VizierID), "UUID", "uuidpb.UUID", 1) + `,`,
		`OrgID:` + strings.Replace(fmt.Sprintf("%v", this.OrgID), "UUID", "uuidpb.UUID", 1) + `,`,
		`K8sUID:` + fmt.Sprintf("%v", this.K8sUID) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GetVizierInfosRequest) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForVizierIDs := "[]*UUID{"
	for _, f := range this.VizierIDs {
		repeatedStringForVizierIDs += strings.Replace(fmt.Sprintf("%v", f), "UUID", "uuidpb.UUID", 1) + ","
	}
	repeatedStringForVizierIDs += "}"
	s := strings.Join([]string{`&GetVizierInfosRequest{`,
		`VizierIDs:` + repeatedStringForVizierIDs + `,`,
		`}`,
	}, "")
	return s
}
func (this *GetVizierInfosResponse) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForVizierInfos := "[]*VizierInfo{"
	for _, f := range this.VizierInfos {
		repeatedStringForVizierInfos += strings.Replace(fmt.Sprintf("%v", f), "VizierInfo", "cvmsgspb.VizierInfo", 1) + ","
	}
	repeatedStringForVizierInfos += "}"
	s := strings.Join([]string{`&GetVizierInfosResponse{`,
		`VizierInfos:` + repeatedStringForVizierInfos + `,`,
		`}`,
	}, "")
	return s
}
func (this *DeploymentKeyMetadata) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DeploymentKeyMetadata{`,
		`ID:` + strings.Replace(fmt.Sprintf("%v", this.ID), "UUID", "uuidpb.UUID", 1) + `,`,
		`CreatedAt:` + strings.Replace(fmt.Sprintf("%v", this.CreatedAt), "Timestamp", "types.Timestamp", 1) + `,`,
		`Desc:` + fmt.Sprintf("%v", this.Desc) + `,`,
		`OrgID:` + strings.Replace(fmt.Sprintf("%v", this.OrgID), "UUID", "uuidpb.UUID", 1) + `,`,
		`UserID:` + strings.Replace(fmt.Sprintf("%v", this.UserID), "UUID", "uuidpb.UUID", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DeploymentKey) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DeploymentKey{`,
		`ID:` + strings.Replace(fmt.Sprintf("%v", this.ID), "UUID", "uuidpb.UUID", 1) + `,`,
		`Key:` + fmt.Sprintf("%v", this.Key) + `,`,
		`CreatedAt:` + strings.Replace(fmt.Sprintf("%v", this.CreatedAt), "Timestamp", "types.Timestamp", 1) + `,`,
		`Desc:` + fmt.Sprintf("%v", this.Desc) + `,`,
		`OrgID:` + strings.Replace(fmt.Sprintf("%v", this.OrgID), "UUID", "uuidpb.UUID", 1) + `,`,
		`UserID:` + strings.Replace(fmt.Sprintf("%v", this.UserID), "UUID", "uuidpb.UUID", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *CreateDeploymentKeyRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&CreateDeploymentKeyRequest{`,
		`Desc:` + fmt.Sprintf("%v", this.Desc) + `,`,
		`OrgID:` + strings.Replace(fmt.Sprintf("%v", this.OrgID), "UUID", "uuidpb.UUID", 1) + `,`,
		`UserID:` + strings.Replace(fmt.Sprintf("%v", this.UserID), "UUID", "uuidpb.UUID", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ListDeploymentKeyRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ListDeploymentKeyRequest{`,
		`OrgID:` + strings.Replace(fmt.Sprintf("%v", this.OrgID), "UUID", "uuidpb.UUID", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ListDeploymentKeyResponse) String() string {
	if this == nil {
		return "nil"
	}
	repeatedStringForKeys := "[]*DeploymentKeyMetadata{"
	for _, f := range this.Keys {
		repeatedStringForKeys += strings.Replace(f.String(), "DeploymentKeyMetadata", "DeploymentKeyMetadata", 1) + ","
	}
	repeatedStringForKeys += "}"
	s := strings.Join([]string{`&ListDeploymentKeyResponse{`,
		`Keys:` + repeatedStringForKeys + `,`,
		`}`,
	}, "")
	return s
}
func (this *GetDeploymentKeyRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GetDeploymentKeyRequest{`,
		`ID:` + strings.Replace(fmt.Sprintf("%v", this.ID), "UUID", "uuidpb.UUID", 1) + `,`,
		`OrgID:` + strings.Replace(fmt.Sprintf("%v", this.OrgID), "UUID", "uuidpb.UUID", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GetDeploymentKeyResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GetDeploymentKeyResponse{`,
		`Key:` + strings.Replace(this.Key.String(), "DeploymentKey", "DeploymentKey", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *DeleteDeploymentKeyRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&DeleteDeploymentKeyRequest{`,
		`ID:` + strings.Replace(fmt.Sprintf("%v", this.ID), "UUID", "uuidpb.UUID", 1) + `,`,
		`OrgID:` + strings.Replace(fmt.Sprintf("%v", this.OrgID), "UUID", "uuidpb.UUID", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *LookupDeploymentKeyRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&LookupDeploymentKeyRequest{`,
		`Key:` + fmt.Sprintf("%v", this.Key) + `,`,
		`}`,
	}, "")
	return s
}
func (this *LookupDeploymentKeyResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&LookupDeploymentKeyResponse{`,
		`Key:` + strings.Replace(this.Key.String(), "DeploymentKey", "DeploymentKey", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *RegisterVizierDeploymentRequest) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&RegisterVizierDeploymentRequest{`,
		`K8sClusterUID:` + fmt.Sprintf("%v", this.K8sClusterUID) + `,`,
		`DeploymentKey:` + fmt.Sprintf("%v", this.DeploymentKey) + `,`,
		`K8sClusterName:` + fmt.Sprintf("%v", this.K8sClusterName) + `,`,
		`}`,
	}, "")
	return s
}
func (this *RegisterVizierDeploymentResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&RegisterVizierDeploymentResponse{`,
		`VizierID:` + strings.Replace(fmt.Sprintf("%v", this.VizierID), "UUID", "uuidpb.UUID", 1) + `,`,
		`VizierName:` + fmt.Sprintf("%v", this.VizierName) + `,`,
		`}`,
	}, "")
	return s
}
func (this *GetOrgFromVizierResponse) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&GetOrgFromVizierResponse{`,
		`OrgID:` + strings.Replace(fmt.Sprintf("%v", this.OrgID), "UUID", "uuidpb.UUID", 1) + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringService(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *CreateVizierClusterRequest) 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 ErrIntOverflowService
			}
			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: CreateVizierClusterRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CreateVizierClusterRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrgID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.OrgID == nil {
				m.OrgID = &uuidpb.UUID{}
			}
			if err := m.OrgID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProjectName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				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 ErrInvalidLengthService
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ProjectName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *GetViziersByShardResponse_VizierInfo) 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 ErrIntOverflowService
			}
			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: VizierInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: VizierInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field VizierID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.VizierID == nil {
				m.VizierID = &uuidpb.UUID{}
			}
			if err := m.VizierID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrgID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.OrgID == nil {
				m.OrgID = &uuidpb.UUID{}
			}
			if err := m.OrgID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field K8sUID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				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 ErrInvalidLengthService
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.K8sUID = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DeploymentKeyMetadata) 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 ErrIntOverflowService
			}
			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: DeploymentKeyMetadata: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DeploymentKeyMetadata: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ID == nil {
				m.ID = &uuidpb.UUID{}
			}
			if err := m.ID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreatedAt", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.CreatedAt == nil {
				m.CreatedAt = &types.Timestamp{}
			}
			if err := m.CreatedAt.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Desc", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				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 ErrInvalidLengthService
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Desc = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrgID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.OrgID == nil {
				m.OrgID = &uuidpb.UUID{}
			}
			if err := m.OrgID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UserID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.UserID == nil {
				m.UserID = &uuidpb.UUID{}
			}
			if err := m.UserID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *DeploymentKey) 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 ErrIntOverflowService
			}
			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: DeploymentKey: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: DeploymentKey: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ID == nil {
				m.ID = &uuidpb.UUID{}
			}
			if err := m.ID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				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 ErrInvalidLengthService
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Key = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CreatedAt", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.CreatedAt == nil {
				m.CreatedAt = &types.Timestamp{}
			}
			if err := m.CreatedAt.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Desc", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				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 ErrInvalidLengthService
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Desc = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field OrgID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.OrgID == nil {
				m.OrgID = &uuidpb.UUID{}
			}
			if err := m.OrgID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field UserID", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowService
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthService
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthService
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.UserID == nil {
				m.UserID = &uuidpb.UUID{}
			}
			if err := m.UserID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipService(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthService
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

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

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

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

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

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

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

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

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

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

var (
	ErrInvalidLengthService        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowService          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupService = fmt.Errorf("proto: unexpected end of group")
)