// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.3.0
// - protoc             v3.21.12
// source: api/management/v1/management.proto

package v1

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.32.0 or later.
const _ = grpc.SupportPackageIsVersion7

const (
	Management_BaseInformation_FullMethodName     = "/api.management.v1.Management/BaseInformation"
	Management_Testplan_FullMethodName            = "/api.management.v1.Management/Testplan"
	Management_CreateProject_FullMethodName       = "/api.management.v1.Management/CreateProject"
	Management_UpdateProject_FullMethodName       = "/api.management.v1.Management/UpdateProject"
	Management_DeleteProject_FullMethodName       = "/api.management.v1.Management/DeleteProject"
	Management_GetProject_FullMethodName          = "/api.management.v1.Management/GetProject"
	Management_ListProject_FullMethodName         = "/api.management.v1.Management/ListProject"
	Management_GetUserProjectList_FullMethodName  = "/api.management.v1.Management/GetUserProjectList"
	Management_CreateTestcase_FullMethodName      = "/api.management.v1.Management/CreateTestcase"
	Management_GenerateTestcase_FullMethodName    = "/api.management.v1.Management/GenerateTestcase"
	Management_UpdateTestcase_FullMethodName      = "/api.management.v1.Management/UpdateTestcase"
	Management_DeleteTestcase_FullMethodName      = "/api.management.v1.Management/DeleteTestcase"
	Management_GetTestcaseById_FullMethodName     = "/api.management.v1.Management/GetTestcaseById"
	Management_ListTestcase_FullMethodName        = "/api.management.v1.Management/ListTestcase"
	Management_DebugTestcase_FullMethodName       = "/api.management.v1.Management/DebugTestcase"
	Management_LoadFramework_FullMethodName       = "/api.management.v1.Management/LoadFramework"
	Management_CreateTestcaseSuite_FullMethodName = "/api.management.v1.Management/CreateTestcaseSuite"
	Management_GetTestcaseSuite_FullMethodName    = "/api.management.v1.Management/GetTestcaseSuite"
	Management_CreateTask_FullMethodName          = "/api.management.v1.Management/CreateTask"
	Management_ExecuteTask_FullMethodName         = "/api.management.v1.Management/ExecuteTask"
	Management_TaskInfo_FullMethodName            = "/api.management.v1.Management/TaskInfo"
	Management_DeleteTask_FullMethodName          = "/api.management.v1.Management/DeleteTask"
	Management_ListTimingTask_FullMethodName      = "/api.management.v1.Management/ListTimingTask"
	Management_GetTaskProgress_FullMethodName     = "/api.management.v1.Management/GetTaskProgress"
	Management_CreateApi_FullMethodName           = "/api.management.v1.Management/CreateApi"
	Management_UpdateApi_FullMethodName           = "/api.management.v1.Management/UpdateApi"
	Management_DeleteApi_FullMethodName           = "/api.management.v1.Management/DeleteApi"
	Management_GetApi_FullMethodName              = "/api.management.v1.Management/GetApi"
	Management_DebugApi_FullMethodName            = "/api.management.v1.Management/DebugApi"
	Management_ListApi_FullMethodName             = "/api.management.v1.Management/ListApi"
)

