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

package v1

import (
	context "context"
	http "github.com/go-kratos/kratos/v2/transport/http"
	binding "github.com/go-kratos/kratos/v2/transport/http/binding"
	emptypb "google.golang.org/protobuf/types/known/emptypb"
)

// This is a compile-time assertion to ensure that this generated file
// is compatible with the kratos package it is being compiled against.
var _ = new(context.Context)
var _ = binding.EncodeURL

const _ = http.SupportPackageIsVersion1

const OperationManagementBaseInformation = "/api.management.v1.Management/BaseInformation"
const OperationManagementCreateApi = "/api.management.v1.Management/CreateApi"
const OperationManagementCreateProject = "/api.management.v1.Management/CreateProject"
const OperationManagementCreateTask = "/api.management.v1.Management/CreateTask"
const OperationManagementCreateTestcase = "/api.management.v1.Management/CreateTestcase"
const OperationManagementCreateTestcaseSuite = "/api.management.v1.Management/CreateTestcaseSuite"
const OperationManagementDebugTestcase = "/api.management.v1.Management/DebugTestcase"
const OperationManagementExecuteTask = "/api.management.v1.Management/ExecuteTask"
const OperationManagementGetProject = "/api.management.v1.Management/GetProject"
const OperationManagementGetTaskProgress = "/api.management.v1.Management/GetTaskProgress"
const OperationManagementGetTestcaseById = "/api.management.v1.Management/GetTestcaseById"
const OperationManagementListApi = "/api.management.v1.Management/ListApi"
const OperationManagementLoadFramework = "/api.management.v1.Management/LoadFramework"
const OperationManagementTaskInfo = "/api.management.v1.Management/TaskInfo"
const OperationManagementTestplan = "/api.management.v1.Management/Testplan"
const OperationManagementUpdateApi = "/api.management.v1.Management/UpdateApi"
const OperationManagementUpdateProject = "/api.management.v1.Management/UpdateProject"
const OperationManagementUpdateTestcase = "/api.management.v1.Management/UpdateTestcase"

type ManagementHTTPServer interface {
	BaseInformation(context.Context, *emptypb.Empty) (*BaseInfoReply, error)
	// CreateApi API
	CreateApi(context.Context, *CreateApiRequest) (*CreateApiReply, error)
	// CreateProject project module
	CreateProject(context.Context, *CreateProjectRequest) (*CreateProjectReply, error)
	// CreateTask 创建任务接口
	CreateTask(context.Context, *CreateTaskRequest) (*CreateTaskReply, error)
	// CreateTestcase testcase module
	CreateTestcase(context.Context, *CreateTestcaseRequest) (*CreateTestcaseReply, error)
	CreateTestcaseSuite(context.Context, *CreateTestcaseSuiteRequest) (*CreateTestcaseSuiteReply, error)
	DebugTestcase(context.Context, *DebugTestcaseRequest) (*DebugTestcaseReply, error)
	ExecuteTask(context.Context, *ExecuteTaskRequest) (*emptypb.Empty, error)
	GetProject(context.Context, *GetProjectRequest) (*ProjectInfo, error)
	GetTaskProgress(context.Context, *TaskProgressRequest) (*TaskProgressReply, error)
	GetTestcaseById(context.Context, *GetTestcaseRequest) (*GetTestcaseReply, error)
	ListApi(context.Context, *ListApiRequest) (*ListApiReply, error)
	LoadFramework(context.Context, *LoadFrameworkRequest) (*LoadFrameworkReply, error)
	TaskInfo(context.Context, *TaskInfoRequest) (*Task, error)
	Testplan(context.Context, *TestplanRequest) (*TestplanReply, error)
	UpdateApi(context.Context, *UpdateApiRequest) (*UpdateApiReply, error)
	UpdateProject(context.Context, *UpdateProjectRequest) (*emptypb.Empty, error)
	UpdateTestcase(context.Context, *UpdateTestcaseRequest) (*UpdateTestcaseReply, error)
}

