// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.4.0
// - protoc             (unknown)
// source: tidb_mgmt_service/v1/spu.proto

package tidb_mgmt_servicev1

import (
	context "context"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
	emptypb "google.golang.org/protobuf/types/known/emptypb"
)

// This is a compile-time assertion to ensure that this generated file
// is compatible with the grpc package it is being compiled against.
// Requires gRPC-Go v1.62.0 or later.
const _ = grpc.SupportPackageIsVersion8

const (
	SpuService_CreateComputeMu_FullMethodName = "/tidb_mgmt_service.v1.SpuService/CreateComputeMu"
	SpuService_DeleteComputeMu_FullMethodName = "/tidb_mgmt_service.v1.SpuService/DeleteComputeMu"
	SpuService_GetComputeMu_FullMethodName    = "/tidb_mgmt_service.v1.SpuService/GetComputeMu"
	SpuService_ListComputeMus_FullMethodName  = "/tidb_mgmt_service.v1.SpuService/ListComputeMus"
	SpuService_CreateStorageMu_FullMethodName = "/tidb_mgmt_service.v1.SpuService/CreateStorageMu"
	SpuService_DeleteStorageMu_FullMethodName = "/tidb_mgmt_service.v1.SpuService/DeleteStorageMu"
	SpuService_GetStorageMu_FullMethodName    = "/tidb_mgmt_service.v1.SpuService/GetStorageMu"
	SpuService_ListStorageMus_FullMethodName  = "/tidb_mgmt_service.v1.SpuService/ListStorageMus"
	SpuService_CreateSku_FullMethodName       = "/tidb_mgmt_service.v1.SpuService/CreateSku"
	SpuService_UpdateSku_FullMethodName       = "/tidb_mgmt_service.v1.SpuService/UpdateSku"
	SpuService_DeleteSku_FullMethodName       = "/tidb_mgmt_service.v1.SpuService/DeleteSku"
	SpuService_GetSku_FullMethodName          = "/tidb_mgmt_service.v1.SpuService/GetSku"
	SpuService_ListSkus_FullMethodName        = "/tidb_mgmt_service.v1.SpuService/ListSkus"
	SpuService_CreateSpu_FullMethodName       = "/tidb_mgmt_service.v1.SpuService/CreateSpu"
	SpuService_UpdateSpu_FullMethodName       = "/tidb_mgmt_service.v1.SpuService/UpdateSpu"
	SpuService_DeleteSpu_FullMethodName       = "/tidb_mgmt_service.v1.SpuService/DeleteSpu"
	SpuService_GetSpu_FullMethodName          = "/tidb_mgmt_service.v1.SpuService/GetSpu"
	SpuService_ListSpus_FullMethodName        = "/tidb_mgmt_service.v1.SpuService/ListSpus"
)

