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

package console

import (
	context "context"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	status "google.golang.org/grpc/status"
)

// 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 (
	MigrationService_Precheck_FullMethodName                    = "/console.MigrationService/Precheck"
	MigrationService_CreateTask_FullMethodName                  = "/console.MigrationService/CreateTask"
	MigrationService_GetTask_FullMethodName                     = "/console.MigrationService/GetTask"
	MigrationService_ListTasks_FullMethodName                   = "/console.MigrationService/ListTasks"
	MigrationService_DeleteTask_FullMethodName                  = "/console.MigrationService/DeleteTask"
	MigrationService_PauseTask_FullMethodName                   = "/console.MigrationService/PauseTask"
	MigrationService_ResumeTask_FullMethodName                  = "/console.MigrationService/ResumeTask"
	MigrationService_CancelPrecheck_FullMethodName              = "/console.MigrationService/CancelPrecheck"
	MigrationService_GetPrecheck_FullMethodName                 = "/console.MigrationService/GetPrecheck"
	MigrationService_GetSupportedSources_FullMethodName         = "/console.MigrationService/GetSupportedSources"
	MigrationService_GetSourceTables_FullMethodName             = "/console.MigrationService/GetSourceTables"
	MigrationService_ValidateMigrationSourceConn_FullMethodName = "/console.MigrationService/ValidateMigrationSourceConn"
	MigrationService_ValidateMigrationTargetConn_FullMethodName = "/console.MigrationService/ValidateMigrationTargetConn"
	MigrationService_CreateVpcEndpoint_FullMethodName           = "/console.MigrationService/CreateVpcEndpoint"
	MigrationService_DescribeVpcEndpoint_FullMethodName         = "/console.MigrationService/DescribeVpcEndpoint"
	MigrationService_GetVpcInfo_FullMethodName                  = "/console.MigrationService/GetVpcInfo"
	MigrationService_GetIpWhitelist_FullMethodName              = "/console.MigrationService/GetIpWhitelist"
)

// MigrationServiceClient is the client API for MigrationService 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 MigrationServiceClient interface {
	// re-use the param of CreateTask
	Precheck(ctx context.Context, in *CreateMigrationTaskReq, opts ...grpc.CallOption) (*CreateMigrationPrecheckResp, error)
	CreateTask(ctx context.Context, in *CreateMigrationTaskReq, opts ...grpc.CallOption) (*MigrationTask, error)
	GetTask(ctx context.Context, in *GetMigrationTaskReq, opts ...grpc.CallOption) (*MigrationTask, error)
	ListTasks(ctx context.Context, in *ListMigrationTasksReq, opts ...grpc.CallOption) (*ListMigrationTasksResp, error)
	DeleteTask(ctx context.Context, in *DeleteMigrationTaskReq, opts ...grpc.CallOption) (*MigrationTask, error)
	PauseTask(ctx context.Context, in *PauseMigrationTaskReq, opts ...grpc.CallOption) (*EmptyResp, error)
	ResumeTask(ctx context.Context, in *ResumeMigrationTaskReq, opts ...grpc.CallOption) (*EmptyResp, error)
	CancelPrecheck(ctx context.Context, in *CancelMigrationPrecheckReq, opts ...grpc.CallOption) (*EmptyResp, error)
	GetPrecheck(ctx context.Context, in *GetMigrationPrecheckReq, opts ...grpc.CallOption) (*MigrationPrecheck, error)
	GetSupportedSources(ctx context.Context, in *GetSupportedSourcesReq, opts ...grpc.CallOption) (*GetSupportedSourcesResp, error)
	GetSourceTables(ctx context.Context, in *MigrationSourceDBConnProfile, opts ...grpc.CallOption) (*GetSourceTablesResp, error)
	ValidateMigrationSourceConn(ctx context.Context, in *MigrationSourceDBConnProfile, opts ...grpc.CallOption) (*EmptyResp, error)
	ValidateMigrationTargetConn(ctx context.Context, in *MigrationTargetDBConnProfile, opts ...grpc.CallOption) (*EmptyResp, error)
	CreateVpcEndpoint(ctx context.Context, in *CreateEndpointReq, opts ...grpc.CallOption) (*CreateEndpointResp, error)
	DescribeVpcEndpoint(ctx context.Context, in *DescribeEndpointReq, opts ...grpc.CallOption) (*DescribeEndpointResp, error)
	GetVpcInfo(ctx context.Context, in *GetVpcInfoReq, opts ...grpc.CallOption) (*GetVpcInfoResp, error)
	GetIpWhitelist(ctx context.Context, in *GetIpWhitelistReq, opts ...grpc.CallOption) (*GetIpWhitelistResp, error)
}

type migrationServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewMigrationServiceClient(cc grpc.ClientConnInterface) MigrationServiceClient {
	return &migrationServiceClient{cc}
}

func (c *migrationServiceClient) Precheck(ctx context.Context, in *CreateMigrationTaskReq, opts ...grpc.CallOption) (*CreateMigrationPrecheckResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CreateMigrationPrecheckResp)
	err := c.cc.Invoke(ctx, MigrationService_Precheck_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *migrationServiceClient) CreateTask(ctx context.Context, in *CreateMigrationTaskReq, opts ...grpc.CallOption) (*MigrationTask, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(MigrationTask)
	err := c.cc.Invoke(ctx, MigrationService_CreateTask_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *migrationServiceClient) GetTask(ctx context.Context, in *GetMigrationTaskReq, opts ...grpc.CallOption) (*MigrationTask, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(MigrationTask)
	err := c.cc.Invoke(ctx, MigrationService_GetTask_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *migrationServiceClient) ListTasks(ctx context.Context, in *ListMigrationTasksReq, opts ...grpc.CallOption) (*ListMigrationTasksResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListMigrationTasksResp)
	err := c.cc.Invoke(ctx, MigrationService_ListTasks_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *migrationServiceClient) DeleteTask(ctx context.Context, in *DeleteMigrationTaskReq, opts ...grpc.CallOption) (*MigrationTask, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(MigrationTask)
	err := c.cc.Invoke(ctx, MigrationService_DeleteTask_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *migrationServiceClient) PauseTask(ctx context.Context, in *PauseMigrationTaskReq, opts ...grpc.CallOption) (*EmptyResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(EmptyResp)
	err := c.cc.Invoke(ctx, MigrationService_PauseTask_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *migrationServiceClient) ResumeTask(ctx context.Context, in *ResumeMigrationTaskReq, opts ...grpc.CallOption) (*EmptyResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(EmptyResp)
	err := c.cc.Invoke(ctx, MigrationService_ResumeTask_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *migrationServiceClient) CancelPrecheck(ctx context.Context, in *CancelMigrationPrecheckReq, opts ...grpc.CallOption) (*EmptyResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(EmptyResp)
	err := c.cc.Invoke(ctx, MigrationService_CancelPrecheck_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *migrationServiceClient) GetPrecheck(ctx context.Context, in *GetMigrationPrecheckReq, opts ...grpc.CallOption) (*MigrationPrecheck, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(MigrationPrecheck)
	err := c.cc.Invoke(ctx, MigrationService_GetPrecheck_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *migrationServiceClient) GetSupportedSources(ctx context.Context, in *GetSupportedSourcesReq, opts ...grpc.CallOption) (*GetSupportedSourcesResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetSupportedSourcesResp)
	err := c.cc.Invoke(ctx, MigrationService_GetSupportedSources_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *migrationServiceClient) GetSourceTables(ctx context.Context, in *MigrationSourceDBConnProfile, opts ...grpc.CallOption) (*GetSourceTablesResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetSourceTablesResp)
	err := c.cc.Invoke(ctx, MigrationService_GetSourceTables_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *migrationServiceClient) ValidateMigrationSourceConn(ctx context.Context, in *MigrationSourceDBConnProfile, opts ...grpc.CallOption) (*EmptyResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(EmptyResp)
	err := c.cc.Invoke(ctx, MigrationService_ValidateMigrationSourceConn_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *migrationServiceClient) ValidateMigrationTargetConn(ctx context.Context, in *MigrationTargetDBConnProfile, opts ...grpc.CallOption) (*EmptyResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(EmptyResp)
	err := c.cc.Invoke(ctx, MigrationService_ValidateMigrationTargetConn_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *migrationServiceClient) CreateVpcEndpoint(ctx context.Context, in *CreateEndpointReq, opts ...grpc.CallOption) (*CreateEndpointResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(CreateEndpointResp)
	err := c.cc.Invoke(ctx, MigrationService_CreateVpcEndpoint_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *migrationServiceClient) DescribeVpcEndpoint(ctx context.Context, in *DescribeEndpointReq, opts ...grpc.CallOption) (*DescribeEndpointResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DescribeEndpointResp)
	err := c.cc.Invoke(ctx, MigrationService_DescribeVpcEndpoint_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *migrationServiceClient) GetVpcInfo(ctx context.Context, in *GetVpcInfoReq, opts ...grpc.CallOption) (*GetVpcInfoResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetVpcInfoResp)
	err := c.cc.Invoke(ctx, MigrationService_GetVpcInfo_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *migrationServiceClient) GetIpWhitelist(ctx context.Context, in *GetIpWhitelistReq, opts ...grpc.CallOption) (*GetIpWhitelistResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(GetIpWhitelistResp)
	err := c.cc.Invoke(ctx, MigrationService_GetIpWhitelist_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// MigrationServiceServer is the server API for MigrationService service.
// All implementations must embed UnimplementedMigrationServiceServer
// for forward compatibility
type MigrationServiceServer interface {
	// re-use the param of CreateTask
	Precheck(context.Context, *CreateMigrationTaskReq) (*CreateMigrationPrecheckResp, error)
	CreateTask(context.Context, *CreateMigrationTaskReq) (*MigrationTask, error)
	GetTask(context.Context, *GetMigrationTaskReq) (*MigrationTask, error)
	ListTasks(context.Context, *ListMigrationTasksReq) (*ListMigrationTasksResp, error)
	DeleteTask(context.Context, *DeleteMigrationTaskReq) (*MigrationTask, error)
	PauseTask(context.Context, *PauseMigrationTaskReq) (*EmptyResp, error)
	ResumeTask(context.Context, *ResumeMigrationTaskReq) (*EmptyResp, error)
	CancelPrecheck(context.Context, *CancelMigrationPrecheckReq) (*EmptyResp, error)
	GetPrecheck(context.Context, *GetMigrationPrecheckReq) (*MigrationPrecheck, error)
	GetSupportedSources(context.Context, *GetSupportedSourcesReq) (*GetSupportedSourcesResp, error)
	GetSourceTables(context.Context, *MigrationSourceDBConnProfile) (*GetSourceTablesResp, error)
	ValidateMigrationSourceConn(context.Context, *MigrationSourceDBConnProfile) (*EmptyResp, error)
	ValidateMigrationTargetConn(context.Context, *MigrationTargetDBConnProfile) (*EmptyResp, error)
	CreateVpcEndpoint(context.Context, *CreateEndpointReq) (*CreateEndpointResp, error)
	DescribeVpcEndpoint(context.Context, *DescribeEndpointReq) (*DescribeEndpointResp, error)
	GetVpcInfo(context.Context, *GetVpcInfoReq) (*GetVpcInfoResp, error)
	GetIpWhitelist(context.Context, *GetIpWhitelistReq) (*GetIpWhitelistResp, error)
	mustEmbedUnimplementedMigrationServiceServer()
}

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

func (UnimplementedMigrationServiceServer) Precheck(context.Context, *CreateMigrationTaskReq) (*CreateMigrationPrecheckResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Precheck not implemented")
}
func (UnimplementedMigrationServiceServer) CreateTask(context.Context, *CreateMigrationTaskReq) (*MigrationTask, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateTask not implemented")
}
func (UnimplementedMigrationServiceServer) GetTask(context.Context, *GetMigrationTaskReq) (*MigrationTask, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetTask not implemented")
}
func (UnimplementedMigrationServiceServer) ListTasks(context.Context, *ListMigrationTasksReq) (*ListMigrationTasksResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListTasks not implemented")
}
func (UnimplementedMigrationServiceServer) DeleteTask(context.Context, *DeleteMigrationTaskReq) (*MigrationTask, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteTask not implemented")
}
func (UnimplementedMigrationServiceServer) PauseTask(context.Context, *PauseMigrationTaskReq) (*EmptyResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PauseTask not implemented")
}
func (UnimplementedMigrationServiceServer) ResumeTask(context.Context, *ResumeMigrationTaskReq) (*EmptyResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ResumeTask not implemented")
}
func (UnimplementedMigrationServiceServer) CancelPrecheck(context.Context, *CancelMigrationPrecheckReq) (*EmptyResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CancelPrecheck not implemented")
}
func (UnimplementedMigrationServiceServer) GetPrecheck(context.Context, *GetMigrationPrecheckReq) (*MigrationPrecheck, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetPrecheck not implemented")
}
func (UnimplementedMigrationServiceServer) GetSupportedSources(context.Context, *GetSupportedSourcesReq) (*GetSupportedSourcesResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetSupportedSources not implemented")
}
func (UnimplementedMigrationServiceServer) GetSourceTables(context.Context, *MigrationSourceDBConnProfile) (*GetSourceTablesResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetSourceTables not implemented")
}
func (UnimplementedMigrationServiceServer) ValidateMigrationSourceConn(context.Context, *MigrationSourceDBConnProfile) (*EmptyResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ValidateMigrationSourceConn not implemented")
}
func (UnimplementedMigrationServiceServer) ValidateMigrationTargetConn(context.Context, *MigrationTargetDBConnProfile) (*EmptyResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ValidateMigrationTargetConn not implemented")
}
func (UnimplementedMigrationServiceServer) CreateVpcEndpoint(context.Context, *CreateEndpointReq) (*CreateEndpointResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateVpcEndpoint not implemented")
}
func (UnimplementedMigrationServiceServer) DescribeVpcEndpoint(context.Context, *DescribeEndpointReq) (*DescribeEndpointResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DescribeVpcEndpoint not implemented")
}
func (UnimplementedMigrationServiceServer) GetVpcInfo(context.Context, *GetVpcInfoReq) (*GetVpcInfoResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetVpcInfo not implemented")
}
func (UnimplementedMigrationServiceServer) GetIpWhitelist(context.Context, *GetIpWhitelistReq) (*GetIpWhitelistResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetIpWhitelist not implemented")
}
func (UnimplementedMigrationServiceServer) mustEmbedUnimplementedMigrationServiceServer() {}

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

func RegisterMigrationServiceServer(s grpc.ServiceRegistrar, srv MigrationServiceServer) {
	s.RegisterService(&MigrationService_ServiceDesc, srv)
}

func _MigrationService_Precheck_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateMigrationTaskReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MigrationServiceServer).Precheck(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: MigrationService_Precheck_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MigrationServiceServer).Precheck(ctx, req.(*CreateMigrationTaskReq))
	}
	return interceptor(ctx, in, info, handler)
}

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

func _MigrationService_GetTask_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetMigrationTaskReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MigrationServiceServer).GetTask(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: MigrationService_GetTask_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MigrationServiceServer).GetTask(ctx, req.(*GetMigrationTaskReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _MigrationService_ListTasks_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListMigrationTasksReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MigrationServiceServer).ListTasks(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: MigrationService_ListTasks_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MigrationServiceServer).ListTasks(ctx, req.(*ListMigrationTasksReq))
	}
	return interceptor(ctx, in, info, handler)
}

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

func _MigrationService_PauseTask_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PauseMigrationTaskReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MigrationServiceServer).PauseTask(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: MigrationService_PauseTask_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MigrationServiceServer).PauseTask(ctx, req.(*PauseMigrationTaskReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _MigrationService_ResumeTask_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ResumeMigrationTaskReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MigrationServiceServer).ResumeTask(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: MigrationService_ResumeTask_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MigrationServiceServer).ResumeTask(ctx, req.(*ResumeMigrationTaskReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _MigrationService_CancelPrecheck_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CancelMigrationPrecheckReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MigrationServiceServer).CancelPrecheck(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: MigrationService_CancelPrecheck_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MigrationServiceServer).CancelPrecheck(ctx, req.(*CancelMigrationPrecheckReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _MigrationService_GetPrecheck_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetMigrationPrecheckReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MigrationServiceServer).GetPrecheck(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: MigrationService_GetPrecheck_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MigrationServiceServer).GetPrecheck(ctx, req.(*GetMigrationPrecheckReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _MigrationService_GetSupportedSources_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetSupportedSourcesReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MigrationServiceServer).GetSupportedSources(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: MigrationService_GetSupportedSources_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MigrationServiceServer).GetSupportedSources(ctx, req.(*GetSupportedSourcesReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _MigrationService_GetSourceTables_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MigrationSourceDBConnProfile)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MigrationServiceServer).GetSourceTables(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: MigrationService_GetSourceTables_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MigrationServiceServer).GetSourceTables(ctx, req.(*MigrationSourceDBConnProfile))
	}
	return interceptor(ctx, in, info, handler)
}

func _MigrationService_ValidateMigrationSourceConn_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MigrationSourceDBConnProfile)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MigrationServiceServer).ValidateMigrationSourceConn(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: MigrationService_ValidateMigrationSourceConn_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MigrationServiceServer).ValidateMigrationSourceConn(ctx, req.(*MigrationSourceDBConnProfile))
	}
	return interceptor(ctx, in, info, handler)
}

func _MigrationService_ValidateMigrationTargetConn_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(MigrationTargetDBConnProfile)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MigrationServiceServer).ValidateMigrationTargetConn(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: MigrationService_ValidateMigrationTargetConn_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MigrationServiceServer).ValidateMigrationTargetConn(ctx, req.(*MigrationTargetDBConnProfile))
	}
	return interceptor(ctx, in, info, handler)
}

func _MigrationService_CreateVpcEndpoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateEndpointReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MigrationServiceServer).CreateVpcEndpoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: MigrationService_CreateVpcEndpoint_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MigrationServiceServer).CreateVpcEndpoint(ctx, req.(*CreateEndpointReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _MigrationService_DescribeVpcEndpoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DescribeEndpointReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MigrationServiceServer).DescribeVpcEndpoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: MigrationService_DescribeVpcEndpoint_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MigrationServiceServer).DescribeVpcEndpoint(ctx, req.(*DescribeEndpointReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _MigrationService_GetVpcInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetVpcInfoReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MigrationServiceServer).GetVpcInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: MigrationService_GetVpcInfo_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MigrationServiceServer).GetVpcInfo(ctx, req.(*GetVpcInfoReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _MigrationService_GetIpWhitelist_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetIpWhitelistReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(MigrationServiceServer).GetIpWhitelist(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: MigrationService_GetIpWhitelist_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(MigrationServiceServer).GetIpWhitelist(ctx, req.(*GetIpWhitelistReq))
	}
	return interceptor(ctx, in, info, handler)
}

// MigrationService_ServiceDesc is the grpc.ServiceDesc for MigrationService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var MigrationService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "console.MigrationService",
	HandlerType: (*MigrationServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Precheck",
			Handler:    _MigrationService_Precheck_Handler,
		},
		{
			MethodName: "CreateTask",
			Handler:    _MigrationService_CreateTask_Handler,
		},
		{
			MethodName: "GetTask",
			Handler:    _MigrationService_GetTask_Handler,
		},
		{
			MethodName: "ListTasks",
			Handler:    _MigrationService_ListTasks_Handler,
		},
		{
			MethodName: "DeleteTask",
			Handler:    _MigrationService_DeleteTask_Handler,
		},
		{
			MethodName: "PauseTask",
			Handler:    _MigrationService_PauseTask_Handler,
		},
		{
			MethodName: "ResumeTask",
			Handler:    _MigrationService_ResumeTask_Handler,
		},
		{
			MethodName: "CancelPrecheck",
			Handler:    _MigrationService_CancelPrecheck_Handler,
		},
		{
			MethodName: "GetPrecheck",
			Handler:    _MigrationService_GetPrecheck_Handler,
		},
		{
			MethodName: "GetSupportedSources",
			Handler:    _MigrationService_GetSupportedSources_Handler,
		},
		{
			MethodName: "GetSourceTables",
			Handler:    _MigrationService_GetSourceTables_Handler,
		},
		{
			MethodName: "ValidateMigrationSourceConn",
			Handler:    _MigrationService_ValidateMigrationSourceConn_Handler,
		},
		{
			MethodName: "ValidateMigrationTargetConn",
			Handler:    _MigrationService_ValidateMigrationTargetConn_Handler,
		},
		{
			MethodName: "CreateVpcEndpoint",
			Handler:    _MigrationService_CreateVpcEndpoint_Handler,
		},
		{
			MethodName: "DescribeVpcEndpoint",
			Handler:    _MigrationService_DescribeVpcEndpoint_Handler,
		},
		{
			MethodName: "GetVpcInfo",
			Handler:    _MigrationService_GetVpcInfo_Handler,
		},
		{
			MethodName: "GetIpWhitelist",
			Handler:    _MigrationService_GetIpWhitelist_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "console/dm.proto",
}