func RegisterManagementHTTPServer(s *http.Server, srv ManagementHTTPServer) {
	r := s.Route("/")
	r.GET("v1/api/management/info", _Management_BaseInformation0_HTTP_Handler(srv))
	r.GET("v1/api/management/testplan/{id}", _Management_Testplan0_HTTP_Handler(srv))
	r.PUT("v1/api/management/testplan", _Management_Testplan1_HTTP_Handler(srv))
	r.POST("v1/api/management/testplan", _Management_Testplan2_HTTP_Handler(srv))
	r.POST("v1/api/management/project", _Management_CreateProject0_HTTP_Handler(srv))
	r.PUT("v1/api/management/project", _Management_UpdateProject0_HTTP_Handler(srv))
	r.GET("v1/api/management/project/{id}", _Management_GetProject0_HTTP_Handler(srv))
	r.POST("v1/api/management/testcase", _Management_CreateTestcase0_HTTP_Handler(srv))
	r.PUT("v1/api/management/testcase", _Management_UpdateTestcase0_HTTP_Handler(srv))
	r.GET("v1/api/management/testcase/{id}", _Management_GetTestcaseById0_HTTP_Handler(srv))
	r.POST("v1/api/management/testcase/debug", _Management_DebugTestcase0_HTTP_Handler(srv))
	r.POST("v1/api/management/testcase/loadFramework", _Management_LoadFramework0_HTTP_Handler(srv))
	r.POST("v1/api/management/case-suite", _Management_CreateTestcaseSuite0_HTTP_Handler(srv))
	r.POST("v1/api/management/task", _Management_CreateTask0_HTTP_Handler(srv))
	r.POST("v1/api/management/task/execute", _Management_ExecuteTask0_HTTP_Handler(srv))
	r.PUT("v1/api/management/task/{id}", _Management_TaskInfo0_HTTP_Handler(srv))
	r.GET("v1/api/management/task/{id}", _Management_TaskInfo1_HTTP_Handler(srv))
	r.GET("v1/api/management/task/{id}/progress", _Management_GetTaskProgress0_HTTP_Handler(srv))
	r.POST("v1/api/management/interface", _Management_CreateApi0_HTTP_Handler(srv))
	r.PUT("v1/api/management/interface", _Management_UpdateApi0_HTTP_Handler(srv))
	r.GET("v1/api/management/interface/list/{pageNum}/{pageSize}", _Management_ListApi0_HTTP_Handler(srv))
}

func _Management_BaseInformation0_HTTP_Handler(srv ManagementHTTPServer) func(ctx http.Context) error {
	return func(ctx http.Context) error {
		var in emptypb.Empty
		if err := ctx.BindQuery(&in); err != nil {
			return err
		}
		http.SetOperation(ctx, OperationManagementBaseInformation)
		h := ctx.Middleware(func(ctx context.Context, req interface{}) (interface{}, error) {
			return srv.BaseInformation(ctx, req.(*emptypb.Empty))
		})
		out, err := h(ctx, &in)
		if err != nil {
			return err
		}
		reply := out.(*BaseInfoReply)
		return ctx.Result(200, reply)
	}
}

func _Management_Testplan0_HTTP_Handler(srv ManagementHTTPServer) func(ctx http.Context) error {
	return func(ctx http.Context) error {
		var in TestplanRequest
		if err := ctx.BindQuery(&in); err != nil {
			return err
		}
		if err := ctx.BindVars(&in); err != nil {
			return err
		}
		http.SetOperation(ctx, OperationManagementTestplan)
		h := ctx.Middleware(func(ctx context.Context, req interface{}) (interface{}, error) {
			return srv.Testplan(ctx, req.(*TestplanRequest))
		})
		out, err := h(ctx, &in)
		if err != nil {
			return err
		}
		reply := out.(*TestplanReply)
		return ctx.Result(200, reply)
	}
}

func _Management_Testplan1_HTTP_Handler(srv ManagementHTTPServer) func(ctx http.Context) error {
	return func(ctx http.Context) error {
		var in TestplanRequest
		if err := ctx.Bind(&in); err != nil {
			return err
		}
		if err := ctx.BindQuery(&in); err != nil {
			return err
		}
		http.SetOperation(ctx, OperationManagementTestplan)
		h := ctx.Middleware(func(ctx context.Context, req interface{}) (interface{}, error) {
			return srv.Testplan(ctx, req.(*TestplanRequest))
		})
		out, err := h(ctx, &in)
		if err != nil {
			return err
		}
		reply := out.(*TestplanReply)
		return ctx.Result(200, reply)
	}
}

func _Management_Testplan2_HTTP_Handler(srv ManagementHTTPServer) func(ctx http.Context) error {
	return func(ctx http.Context) error {
		var in TestplanRequest
		if err := ctx.Bind(&in); err != nil {
			return err
		}
		if err := ctx.BindQuery(&in); err != nil {
			return err
		}
		http.SetOperation(ctx, OperationManagementTestplan)
		h := ctx.Middleware(func(ctx context.Context, req interface{}) (interface{}, error) {
			return srv.Testplan(ctx, req.(*TestplanRequest))
		})
		out, err := h(ctx, &in)
		if err != nil {
			return err
		}
		reply := out.(*TestplanReply)
		return ctx.Result(200, reply)
	}
}

