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

package console

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

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

const (
	ImportService_Upload_FullMethodName                  = "/console.ImportService/Upload"
	ImportService_ListImports_FullMethodName             = "/console.ImportService/ListImports"
	ImportService_CreateImport_FullMethodName            = "/console.ImportService/CreateImport"
	ImportService_GetImport_FullMethodName               = "/console.ImportService/GetImport"
	ImportService_CancelImport_FullMethodName            = "/console.ImportService/CancelImport"
	ImportService_PreviewLocal_FullMethodName            = "/console.ImportService/PreviewLocal"
	ImportService_GetTableColumns_FullMethodName         = "/console.ImportService/GetTableColumns"
	ImportService_GetDataIngestionProfile_FullMethodName = "/console.ImportService/GetDataIngestionProfile"
	ImportService_ListSupportedDataTypes_FullMethodName  = "/console.ImportService/ListSupportedDataTypes"
	ImportService_ValidateImport_FullMethodName          = "/console.ImportService/ValidateImport"
	ImportService_Precheck_FullMethodName                = "/console.ImportService/Precheck"
	ImportService_ListTargetTables_FullMethodName        = "/console.ImportService/ListTargetTables"
)

// ImportServiceClient is the client API for ImportService 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.
//
// Service for managing TiDB Serverless import.
type ImportServiceClient interface {
	// Generate Upload url for importing data.
	Upload(ctx context.Context, in *UploadRequest, opts ...grpc.CallOption) (*UploadResponse, error)
	// Provides a list of import jobs.
	ListImports(ctx context.Context, in *ListImportsReq, opts ...grpc.CallOption) (*ListImportsResp, error)
	// Create an import job.
	CreateImport(ctx context.Context, in *CreateImportReq, opts ...grpc.CallOption) (*Import, error)
	// Get an import detailed information.
	GetImport(ctx context.Context, in *ImportIds, opts ...grpc.CallOption) (*Import, error)
	// Cancel an import job.
	CancelImport(ctx context.Context, in *ImportIds, opts ...grpc.CallOption) (*Import, error)
	// Preview the local import result.
	PreviewLocal(ctx context.Context, in *ImportsPreviewLocalReq, opts ...grpc.CallOption) (*ImportsPreviewLocalResp, error)
	// Get the columns of a table.
	GetTableColumns(ctx context.Context, in *ImportsGetTableColumnsReq, opts ...grpc.CallOption) (*ImportsGetTableColumnsResp, error)
	// Get the data ingestion profile of a cluster.
	GetDataIngestionProfile(ctx context.Context, in *GetProfileReq, opts ...grpc.CallOption) (*DataIngestionProfile, error)
	// List the data types supported by the import.
	ListSupportedDataTypes(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*ImportsSupportedDataTypesResp, error)
	// Validate the import.
	ValidateImport(ctx context.Context, in *ValidateImportReq, opts ...grpc.CallOption) (*ValidateImportResp, error)
	// Precheck and return the scan result.
	Precheck(ctx context.Context, in *PrecheckReq, opts ...grpc.CallOption) (*PrecheckResp, error)
	// List the target tables.
	ListTargetTables(ctx context.Context, in *ListTargetTablesReq, opts ...grpc.CallOption) (*ListTargetTablesResp, error)
}

type importServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewImportServiceClient(cc grpc.ClientConnInterface) ImportServiceClient {
	return &importServiceClient{cc}
}