// ManagementClient is the client API for Management 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 ManagementClient interface {
	BaseInformation(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*BaseInfoReply, error)
	Testplan(ctx context.Context, in *TestplanRequest, opts ...grpc.CallOption) (*TestplanReply, error)
	// project module
	CreateProject(ctx context.Context, in *CreateProjectRequest, opts ...grpc.CallOption) (*CreateProjectReply, error)
	UpdateProject(ctx context.Context, in *UpdateProjectRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	DeleteProject(ctx context.Context, in *DeleteProjectRequest, opts ...grpc.CallOption) (*DeleteProjectReply, error)
	GetProject(ctx context.Context, in *GetProjectRequest, opts ...grpc.CallOption) (*ProjectInfo, error)
	ListProject(ctx context.Context, in *ListProjectRequest, opts ...grpc.CallOption) (*ListProjectReply, error)
	GetUserProjectList(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*ListProjectReply, error)
	// testcase module
	CreateTestcase(ctx context.Context, in *CreateTestcaseRequest, opts ...grpc.CallOption) (*CreateTestcaseReply, error)
	GenerateTestcase(ctx context.Context, in *GenerateTestcaseFileRequest, opts ...grpc.CallOption) (*GenerateTestcaseFileReply, error)
	UpdateTestcase(ctx context.Context, in *UpdateTestcaseRequest, opts ...grpc.CallOption) (*UpdateTestcaseReply, error)
	DeleteTestcase(ctx context.Context, in *DeleteTestcaseRequest, opts ...grpc.CallOption) (*DeleteTestcaseReply, error)
	GetTestcaseById(ctx context.Context, in *GetTestcaseRequest, opts ...grpc.CallOption) (*GetTestcaseReply, error)
	ListTestcase(ctx context.Context, in *ListTestcaseRequest, opts ...grpc.CallOption) (*ListTestcaseReply, error)
	DebugTestcase(ctx context.Context, in *DebugTestcaseRequest, opts ...grpc.CallOption) (*DebugTestcaseReply, error)
	LoadFramework(ctx context.Context, in *LoadFrameworkRequest, opts ...grpc.CallOption) (*LoadFrameworkReply, error)
	CreateTestcaseSuite(ctx context.Context, in *CreateTestcaseSuiteRequest, opts ...grpc.CallOption) (*CreateTestcaseSuiteReply, error)
	GetTestcaseSuite(ctx context.Context, in *GetTestcaseSuiteRequest, opts ...grpc.CallOption) (*GetTestcaseSuiteReply, error)
	// 创建任务接口
	CreateTask(ctx context.Context, in *CreateTaskRequest, opts ...grpc.CallOption) (*CreateTaskReply, error)
	ExecuteTask(ctx context.Context, in *ExecuteTaskRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	TaskInfo(ctx context.Context, in *TaskInfoRequest, opts ...grpc.CallOption) (*Task, error)
	DeleteTask(ctx context.Context, in *DeleteTaskRequest, opts ...grpc.CallOption) (*DeleteTaskReply, error)
	ListTimingTask(ctx context.Context, in *ListTimingTaskRequest, opts ...grpc.CallOption) (*ListTimingTaskReply, error)
	GetTaskProgress(ctx context.Context, in *TaskProgressRequest, opts ...grpc.CallOption) (*TaskProgressReply, error)
	// API
	CreateApi(ctx context.Context, in *CreateApiRequest, opts ...grpc.CallOption) (*CreateApiReply, error)
	UpdateApi(ctx context.Context, in *UpdateApiRequest, opts ...grpc.CallOption) (*UpdateApiReply, error)
	DeleteApi(ctx context.Context, in *DeleteApiRequest, opts ...grpc.CallOption) (*DeleteApiReply, error)
	GetApi(ctx context.Context, in *GetApiRequest, opts ...grpc.CallOption) (*GetApiReply, error)
	DebugApi(ctx context.Context, in *DebugApiRequest, opts ...grpc.CallOption) (*DebugApiReply, error)
	ListApi(ctx context.Context, in *ListApiRequest, opts ...grpc.CallOption) (*ListApiReply, error)
}

type managementClient struct {
	cc grpc.ClientConnInterface
}

func NewManagementClient(cc grpc.ClientConnInterface) ManagementClient {
	return &managementClient{cc}
}

func (c *managementClient) BaseInformation(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*BaseInfoReply, error) {
	out := new(BaseInfoReply)
	err := c.cc.Invoke(ctx, Management_BaseInformation_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managementClient) Testplan(ctx context.Context, in *TestplanRequest, opts ...grpc.CallOption) (*TestplanReply, error) {
	out := new(TestplanReply)
	err := c.cc.Invoke(ctx, Management_Testplan_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managementClient) CreateProject(ctx context.Context, in *CreateProjectRequest, opts ...grpc.CallOption) (*CreateProjectReply, error) {
	out := new(CreateProjectReply)
	err := c.cc.Invoke(ctx, Management_CreateProject_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managementClient) UpdateProject(ctx context.Context, in *UpdateProjectRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, Management_UpdateProject_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managementClient) DeleteProject(ctx context.Context, in *DeleteProjectRequest, opts ...grpc.CallOption) (*DeleteProjectReply, error) {
	out := new(DeleteProjectReply)
	err := c.cc.Invoke(ctx, Management_DeleteProject_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managementClient) GetProject(ctx context.Context, in *GetProjectRequest, opts ...grpc.CallOption) (*ProjectInfo, error) {
	out := new(ProjectInfo)
	err := c.cc.Invoke(ctx, Management_GetProject_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managementClient) ListProject(ctx context.Context, in *ListProjectRequest, opts ...grpc.CallOption) (*ListProjectReply, error) {
	out := new(ListProjectReply)
	err := c.cc.Invoke(ctx, Management_ListProject_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managementClient) GetUserProjectList(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*ListProjectReply, error) {
	out := new(ListProjectReply)
	err := c.cc.Invoke(ctx, Management_GetUserProjectList_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managementClient) CreateTestcase(ctx context.Context, in *CreateTestcaseRequest, opts ...grpc.CallOption) (*CreateTestcaseReply, error) {
	out := new(CreateTestcaseReply)
	err := c.cc.Invoke(ctx, Management_CreateTestcase_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managementClient) GenerateTestcase(ctx context.Context, in *GenerateTestcaseFileRequest, opts ...grpc.CallOption) (*GenerateTestcaseFileReply, error) {
	out := new(GenerateTestcaseFileReply)
	err := c.cc.Invoke(ctx, Management_GenerateTestcase_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managementClient) UpdateTestcase(ctx context.Context, in *UpdateTestcaseRequest, opts ...grpc.CallOption) (*UpdateTestcaseReply, error) {
	out := new(UpdateTestcaseReply)
	err := c.cc.Invoke(ctx, Management_UpdateTestcase_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managementClient) DeleteTestcase(ctx context.Context, in *DeleteTestcaseRequest, opts ...grpc.CallOption) (*DeleteTestcaseReply, error) {
	out := new(DeleteTestcaseReply)
	err := c.cc.Invoke(ctx, Management_DeleteTestcase_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managementClient) GetTestcaseById(ctx context.Context, in *GetTestcaseRequest, opts ...grpc.CallOption) (*GetTestcaseReply, error) {
	out := new(GetTestcaseReply)
	err := c.cc.Invoke(ctx, Management_GetTestcaseById_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managementClient) ListTestcase(ctx context.Context, in *ListTestcaseRequest, opts ...grpc.CallOption) (*ListTestcaseReply, error) {
	out := new(ListTestcaseReply)
	err := c.cc.Invoke(ctx, Management_ListTestcase_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managementClient) DebugTestcase(ctx context.Context, in *DebugTestcaseRequest, opts ...grpc.CallOption) (*DebugTestcaseReply, error) {
	out := new(DebugTestcaseReply)
	err := c.cc.Invoke(ctx, Management_DebugTestcase_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managementClient) LoadFramework(ctx context.Context, in *LoadFrameworkRequest, opts ...grpc.CallOption) (*LoadFrameworkReply, error) {
	out := new(LoadFrameworkReply)
	err := c.cc.Invoke(ctx, Management_LoadFramework_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managementClient) CreateTestcaseSuite(ctx context.Context, in *CreateTestcaseSuiteRequest, opts ...grpc.CallOption) (*CreateTestcaseSuiteReply, error) {
	out := new(CreateTestcaseSuiteReply)
	err := c.cc.Invoke(ctx, Management_CreateTestcaseSuite_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managementClient) GetTestcaseSuite(ctx context.Context, in *GetTestcaseSuiteRequest, opts ...grpc.CallOption) (*GetTestcaseSuiteReply, error) {
	out := new(GetTestcaseSuiteReply)
	err := c.cc.Invoke(ctx, Management_GetTestcaseSuite_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managementClient) CreateTask(ctx context.Context, in *CreateTaskRequest, opts ...grpc.CallOption) (*CreateTaskReply, error) {
	out := new(CreateTaskReply)
	err := c.cc.Invoke(ctx, Management_CreateTask_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managementClient) ExecuteTask(ctx context.Context, in *ExecuteTaskRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, Management_ExecuteTask_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managementClient) TaskInfo(ctx context.Context, in *TaskInfoRequest, opts ...grpc.CallOption) (*Task, error) {
	out := new(Task)
	err := c.cc.Invoke(ctx, Management_TaskInfo_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managementClient) DeleteTask(ctx context.Context, in *DeleteTaskRequest, opts ...grpc.CallOption) (*DeleteTaskReply, error) {
	out := new(DeleteTaskReply)
	err := c.cc.Invoke(ctx, Management_DeleteTask_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managementClient) ListTimingTask(ctx context.Context, in *ListTimingTaskRequest, opts ...grpc.CallOption) (*ListTimingTaskReply, error) {
	out := new(ListTimingTaskReply)
	err := c.cc.Invoke(ctx, Management_ListTimingTask_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managementClient) GetTaskProgress(ctx context.Context, in *TaskProgressRequest, opts ...grpc.CallOption) (*TaskProgressReply, error) {
	out := new(TaskProgressReply)
	err := c.cc.Invoke(ctx, Management_GetTaskProgress_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managementClient) CreateApi(ctx context.Context, in *CreateApiRequest, opts ...grpc.CallOption) (*CreateApiReply, error) {
	out := new(CreateApiReply)
	err := c.cc.Invoke(ctx, Management_CreateApi_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managementClient) UpdateApi(ctx context.Context, in *UpdateApiRequest, opts ...grpc.CallOption) (*UpdateApiReply, error) {
	out := new(UpdateApiReply)
	err := c.cc.Invoke(ctx, Management_UpdateApi_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managementClient) DeleteApi(ctx context.Context, in *DeleteApiRequest, opts ...grpc.CallOption) (*DeleteApiReply, error) {
	out := new(DeleteApiReply)
	err := c.cc.Invoke(ctx, Management_DeleteApi_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managementClient) GetApi(ctx context.Context, in *GetApiRequest, opts ...grpc.CallOption) (*GetApiReply, error) {
	out := new(GetApiReply)
	err := c.cc.Invoke(ctx, Management_GetApi_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managementClient) DebugApi(ctx context.Context, in *DebugApiRequest, opts ...grpc.CallOption) (*DebugApiReply, error) {
	out := new(DebugApiReply)
	err := c.cc.Invoke(ctx, Management_DebugApi_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *managementClient) ListApi(ctx context.Context, in *ListApiRequest, opts ...grpc.CallOption) (*ListApiReply, error) {
	out := new(ListApiReply)
	err := c.cc.Invoke(ctx, Management_ListApi_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ManagementServer is the server API for Management service.
// All implementations must embed UnimplementedManagementServer
// for forward compatibility
type ManagementServer interface {
	BaseInformation(context.Context, *emptypb.Empty) (*BaseInfoReply, error)
	Testplan(context.Context, *TestplanRequest) (*TestplanReply, error)
	// project module
	CreateProject(context.Context, *CreateProjectRequest) (*CreateProjectReply, error)
	UpdateProject(context.Context, *UpdateProjectRequest) (*emptypb.Empty, error)
	DeleteProject(context.Context, *DeleteProjectRequest) (*DeleteProjectReply, error)
	GetProject(context.Context, *GetProjectRequest) (*ProjectInfo, error)
	ListProject(context.Context, *ListProjectRequest) (*ListProjectReply, error)
	GetUserProjectList(context.Context, *emptypb.Empty) (*ListProjectReply, error)
	// testcase module
	CreateTestcase(context.Context, *CreateTestcaseRequest) (*CreateTestcaseReply, error)
	GenerateTestcase(context.Context, *GenerateTestcaseFileRequest) (*GenerateTestcaseFileReply, error)
	UpdateTestcase(context.Context, *UpdateTestcaseRequest) (*UpdateTestcaseReply, error)
	DeleteTestcase(context.Context, *DeleteTestcaseRequest) (*DeleteTestcaseReply, error)
	GetTestcaseById(context.Context, *GetTestcaseRequest) (*GetTestcaseReply, error)
	ListTestcase(context.Context, *ListTestcaseRequest) (*ListTestcaseReply, error)
	DebugTestcase(context.Context, *DebugTestcaseRequest) (*DebugTestcaseReply, error)
	LoadFramework(context.Context, *LoadFrameworkRequest) (*LoadFrameworkReply, error)
	CreateTestcaseSuite(context.Context, *CreateTestcaseSuiteRequest) (*CreateTestcaseSuiteReply, error)
	GetTestcaseSuite(context.Context, *GetTestcaseSuiteRequest) (*GetTestcaseSuiteReply, error)
	// 创建任务接口
	CreateTask(context.Context, *CreateTaskRequest) (*CreateTaskReply, error)
	ExecuteTask(context.Context, *ExecuteTaskRequest) (*emptypb.Empty, error)
	TaskInfo(context.Context, *TaskInfoRequest) (*Task, error)
	DeleteTask(context.Context, *DeleteTaskRequest) (*DeleteTaskReply, error)
	ListTimingTask(context.Context, *ListTimingTaskRequest) (*ListTimingTaskReply, error)
	GetTaskProgress(context.Context, *TaskProgressRequest) (*TaskProgressReply, error)
	// API
	CreateApi(context.Context, *CreateApiRequest) (*CreateApiReply, error)
	UpdateApi(context.Context, *UpdateApiRequest) (*UpdateApiReply, error)
	DeleteApi(context.Context, *DeleteApiRequest) (*DeleteApiReply, error)
	GetApi(context.Context, *GetApiRequest) (*GetApiReply, error)
	DebugApi(context.Context, *DebugApiRequest) (*DebugApiReply, error)
	ListApi(context.Context, *ListApiRequest) (*ListApiReply, error)
	mustEmbedUnimplementedManagementServer()
}

// UnimplementedManagementServer must be embedded to have forward compatible implementations.
type UnimplementedManagementServer struct {
}

func (UnimplementedManagementServer) BaseInformation(context.Context, *emptypb.Empty) (*BaseInfoReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method BaseInformation not implemented")
}
func (UnimplementedManagementServer) Testplan(context.Context, *TestplanRequest) (*TestplanReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Testplan not implemented")
}
func (UnimplementedManagementServer) CreateProject(context.Context, *CreateProjectRequest) (*CreateProjectReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateProject not implemented")
}
func (UnimplementedManagementServer) UpdateProject(context.Context, *UpdateProjectRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateProject not implemented")
}
func (UnimplementedManagementServer) DeleteProject(context.Context, *DeleteProjectRequest) (*DeleteProjectReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteProject not implemented")
}
func (UnimplementedManagementServer) GetProject(context.Context, *GetProjectRequest) (*ProjectInfo, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetProject not implemented")
}
func (UnimplementedManagementServer) ListProject(context.Context, *ListProjectRequest) (*ListProjectReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListProject not implemented")
}
func (UnimplementedManagementServer) GetUserProjectList(context.Context, *emptypb.Empty) (*ListProjectReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetUserProjectList not implemented")
}
func (UnimplementedManagementServer) CreateTestcase(context.Context, *CreateTestcaseRequest) (*CreateTestcaseReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateTestcase not implemented")
}
func (UnimplementedManagementServer) GenerateTestcase(context.Context, *GenerateTestcaseFileRequest) (*GenerateTestcaseFileReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GenerateTestcase not implemented")
}
func (UnimplementedManagementServer) UpdateTestcase(context.Context, *UpdateTestcaseRequest) (*UpdateTestcaseReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateTestcase not implemented")
}
func (UnimplementedManagementServer) DeleteTestcase(context.Context, *DeleteTestcaseRequest) (*DeleteTestcaseReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteTestcase not implemented")
}
func (UnimplementedManagementServer) GetTestcaseById(context.Context, *GetTestcaseRequest) (*GetTestcaseReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetTestcaseById not implemented")
}
func (UnimplementedManagementServer) ListTestcase(context.Context, *ListTestcaseRequest) (*ListTestcaseReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListTestcase not implemented")
}
func (UnimplementedManagementServer) DebugTestcase(context.Context, *DebugTestcaseRequest) (*DebugTestcaseReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DebugTestcase not implemented")
}
func (UnimplementedManagementServer) LoadFramework(context.Context, *LoadFrameworkRequest) (*LoadFrameworkReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method LoadFramework not implemented")
}
func (UnimplementedManagementServer) CreateTestcaseSuite(context.Context, *CreateTestcaseSuiteRequest) (*CreateTestcaseSuiteReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateTestcaseSuite not implemented")
}
func (UnimplementedManagementServer) GetTestcaseSuite(context.Context, *GetTestcaseSuiteRequest) (*GetTestcaseSuiteReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetTestcaseSuite not implemented")
}
func (UnimplementedManagementServer) CreateTask(context.Context, *CreateTaskRequest) (*CreateTaskReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateTask not implemented")
}
func (UnimplementedManagementServer) ExecuteTask(context.Context, *ExecuteTaskRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ExecuteTask not implemented")
}
func (UnimplementedManagementServer) TaskInfo(context.Context, *TaskInfoRequest) (*Task, error) {
	return nil, status.Errorf(codes.Unimplemented, "method TaskInfo not implemented")
}
func (UnimplementedManagementServer) DeleteTask(context.Context, *DeleteTaskRequest) (*DeleteTaskReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteTask not implemented")
}
func (UnimplementedManagementServer) ListTimingTask(context.Context, *ListTimingTaskRequest) (*ListTimingTaskReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListTimingTask not implemented")
}
func (UnimplementedManagementServer) GetTaskProgress(context.Context, *TaskProgressRequest) (*TaskProgressReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetTaskProgress not implemented")
}
func (UnimplementedManagementServer) CreateApi(context.Context, *CreateApiRequest) (*CreateApiReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateApi not implemented")
}
func (UnimplementedManagementServer) UpdateApi(context.Context, *UpdateApiRequest) (*UpdateApiReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateApi not implemented")
}
func (UnimplementedManagementServer) DeleteApi(context.Context, *DeleteApiRequest) (*DeleteApiReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteApi not implemented")
}
func (UnimplementedManagementServer) GetApi(context.Context, *GetApiRequest) (*GetApiReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetApi not implemented")
}
func (UnimplementedManagementServer) DebugApi(context.Context, *DebugApiRequest) (*DebugApiReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DebugApi not implemented")
}
func (UnimplementedManagementServer) ListApi(context.Context, *ListApiRequest) (*ListApiReply, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListApi not implemented")
}
func (UnimplementedManagementServer) mustEmbedUnimplementedManagementServer() {}

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

func RegisterManagementServer(s grpc.ServiceRegistrar, srv ManagementServer) {
	s.RegisterService(&Management_ServiceDesc, srv)
}

func _Management_BaseInformation_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(emptypb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagementServer).BaseInformation(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Management_BaseInformation_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagementServer).BaseInformation(ctx, req.(*emptypb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _Management_Testplan_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TestplanRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagementServer).Testplan(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Management_Testplan_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagementServer).Testplan(ctx, req.(*TestplanRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Management_CreateProject_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateProjectRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagementServer).CreateProject(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Management_CreateProject_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagementServer).CreateProject(ctx, req.(*CreateProjectRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Management_UpdateProject_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateProjectRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagementServer).UpdateProject(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Management_UpdateProject_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagementServer).UpdateProject(ctx, req.(*UpdateProjectRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Management_DeleteProject_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteProjectRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagementServer).DeleteProject(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Management_DeleteProject_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagementServer).DeleteProject(ctx, req.(*DeleteProjectRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Management_GetProject_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetProjectRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagementServer).GetProject(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Management_GetProject_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagementServer).GetProject(ctx, req.(*GetProjectRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Management_ListProject_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListProjectRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagementServer).ListProject(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Management_ListProject_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagementServer).ListProject(ctx, req.(*ListProjectRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Management_GetUserProjectList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(emptypb.Empty)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagementServer).GetUserProjectList(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Management_GetUserProjectList_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagementServer).GetUserProjectList(ctx, req.(*emptypb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _Management_CreateTestcase_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateTestcaseRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagementServer).CreateTestcase(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Management_CreateTestcase_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagementServer).CreateTestcase(ctx, req.(*CreateTestcaseRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Management_GenerateTestcase_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GenerateTestcaseFileRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagementServer).GenerateTestcase(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Management_GenerateTestcase_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagementServer).GenerateTestcase(ctx, req.(*GenerateTestcaseFileRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Management_UpdateTestcase_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateTestcaseRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagementServer).UpdateTestcase(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Management_UpdateTestcase_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagementServer).UpdateTestcase(ctx, req.(*UpdateTestcaseRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Management_DeleteTestcase_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteTestcaseRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagementServer).DeleteTestcase(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Management_DeleteTestcase_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagementServer).DeleteTestcase(ctx, req.(*DeleteTestcaseRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Management_GetTestcaseById_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetTestcaseRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagementServer).GetTestcaseById(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Management_GetTestcaseById_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagementServer).GetTestcaseById(ctx, req.(*GetTestcaseRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Management_ListTestcase_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListTestcaseRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagementServer).ListTestcase(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Management_ListTestcase_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagementServer).ListTestcase(ctx, req.(*ListTestcaseRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Management_DebugTestcase_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DebugTestcaseRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagementServer).DebugTestcase(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Management_DebugTestcase_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagementServer).DebugTestcase(ctx, req.(*DebugTestcaseRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Management_LoadFramework_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LoadFrameworkRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagementServer).LoadFramework(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Management_LoadFramework_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagementServer).LoadFramework(ctx, req.(*LoadFrameworkRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Management_CreateTestcaseSuite_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateTestcaseSuiteRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagementServer).CreateTestcaseSuite(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Management_CreateTestcaseSuite_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagementServer).CreateTestcaseSuite(ctx, req.(*CreateTestcaseSuiteRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Management_GetTestcaseSuite_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetTestcaseSuiteRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagementServer).GetTestcaseSuite(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Management_GetTestcaseSuite_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagementServer).GetTestcaseSuite(ctx, req.(*GetTestcaseSuiteRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Management_CreateTask_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateTaskRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagementServer).CreateTask(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Management_CreateTask_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagementServer).CreateTask(ctx, req.(*CreateTaskRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Management_ExecuteTask_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ExecuteTaskRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagementServer).ExecuteTask(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Management_ExecuteTask_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagementServer).ExecuteTask(ctx, req.(*ExecuteTaskRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Management_TaskInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TaskInfoRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagementServer).TaskInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Management_TaskInfo_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagementServer).TaskInfo(ctx, req.(*TaskInfoRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Management_DeleteTask_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteTaskRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagementServer).DeleteTask(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Management_DeleteTask_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagementServer).DeleteTask(ctx, req.(*DeleteTaskRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Management_ListTimingTask_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListTimingTaskRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagementServer).ListTimingTask(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Management_ListTimingTask_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagementServer).ListTimingTask(ctx, req.(*ListTimingTaskRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Management_GetTaskProgress_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(TaskProgressRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagementServer).GetTaskProgress(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Management_GetTaskProgress_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagementServer).GetTaskProgress(ctx, req.(*TaskProgressRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Management_CreateApi_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateApiRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagementServer).CreateApi(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Management_CreateApi_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagementServer).CreateApi(ctx, req.(*CreateApiRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Management_UpdateApi_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateApiRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagementServer).UpdateApi(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Management_UpdateApi_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagementServer).UpdateApi(ctx, req.(*UpdateApiRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Management_DeleteApi_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteApiRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagementServer).DeleteApi(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Management_DeleteApi_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagementServer).DeleteApi(ctx, req.(*DeleteApiRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Management_GetApi_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetApiRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagementServer).GetApi(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Management_GetApi_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagementServer).GetApi(ctx, req.(*GetApiRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Management_DebugApi_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DebugApiRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagementServer).DebugApi(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Management_DebugApi_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagementServer).DebugApi(ctx, req.(*DebugApiRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _Management_ListApi_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListApiRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ManagementServer).ListApi(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: Management_ListApi_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ManagementServer).ListApi(ctx, req.(*ListApiRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// Management_ServiceDesc is the grpc.ServiceDesc for Management service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var Management_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "api.management.v1.Management",
	HandlerType: (*ManagementServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "BaseInformation",
			Handler:    _Management_BaseInformation_Handler,
		},
		{
			MethodName: "Testplan",
			Handler:    _Management_Testplan_Handler,
		},
		{
			MethodName: "CreateProject",
			Handler:    _Management_CreateProject_Handler,
		},
		{
			MethodName: "UpdateProject",
			Handler:    _Management_UpdateProject_Handler,
		},
		{
			MethodName: "DeleteProject",
			Handler:    _Management_DeleteProject_Handler,
		},
		{
			MethodName: "GetProject",
			Handler:    _Management_GetProject_Handler,
		},
		{
			MethodName: "ListProject",
			Handler:    _Management_ListProject_Handler,
		},
		{
			MethodName: "GetUserProjectList",
			Handler:    _Management_GetUserProjectList_Handler,
		},
		{
			MethodName: "CreateTestcase",
			Handler:    _Management_CreateTestcase_Handler,
		},
		{
			MethodName: "GenerateTestcase",
			Handler:    _Management_GenerateTestcase_Handler,
		},
		{
			MethodName: "UpdateTestcase",
			Handler:    _Management_UpdateTestcase_Handler,
		},
		{
			MethodName: "DeleteTestcase",
			Handler:    _Management_DeleteTestcase_Handler,
		},
		{
			MethodName: "GetTestcaseById",
			Handler:    _Management_GetTestcaseById_Handler,
		},
		{
			MethodName: "ListTestcase",
			Handler:    _Management_ListTestcase_Handler,
		},
		{
			MethodName: "DebugTestcase",
			Handler:    _Management_DebugTestcase_Handler,
		},
		{
			MethodName: "LoadFramework",
			Handler:    _Management_LoadFramework_Handler,
		},
		{
			MethodName: "CreateTestcaseSuite",
			Handler:    _Management_CreateTestcaseSuite_Handler,
		},
		{
			MethodName: "GetTestcaseSuite",
			Handler:    _Management_GetTestcaseSuite_Handler,
		},
		{
			MethodName: "CreateTask",
			Handler:    _Management_CreateTask_Handler,
		},
		{
			MethodName: "ExecuteTask",
			Handler:    _Management_ExecuteTask_Handler,
		},
		{
			MethodName: "TaskInfo",
			Handler:    _Management_TaskInfo_Handler,
		},
		{
			MethodName: "DeleteTask",
			Handler:    _Management_DeleteTask_Handler,
		},
		{
			MethodName: "ListTimingTask",
			Handler:    _Management_ListTimingTask_Handler,
		},
		{
			MethodName: "GetTaskProgress",
			Handler:    _Management_GetTaskProgress_Handler,
		},
		{
			MethodName: "CreateApi",
			Handler:    _Management_CreateApi_Handler,
		},
		{
			MethodName: "UpdateApi",
			Handler:    _Management_UpdateApi_Handler,
		},
		{
			MethodName: "DeleteApi",
			Handler:    _Management_DeleteApi_Handler,
		},
		{
			MethodName: "GetApi",
			Handler:    _Management_GetApi_Handler,
		},
		{
			MethodName: "DebugApi",
			Handler:    _Management_DebugApi_Handler,
		},
		{
			MethodName: "ListApi",
			Handler:    _Management_ListApi_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "api/management/v1/management.proto",
}