func _Management_CreateProject0_HTTP_Handler(srv ManagementHTTPServer) func(ctx http.Context) error {
	return func(ctx http.Context) error {
		var in CreateProjectRequest
		if err := ctx.Bind(&in); err != nil {
			return err
		}
		if err := ctx.BindQuery(&in); err != nil {
			return err
		}
		http.SetOperation(ctx, OperationManagementCreateProject)
		h := ctx.Middleware(func(ctx context.Context, req interface{}) (interface{}, error) {
			return srv.CreateProject(ctx, req.(*CreateProjectRequest))
		})
		out, err := h(ctx, &in)
		if err != nil {
			return err
		}
		reply := out.(*CreateProjectReply)
		return ctx.Result(200, reply)
	}
}

func _Management_UpdateProject0_HTTP_Handler(srv ManagementHTTPServer) func(ctx http.Context) error {
	return func(ctx http.Context) error {
		var in UpdateProjectRequest
		if err := ctx.Bind(&in); err != nil {
			return err
		}
		if err := ctx.BindQuery(&in); err != nil {
			return err
		}
		http.SetOperation(ctx, OperationManagementUpdateProject)
		h := ctx.Middleware(func(ctx context.Context, req interface{}) (interface{}, error) {
			return srv.UpdateProject(ctx, req.(*UpdateProjectRequest))
		})
		out, err := h(ctx, &in)
		if err != nil {
			return err
		}
		reply := out.(*emptypb.Empty)
		return ctx.Result(200, reply)
	}
}

func _Management_GetProject0_HTTP_Handler(srv ManagementHTTPServer) func(ctx http.Context) error {
	return func(ctx http.Context) error {
		var in GetProjectRequest
		if err := ctx.BindQuery(&in); err != nil {
			return err
		}
		if err := ctx.BindVars(&in); err != nil {
			return err
		}
		http.SetOperation(ctx, OperationManagementGetProject)
		h := ctx.Middleware(func(ctx context.Context, req interface{}) (interface{}, error) {
			return srv.GetProject(ctx, req.(*GetProjectRequest))
		})
		out, err := h(ctx, &in)
		if err != nil {
			return err
		}
		reply := out.(*ProjectInfo)
		return ctx.Result(200, reply)
	}
}

func _Management_CreateTestcase0_HTTP_Handler(srv ManagementHTTPServer) func(ctx http.Context) error {
	return func(ctx http.Context) error {
		var in CreateTestcaseRequest
		if err := ctx.Bind(&in); err != nil {
			return err
		}
		if err := ctx.BindQuery(&in); err != nil {
			return err
		}
		http.SetOperation(ctx, OperationManagementCreateTestcase)
		h := ctx.Middleware(func(ctx context.Context, req interface{}) (interface{}, error) {
			return srv.CreateTestcase(ctx, req.(*CreateTestcaseRequest))
		})
		out, err := h(ctx, &in)
		if err != nil {
			return err
		}
		reply := out.(*CreateTestcaseReply)
		return ctx.Result(200, reply)
	}
}

func _Management_UpdateTestcase0_HTTP_Handler(srv ManagementHTTPServer) func(ctx http.Context) error {
	return func(ctx http.Context) error {
		var in UpdateTestcaseRequest
		if err := ctx.Bind(&in); err != nil {
			return err
		}
		if err := ctx.BindQuery(&in); err != nil {
			return err
		}
		http.SetOperation(ctx, OperationManagementUpdateTestcase)
		h := ctx.Middleware(func(ctx context.Context, req interface{}) (interface{}, error) {
			return srv.UpdateTestcase(ctx, req.(*UpdateTestcaseRequest))
		})
		out, err := h(ctx, &in)
		if err != nil {
			return err
		}
		reply := out.(*UpdateTestcaseReply)
		return ctx.Result(200, reply)
	}
}

func _Management_GetTestcaseById0_HTTP_Handler(srv ManagementHTTPServer) func(ctx http.Context) error {
	return func(ctx http.Context) error {
		var in GetTestcaseRequest
		if err := ctx.BindQuery(&in); err != nil {
			return err
		}
		if err := ctx.BindVars(&in); err != nil {
			return err
		}
		http.SetOperation(ctx, OperationManagementGetTestcaseById)
		h := ctx.Middleware(func(ctx context.Context, req interface{}) (interface{}, error) {
			return srv.GetTestcaseById(ctx, req.(*GetTestcaseRequest))
		})
		out, err := h(ctx, &in)
		if err != nil {
			return err
		}
		reply := out.(*GetTestcaseReply)
		return ctx.Result(200, reply)
	}
}