func (c *importServiceClient) Upload(ctx context.Context, in *UploadRequest, opts ...grpc.CallOption) (*UploadResponse, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(UploadResponse)
	err := c.cc.Invoke(ctx, ImportService_Upload_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *importServiceClient) ListImports(ctx context.Context, in *ListImportsReq, opts ...grpc.CallOption) (*ListImportsResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListImportsResp)
	err := c.cc.Invoke(ctx, ImportService_ListImports_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *importServiceClient) CreateImport(ctx context.Context, in *CreateImportReq, opts ...grpc.CallOption) (*Import, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Import)
	err := c.cc.Invoke(ctx, ImportService_CreateImport_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *importServiceClient) GetImport(ctx context.Context, in *ImportIds, opts ...grpc.CallOption) (*Import, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Import)
	err := c.cc.Invoke(ctx, ImportService_GetImport_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *importServiceClient) CancelImport(ctx context.Context, in *ImportIds, opts ...grpc.CallOption) (*Import, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(Import)
	err := c.cc.Invoke(ctx, ImportService_CancelImport_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *importServiceClient) PreviewLocal(ctx context.Context, in *ImportsPreviewLocalReq, opts ...grpc.CallOption) (*ImportsPreviewLocalResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ImportsPreviewLocalResp)
	err := c.cc.Invoke(ctx, ImportService_PreviewLocal_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *importServiceClient) GetTableColumns(ctx context.Context, in *ImportsGetTableColumnsReq, opts ...grpc.CallOption) (*ImportsGetTableColumnsResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ImportsGetTableColumnsResp)
	err := c.cc.Invoke(ctx, ImportService_GetTableColumns_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *importServiceClient) GetDataIngestionProfile(ctx context.Context, in *GetProfileReq, opts ...grpc.CallOption) (*DataIngestionProfile, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(DataIngestionProfile)
	err := c.cc.Invoke(ctx, ImportService_GetDataIngestionProfile_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

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

func (c *importServiceClient) ValidateImport(ctx context.Context, in *ValidateImportReq, opts ...grpc.CallOption) (*ValidateImportResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ValidateImportResp)
	err := c.cc.Invoke(ctx, ImportService_ValidateImport_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

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

func (c *importServiceClient) ListTargetTables(ctx context.Context, in *ListTargetTablesReq, opts ...grpc.CallOption) (*ListTargetTablesResp, error) {
	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
	out := new(ListTargetTablesResp)
	err := c.cc.Invoke(ctx, ImportService_ListTargetTables_FullMethodName, in, out, cOpts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ImportServiceServer is the server API for ImportService service.
// All implementations must embed UnimplementedImportServiceServer
// for forward compatibility
//
// Service for managing TiDB Serverless import.
type ImportServiceServer interface {
	// Generate Upload url for importing data.
	Upload(context.Context, *UploadRequest) (*UploadResponse, error)
	// Provides a list of import jobs.
	ListImports(context.Context, *ListImportsReq) (*ListImportsResp, error)
	// Create an import job.
	CreateImport(context.Context, *CreateImportReq) (*Import, error)
	// Get an import detailed information.
	GetImport(context.Context, *ImportIds) (*Import, error)
	// Cancel an import job.
	CancelImport(context.Context, *ImportIds) (*Import, error)
	// Preview the local import result.
	PreviewLocal(context.Context, *ImportsPreviewLocalReq) (*ImportsPreviewLocalResp, error)
	// Get the columns of a table.
	GetTableColumns(context.Context, *ImportsGetTableColumnsReq) (*ImportsGetTableColumnsResp, error)
	// Get the data ingestion profile of a cluster.
	GetDataIngestionProfile(context.Context, *GetProfileReq) (*DataIngestionProfile, error)
	// List the data types supported by the import.
	ListSupportedDataTypes(context.Context, *emptypb.Empty) (*ImportsSupportedDataTypesResp, error)
	// Validate the import.
	ValidateImport(context.Context, *ValidateImportReq) (*ValidateImportResp, error)
	// Precheck and return the scan result.
	Precheck(context.Context, *PrecheckReq) (*PrecheckResp, error)
	// List the target tables.
	ListTargetTables(context.Context, *ListTargetTablesReq) (*ListTargetTablesResp, error)
	mustEmbedUnimplementedImportServiceServer()
}

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

func (UnimplementedImportServiceServer) Upload(context.Context, *UploadRequest) (*UploadResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Upload not implemented")
}
func (UnimplementedImportServiceServer) ListImports(context.Context, *ListImportsReq) (*ListImportsResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListImports not implemented")
}
func (UnimplementedImportServiceServer) CreateImport(context.Context, *CreateImportReq) (*Import, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateImport not implemented")
}
func (UnimplementedImportServiceServer) GetImport(context.Context, *ImportIds) (*Import, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetImport not implemented")
}
func (UnimplementedImportServiceServer) CancelImport(context.Context, *ImportIds) (*Import, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CancelImport not implemented")
}
func (UnimplementedImportServiceServer) PreviewLocal(context.Context, *ImportsPreviewLocalReq) (*ImportsPreviewLocalResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PreviewLocal not implemented")
}
func (UnimplementedImportServiceServer) GetTableColumns(context.Context, *ImportsGetTableColumnsReq) (*ImportsGetTableColumnsResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetTableColumns not implemented")
}
func (UnimplementedImportServiceServer) GetDataIngestionProfile(context.Context, *GetProfileReq) (*DataIngestionProfile, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetDataIngestionProfile not implemented")
}
func (UnimplementedImportServiceServer) ListSupportedDataTypes(context.Context, *emptypb.Empty) (*ImportsSupportedDataTypesResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListSupportedDataTypes not implemented")
}
func (UnimplementedImportServiceServer) ValidateImport(context.Context, *ValidateImportReq) (*ValidateImportResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ValidateImport not implemented")
}
func (UnimplementedImportServiceServer) Precheck(context.Context, *PrecheckReq) (*PrecheckResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Precheck not implemented")
}
func (UnimplementedImportServiceServer) ListTargetTables(context.Context, *ListTargetTablesReq) (*ListTargetTablesResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListTargetTables not implemented")
}
func (UnimplementedImportServiceServer) mustEmbedUnimplementedImportServiceServer() {}

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

func RegisterImportServiceServer(s grpc.ServiceRegistrar, srv ImportServiceServer) {
	s.RegisterService(&ImportService_ServiceDesc, srv)
}

func _ImportService_Upload_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UploadRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ImportServiceServer).Upload(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ImportService_Upload_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ImportServiceServer).Upload(ctx, req.(*UploadRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _ImportService_ListImports_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListImportsReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ImportServiceServer).ListImports(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ImportService_ListImports_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ImportServiceServer).ListImports(ctx, req.(*ListImportsReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ImportService_CreateImport_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateImportReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ImportServiceServer).CreateImport(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ImportService_CreateImport_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ImportServiceServer).CreateImport(ctx, req.(*CreateImportReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ImportService_GetImport_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ImportIds)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ImportServiceServer).GetImport(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ImportService_GetImport_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ImportServiceServer).GetImport(ctx, req.(*ImportIds))
	}
	return interceptor(ctx, in, info, handler)
}

func _ImportService_CancelImport_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ImportIds)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ImportServiceServer).CancelImport(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ImportService_CancelImport_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ImportServiceServer).CancelImport(ctx, req.(*ImportIds))
	}
	return interceptor(ctx, in, info, handler)
}

func _ImportService_PreviewLocal_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ImportsPreviewLocalReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ImportServiceServer).PreviewLocal(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ImportService_PreviewLocal_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ImportServiceServer).PreviewLocal(ctx, req.(*ImportsPreviewLocalReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ImportService_GetTableColumns_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ImportsGetTableColumnsReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ImportServiceServer).GetTableColumns(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ImportService_GetTableColumns_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ImportServiceServer).GetTableColumns(ctx, req.(*ImportsGetTableColumnsReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ImportService_GetDataIngestionProfile_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetProfileReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ImportServiceServer).GetDataIngestionProfile(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ImportService_GetDataIngestionProfile_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ImportServiceServer).GetDataIngestionProfile(ctx, req.(*GetProfileReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ImportService_ListSupportedDataTypes_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.(ImportServiceServer).ListSupportedDataTypes(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ImportService_ListSupportedDataTypes_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ImportServiceServer).ListSupportedDataTypes(ctx, req.(*emptypb.Empty))
	}
	return interceptor(ctx, in, info, handler)
}

func _ImportService_ValidateImport_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ValidateImportReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ImportServiceServer).ValidateImport(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ImportService_ValidateImport_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ImportServiceServer).ValidateImport(ctx, req.(*ValidateImportReq))
	}
	return interceptor(ctx, in, info, handler)
}

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