// SpuServiceClient is the client API for SpuService service.
//
// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://pkg.go.dev/google.golang.org/grpc/?tab=doc#ClientConn.NewStream.
type SpuServiceClient interface {
	CreateComputeMu(ctx context.Context, in *CreateComputeMuRequest, opts ...grpc.CallOption) (*ComputeMu, error)
	DeleteComputeMu(ctx context.Context, in *DeleteComputeMuRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	GetComputeMu(ctx context.Context, in *GetComputeMuRequest, opts ...grpc.CallOption) (*ComputeMu, error)
	ListComputeMus(ctx context.Context, in *ListComputeMusRequest, opts ...grpc.CallOption) (*ListComputeMusResponse, error)
	CreateStorageMu(ctx context.Context, in *CreateStorageMuRequest, opts ...grpc.CallOption) (*StorageMu, error)
	DeleteStorageMu(ctx context.Context, in *DeleteStorageMuRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	GetStorageMu(ctx context.Context, in *GetStorageMuRequest, opts ...grpc.CallOption) (*StorageMu, error)
	ListStorageMus(ctx context.Context, in *ListStorageMusRequest, opts ...grpc.CallOption) (*ListStorageMusResponse, error)
	CreateSku(ctx context.Context, in *CreateSkuRequest, opts ...grpc.CallOption) (*Sku, error)
	UpdateSku(ctx context.Context, in *UpdateSkuRequest, opts ...grpc.CallOption) (*Sku, error)
	DeleteSku(ctx context.Context, in *DeleteSkuRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	GetSku(ctx context.Context, in *GetSkuRequest, opts ...grpc.CallOption) (*Sku, error)
	ListSkus(ctx context.Context, in *ListSkusRequest, opts ...grpc.CallOption) (*ListSkusResponse, error)
	CreateSpu(ctx context.Context, in *CreateSpuRequest, opts ...grpc.CallOption) (*Spu, error)
	UpdateSpu(ctx context.Context, in *UpdateSpuRequest, opts ...grpc.CallOption) (*Spu, error)
	DeleteSpu(ctx context.Context, in *DeleteSpuRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	GetSpu(ctx context.Context, in *GetSpuRequest, opts ...grpc.CallOption) (*Spu, error)
	ListSpus(ctx context.Context, in *ListSpusRequest, opts ...grpc.CallOption) (*ListSpusResponse, error)
}

type spuServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewSpuServiceClient(cc grpc.ClientConnInterface) SpuServiceClient {
	return &spuServiceClient{cc}
}

func (c *spuServiceClient) CreateComputeMu(ctx context.Context, in *CreateComputeMuRequest, opts ...grpc.CallOption) (*ComputeMu, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ComputeMu)
	err := c.cc.Invoke(ctx, SpuService_CreateComputeMu_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *spuServiceClient) DeleteComputeMu(ctx context.Context, in *DeleteComputeMuRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, SpuService_DeleteComputeMu_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *spuServiceClient) GetComputeMu(ctx context.Context, in *GetComputeMuRequest, opts ...grpc.CallOption) (*ComputeMu, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ComputeMu)
	err := c.cc.Invoke(ctx, SpuService_GetComputeMu_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *spuServiceClient) ListComputeMus(ctx context.Context, in *ListComputeMusRequest, opts ...grpc.CallOption) (*ListComputeMusResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListComputeMusResponse)
	err := c.cc.Invoke(ctx, SpuService_ListComputeMus_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *spuServiceClient) CreateStorageMu(ctx context.Context, in *CreateStorageMuRequest, opts ...grpc.CallOption) (*StorageMu, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(StorageMu)
	err := c.cc.Invoke(ctx, SpuService_CreateStorageMu_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *spuServiceClient) DeleteStorageMu(ctx context.Context, in *DeleteStorageMuRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, SpuService_DeleteStorageMu_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *spuServiceClient) GetStorageMu(ctx context.Context, in *GetStorageMuRequest, opts ...grpc.CallOption) (*StorageMu, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(StorageMu)
	err := c.cc.Invoke(ctx, SpuService_GetStorageMu_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *spuServiceClient) ListStorageMus(ctx context.Context, in *ListStorageMusRequest, opts ...grpc.CallOption) (*ListStorageMusResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListStorageMusResponse)
	err := c.cc.Invoke(ctx, SpuService_ListStorageMus_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *spuServiceClient) CreateSku(ctx context.Context, in *CreateSkuRequest, opts ...grpc.CallOption) (*Sku, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Sku)
	err := c.cc.Invoke(ctx, SpuService_CreateSku_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *spuServiceClient) UpdateSku(ctx context.Context, in *UpdateSkuRequest, opts ...grpc.CallOption) (*Sku, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Sku)
	err := c.cc.Invoke(ctx, SpuService_UpdateSku_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *spuServiceClient) DeleteSku(ctx context.Context, in *DeleteSkuRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, SpuService_DeleteSku_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *spuServiceClient) GetSku(ctx context.Context, in *GetSkuRequest, opts ...grpc.CallOption) (*Sku, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Sku)
	err := c.cc.Invoke(ctx, SpuService_GetSku_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *spuServiceClient) ListSkus(ctx context.Context, in *ListSkusRequest, opts ...grpc.CallOption) (*ListSkusResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListSkusResponse)
	err := c.cc.Invoke(ctx, SpuService_ListSkus_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *spuServiceClient) CreateSpu(ctx context.Context, in *CreateSpuRequest, opts ...grpc.CallOption) (*Spu, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Spu)
	err := c.cc.Invoke(ctx, SpuService_CreateSpu_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *spuServiceClient) UpdateSpu(ctx context.Context, in *UpdateSpuRequest, opts ...grpc.CallOption) (*Spu, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Spu)
	err := c.cc.Invoke(ctx, SpuService_UpdateSpu_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *spuServiceClient) DeleteSpu(ctx context.Context, in *DeleteSpuRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, SpuService_DeleteSpu_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *spuServiceClient) GetSpu(ctx context.Context, in *GetSpuRequest, opts ...grpc.CallOption) (*Spu, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Spu)
	err := c.cc.Invoke(ctx, SpuService_GetSpu_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *spuServiceClient) ListSpus(ctx context.Context, in *ListSpusRequest, opts ...grpc.CallOption) (*ListSpusResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListSpusResponse)
	err := c.cc.Invoke(ctx, SpuService_ListSpus_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// SpuServiceServer is the server API for SpuService service.
// All implementations should embed UnimplementedSpuServiceServer
// for forward compatibility
type SpuServiceServer interface {
	CreateComputeMu(context.Context, *CreateComputeMuRequest) (*ComputeMu, error)
	DeleteComputeMu(context.Context, *DeleteComputeMuRequest) (*emptypb.Empty, error)
	GetComputeMu(context.Context, *GetComputeMuRequest) (*ComputeMu, error)
	ListComputeMus(context.Context, *ListComputeMusRequest) (*ListComputeMusResponse, error)
	CreateStorageMu(context.Context, *CreateStorageMuRequest) (*StorageMu, error)
	DeleteStorageMu(context.Context, *DeleteStorageMuRequest) (*emptypb.Empty, error)
	GetStorageMu(context.Context, *GetStorageMuRequest) (*StorageMu, error)
	ListStorageMus(context.Context, *ListStorageMusRequest) (*ListStorageMusResponse, error)
	CreateSku(context.Context, *CreateSkuRequest) (*Sku, error)
	UpdateSku(context.Context, *UpdateSkuRequest) (*Sku, error)
	DeleteSku(context.Context, *DeleteSkuRequest) (*emptypb.Empty, error)
	GetSku(context.Context, *GetSkuRequest) (*Sku, error)
	ListSkus(context.Context, *ListSkusRequest) (*ListSkusResponse, error)
	CreateSpu(context.Context, *CreateSpuRequest) (*Spu, error)
	UpdateSpu(context.Context, *UpdateSpuRequest) (*Spu, error)
	DeleteSpu(context.Context, *DeleteSpuRequest) (*emptypb.Empty, error)
	GetSpu(context.Context, *GetSpuRequest) (*Spu, error)
	ListSpus(context.Context, *ListSpusRequest) (*ListSpusResponse, error)
}

// UnimplementedSpuServiceServer should be embedded to have forward compatible implementations.
type UnimplementedSpuServiceServer struct {
}

func (UnimplementedSpuServiceServer) CreateComputeMu(context.Context, *CreateComputeMuRequest) (*ComputeMu, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateComputeMu not implemented")
}
func (UnimplementedSpuServiceServer) DeleteComputeMu(context.Context, *DeleteComputeMuRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteComputeMu not implemented")
}
func (UnimplementedSpuServiceServer) GetComputeMu(context.Context, *GetComputeMuRequest) (*ComputeMu, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetComputeMu not implemented")
}
func (UnimplementedSpuServiceServer) ListComputeMus(context.Context, *ListComputeMusRequest) (*ListComputeMusResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListComputeMus not implemented")
}
func (UnimplementedSpuServiceServer) CreateStorageMu(context.Context, *CreateStorageMuRequest) (*StorageMu, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateStorageMu not implemented")
}
func (UnimplementedSpuServiceServer) DeleteStorageMu(context.Context, *DeleteStorageMuRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteStorageMu not implemented")
}
func (UnimplementedSpuServiceServer) GetStorageMu(context.Context, *GetStorageMuRequest) (*StorageMu, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetStorageMu not implemented")
}
func (UnimplementedSpuServiceServer) ListStorageMus(context.Context, *ListStorageMusRequest) (*ListStorageMusResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListStorageMus not implemented")
}
func (UnimplementedSpuServiceServer) CreateSku(context.Context, *CreateSkuRequest) (*Sku, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateSku not implemented")
}
func (UnimplementedSpuServiceServer) UpdateSku(context.Context, *UpdateSkuRequest) (*Sku, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateSku not implemented")
}
func (UnimplementedSpuServiceServer) DeleteSku(context.Context, *DeleteSkuRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteSku not implemented")
}
func (UnimplementedSpuServiceServer) GetSku(context.Context, *GetSkuRequest) (*Sku, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetSku not implemented")
}
func (UnimplementedSpuServiceServer) ListSkus(context.Context, *ListSkusRequest) (*ListSkusResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListSkus not implemented")
}
func (UnimplementedSpuServiceServer) CreateSpu(context.Context, *CreateSpuRequest) (*Spu, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateSpu not implemented")
}
func (UnimplementedSpuServiceServer) UpdateSpu(context.Context, *UpdateSpuRequest) (*Spu, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateSpu not implemented")
}
func (UnimplementedSpuServiceServer) DeleteSpu(context.Context, *DeleteSpuRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteSpu not implemented")
}
func (UnimplementedSpuServiceServer) GetSpu(context.Context, *GetSpuRequest) (*Spu, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetSpu not implemented")
}
func (UnimplementedSpuServiceServer) ListSpus(context.Context, *ListSpusRequest) (*ListSpusResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListSpus not implemented")
}

// UnsafeSpuServiceServer may be embedded to opt out of forward compatibility for this service.
// Use of this interface is not recommended, as added methods to SpuServiceServer will
// result in compilation errors.
type UnsafeSpuServiceServer interface {
	mustEmbedUnimplementedSpuServiceServer()
}

func RegisterSpuServiceServer(s grpc.ServiceRegistrar, srv SpuServiceServer) {
	s.RegisterService(&SpuService_ServiceDesc, srv)
}

func _SpuService_CreateComputeMu_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateComputeMuRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SpuServiceServer).CreateComputeMu(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SpuService_CreateComputeMu_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SpuServiceServer).CreateComputeMu(ctx, req.(*CreateComputeMuRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SpuService_DeleteComputeMu_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteComputeMuRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SpuServiceServer).DeleteComputeMu(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SpuService_DeleteComputeMu_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SpuServiceServer).DeleteComputeMu(ctx, req.(*DeleteComputeMuRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SpuService_GetComputeMu_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetComputeMuRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SpuServiceServer).GetComputeMu(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SpuService_GetComputeMu_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SpuServiceServer).GetComputeMu(ctx, req.(*GetComputeMuRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SpuService_ListComputeMus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListComputeMusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SpuServiceServer).ListComputeMus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SpuService_ListComputeMus_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SpuServiceServer).ListComputeMus(ctx, req.(*ListComputeMusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SpuService_CreateStorageMu_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateStorageMuRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SpuServiceServer).CreateStorageMu(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SpuService_CreateStorageMu_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SpuServiceServer).CreateStorageMu(ctx, req.(*CreateStorageMuRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SpuService_DeleteStorageMu_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteStorageMuRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SpuServiceServer).DeleteStorageMu(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SpuService_DeleteStorageMu_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SpuServiceServer).DeleteStorageMu(ctx, req.(*DeleteStorageMuRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SpuService_GetStorageMu_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetStorageMuRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SpuServiceServer).GetStorageMu(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SpuService_GetStorageMu_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SpuServiceServer).GetStorageMu(ctx, req.(*GetStorageMuRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SpuService_ListStorageMus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListStorageMusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SpuServiceServer).ListStorageMus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SpuService_ListStorageMus_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SpuServiceServer).ListStorageMus(ctx, req.(*ListStorageMusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SpuService_CreateSku_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateSkuRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SpuServiceServer).CreateSku(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SpuService_CreateSku_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SpuServiceServer).CreateSku(ctx, req.(*CreateSkuRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SpuService_UpdateSku_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateSkuRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SpuServiceServer).UpdateSku(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SpuService_UpdateSku_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SpuServiceServer).UpdateSku(ctx, req.(*UpdateSkuRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SpuService_DeleteSku_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteSkuRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SpuServiceServer).DeleteSku(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SpuService_DeleteSku_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SpuServiceServer).DeleteSku(ctx, req.(*DeleteSkuRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SpuService_GetSku_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetSkuRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SpuServiceServer).GetSku(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SpuService_GetSku_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SpuServiceServer).GetSku(ctx, req.(*GetSkuRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SpuService_ListSkus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListSkusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SpuServiceServer).ListSkus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SpuService_ListSkus_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SpuServiceServer).ListSkus(ctx, req.(*ListSkusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SpuService_CreateSpu_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateSpuRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SpuServiceServer).CreateSpu(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SpuService_CreateSpu_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SpuServiceServer).CreateSpu(ctx, req.(*CreateSpuRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SpuService_UpdateSpu_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateSpuRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SpuServiceServer).UpdateSpu(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SpuService_UpdateSpu_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SpuServiceServer).UpdateSpu(ctx, req.(*UpdateSpuRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SpuService_DeleteSpu_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteSpuRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SpuServiceServer).DeleteSpu(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SpuService_DeleteSpu_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SpuServiceServer).DeleteSpu(ctx, req.(*DeleteSpuRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SpuService_GetSpu_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetSpuRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SpuServiceServer).GetSpu(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SpuService_GetSpu_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SpuServiceServer).GetSpu(ctx, req.(*GetSpuRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SpuService_ListSpus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListSpusRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SpuServiceServer).ListSpus(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SpuService_ListSpus_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SpuServiceServer).ListSpus(ctx, req.(*ListSpusRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// SpuService_ServiceDesc is the grpc.ServiceDesc for SpuService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var SpuService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "tidb_mgmt_service.v1.SpuService",
	HandlerType: (*SpuServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateComputeMu",
			Handler:    _SpuService_CreateComputeMu_Handler,
		},
		{
			MethodName: "DeleteComputeMu",
			Handler:    _SpuService_DeleteComputeMu_Handler,
		},
		{
			MethodName: "GetComputeMu",
			Handler:    _SpuService_GetComputeMu_Handler,
		},
		{
			MethodName: "ListComputeMus",
			Handler:    _SpuService_ListComputeMus_Handler,
		},
		{
			MethodName: "CreateStorageMu",
			Handler:    _SpuService_CreateStorageMu_Handler,
		},
		{
			MethodName: "DeleteStorageMu",
			Handler:    _SpuService_DeleteStorageMu_Handler,
		},
		{
			MethodName: "GetStorageMu",
			Handler:    _SpuService_GetStorageMu_Handler,
		},
		{
			MethodName: "ListStorageMus",
			Handler:    _SpuService_ListStorageMus_Handler,
		},
		{
			MethodName: "CreateSku",
			Handler:    _SpuService_CreateSku_Handler,
		},
		{
			MethodName: "UpdateSku",
			Handler:    _SpuService_UpdateSku_Handler,
		},
		{
			MethodName: "DeleteSku",
			Handler:    _SpuService_DeleteSku_Handler,
		},
		{
			MethodName: "GetSku",
			Handler:    _SpuService_GetSku_Handler,
		},
		{
			MethodName: "ListSkus",
			Handler:    _SpuService_ListSkus_Handler,
		},
		{
			MethodName: "CreateSpu",
			Handler:    _SpuService_CreateSpu_Handler,
		},
		{
			MethodName: "UpdateSpu",
			Handler:    _SpuService_UpdateSpu_Handler,
		},
		{
			MethodName: "DeleteSpu",
			Handler:    _SpuService_DeleteSpu_Handler,
		},
		{
			MethodName: "GetSpu",
			Handler:    _SpuService_GetSpu_Handler,
		},
		{
			MethodName: "ListSpus",
			Handler:    _SpuService_ListSpus_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "tidb_mgmt_service/v1/spu.proto",
}