func _Management_DebugTestcase0_HTTP_Handler(srv ManagementHTTPServer) func(ctx http.Context) error {
	return func(ctx http.Context) error {
		var in DebugTestcaseRequest
		if err := ctx.Bind(&in); err != nil {
			return err
		}
		if err := ctx.BindQuery(&in); err != nil {
			return err
		}
		http.SetOperation(ctx, OperationManagementDebugTestcase)
		h := ctx.Middleware(func(ctx context.Context, req interface{}) (interface{}, error) {
			return srv.DebugTestcase(ctx, req.(*DebugTestcaseRequest))
		})
		out, err := h(ctx, &in)
		if err != nil {
			return err
		}
		reply := out.(*DebugTestcaseReply)
		return ctx.Result(200, reply)
	}
}

func _Management_LoadFramework0_HTTP_Handler(srv ManagementHTTPServer) func(ctx http.Context) error {
	return func(ctx http.Context) error {
		var in LoadFrameworkRequest
		if err := ctx.Bind(&in); err != nil {
			return err
		}
		if err := ctx.BindQuery(&in); err != nil {
			return err
		}
		http.SetOperation(ctx, OperationManagementLoadFramework)
		h := ctx.Middleware(func(ctx context.Context, req interface{}) (interface{}, error) {
			return srv.LoadFramework(ctx, req.(*LoadFrameworkRequest))
		})
		out, err := h(ctx, &in)
		if err != nil {
			return err
		}
		reply := out.(*LoadFrameworkReply)
		return ctx.Result(200, reply)
	}
}

func _Management_CreateTestcaseSuite0_HTTP_Handler(srv ManagementHTTPServer) func(ctx http.Context) error {
	return func(ctx http.Context) error {
		var in CreateTestcaseSuiteRequest
		if err := ctx.Bind(&in); err != nil {
			return err
		}
		if err := ctx.BindQuery(&in); err != nil {
			return err
		}
		http.SetOperation(ctx, OperationManagementCreateTestcaseSuite)
		h := ctx.Middleware(func(ctx context.Context, req interface{}) (interface{}, error) {
			return srv.CreateTestcaseSuite(ctx, req.(*CreateTestcaseSuiteRequest))
		})
		out, err := h(ctx, &in)
		if err != nil {
			return err
		}
		reply := out.(*CreateTestcaseSuiteReply)
		return ctx.Result(200, reply)
	}
}

func _Management_CreateTask0_HTTP_Handler(srv ManagementHTTPServer) func(ctx http.Context) error {
	return func(ctx http.Context) error {
		var in CreateTaskRequest
		if err := ctx.Bind(&in); err != nil {
			return err
		}
		if err := ctx.BindQuery(&in); err != nil {
			return err
		}
		http.SetOperation(ctx, OperationManagementCreateTask)
		h := ctx.Middleware(func(ctx context.Context, req interface{}) (interface{}, error) {
			return srv.CreateTask(ctx, req.(*CreateTaskRequest))
		})
		out, err := h(ctx, &in)
		if err != nil {
			return err
		}
		reply := out.(*CreateTaskReply)
		return ctx.Result(200, reply)
	}
}

func _Management_ExecuteTask0_HTTP_Handler(srv ManagementHTTPServer) func(ctx http.Context) error {
	return func(ctx http.Context) error {
		var in ExecuteTaskRequest
		if err := ctx.Bind(&in); err != nil {
			return err
		}
		if err := ctx.BindQuery(&in); err != nil {
			return err
		}
		http.SetOperation(ctx, OperationManagementExecuteTask)
		h := ctx.Middleware(func(ctx context.Context, req interface{}) (interface{}, error) {
			return srv.ExecuteTask(ctx, req.(*ExecuteTaskRequest))
		})
		out, err := h(ctx, &in)
		if err != nil {
			return err
		}
		reply := out.(*emptypb.Empty)
		return ctx.Result(200, reply)
	}
}