func _ImportService_ListTargetTables_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListTargetTablesReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ImportServiceServer).ListTargetTables(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ImportService_ListTargetTables_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ImportServiceServer).ListTargetTables(ctx, req.(*ListTargetTablesReq))
	}
	return interceptor(ctx, in, info, handler)
}

// ImportService_ServiceDesc is the grpc.ServiceDesc for ImportService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var ImportService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "console.ImportService",
	HandlerType: (*ImportServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Upload",
			Handler:    _ImportService_Upload_Handler,
		},
		{
			MethodName: "ListImports",
			Handler:    _ImportService_ListImports_Handler,
		},
		{
			MethodName: "CreateImport",
			Handler:    _ImportService_CreateImport_Handler,
		},
		{
			MethodName: "GetImport",
			Handler:    _ImportService_GetImport_Handler,
		},
		{
			MethodName: "CancelImport",
			Handler:    _ImportService_CancelImport_Handler,
		},
		{
			MethodName: "PreviewLocal",
			Handler:    _ImportService_PreviewLocal_Handler,
		},
		{
			MethodName: "GetTableColumns",
			Handler:    _ImportService_GetTableColumns_Handler,
		},
		{
			MethodName: "GetDataIngestionProfile",
			Handler:    _ImportService_GetDataIngestionProfile_Handler,
		},
		{
			MethodName: "ListSupportedDataTypes",
			Handler:    _ImportService_ListSupportedDataTypes_Handler,
		},
		{
			MethodName: "ValidateImport",
			Handler:    _ImportService_ValidateImport_Handler,
		},
		{
			MethodName: "Precheck",
			Handler:    _ImportService_Precheck_Handler,
		},
		{
			MethodName: "ListTargetTables",
			Handler:    _ImportService_ListTargetTables_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "console/import.proto",
}