func _Management_TaskInfo0_HTTP_Handler(srv ManagementHTTPServer) func(ctx http.Context) error {
	return func(ctx http.Context) error {
		var in TaskInfoRequest
		if err := ctx.Bind(&in); err != nil {
			return err
		}
		if err := ctx.BindQuery(&in); err != nil {
			return err
		}
		if err := ctx.BindVars(&in); err != nil {
			return err
		}
		http.SetOperation(ctx, OperationManagementTaskInfo)
		h := ctx.Middleware(func(ctx context.Context, req interface{}) (interface{}, error) {
			return srv.TaskInfo(ctx, req.(*TaskInfoRequest))
		})
		out, err := h(ctx, &in)
		if err != nil {
			return err
		}
		reply := out.(*Task)
		return ctx.Result(200, reply)
	}
}

func _Management_TaskInfo1_HTTP_Handler(srv ManagementHTTPServer) func(ctx http.Context) error {
	return func(ctx http.Context) error {
		var in TaskInfoRequest
		if err := ctx.BindQuery(&in); err != nil {
			return err
		}
		if err := ctx.BindVars(&in); err != nil {
			return err
		}
		http.SetOperation(ctx, OperationManagementTaskInfo)
		h := ctx.Middleware(func(ctx context.Context, req interface{}) (interface{}, error) {
			return srv.TaskInfo(ctx, req.(*TaskInfoRequest))
		})
		out, err := h(ctx, &in)
		if err != nil {
			return err
		}
		reply := out.(*Task)
		return ctx.Result(200, reply)
	}
}

func _Management_GetTaskProgress0_HTTP_Handler(srv ManagementHTTPServer) func(ctx http.Context) error {
	return func(ctx http.Context) error {
		var in TaskProgressRequest
		if err := ctx.BindQuery(&in); err != nil {
			return err
		}
		if err := ctx.BindVars(&in); err != nil {
			return err
		}
		http.SetOperation(ctx, OperationManagementGetTaskProgress)
		h := ctx.Middleware(func(ctx context.Context, req interface{}) (interface{}, error) {
			return srv.GetTaskProgress(ctx, req.(*TaskProgressRequest))
		})
		out, err := h(ctx, &in)
		if err != nil {
			return err
		}
		reply := out.(*TaskProgressReply)
		return ctx.Result(200, reply)
	}
}

func _Management_CreateApi0_HTTP_Handler(srv ManagementHTTPServer) func(ctx http.Context) error {
	return func(ctx http.Context) error {
		var in CreateApiRequest
		if err := ctx.Bind(&in); err != nil {
			return err
		}
		if err := ctx.BindQuery(&in); err != nil {
			return err
		}
		http.SetOperation(ctx, OperationManagementCreateApi)
		h := ctx.Middleware(func(ctx context.Context, req interface{}) (interface{}, error) {
			return srv.CreateApi(ctx, req.(*CreateApiRequest))
		})
		out, err := h(ctx, &in)
		if err != nil {
			return err
		}
		reply := out.(*CreateApiReply)
		return ctx.Result(200, reply)
	}
}

func _Management_UpdateApi0_HTTP_Handler(srv ManagementHTTPServer) func(ctx http.Context) error {
	return func(ctx http.Context) error {
		var in UpdateApiRequest
		if err := ctx.Bind(&in); err != nil {
			return err
		}
		if err := ctx.BindQuery(&in); err != nil {
			return err
		}
		http.SetOperation(ctx, OperationManagementUpdateApi)
		h := ctx.Middleware(func(ctx context.Context, req interface{}) (interface{}, error) {
			return srv.UpdateApi(ctx, req.(*UpdateApiRequest))
		})
		out, err := h(ctx, &in)
		if err != nil {
			return err
		}
		reply := out.(*UpdateApiReply)
		return ctx.Result(200, reply)
	}
}

func _Management_ListApi0_HTTP_Handler(srv ManagementHTTPServer) func(ctx http.Context) error {
	return func(ctx http.Context) error {
		var in ListApiRequest
		if err := ctx.BindQuery(&in); err != nil {
			return err
		}
		if err := ctx.BindVars(&in); err != nil {
			return err
		}
		http.SetOperation(ctx, OperationManagementListApi)
		h := ctx.Middleware(func(ctx context.Context, req interface{}) (interface{}, error) {
			return srv.ListApi(ctx, req.(*ListApiRequest))
		})
		out, err := h(ctx, &in)
		if err != nil {
			return err
		}
		reply := out.(*ListApiReply)
		return ctx.Result(200, reply)
	}
}

type ManagementHTTPClient interface {
	BaseInformation(ctx context.Context, req *emptypb.Empty, opts ...http.CallOption) (rsp *BaseInfoReply, err error)
	CreateApi(ctx context.Context, req *CreateApiRequest, opts ...http.CallOption) (rsp *CreateApiReply, err error)
	CreateProject(ctx context.Context, req *CreateProjectRequest, opts ...http.CallOption) (rsp *CreateProjectReply, err error)
	CreateTask(ctx context.Context, req *CreateTaskRequest, opts ...http.CallOption) (rsp *CreateTaskReply, err error)
	CreateTestcase(ctx context.Context, req *CreateTestcaseRequest, opts ...http.CallOption) (rsp *CreateTestcaseReply, err error)
	CreateTestcaseSuite(ctx context.Context, req *CreateTestcaseSuiteRequest, opts ...http.CallOption) (rsp *CreateTestcaseSuiteReply, err error)
	DebugTestcase(ctx context.Context, req *DebugTestcaseRequest, opts ...http.CallOption) (rsp *DebugTestcaseReply, err error)
	ExecuteTask(ctx context.Context, req *ExecuteTaskRequest, opts ...http.CallOption) (rsp *emptypb.Empty, err error)
	GetProject(ctx context.Context, req *GetProjectRequest, opts ...http.CallOption) (rsp *ProjectInfo, err error)
	GetTaskProgress(ctx context.Context, req *TaskProgressRequest, opts ...http.CallOption) (rsp *TaskProgressReply, err error)
	GetTestcaseById(ctx context.Context, req *GetTestcaseRequest, opts ...http.CallOption) (rsp *GetTestcaseReply, err error)
	ListApi(ctx context.Context, req *ListApiRequest, opts ...http.CallOption) (rsp *ListApiReply, err error)
	LoadFramework(ctx context.Context, req *LoadFrameworkRequest, opts ...http.CallOption) (rsp *LoadFrameworkReply, err error)
	TaskInfo(ctx context.Context, req *TaskInfoRequest, opts ...http.CallOption) (rsp *Task, err error)
	Testplan(ctx context.Context, req *TestplanRequest, opts ...http.CallOption) (rsp *TestplanReply, err error)
	UpdateApi(ctx context.Context, req *UpdateApiRequest, opts ...http.CallOption) (rsp *UpdateApiReply, err error)
	UpdateProject(ctx context.Context, req *UpdateProjectRequest, opts ...http.CallOption) (rsp *emptypb.Empty, err error)
	UpdateTestcase(ctx context.Context, req *UpdateTestcaseRequest, opts ...http.CallOption) (rsp *UpdateTestcaseReply, err error)
}

type ManagementHTTPClientImpl struct {
	cc *http.Client
}

func NewManagementHTTPClient(client *http.Client) ManagementHTTPClient {
	return &ManagementHTTPClientImpl{client}
}

func (c *ManagementHTTPClientImpl) BaseInformation(ctx context.Context, in *emptypb.Empty, opts ...http.CallOption) (*BaseInfoReply, error) {
	var out BaseInfoReply
	pattern := "v1/api/management/info"
	path := binding.EncodeURL(pattern, in, true)
	opts = append(opts, http.Operation(OperationManagementBaseInformation))
	opts = append(opts, http.PathTemplate(pattern))
	err := c.cc.Invoke(ctx, "GET", path, nil, &out, opts...)
	if err != nil {
		return nil, err
	}
	return &out, err
}

func (c *ManagementHTTPClientImpl) CreateApi(ctx context.Context, in *CreateApiRequest, opts ...http.CallOption) (*CreateApiReply, error) {
	var out CreateApiReply
	pattern := "v1/api/management/interface"
	path := binding.EncodeURL(pattern, in, false)
	opts = append(opts, http.Operation(OperationManagementCreateApi))
	opts = append(opts, http.PathTemplate(pattern))
	err := c.cc.Invoke(ctx, "POST", path, in, &out, opts...)
	if err != nil {
		return nil, err
	}
	return &out, err
}

func (c *ManagementHTTPClientImpl) CreateProject(ctx context.Context, in *CreateProjectRequest, opts ...http.CallOption) (*CreateProjectReply, error) {
	var out CreateProjectReply
	pattern := "v1/api/management/project"
	path := binding.EncodeURL(pattern, in, false)
	opts = append(opts, http.Operation(OperationManagementCreateProject))
	opts = append(opts, http.PathTemplate(pattern))
	err := c.cc.Invoke(ctx, "POST", path, in, &out, opts...)
	if err != nil {
		return nil, err
	}
	return &out, err
}

func (c *ManagementHTTPClientImpl) CreateTask(ctx context.Context, in *CreateTaskRequest, opts ...http.CallOption) (*CreateTaskReply, error) {
	var out CreateTaskReply
	pattern := "v1/api/management/task"
	path := binding.EncodeURL(pattern, in, false)
	opts = append(opts, http.Operation(OperationManagementCreateTask))
	opts = append(opts, http.PathTemplate(pattern))
	err := c.cc.Invoke(ctx, "POST", path, in, &out, opts...)
	if err != nil {
		return nil, err
	}
	return &out, err
}

func (c *ManagementHTTPClientImpl) CreateTestcase(ctx context.Context, in *CreateTestcaseRequest, opts ...http.CallOption) (*CreateTestcaseReply, error) {
	var out CreateTestcaseReply
	pattern := "v1/api/management/testcase"
	path := binding.EncodeURL(pattern, in, false)
	opts = append(opts, http.Operation(OperationManagementCreateTestcase))
	opts = append(opts, http.PathTemplate(pattern))
	err := c.cc.Invoke(ctx, "POST", path, in, &out, opts...)
	if err != nil {
		return nil, err
	}
	return &out, err
}

func (c *ManagementHTTPClientImpl) CreateTestcaseSuite(ctx context.Context, in *CreateTestcaseSuiteRequest, opts ...http.CallOption) (*CreateTestcaseSuiteReply, error) {
	var out CreateTestcaseSuiteReply
	pattern := "v1/api/management/case-suite"
	path := binding.EncodeURL(pattern, in, false)
	opts = append(opts, http.Operation(OperationManagementCreateTestcaseSuite))
	opts = append(opts, http.PathTemplate(pattern))
	err := c.cc.Invoke(ctx, "POST", path, in, &out, opts...)
	if err != nil {
		return nil, err
	}
	return &out, err
}

func (c *ManagementHTTPClientImpl) DebugTestcase(ctx context.Context, in *DebugTestcaseRequest, opts ...http.CallOption) (*DebugTestcaseReply, error) {
	var out DebugTestcaseReply
	pattern := "v1/api/management/testcase/debug"
	path := binding.EncodeURL(pattern, in, false)
	opts = append(opts, http.Operation(OperationManagementDebugTestcase))
	opts = append(opts, http.PathTemplate(pattern))
	err := c.cc.Invoke(ctx, "POST", path, in, &out, opts...)
	if err != nil {
		return nil, err
	}
	return &out, err
}

func (c *ManagementHTTPClientImpl) ExecuteTask(ctx context.Context, in *ExecuteTaskRequest, opts ...http.CallOption) (*emptypb.Empty, error) {
	var out emptypb.Empty
	pattern := "v1/api/management/task/execute"
	path := binding.EncodeURL(pattern, in, false)
	opts = append(opts, http.Operation(OperationManagementExecuteTask))
	opts = append(opts, http.PathTemplate(pattern))
	err := c.cc.Invoke(ctx, "POST", path, in, &out, opts...)
	if err != nil {
		return nil, err
	}
	return &out, err
}

func (c *ManagementHTTPClientImpl) GetProject(ctx context.Context, in *GetProjectRequest, opts ...http.CallOption) (*ProjectInfo, error) {
	var out ProjectInfo
	pattern := "v1/api/management/project/{id}"
	path := binding.EncodeURL(pattern, in, true)
	opts = append(opts, http.Operation(OperationManagementGetProject))
	opts = append(opts, http.PathTemplate(pattern))
	err := c.cc.Invoke(ctx, "GET", path, nil, &out, opts...)
	if err != nil {
		return nil, err
	}
	return &out, err
}

func (c *ManagementHTTPClientImpl) GetTaskProgress(ctx context.Context, in *TaskProgressRequest, opts ...http.CallOption) (*TaskProgressReply, error) {
	var out TaskProgressReply
	pattern := "v1/api/management/task/{id}/progress"
	path := binding.EncodeURL(pattern, in, true)
	opts = append(opts, http.Operation(OperationManagementGetTaskProgress))
	opts = append(opts, http.PathTemplate(pattern))
	err := c.cc.Invoke(ctx, "GET", path, nil, &out, opts...)
	if err != nil {
		return nil, err
	}
	return &out, err
}

func (c *ManagementHTTPClientImpl) GetTestcaseById(ctx context.Context, in *GetTestcaseRequest, opts ...http.CallOption) (*GetTestcaseReply, error) {
	var out GetTestcaseReply
	pattern := "v1/api/management/testcase/{id}"
	path := binding.EncodeURL(pattern, in, true)
	opts = append(opts, http.Operation(OperationManagementGetTestcaseById))
	opts = append(opts, http.PathTemplate(pattern))
	err := c.cc.Invoke(ctx, "GET", path, nil, &out, opts...)
	if err != nil {
		return nil, err
	}
	return &out, err
}

func (c *ManagementHTTPClientImpl) ListApi(ctx context.Context, in *ListApiRequest, opts ...http.CallOption) (*ListApiReply, error) {
	var out ListApiReply
	pattern := "v1/api/management/interface/list/{pageNum}/{pageSize}"
	path := binding.EncodeURL(pattern, in, true)
	opts = append(opts, http.Operation(OperationManagementListApi))
	opts = append(opts, http.PathTemplate(pattern))
	err := c.cc.Invoke(ctx, "GET", path, nil, &out, opts...)
	if err != nil {
		return nil, err
	}
	return &out, err
}

func (c *ManagementHTTPClientImpl) LoadFramework(ctx context.Context, in *LoadFrameworkRequest, opts ...http.CallOption) (*LoadFrameworkReply, error) {
	var out LoadFrameworkReply
	pattern := "v1/api/management/testcase/loadFramework"
	path := binding.EncodeURL(pattern, in, false)
	opts = append(opts, http.Operation(OperationManagementLoadFramework))
	opts = append(opts, http.PathTemplate(pattern))
	err := c.cc.Invoke(ctx, "POST", path, in, &out, opts...)
	if err != nil {
		return nil, err
	}
	return &out, err
}

func (c *ManagementHTTPClientImpl) TaskInfo(ctx context.Context, in *TaskInfoRequest, opts ...http.CallOption) (*Task, error) {
	var out Task
	pattern := "v1/api/management/task/{id}"
	path := binding.EncodeURL(pattern, in, true)
	opts = append(opts, http.Operation(OperationManagementTaskInfo))
	opts = append(opts, http.PathTemplate(pattern))
	err := c.cc.Invoke(ctx, "GET", path, nil, &out, opts...)
	if err != nil {
		return nil, err
	}
	return &out, err
}

func (c *ManagementHTTPClientImpl) Testplan(ctx context.Context, in *TestplanRequest, opts ...http.CallOption) (*TestplanReply, error) {
	var out TestplanReply
	pattern := "v1/api/management/testplan"
	path := binding.EncodeURL(pattern, in, false)
	opts = append(opts, http.Operation(OperationManagementTestplan))
	opts = append(opts, http.PathTemplate(pattern))
	err := c.cc.Invoke(ctx, "POST", path, in, &out, opts...)
	if err != nil {
		return nil, err
	}
	return &out, err
}

func (c *ManagementHTTPClientImpl) UpdateApi(ctx context.Context, in *UpdateApiRequest, opts ...http.CallOption) (*UpdateApiReply, error) {
	var out UpdateApiReply
	pattern := "v1/api/management/interface"
	path := binding.EncodeURL(pattern, in, false)
	opts = append(opts, http.Operation(OperationManagementUpdateApi))
	opts = append(opts, http.PathTemplate(pattern))
	err := c.cc.Invoke(ctx, "PUT", path, in, &out, opts...)
	if err != nil {
		return nil, err
	}
	return &out, err
}

func (c *ManagementHTTPClientImpl) UpdateProject(ctx context.Context, in *UpdateProjectRequest, opts ...http.CallOption) (*emptypb.Empty, error) {
	var out emptypb.Empty
	pattern := "v1/api/management/project"
	path := binding.EncodeURL(pattern, in, false)
	opts = append(opts, http.Operation(OperationManagementUpdateProject))
	opts = append(opts, http.PathTemplate(pattern))
	err := c.cc.Invoke(ctx, "PUT", path, in, &out, opts...)
	if err != nil {
		return nil, err
	}
	return &out, err
}

func (c *ManagementHTTPClientImpl) UpdateTestcase(ctx context.Context, in *UpdateTestcaseRequest, opts ...http.CallOption) (*UpdateTestcaseReply, error) {
	var out UpdateTestcaseReply
	pattern := "v1/api/management/testcase"
	path := binding.EncodeURL(pattern, in, false)
	opts = append(opts, http.Operation(OperationManagementUpdateTestcase))
	opts = append(opts, http.PathTemplate(pattern))
	err := c.cc.Invoke(ctx, "PUT", path, in, &out, opts...)
	if err != nil {
		return nil, err
	}
	return &out, err
}
