// Code generated by protoc-gen-go-grpc. DO NOT EDIT.
// versions:
// - protoc-gen-go-grpc v1.3.0
// - protoc             (unknown)
// source: dataflow/service.proto

// gRPC for our DBaaS dataflow service
//
// notably uses gRPC-Gateway with OpenAPI

package dataflow

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"
	structpb "google.golang.org/protobuf/types/known/structpb"
)

// 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 (
	ImportService_Precheck_FullMethodName                 = "/dataflow.ImportService/Precheck"
	ImportService_Create_FullMethodName                   = "/dataflow.ImportService/Create"
	ImportService_Get_FullMethodName                      = "/dataflow.ImportService/Get"
	ImportService_List_FullMethodName                     = "/dataflow.ImportService/List"
	ImportService_Cancel_FullMethodName                   = "/dataflow.ImportService/Cancel"
	ImportService_Exit_FullMethodName                     = "/dataflow.ImportService/Exit"
	ImportService_GetDataIngestionProfile_FullMethodName  = "/dataflow.ImportService/GetDataIngestionProfile"
	ImportService_GetS3BucketRegion_FullMethodName        = "/dataflow.ImportService/GetS3BucketRegion"
	ImportService_Validate_FullMethodName                 = "/dataflow.ImportService/Validate"
	ImportService_ApplyTableFilters_FullMethodName        = "/dataflow.ImportService/ApplyTableFilters"
	ImportService_GetSchemasMeta_FullMethodName           = "/dataflow.ImportService/GetSchemasMeta"
	ImportService_Preview_FullMethodName                  = "/dataflow.ImportService/Preview"
	ImportService_PreviewCsvFile_FullMethodName           = "/dataflow.ImportService/PreviewCsvFile"
	ImportService_GenerateUploadUrl_FullMethodName        = "/dataflow.ImportService/GenerateUploadUrl"
	ImportService_PreviewLocal_FullMethodName             = "/dataflow.ImportService/PreviewLocal"
	ImportService_ListDataTypes_FullMethodName            = "/dataflow.ImportService/ListDataTypes"
	ImportService_GetTableColumns_FullMethodName          = "/dataflow.ImportService/GetTableColumns"
	ImportService_GetClusterTables_FullMethodName         = "/dataflow.ImportService/GetClusterTables"
	ImportService_ValidateTargetTableEmpty_FullMethodName = "/dataflow.ImportService/ValidateTargetTableEmpty"
	ImportService_SearchImportFiles_FullMethodName        = "/dataflow.ImportService/SearchImportFiles"
)

// 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.
type ImportServiceClient interface {
	// Precheck and return the scan result.
	Precheck(ctx context.Context, in *ImportPrecheckReq, opts ...grpc.CallOption) (*ImportPrecheckResp, error)
	Create(ctx context.Context, in *ImportCreateReq, opts ...grpc.CallOption) (*ClusterImportId, error)
	Get(ctx context.Context, in *ClusterImportId, opts ...grpc.CallOption) (*ImportGetResp, error)
	List(ctx context.Context, in *ListImportReq, opts ...grpc.CallOption) (*ListImportResp, error)
	// Cancel the import and mark the status as 'canceled' status.
	Cancel(ctx context.Context, in *ClusterImportId, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// Exit make the cluster exit the importing status
	// By design, when the cluster in the importing status, will display the
	// importing information and can not see the metrics than display at normal
	// status and some operation like scale is also forbidden. After the import
	// finish, the cluster will still keep on importing status for user to check
	// the result, the user must click the 'Exit' button to exit the importing
	// status explicitly. only finished status(success, failed, canceled) of a
	// import can exit the importing status.
	Exit(ctx context.Context, in *ClusterImportId, opts ...grpc.CallOption) (*emptypb.Empty, error)
	GetDataIngestionProfile(ctx context.Context, in *ClusterIdReq, opts ...grpc.CallOption) (*DataIngestionProfile, error)
	GetS3BucketRegion(ctx context.Context, in *GetS3BucketRegionReq, opts ...grpc.CallOption) (*GetS3BucketRegionResp, error)
	Validate(ctx context.Context, in *ImportValidateReq, opts ...grpc.CallOption) (*emptypb.Empty, error)
	ApplyTableFilters(ctx context.Context, in *ImportsApplyTableFiltersReq, opts ...grpc.CallOption) (*ImportsApplyTableFiltersResp, error)
	GetSchemasMeta(ctx context.Context, in *ImportsGetSchemasMetaReq, opts ...grpc.CallOption) (*ImportsGetSchemasMetaResp, error)
	Preview(ctx context.Context, in *ImportsPreviewReq, opts ...grpc.CallOption) (*ImportsPreviewResp, error)
	PreviewCsvFile(ctx context.Context, in *ImportsPreviewCsvFileReq, opts ...grpc.CallOption) (*ImportsPreviewCsvFileResp, error)
	GenerateUploadUrl(ctx context.Context, in *ImportsGenerateUploadUrlReq, opts ...grpc.CallOption) (*ImportsGenerateUploadUrlResp, error)
	PreviewLocal(ctx context.Context, in *ImportsPreviewLocalReq, opts ...grpc.CallOption) (*ImportsPreviewLocalResp, error)
	ListDataTypes(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*ImportsListDataTypesResp, error)
	GetTableColumns(ctx context.Context, in *ImportsGetTableColumnsReq, opts ...grpc.CallOption) (*ImportsGetTableColumnsResp, error)
	GetClusterTables(ctx context.Context, in *ImportsGetClusterTablesReq, opts ...grpc.CallOption) (*ImportsGetClusterTablesResp, error)
	ValidateTargetTableEmpty(ctx context.Context, in *ImportsValidateTargetTableEmptyReq, opts ...grpc.CallOption) (*emptypb.Empty, error)
	SearchImportFiles(ctx context.Context, in *ImportsSearchImportFilesReq, opts ...grpc.CallOption) (*ImportsSearchImportFilesResp, error)
}

type importServiceClient struct {
	cc grpc.ClientConnInterface
}

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

func (c *importServiceClient) Precheck(ctx context.Context, in *ImportPrecheckReq, opts ...grpc.CallOption) (*ImportPrecheckResp, error) {
	out := new(ImportPrecheckResp)
	err := c.cc.Invoke(ctx, ImportService_Precheck_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *importServiceClient) Create(ctx context.Context, in *ImportCreateReq, opts ...grpc.CallOption) (*ClusterImportId, error) {
	out := new(ClusterImportId)
	err := c.cc.Invoke(ctx, ImportService_Create_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *importServiceClient) Get(ctx context.Context, in *ClusterImportId, opts ...grpc.CallOption) (*ImportGetResp, error) {
	out := new(ImportGetResp)
	err := c.cc.Invoke(ctx, ImportService_Get_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *importServiceClient) List(ctx context.Context, in *ListImportReq, opts ...grpc.CallOption) (*ListImportResp, error) {
	out := new(ListImportResp)
	err := c.cc.Invoke(ctx, ImportService_List_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *importServiceClient) Cancel(ctx context.Context, in *ClusterImportId, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, ImportService_Cancel_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *importServiceClient) Exit(ctx context.Context, in *ClusterImportId, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, ImportService_Exit_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

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

func (c *importServiceClient) GetS3BucketRegion(ctx context.Context, in *GetS3BucketRegionReq, opts ...grpc.CallOption) (*GetS3BucketRegionResp, error) {
	out := new(GetS3BucketRegionResp)
	err := c.cc.Invoke(ctx, ImportService_GetS3BucketRegion_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *importServiceClient) Validate(ctx context.Context, in *ImportValidateReq, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, ImportService_Validate_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *importServiceClient) ApplyTableFilters(ctx context.Context, in *ImportsApplyTableFiltersReq, opts ...grpc.CallOption) (*ImportsApplyTableFiltersResp, error) {
	out := new(ImportsApplyTableFiltersResp)
	err := c.cc.Invoke(ctx, ImportService_ApplyTableFilters_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *importServiceClient) GetSchemasMeta(ctx context.Context, in *ImportsGetSchemasMetaReq, opts ...grpc.CallOption) (*ImportsGetSchemasMetaResp, error) {
	out := new(ImportsGetSchemasMetaResp)
	err := c.cc.Invoke(ctx, ImportService_GetSchemasMeta_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *importServiceClient) Preview(ctx context.Context, in *ImportsPreviewReq, opts ...grpc.CallOption) (*ImportsPreviewResp, error) {
	out := new(ImportsPreviewResp)
	err := c.cc.Invoke(ctx, ImportService_Preview_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *importServiceClient) PreviewCsvFile(ctx context.Context, in *ImportsPreviewCsvFileReq, opts ...grpc.CallOption) (*ImportsPreviewCsvFileResp, error) {
	out := new(ImportsPreviewCsvFileResp)
	err := c.cc.Invoke(ctx, ImportService_PreviewCsvFile_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *importServiceClient) GenerateUploadUrl(ctx context.Context, in *ImportsGenerateUploadUrlReq, opts ...grpc.CallOption) (*ImportsGenerateUploadUrlResp, error) {
	out := new(ImportsGenerateUploadUrlResp)
	err := c.cc.Invoke(ctx, ImportService_GenerateUploadUrl_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

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

func (c *importServiceClient) ListDataTypes(ctx context.Context, in *emptypb.Empty, opts ...grpc.CallOption) (*ImportsListDataTypesResp, error) {
	out := new(ImportsListDataTypesResp)
	err := c.cc.Invoke(ctx, ImportService_ListDataTypes_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

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

func (c *importServiceClient) GetClusterTables(ctx context.Context, in *ImportsGetClusterTablesReq, opts ...grpc.CallOption) (*ImportsGetClusterTablesResp, error) {
	out := new(ImportsGetClusterTablesResp)
	err := c.cc.Invoke(ctx, ImportService_GetClusterTables_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *importServiceClient) ValidateTargetTableEmpty(ctx context.Context, in *ImportsValidateTargetTableEmptyReq, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, ImportService_ValidateTargetTableEmpty_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *importServiceClient) SearchImportFiles(ctx context.Context, in *ImportsSearchImportFilesReq, opts ...grpc.CallOption) (*ImportsSearchImportFilesResp, error) {
	out := new(ImportsSearchImportFilesResp)
	err := c.cc.Invoke(ctx, ImportService_SearchImportFiles_FullMethodName, in, out, opts...)
	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
type ImportServiceServer interface {
	// Precheck and return the scan result.
	Precheck(context.Context, *ImportPrecheckReq) (*ImportPrecheckResp, error)
	Create(context.Context, *ImportCreateReq) (*ClusterImportId, error)
	Get(context.Context, *ClusterImportId) (*ImportGetResp, error)
	List(context.Context, *ListImportReq) (*ListImportResp, error)
	// Cancel the import and mark the status as 'canceled' status.
	Cancel(context.Context, *ClusterImportId) (*emptypb.Empty, error)
	// Exit make the cluster exit the importing status
	// By design, when the cluster in the importing status, will display the
	// importing information and can not see the metrics than display at normal
	// status and some operation like scale is also forbidden. After the import
	// finish, the cluster will still keep on importing status for user to check
	// the result, the user must click the 'Exit' button to exit the importing
	// status explicitly. only finished status(success, failed, canceled) of a
	// import can exit the importing status.
	Exit(context.Context, *ClusterImportId) (*emptypb.Empty, error)
	GetDataIngestionProfile(context.Context, *ClusterIdReq) (*DataIngestionProfile, error)
	GetS3BucketRegion(context.Context, *GetS3BucketRegionReq) (*GetS3BucketRegionResp, error)
	Validate(context.Context, *ImportValidateReq) (*emptypb.Empty, error)
	ApplyTableFilters(context.Context, *ImportsApplyTableFiltersReq) (*ImportsApplyTableFiltersResp, error)
	GetSchemasMeta(context.Context, *ImportsGetSchemasMetaReq) (*ImportsGetSchemasMetaResp, error)
	Preview(context.Context, *ImportsPreviewReq) (*ImportsPreviewResp, error)
	PreviewCsvFile(context.Context, *ImportsPreviewCsvFileReq) (*ImportsPreviewCsvFileResp, error)
	GenerateUploadUrl(context.Context, *ImportsGenerateUploadUrlReq) (*ImportsGenerateUploadUrlResp, error)
	PreviewLocal(context.Context, *ImportsPreviewLocalReq) (*ImportsPreviewLocalResp, error)
	ListDataTypes(context.Context, *emptypb.Empty) (*ImportsListDataTypesResp, error)
	GetTableColumns(context.Context, *ImportsGetTableColumnsReq) (*ImportsGetTableColumnsResp, error)
	GetClusterTables(context.Context, *ImportsGetClusterTablesReq) (*ImportsGetClusterTablesResp, error)
	ValidateTargetTableEmpty(context.Context, *ImportsValidateTargetTableEmptyReq) (*emptypb.Empty, error)
	SearchImportFiles(context.Context, *ImportsSearchImportFilesReq) (*ImportsSearchImportFilesResp, error)
	mustEmbedUnimplementedImportServiceServer()
}

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

func (UnimplementedImportServiceServer) Precheck(context.Context, *ImportPrecheckReq) (*ImportPrecheckResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Precheck not implemented")
}
func (UnimplementedImportServiceServer) Create(context.Context, *ImportCreateReq) (*ClusterImportId, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Create not implemented")
}
func (UnimplementedImportServiceServer) Get(context.Context, *ClusterImportId) (*ImportGetResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Get not implemented")
}
func (UnimplementedImportServiceServer) List(context.Context, *ListImportReq) (*ListImportResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method List not implemented")
}
func (UnimplementedImportServiceServer) Cancel(context.Context, *ClusterImportId) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Cancel not implemented")
}
func (UnimplementedImportServiceServer) Exit(context.Context, *ClusterImportId) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Exit not implemented")
}
func (UnimplementedImportServiceServer) GetDataIngestionProfile(context.Context, *ClusterIdReq) (*DataIngestionProfile, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetDataIngestionProfile not implemented")
}
func (UnimplementedImportServiceServer) GetS3BucketRegion(context.Context, *GetS3BucketRegionReq) (*GetS3BucketRegionResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetS3BucketRegion not implemented")
}
func (UnimplementedImportServiceServer) Validate(context.Context, *ImportValidateReq) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Validate not implemented")
}
func (UnimplementedImportServiceServer) ApplyTableFilters(context.Context, *ImportsApplyTableFiltersReq) (*ImportsApplyTableFiltersResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ApplyTableFilters not implemented")
}
func (UnimplementedImportServiceServer) GetSchemasMeta(context.Context, *ImportsGetSchemasMetaReq) (*ImportsGetSchemasMetaResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetSchemasMeta not implemented")
}
func (UnimplementedImportServiceServer) Preview(context.Context, *ImportsPreviewReq) (*ImportsPreviewResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Preview not implemented")
}
func (UnimplementedImportServiceServer) PreviewCsvFile(context.Context, *ImportsPreviewCsvFileReq) (*ImportsPreviewCsvFileResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PreviewCsvFile not implemented")
}
func (UnimplementedImportServiceServer) GenerateUploadUrl(context.Context, *ImportsGenerateUploadUrlReq) (*ImportsGenerateUploadUrlResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GenerateUploadUrl not implemented")
}
func (UnimplementedImportServiceServer) PreviewLocal(context.Context, *ImportsPreviewLocalReq) (*ImportsPreviewLocalResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PreviewLocal not implemented")
}
func (UnimplementedImportServiceServer) ListDataTypes(context.Context, *emptypb.Empty) (*ImportsListDataTypesResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListDataTypes not implemented")
}
func (UnimplementedImportServiceServer) GetTableColumns(context.Context, *ImportsGetTableColumnsReq) (*ImportsGetTableColumnsResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetTableColumns not implemented")
}
func (UnimplementedImportServiceServer) GetClusterTables(context.Context, *ImportsGetClusterTablesReq) (*ImportsGetClusterTablesResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetClusterTables not implemented")
}
func (UnimplementedImportServiceServer) ValidateTargetTableEmpty(context.Context, *ImportsValidateTargetTableEmptyReq) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ValidateTargetTableEmpty not implemented")
}
func (UnimplementedImportServiceServer) SearchImportFiles(context.Context, *ImportsSearchImportFilesReq) (*ImportsSearchImportFilesResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method SearchImportFiles 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_Precheck_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ImportPrecheckReq)
	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.(*ImportPrecheckReq))
	}
	return interceptor(ctx, in, info, handler)
}

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

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

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

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

func _ImportService_Exit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ClusterImportId)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ImportServiceServer).Exit(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ImportService_Exit_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ImportServiceServer).Exit(ctx, req.(*ClusterImportId))
	}
	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(ClusterIdReq)
	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.(*ClusterIdReq))
	}
	return interceptor(ctx, in, info, handler)
}

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

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

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

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

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

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

func _ImportService_GenerateUploadUrl_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ImportsGenerateUploadUrlReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ImportServiceServer).GenerateUploadUrl(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ImportService_GenerateUploadUrl_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ImportServiceServer).GenerateUploadUrl(ctx, req.(*ImportsGenerateUploadUrlReq))
	}
	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_ListDataTypes_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).ListDataTypes(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ImportService_ListDataTypes_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ImportServiceServer).ListDataTypes(ctx, req.(*emptypb.Empty))
	}
	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_GetClusterTables_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ImportsGetClusterTablesReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ImportServiceServer).GetClusterTables(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ImportService_GetClusterTables_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ImportServiceServer).GetClusterTables(ctx, req.(*ImportsGetClusterTablesReq))
	}
	return interceptor(ctx, in, info, handler)
}

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

func _ImportService_SearchImportFiles_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ImportsSearchImportFilesReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ImportServiceServer).SearchImportFiles(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ImportService_SearchImportFiles_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ImportServiceServer).SearchImportFiles(ctx, req.(*ImportsSearchImportFilesReq))
	}
	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: "dataflow.ImportService",
	HandlerType: (*ImportServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Precheck",
			Handler:    _ImportService_Precheck_Handler,
		},
		{
			MethodName: "Create",
			Handler:    _ImportService_Create_Handler,
		},
		{
			MethodName: "Get",
			Handler:    _ImportService_Get_Handler,
		},
		{
			MethodName: "List",
			Handler:    _ImportService_List_Handler,
		},
		{
			MethodName: "Cancel",
			Handler:    _ImportService_Cancel_Handler,
		},
		{
			MethodName: "Exit",
			Handler:    _ImportService_Exit_Handler,
		},
		{
			MethodName: "GetDataIngestionProfile",
			Handler:    _ImportService_GetDataIngestionProfile_Handler,
		},
		{
			MethodName: "GetS3BucketRegion",
			Handler:    _ImportService_GetS3BucketRegion_Handler,
		},
		{
			MethodName: "Validate",
			Handler:    _ImportService_Validate_Handler,
		},
		{
			MethodName: "ApplyTableFilters",
			Handler:    _ImportService_ApplyTableFilters_Handler,
		},
		{
			MethodName: "GetSchemasMeta",
			Handler:    _ImportService_GetSchemasMeta_Handler,
		},
		{
			MethodName: "Preview",
			Handler:    _ImportService_Preview_Handler,
		},
		{
			MethodName: "PreviewCsvFile",
			Handler:    _ImportService_PreviewCsvFile_Handler,
		},
		{
			MethodName: "GenerateUploadUrl",
			Handler:    _ImportService_GenerateUploadUrl_Handler,
		},
		{
			MethodName: "PreviewLocal",
			Handler:    _ImportService_PreviewLocal_Handler,
		},
		{
			MethodName: "ListDataTypes",
			Handler:    _ImportService_ListDataTypes_Handler,
		},
		{
			MethodName: "GetTableColumns",
			Handler:    _ImportService_GetTableColumns_Handler,
		},
		{
			MethodName: "GetClusterTables",
			Handler:    _ImportService_GetClusterTables_Handler,
		},
		{
			MethodName: "ValidateTargetTableEmpty",
			Handler:    _ImportService_ValidateTargetTableEmpty_Handler,
		},
		{
			MethodName: "SearchImportFiles",
			Handler:    _ImportService_SearchImportFiles_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "dataflow/service.proto",
}

const (
	ImportInnerService_Create_FullMethodName            = "/dataflow.ImportInnerService/Create"
	ImportInnerService_Get_FullMethodName               = "/dataflow.ImportInnerService/Get"
	ImportInnerService_Cancel_FullMethodName            = "/dataflow.ImportInnerService/Cancel"
	ImportInnerService_GetS3BucketRegion_FullMethodName = "/dataflow.ImportInnerService/GetS3BucketRegion"
	ImportInnerService_Validate_FullMethodName          = "/dataflow.ImportInnerService/Validate"
	ImportInnerService_Exit_FullMethodName              = "/dataflow.ImportInnerService/Exit"
	ImportInnerService_List_FullMethodName              = "/dataflow.ImportInnerService/List"
)

// ImportInnerServiceClient is the client API for ImportInnerService 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 ImportInnerServiceClient interface {
	Create(ctx context.Context, in *ImportCreateReq, opts ...grpc.CallOption) (*ClusterImportId, error)
	Get(ctx context.Context, in *ClusterImportId, opts ...grpc.CallOption) (*ImportGetResp, error)
	Cancel(ctx context.Context, in *ClusterImportId, opts ...grpc.CallOption) (*emptypb.Empty, error)
	GetS3BucketRegion(ctx context.Context, in *GetS3BucketRegionReq, opts ...grpc.CallOption) (*GetS3BucketRegionResp, error)
	Validate(ctx context.Context, in *ImportValidateReq, opts ...grpc.CallOption) (*emptypb.Empty, error)
	Exit(ctx context.Context, in *ClusterImportId, opts ...grpc.CallOption) (*emptypb.Empty, error)
	List(ctx context.Context, in *ListImportReq, opts ...grpc.CallOption) (*ListImportResp, error)
}

type importInnerServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewImportInnerServiceClient(cc grpc.ClientConnInterface) ImportInnerServiceClient {
	return &importInnerServiceClient{cc}
}

func (c *importInnerServiceClient) Create(ctx context.Context, in *ImportCreateReq, opts ...grpc.CallOption) (*ClusterImportId, error) {
	out := new(ClusterImportId)
	err := c.cc.Invoke(ctx, ImportInnerService_Create_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *importInnerServiceClient) Get(ctx context.Context, in *ClusterImportId, opts ...grpc.CallOption) (*ImportGetResp, error) {
	out := new(ImportGetResp)
	err := c.cc.Invoke(ctx, ImportInnerService_Get_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *importInnerServiceClient) Cancel(ctx context.Context, in *ClusterImportId, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, ImportInnerService_Cancel_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *importInnerServiceClient) GetS3BucketRegion(ctx context.Context, in *GetS3BucketRegionReq, opts ...grpc.CallOption) (*GetS3BucketRegionResp, error) {
	out := new(GetS3BucketRegionResp)
	err := c.cc.Invoke(ctx, ImportInnerService_GetS3BucketRegion_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *importInnerServiceClient) Validate(ctx context.Context, in *ImportValidateReq, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, ImportInnerService_Validate_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *importInnerServiceClient) Exit(ctx context.Context, in *ClusterImportId, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, ImportInnerService_Exit_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *importInnerServiceClient) List(ctx context.Context, in *ListImportReq, opts ...grpc.CallOption) (*ListImportResp, error) {
	out := new(ListImportResp)
	err := c.cc.Invoke(ctx, ImportInnerService_List_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ImportInnerServiceServer is the server API for ImportInnerService service.
// All implementations must embed UnimplementedImportInnerServiceServer
// for forward compatibility
type ImportInnerServiceServer interface {
	Create(context.Context, *ImportCreateReq) (*ClusterImportId, error)
	Get(context.Context, *ClusterImportId) (*ImportGetResp, error)
	Cancel(context.Context, *ClusterImportId) (*emptypb.Empty, error)
	GetS3BucketRegion(context.Context, *GetS3BucketRegionReq) (*GetS3BucketRegionResp, error)
	Validate(context.Context, *ImportValidateReq) (*emptypb.Empty, error)
	Exit(context.Context, *ClusterImportId) (*emptypb.Empty, error)
	List(context.Context, *ListImportReq) (*ListImportResp, error)
	mustEmbedUnimplementedImportInnerServiceServer()
}

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

func (UnimplementedImportInnerServiceServer) Create(context.Context, *ImportCreateReq) (*ClusterImportId, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Create not implemented")
}
func (UnimplementedImportInnerServiceServer) Get(context.Context, *ClusterImportId) (*ImportGetResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Get not implemented")
}
func (UnimplementedImportInnerServiceServer) Cancel(context.Context, *ClusterImportId) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Cancel not implemented")
}
func (UnimplementedImportInnerServiceServer) GetS3BucketRegion(context.Context, *GetS3BucketRegionReq) (*GetS3BucketRegionResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetS3BucketRegion not implemented")
}
func (UnimplementedImportInnerServiceServer) Validate(context.Context, *ImportValidateReq) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Validate not implemented")
}
func (UnimplementedImportInnerServiceServer) Exit(context.Context, *ClusterImportId) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Exit not implemented")
}
func (UnimplementedImportInnerServiceServer) List(context.Context, *ListImportReq) (*ListImportResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method List not implemented")
}
func (UnimplementedImportInnerServiceServer) mustEmbedUnimplementedImportInnerServiceServer() {}

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

func RegisterImportInnerServiceServer(s grpc.ServiceRegistrar, srv ImportInnerServiceServer) {
	s.RegisterService(&ImportInnerService_ServiceDesc, srv)
}

func _ImportInnerService_Create_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ImportCreateReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ImportInnerServiceServer).Create(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ImportInnerService_Create_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ImportInnerServiceServer).Create(ctx, req.(*ImportCreateReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ImportInnerService_Get_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ClusterImportId)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ImportInnerServiceServer).Get(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ImportInnerService_Get_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ImportInnerServiceServer).Get(ctx, req.(*ClusterImportId))
	}
	return interceptor(ctx, in, info, handler)
}

func _ImportInnerService_Cancel_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ClusterImportId)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ImportInnerServiceServer).Cancel(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ImportInnerService_Cancel_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ImportInnerServiceServer).Cancel(ctx, req.(*ClusterImportId))
	}
	return interceptor(ctx, in, info, handler)
}

func _ImportInnerService_GetS3BucketRegion_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetS3BucketRegionReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ImportInnerServiceServer).GetS3BucketRegion(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ImportInnerService_GetS3BucketRegion_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ImportInnerServiceServer).GetS3BucketRegion(ctx, req.(*GetS3BucketRegionReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ImportInnerService_Validate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ImportValidateReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ImportInnerServiceServer).Validate(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ImportInnerService_Validate_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ImportInnerServiceServer).Validate(ctx, req.(*ImportValidateReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ImportInnerService_Exit_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ClusterImportId)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ImportInnerServiceServer).Exit(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ImportInnerService_Exit_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ImportInnerServiceServer).Exit(ctx, req.(*ClusterImportId))
	}
	return interceptor(ctx, in, info, handler)
}

func _ImportInnerService_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListImportReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ImportInnerServiceServer).List(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ImportInnerService_List_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ImportInnerServiceServer).List(ctx, req.(*ListImportReq))
	}
	return interceptor(ctx, in, info, handler)
}

// ImportInnerService_ServiceDesc is the grpc.ServiceDesc for ImportInnerService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var ImportInnerService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "dataflow.ImportInnerService",
	HandlerType: (*ImportInnerServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "Create",
			Handler:    _ImportInnerService_Create_Handler,
		},
		{
			MethodName: "Get",
			Handler:    _ImportInnerService_Get_Handler,
		},
		{
			MethodName: "Cancel",
			Handler:    _ImportInnerService_Cancel_Handler,
		},
		{
			MethodName: "GetS3BucketRegion",
			Handler:    _ImportInnerService_GetS3BucketRegion_Handler,
		},
		{
			MethodName: "Validate",
			Handler:    _ImportInnerService_Validate_Handler,
		},
		{
			MethodName: "Exit",
			Handler:    _ImportInnerService_Exit_Handler,
		},
		{
			MethodName: "List",
			Handler:    _ImportInnerService_List_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "dataflow/service.proto",
}

const (
	BackupService_List_FullMethodName                           = "/dataflow.BackupService/List"
	BackupService_ListLogBackups_FullMethodName                 = "/dataflow.BackupService/ListLogBackups"
	BackupService_GetBackupOptions_FullMethodName               = "/dataflow.BackupService/GetBackupOptions"
	BackupService_ModifyBackupSetting_FullMethodName            = "/dataflow.BackupService/ModifyBackupSetting"
	BackupService_GetBackupSetting_FullMethodName               = "/dataflow.BackupService/GetBackupSetting"
	BackupService_CreateBackupSchedule_FullMethodName           = "/dataflow.BackupService/CreateBackupSchedule"
	BackupService_GetAutoSetting_FullMethodName                 = "/dataflow.BackupService/GetAutoSetting"
	BackupService_Delete_FullMethodName                         = "/dataflow.BackupService/Delete"
	BackupService_Restore_FullMethodName                        = "/dataflow.BackupService/Restore"
	BackupService_ListPiTRTimeRanges_FullMethodName             = "/dataflow.BackupService/ListPiTRTimeRanges"
	BackupService_GetRestoreProgress_FullMethodName             = "/dataflow.BackupService/GetRestoreProgress"
	BackupService_ListRecycleBinClusters_FullMethodName         = "/dataflow.BackupService/ListRecycleBinClusters"
	BackupService_ListRecycleBinClustersV2_FullMethodName       = "/dataflow.BackupService/ListRecycleBinClustersV2"
	BackupService_GetRecycleBinCluster_FullMethodName           = "/dataflow.BackupService/GetRecycleBinCluster"
	BackupService_DeleteDeletedClusterAndBackups_FullMethodName = "/dataflow.BackupService/DeleteDeletedClusterAndBackups"
	BackupService_ListServerlessRestores_FullMethodName         = "/dataflow.BackupService/ListServerlessRestores"
	BackupService_ListServerlessPiTRTimeRanges_FullMethodName   = "/dataflow.BackupService/ListServerlessPiTRTimeRanges"
)

// BackupServiceClient is the client API for BackupService 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 BackupServiceClient interface {
	List(ctx context.Context, in *BackupListReq, opts ...grpc.CallOption) (*Backups, error)
	ListLogBackups(ctx context.Context, in *LogBackupListReq, opts ...grpc.CallOption) (*LogBackupListResp, error)
	GetBackupOptions(ctx context.Context, in *BackupOptionsReq, opts ...grpc.CallOption) (*BackupOptionsResp, error)
	// Deprecated
	ModifyBackupSetting(ctx context.Context, in *ModifyBackupSettingReq, opts ...grpc.CallOption) (*BackupSettingResp, error)
	// Deprecated: remove it later
	GetBackupSetting(ctx context.Context, in *BackupSettingReq, opts ...grpc.CallOption) (*BackupSettingResp, error)
	CreateBackupSchedule(ctx context.Context, in *BackupCreateReq, opts ...grpc.CallOption) (*CreateBackupScheduleResp, error)
	// Deprecated: remove it later
	GetAutoSetting(ctx context.Context, in *AutoBackupSettingReq, opts ...grpc.CallOption) (*AutoBackupSetting, error)
	Delete(ctx context.Context, in *BackupReq, opts ...grpc.CallOption) (*emptypb.Empty, error)
	Restore(ctx context.Context, in *BackupRestoreReq, opts ...grpc.CallOption) (*RestoreResp, error)
	ListPiTRTimeRanges(ctx context.Context, in *PiTRTimeRangeListReq, opts ...grpc.CallOption) (*PiTRTimeRangeListResp, error)
	GetRestoreProgress(ctx context.Context, in *RestoreProgressReq, opts ...grpc.CallOption) (*RestoreProgressResp, error)
	ListRecycleBinClusters(ctx context.Context, in *ListRecycleBinClustersReq, opts ...grpc.CallOption) (*ListRecycleBinClustersResp, error)
	ListRecycleBinClustersV2(ctx context.Context, in *ListRecycleBinClustersV2Req, opts ...grpc.CallOption) (*ListRecycleBinClustersV2Resp, error)
	GetRecycleBinCluster(ctx context.Context, in *GetRecycleBinClusterReq, opts ...grpc.CallOption) (*GetRecycleBinClusterResp, error)
	DeleteDeletedClusterAndBackups(ctx context.Context, in *ClusterIdReq, opts ...grpc.CallOption) (*emptypb.Empty, error)
	// Serverless dedicated APIs
	// Deprecated: remove it later
	ListServerlessRestores(ctx context.Context, in *ListServerlessRestoresReq, opts ...grpc.CallOption) (*ListServerlessRestoresResp, error)
	// Deprecated: remove it later
	ListServerlessPiTRTimeRanges(ctx context.Context, in *ListServerlessPiTRTimeRangesReq, opts ...grpc.CallOption) (*ListServerlessPiTRTimeRangesResp, error)
}

type backupServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewBackupServiceClient(cc grpc.ClientConnInterface) BackupServiceClient {
	return &backupServiceClient{cc}
}

func (c *backupServiceClient) List(ctx context.Context, in *BackupListReq, opts ...grpc.CallOption) (*Backups, error) {
	out := new(Backups)
	err := c.cc.Invoke(ctx, BackupService_List_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *backupServiceClient) ListLogBackups(ctx context.Context, in *LogBackupListReq, opts ...grpc.CallOption) (*LogBackupListResp, error) {
	out := new(LogBackupListResp)
	err := c.cc.Invoke(ctx, BackupService_ListLogBackups_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *backupServiceClient) GetBackupOptions(ctx context.Context, in *BackupOptionsReq, opts ...grpc.CallOption) (*BackupOptionsResp, error) {
	out := new(BackupOptionsResp)
	err := c.cc.Invoke(ctx, BackupService_GetBackupOptions_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *backupServiceClient) ModifyBackupSetting(ctx context.Context, in *ModifyBackupSettingReq, opts ...grpc.CallOption) (*BackupSettingResp, error) {
	out := new(BackupSettingResp)
	err := c.cc.Invoke(ctx, BackupService_ModifyBackupSetting_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *backupServiceClient) GetBackupSetting(ctx context.Context, in *BackupSettingReq, opts ...grpc.CallOption) (*BackupSettingResp, error) {
	out := new(BackupSettingResp)
	err := c.cc.Invoke(ctx, BackupService_GetBackupSetting_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *backupServiceClient) CreateBackupSchedule(ctx context.Context, in *BackupCreateReq, opts ...grpc.CallOption) (*CreateBackupScheduleResp, error) {
	out := new(CreateBackupScheduleResp)
	err := c.cc.Invoke(ctx, BackupService_CreateBackupSchedule_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *backupServiceClient) GetAutoSetting(ctx context.Context, in *AutoBackupSettingReq, opts ...grpc.CallOption) (*AutoBackupSetting, error) {
	out := new(AutoBackupSetting)
	err := c.cc.Invoke(ctx, BackupService_GetAutoSetting_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *backupServiceClient) Delete(ctx context.Context, in *BackupReq, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, BackupService_Delete_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *backupServiceClient) Restore(ctx context.Context, in *BackupRestoreReq, opts ...grpc.CallOption) (*RestoreResp, error) {
	out := new(RestoreResp)
	err := c.cc.Invoke(ctx, BackupService_Restore_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *backupServiceClient) ListPiTRTimeRanges(ctx context.Context, in *PiTRTimeRangeListReq, opts ...grpc.CallOption) (*PiTRTimeRangeListResp, error) {
	out := new(PiTRTimeRangeListResp)
	err := c.cc.Invoke(ctx, BackupService_ListPiTRTimeRanges_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *backupServiceClient) GetRestoreProgress(ctx context.Context, in *RestoreProgressReq, opts ...grpc.CallOption) (*RestoreProgressResp, error) {
	out := new(RestoreProgressResp)
	err := c.cc.Invoke(ctx, BackupService_GetRestoreProgress_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *backupServiceClient) ListRecycleBinClusters(ctx context.Context, in *ListRecycleBinClustersReq, opts ...grpc.CallOption) (*ListRecycleBinClustersResp, error) {
	out := new(ListRecycleBinClustersResp)
	err := c.cc.Invoke(ctx, BackupService_ListRecycleBinClusters_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *backupServiceClient) ListRecycleBinClustersV2(ctx context.Context, in *ListRecycleBinClustersV2Req, opts ...grpc.CallOption) (*ListRecycleBinClustersV2Resp, error) {
	out := new(ListRecycleBinClustersV2Resp)
	err := c.cc.Invoke(ctx, BackupService_ListRecycleBinClustersV2_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *backupServiceClient) GetRecycleBinCluster(ctx context.Context, in *GetRecycleBinClusterReq, opts ...grpc.CallOption) (*GetRecycleBinClusterResp, error) {
	out := new(GetRecycleBinClusterResp)
	err := c.cc.Invoke(ctx, BackupService_GetRecycleBinCluster_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *backupServiceClient) DeleteDeletedClusterAndBackups(ctx context.Context, in *ClusterIdReq, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, BackupService_DeleteDeletedClusterAndBackups_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *backupServiceClient) ListServerlessRestores(ctx context.Context, in *ListServerlessRestoresReq, opts ...grpc.CallOption) (*ListServerlessRestoresResp, error) {
	out := new(ListServerlessRestoresResp)
	err := c.cc.Invoke(ctx, BackupService_ListServerlessRestores_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *backupServiceClient) ListServerlessPiTRTimeRanges(ctx context.Context, in *ListServerlessPiTRTimeRangesReq, opts ...grpc.CallOption) (*ListServerlessPiTRTimeRangesResp, error) {
	out := new(ListServerlessPiTRTimeRangesResp)
	err := c.cc.Invoke(ctx, BackupService_ListServerlessPiTRTimeRanges_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// BackupServiceServer is the server API for BackupService service.
// All implementations must embed UnimplementedBackupServiceServer
// for forward compatibility
type BackupServiceServer interface {
	List(context.Context, *BackupListReq) (*Backups, error)
	ListLogBackups(context.Context, *LogBackupListReq) (*LogBackupListResp, error)
	GetBackupOptions(context.Context, *BackupOptionsReq) (*BackupOptionsResp, error)
	// Deprecated
	ModifyBackupSetting(context.Context, *ModifyBackupSettingReq) (*BackupSettingResp, error)
	// Deprecated: remove it later
	GetBackupSetting(context.Context, *BackupSettingReq) (*BackupSettingResp, error)
	CreateBackupSchedule(context.Context, *BackupCreateReq) (*CreateBackupScheduleResp, error)
	// Deprecated: remove it later
	GetAutoSetting(context.Context, *AutoBackupSettingReq) (*AutoBackupSetting, error)
	Delete(context.Context, *BackupReq) (*emptypb.Empty, error)
	Restore(context.Context, *BackupRestoreReq) (*RestoreResp, error)
	ListPiTRTimeRanges(context.Context, *PiTRTimeRangeListReq) (*PiTRTimeRangeListResp, error)
	GetRestoreProgress(context.Context, *RestoreProgressReq) (*RestoreProgressResp, error)
	ListRecycleBinClusters(context.Context, *ListRecycleBinClustersReq) (*ListRecycleBinClustersResp, error)
	ListRecycleBinClustersV2(context.Context, *ListRecycleBinClustersV2Req) (*ListRecycleBinClustersV2Resp, error)
	GetRecycleBinCluster(context.Context, *GetRecycleBinClusterReq) (*GetRecycleBinClusterResp, error)
	DeleteDeletedClusterAndBackups(context.Context, *ClusterIdReq) (*emptypb.Empty, error)
	// Serverless dedicated APIs
	// Deprecated: remove it later
	ListServerlessRestores(context.Context, *ListServerlessRestoresReq) (*ListServerlessRestoresResp, error)
	// Deprecated: remove it later
	ListServerlessPiTRTimeRanges(context.Context, *ListServerlessPiTRTimeRangesReq) (*ListServerlessPiTRTimeRangesResp, error)
	mustEmbedUnimplementedBackupServiceServer()
}

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

func (UnimplementedBackupServiceServer) List(context.Context, *BackupListReq) (*Backups, error) {
	return nil, status.Errorf(codes.Unimplemented, "method List not implemented")
}
func (UnimplementedBackupServiceServer) ListLogBackups(context.Context, *LogBackupListReq) (*LogBackupListResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListLogBackups not implemented")
}
func (UnimplementedBackupServiceServer) GetBackupOptions(context.Context, *BackupOptionsReq) (*BackupOptionsResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetBackupOptions not implemented")
}
func (UnimplementedBackupServiceServer) ModifyBackupSetting(context.Context, *ModifyBackupSettingReq) (*BackupSettingResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ModifyBackupSetting not implemented")
}
func (UnimplementedBackupServiceServer) GetBackupSetting(context.Context, *BackupSettingReq) (*BackupSettingResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetBackupSetting not implemented")
}
func (UnimplementedBackupServiceServer) CreateBackupSchedule(context.Context, *BackupCreateReq) (*CreateBackupScheduleResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateBackupSchedule not implemented")
}
func (UnimplementedBackupServiceServer) GetAutoSetting(context.Context, *AutoBackupSettingReq) (*AutoBackupSetting, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetAutoSetting not implemented")
}
func (UnimplementedBackupServiceServer) Delete(context.Context, *BackupReq) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Delete not implemented")
}
func (UnimplementedBackupServiceServer) Restore(context.Context, *BackupRestoreReq) (*RestoreResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Restore not implemented")
}
func (UnimplementedBackupServiceServer) ListPiTRTimeRanges(context.Context, *PiTRTimeRangeListReq) (*PiTRTimeRangeListResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListPiTRTimeRanges not implemented")
}
func (UnimplementedBackupServiceServer) GetRestoreProgress(context.Context, *RestoreProgressReq) (*RestoreProgressResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetRestoreProgress not implemented")
}
func (UnimplementedBackupServiceServer) ListRecycleBinClusters(context.Context, *ListRecycleBinClustersReq) (*ListRecycleBinClustersResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListRecycleBinClusters not implemented")
}
func (UnimplementedBackupServiceServer) ListRecycleBinClustersV2(context.Context, *ListRecycleBinClustersV2Req) (*ListRecycleBinClustersV2Resp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListRecycleBinClustersV2 not implemented")
}
func (UnimplementedBackupServiceServer) GetRecycleBinCluster(context.Context, *GetRecycleBinClusterReq) (*GetRecycleBinClusterResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetRecycleBinCluster not implemented")
}
func (UnimplementedBackupServiceServer) DeleteDeletedClusterAndBackups(context.Context, *ClusterIdReq) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteDeletedClusterAndBackups not implemented")
}
func (UnimplementedBackupServiceServer) ListServerlessRestores(context.Context, *ListServerlessRestoresReq) (*ListServerlessRestoresResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListServerlessRestores not implemented")
}
func (UnimplementedBackupServiceServer) ListServerlessPiTRTimeRanges(context.Context, *ListServerlessPiTRTimeRangesReq) (*ListServerlessPiTRTimeRangesResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListServerlessPiTRTimeRanges not implemented")
}
func (UnimplementedBackupServiceServer) mustEmbedUnimplementedBackupServiceServer() {}

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

func RegisterBackupServiceServer(s grpc.ServiceRegistrar, srv BackupServiceServer) {
	s.RegisterService(&BackupService_ServiceDesc, srv)
}

func _BackupService_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BackupListReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BackupServiceServer).List(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: BackupService_List_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BackupServiceServer).List(ctx, req.(*BackupListReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _BackupService_ListLogBackups_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(LogBackupListReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BackupServiceServer).ListLogBackups(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: BackupService_ListLogBackups_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BackupServiceServer).ListLogBackups(ctx, req.(*LogBackupListReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _BackupService_GetBackupOptions_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BackupOptionsReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BackupServiceServer).GetBackupOptions(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: BackupService_GetBackupOptions_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BackupServiceServer).GetBackupOptions(ctx, req.(*BackupOptionsReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _BackupService_ModifyBackupSetting_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ModifyBackupSettingReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BackupServiceServer).ModifyBackupSetting(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: BackupService_ModifyBackupSetting_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BackupServiceServer).ModifyBackupSetting(ctx, req.(*ModifyBackupSettingReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _BackupService_GetBackupSetting_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BackupSettingReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BackupServiceServer).GetBackupSetting(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: BackupService_GetBackupSetting_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BackupServiceServer).GetBackupSetting(ctx, req.(*BackupSettingReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _BackupService_CreateBackupSchedule_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BackupCreateReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BackupServiceServer).CreateBackupSchedule(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: BackupService_CreateBackupSchedule_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BackupServiceServer).CreateBackupSchedule(ctx, req.(*BackupCreateReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _BackupService_GetAutoSetting_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(AutoBackupSettingReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BackupServiceServer).GetAutoSetting(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: BackupService_GetAutoSetting_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BackupServiceServer).GetAutoSetting(ctx, req.(*AutoBackupSettingReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _BackupService_Delete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BackupReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BackupServiceServer).Delete(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: BackupService_Delete_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BackupServiceServer).Delete(ctx, req.(*BackupReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _BackupService_Restore_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BackupRestoreReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BackupServiceServer).Restore(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: BackupService_Restore_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BackupServiceServer).Restore(ctx, req.(*BackupRestoreReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _BackupService_ListPiTRTimeRanges_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PiTRTimeRangeListReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BackupServiceServer).ListPiTRTimeRanges(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: BackupService_ListPiTRTimeRanges_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BackupServiceServer).ListPiTRTimeRanges(ctx, req.(*PiTRTimeRangeListReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _BackupService_GetRestoreProgress_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RestoreProgressReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BackupServiceServer).GetRestoreProgress(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: BackupService_GetRestoreProgress_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BackupServiceServer).GetRestoreProgress(ctx, req.(*RestoreProgressReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _BackupService_ListRecycleBinClusters_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListRecycleBinClustersReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BackupServiceServer).ListRecycleBinClusters(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: BackupService_ListRecycleBinClusters_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BackupServiceServer).ListRecycleBinClusters(ctx, req.(*ListRecycleBinClustersReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _BackupService_ListRecycleBinClustersV2_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListRecycleBinClustersV2Req)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BackupServiceServer).ListRecycleBinClustersV2(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: BackupService_ListRecycleBinClustersV2_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BackupServiceServer).ListRecycleBinClustersV2(ctx, req.(*ListRecycleBinClustersV2Req))
	}
	return interceptor(ctx, in, info, handler)
}

func _BackupService_GetRecycleBinCluster_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetRecycleBinClusterReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BackupServiceServer).GetRecycleBinCluster(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: BackupService_GetRecycleBinCluster_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BackupServiceServer).GetRecycleBinCluster(ctx, req.(*GetRecycleBinClusterReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _BackupService_DeleteDeletedClusterAndBackups_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ClusterIdReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BackupServiceServer).DeleteDeletedClusterAndBackups(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: BackupService_DeleteDeletedClusterAndBackups_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BackupServiceServer).DeleteDeletedClusterAndBackups(ctx, req.(*ClusterIdReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _BackupService_ListServerlessRestores_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListServerlessRestoresReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BackupServiceServer).ListServerlessRestores(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: BackupService_ListServerlessRestores_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BackupServiceServer).ListServerlessRestores(ctx, req.(*ListServerlessRestoresReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _BackupService_ListServerlessPiTRTimeRanges_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListServerlessPiTRTimeRangesReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BackupServiceServer).ListServerlessPiTRTimeRanges(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: BackupService_ListServerlessPiTRTimeRanges_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BackupServiceServer).ListServerlessPiTRTimeRanges(ctx, req.(*ListServerlessPiTRTimeRangesReq))
	}
	return interceptor(ctx, in, info, handler)
}

// BackupService_ServiceDesc is the grpc.ServiceDesc for BackupService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var BackupService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "dataflow.BackupService",
	HandlerType: (*BackupServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "List",
			Handler:    _BackupService_List_Handler,
		},
		{
			MethodName: "ListLogBackups",
			Handler:    _BackupService_ListLogBackups_Handler,
		},
		{
			MethodName: "GetBackupOptions",
			Handler:    _BackupService_GetBackupOptions_Handler,
		},
		{
			MethodName: "ModifyBackupSetting",
			Handler:    _BackupService_ModifyBackupSetting_Handler,
		},
		{
			MethodName: "GetBackupSetting",
			Handler:    _BackupService_GetBackupSetting_Handler,
		},
		{
			MethodName: "CreateBackupSchedule",
			Handler:    _BackupService_CreateBackupSchedule_Handler,
		},
		{
			MethodName: "GetAutoSetting",
			Handler:    _BackupService_GetAutoSetting_Handler,
		},
		{
			MethodName: "Delete",
			Handler:    _BackupService_Delete_Handler,
		},
		{
			MethodName: "Restore",
			Handler:    _BackupService_Restore_Handler,
		},
		{
			MethodName: "ListPiTRTimeRanges",
			Handler:    _BackupService_ListPiTRTimeRanges_Handler,
		},
		{
			MethodName: "GetRestoreProgress",
			Handler:    _BackupService_GetRestoreProgress_Handler,
		},
		{
			MethodName: "ListRecycleBinClusters",
			Handler:    _BackupService_ListRecycleBinClusters_Handler,
		},
		{
			MethodName: "ListRecycleBinClustersV2",
			Handler:    _BackupService_ListRecycleBinClustersV2_Handler,
		},
		{
			MethodName: "GetRecycleBinCluster",
			Handler:    _BackupService_GetRecycleBinCluster_Handler,
		},
		{
			MethodName: "DeleteDeletedClusterAndBackups",
			Handler:    _BackupService_DeleteDeletedClusterAndBackups_Handler,
		},
		{
			MethodName: "ListServerlessRestores",
			Handler:    _BackupService_ListServerlessRestores_Handler,
		},
		{
			MethodName: "ListServerlessPiTRTimeRanges",
			Handler:    _BackupService_ListServerlessPiTRTimeRanges_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "dataflow/service.proto",
}

const (
	BackupInternalService_CreateFinalBackup_FullMethodName           = "/dataflow.BackupInternalService/CreateFinalBackup"
	BackupInternalService_DeleteDeletedClusterBackups_FullMethodName = "/dataflow.BackupInternalService/DeleteDeletedClusterBackups"
	BackupInternalService_DeleteAllManualBackups_FullMethodName      = "/dataflow.BackupInternalService/DeleteAllManualBackups"
	BackupInternalService_DeleteAllBackups_FullMethodName            = "/dataflow.BackupInternalService/DeleteAllBackups"
	BackupInternalService_ListRestoreOfProject_FullMethodName        = "/dataflow.BackupInternalService/ListRestoreOfProject"
	BackupInternalService_GetRestore_FullMethodName                  = "/dataflow.BackupInternalService/GetRestore"
	BackupInternalService_Restore_FullMethodName                     = "/dataflow.BackupInternalService/Restore"
	BackupInternalService_GetBackup_FullMethodName                   = "/dataflow.BackupInternalService/GetBackup"
	BackupInternalService_GrantAccessBackupBucket_FullMethodName     = "/dataflow.BackupInternalService/GrantAccessBackupBucket"
	BackupInternalService_RevokeAccessBackupBucket_FullMethodName    = "/dataflow.BackupInternalService/RevokeAccessBackupBucket"
	BackupInternalService_PrepareClassicRestoreAccess_FullMethodName = "/dataflow.BackupInternalService/PrepareClassicRestoreAccess"
	BackupInternalService_CleanupClassicRestoreAccess_FullMethodName = "/dataflow.BackupInternalService/CleanupClassicRestoreAccess"
)

// BackupInternalServiceClient is the client API for BackupInternalService 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 BackupInternalServiceClient interface {
	CreateFinalBackup(ctx context.Context, in *CreateFinalBackupReq, opts ...grpc.CallOption) (*CreateFinalBackupResp, error)
	DeleteDeletedClusterBackups(ctx context.Context, in *ClusterIdReq, opts ...grpc.CallOption) (*emptypb.Empty, error)
	DeleteAllManualBackups(ctx context.Context, in *DeleteAllManualBackupsReq, opts ...grpc.CallOption) (*emptypb.Empty, error)
	DeleteAllBackups(ctx context.Context, in *DeleteAllBackupsReq, opts ...grpc.CallOption) (*emptypb.Empty, error)
	ListRestoreOfProject(ctx context.Context, in *ListRestoreOfProjectReq, opts ...grpc.CallOption) (*ListRestoreOfProjectResp, error)
	GetRestore(ctx context.Context, in *GetRestoreReq, opts ...grpc.CallOption) (*GetRestoreResp, error)
	Restore(ctx context.Context, in *BackupInternalRestoreReq, opts ...grpc.CallOption) (*RestoreResp, error)
	// apis for premium restore from dedicated backup
	GetBackup(ctx context.Context, in *GetBackupReq, opts ...grpc.CallOption) (*GetBackupResp, error)
	GrantAccessBackupBucket(ctx context.Context, in *GrantAccessBackupBucketReq, opts ...grpc.CallOption) (*emptypb.Empty, error)
	RevokeAccessBackupBucket(ctx context.Context, in *RevokeAccessBackupBucketReq, opts ...grpc.CallOption) (*emptypb.Empty, error)
	PrepareClassicRestoreAccess(ctx context.Context, in *PrepareClassicRestoreAccessReq, opts ...grpc.CallOption) (*PrepareClassicRestoreAccessResp, error)
	CleanupClassicRestoreAccess(ctx context.Context, in *CleanupClassicRestoreAccessReq, opts ...grpc.CallOption) (*emptypb.Empty, error)
}

type backupInternalServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewBackupInternalServiceClient(cc grpc.ClientConnInterface) BackupInternalServiceClient {
	return &backupInternalServiceClient{cc}
}

func (c *backupInternalServiceClient) CreateFinalBackup(ctx context.Context, in *CreateFinalBackupReq, opts ...grpc.CallOption) (*CreateFinalBackupResp, error) {
	out := new(CreateFinalBackupResp)
	err := c.cc.Invoke(ctx, BackupInternalService_CreateFinalBackup_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *backupInternalServiceClient) DeleteDeletedClusterBackups(ctx context.Context, in *ClusterIdReq, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, BackupInternalService_DeleteDeletedClusterBackups_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *backupInternalServiceClient) DeleteAllManualBackups(ctx context.Context, in *DeleteAllManualBackupsReq, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, BackupInternalService_DeleteAllManualBackups_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *backupInternalServiceClient) DeleteAllBackups(ctx context.Context, in *DeleteAllBackupsReq, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, BackupInternalService_DeleteAllBackups_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *backupInternalServiceClient) ListRestoreOfProject(ctx context.Context, in *ListRestoreOfProjectReq, opts ...grpc.CallOption) (*ListRestoreOfProjectResp, error) {
	out := new(ListRestoreOfProjectResp)
	err := c.cc.Invoke(ctx, BackupInternalService_ListRestoreOfProject_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *backupInternalServiceClient) GetRestore(ctx context.Context, in *GetRestoreReq, opts ...grpc.CallOption) (*GetRestoreResp, error) {
	out := new(GetRestoreResp)
	err := c.cc.Invoke(ctx, BackupInternalService_GetRestore_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *backupInternalServiceClient) Restore(ctx context.Context, in *BackupInternalRestoreReq, opts ...grpc.CallOption) (*RestoreResp, error) {
	out := new(RestoreResp)
	err := c.cc.Invoke(ctx, BackupInternalService_Restore_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *backupInternalServiceClient) GetBackup(ctx context.Context, in *GetBackupReq, opts ...grpc.CallOption) (*GetBackupResp, error) {
	out := new(GetBackupResp)
	err := c.cc.Invoke(ctx, BackupInternalService_GetBackup_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *backupInternalServiceClient) GrantAccessBackupBucket(ctx context.Context, in *GrantAccessBackupBucketReq, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, BackupInternalService_GrantAccessBackupBucket_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *backupInternalServiceClient) RevokeAccessBackupBucket(ctx context.Context, in *RevokeAccessBackupBucketReq, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, BackupInternalService_RevokeAccessBackupBucket_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *backupInternalServiceClient) PrepareClassicRestoreAccess(ctx context.Context, in *PrepareClassicRestoreAccessReq, opts ...grpc.CallOption) (*PrepareClassicRestoreAccessResp, error) {
	out := new(PrepareClassicRestoreAccessResp)
	err := c.cc.Invoke(ctx, BackupInternalService_PrepareClassicRestoreAccess_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *backupInternalServiceClient) CleanupClassicRestoreAccess(ctx context.Context, in *CleanupClassicRestoreAccessReq, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, BackupInternalService_CleanupClassicRestoreAccess_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// BackupInternalServiceServer is the server API for BackupInternalService service.
// All implementations must embed UnimplementedBackupInternalServiceServer
// for forward compatibility
type BackupInternalServiceServer interface {
	CreateFinalBackup(context.Context, *CreateFinalBackupReq) (*CreateFinalBackupResp, error)
	DeleteDeletedClusterBackups(context.Context, *ClusterIdReq) (*emptypb.Empty, error)
	DeleteAllManualBackups(context.Context, *DeleteAllManualBackupsReq) (*emptypb.Empty, error)
	DeleteAllBackups(context.Context, *DeleteAllBackupsReq) (*emptypb.Empty, error)
	ListRestoreOfProject(context.Context, *ListRestoreOfProjectReq) (*ListRestoreOfProjectResp, error)
	GetRestore(context.Context, *GetRestoreReq) (*GetRestoreResp, error)
	Restore(context.Context, *BackupInternalRestoreReq) (*RestoreResp, error)
	// apis for premium restore from dedicated backup
	GetBackup(context.Context, *GetBackupReq) (*GetBackupResp, error)
	GrantAccessBackupBucket(context.Context, *GrantAccessBackupBucketReq) (*emptypb.Empty, error)
	RevokeAccessBackupBucket(context.Context, *RevokeAccessBackupBucketReq) (*emptypb.Empty, error)
	PrepareClassicRestoreAccess(context.Context, *PrepareClassicRestoreAccessReq) (*PrepareClassicRestoreAccessResp, error)
	CleanupClassicRestoreAccess(context.Context, *CleanupClassicRestoreAccessReq) (*emptypb.Empty, error)
	mustEmbedUnimplementedBackupInternalServiceServer()
}

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

func (UnimplementedBackupInternalServiceServer) CreateFinalBackup(context.Context, *CreateFinalBackupReq) (*CreateFinalBackupResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateFinalBackup not implemented")
}
func (UnimplementedBackupInternalServiceServer) DeleteDeletedClusterBackups(context.Context, *ClusterIdReq) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteDeletedClusterBackups not implemented")
}
func (UnimplementedBackupInternalServiceServer) DeleteAllManualBackups(context.Context, *DeleteAllManualBackupsReq) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteAllManualBackups not implemented")
}
func (UnimplementedBackupInternalServiceServer) DeleteAllBackups(context.Context, *DeleteAllBackupsReq) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteAllBackups not implemented")
}
func (UnimplementedBackupInternalServiceServer) ListRestoreOfProject(context.Context, *ListRestoreOfProjectReq) (*ListRestoreOfProjectResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListRestoreOfProject not implemented")
}
func (UnimplementedBackupInternalServiceServer) GetRestore(context.Context, *GetRestoreReq) (*GetRestoreResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetRestore not implemented")
}
func (UnimplementedBackupInternalServiceServer) Restore(context.Context, *BackupInternalRestoreReq) (*RestoreResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method Restore not implemented")
}
func (UnimplementedBackupInternalServiceServer) GetBackup(context.Context, *GetBackupReq) (*GetBackupResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetBackup not implemented")
}
func (UnimplementedBackupInternalServiceServer) GrantAccessBackupBucket(context.Context, *GrantAccessBackupBucketReq) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GrantAccessBackupBucket not implemented")
}
func (UnimplementedBackupInternalServiceServer) RevokeAccessBackupBucket(context.Context, *RevokeAccessBackupBucketReq) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RevokeAccessBackupBucket not implemented")
}
func (UnimplementedBackupInternalServiceServer) PrepareClassicRestoreAccess(context.Context, *PrepareClassicRestoreAccessReq) (*PrepareClassicRestoreAccessResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PrepareClassicRestoreAccess not implemented")
}
func (UnimplementedBackupInternalServiceServer) CleanupClassicRestoreAccess(context.Context, *CleanupClassicRestoreAccessReq) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CleanupClassicRestoreAccess not implemented")
}
func (UnimplementedBackupInternalServiceServer) mustEmbedUnimplementedBackupInternalServiceServer() {}

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

func RegisterBackupInternalServiceServer(s grpc.ServiceRegistrar, srv BackupInternalServiceServer) {
	s.RegisterService(&BackupInternalService_ServiceDesc, srv)
}

func _BackupInternalService_CreateFinalBackup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateFinalBackupReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BackupInternalServiceServer).CreateFinalBackup(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: BackupInternalService_CreateFinalBackup_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BackupInternalServiceServer).CreateFinalBackup(ctx, req.(*CreateFinalBackupReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _BackupInternalService_DeleteDeletedClusterBackups_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ClusterIdReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BackupInternalServiceServer).DeleteDeletedClusterBackups(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: BackupInternalService_DeleteDeletedClusterBackups_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BackupInternalServiceServer).DeleteDeletedClusterBackups(ctx, req.(*ClusterIdReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _BackupInternalService_DeleteAllManualBackups_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteAllManualBackupsReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BackupInternalServiceServer).DeleteAllManualBackups(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: BackupInternalService_DeleteAllManualBackups_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BackupInternalServiceServer).DeleteAllManualBackups(ctx, req.(*DeleteAllManualBackupsReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _BackupInternalService_DeleteAllBackups_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteAllBackupsReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BackupInternalServiceServer).DeleteAllBackups(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: BackupInternalService_DeleteAllBackups_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BackupInternalServiceServer).DeleteAllBackups(ctx, req.(*DeleteAllBackupsReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _BackupInternalService_ListRestoreOfProject_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListRestoreOfProjectReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BackupInternalServiceServer).ListRestoreOfProject(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: BackupInternalService_ListRestoreOfProject_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BackupInternalServiceServer).ListRestoreOfProject(ctx, req.(*ListRestoreOfProjectReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _BackupInternalService_GetRestore_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetRestoreReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BackupInternalServiceServer).GetRestore(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: BackupInternalService_GetRestore_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BackupInternalServiceServer).GetRestore(ctx, req.(*GetRestoreReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _BackupInternalService_Restore_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(BackupInternalRestoreReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BackupInternalServiceServer).Restore(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: BackupInternalService_Restore_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BackupInternalServiceServer).Restore(ctx, req.(*BackupInternalRestoreReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _BackupInternalService_GetBackup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetBackupReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BackupInternalServiceServer).GetBackup(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: BackupInternalService_GetBackup_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BackupInternalServiceServer).GetBackup(ctx, req.(*GetBackupReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _BackupInternalService_GrantAccessBackupBucket_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GrantAccessBackupBucketReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BackupInternalServiceServer).GrantAccessBackupBucket(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: BackupInternalService_GrantAccessBackupBucket_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BackupInternalServiceServer).GrantAccessBackupBucket(ctx, req.(*GrantAccessBackupBucketReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _BackupInternalService_RevokeAccessBackupBucket_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RevokeAccessBackupBucketReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BackupInternalServiceServer).RevokeAccessBackupBucket(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: BackupInternalService_RevokeAccessBackupBucket_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BackupInternalServiceServer).RevokeAccessBackupBucket(ctx, req.(*RevokeAccessBackupBucketReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _BackupInternalService_PrepareClassicRestoreAccess_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PrepareClassicRestoreAccessReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BackupInternalServiceServer).PrepareClassicRestoreAccess(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: BackupInternalService_PrepareClassicRestoreAccess_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BackupInternalServiceServer).PrepareClassicRestoreAccess(ctx, req.(*PrepareClassicRestoreAccessReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _BackupInternalService_CleanupClassicRestoreAccess_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CleanupClassicRestoreAccessReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(BackupInternalServiceServer).CleanupClassicRestoreAccess(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: BackupInternalService_CleanupClassicRestoreAccess_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(BackupInternalServiceServer).CleanupClassicRestoreAccess(ctx, req.(*CleanupClassicRestoreAccessReq))
	}
	return interceptor(ctx, in, info, handler)
}

// BackupInternalService_ServiceDesc is the grpc.ServiceDesc for BackupInternalService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var BackupInternalService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "dataflow.BackupInternalService",
	HandlerType: (*BackupInternalServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateFinalBackup",
			Handler:    _BackupInternalService_CreateFinalBackup_Handler,
		},
		{
			MethodName: "DeleteDeletedClusterBackups",
			Handler:    _BackupInternalService_DeleteDeletedClusterBackups_Handler,
		},
		{
			MethodName: "DeleteAllManualBackups",
			Handler:    _BackupInternalService_DeleteAllManualBackups_Handler,
		},
		{
			MethodName: "DeleteAllBackups",
			Handler:    _BackupInternalService_DeleteAllBackups_Handler,
		},
		{
			MethodName: "ListRestoreOfProject",
			Handler:    _BackupInternalService_ListRestoreOfProject_Handler,
		},
		{
			MethodName: "GetRestore",
			Handler:    _BackupInternalService_GetRestore_Handler,
		},
		{
			MethodName: "Restore",
			Handler:    _BackupInternalService_Restore_Handler,
		},
		{
			MethodName: "GetBackup",
			Handler:    _BackupInternalService_GetBackup_Handler,
		},
		{
			MethodName: "GrantAccessBackupBucket",
			Handler:    _BackupInternalService_GrantAccessBackupBucket_Handler,
		},
		{
			MethodName: "RevokeAccessBackupBucket",
			Handler:    _BackupInternalService_RevokeAccessBackupBucket_Handler,
		},
		{
			MethodName: "PrepareClassicRestoreAccess",
			Handler:    _BackupInternalService_PrepareClassicRestoreAccess_Handler,
		},
		{
			MethodName: "CleanupClassicRestoreAccess",
			Handler:    _BackupInternalService_CleanupClassicRestoreAccess_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "dataflow/service.proto",
}

const (
	ServerlessBackupInternalService_QueryServerlessBackupSetting_FullMethodName  = "/dataflow.ServerlessBackupInternalService/QueryServerlessBackupSetting"
	ServerlessBackupInternalService_ModifyServerlessBackupSetting_FullMethodName = "/dataflow.ServerlessBackupInternalService/ModifyServerlessBackupSetting"
	ServerlessBackupInternalService_ListServerlessBackupSettings_FullMethodName  = "/dataflow.ServerlessBackupInternalService/ListServerlessBackupSettings"
	ServerlessBackupInternalService_ListServerlessBackups_FullMethodName         = "/dataflow.ServerlessBackupInternalService/ListServerlessBackups"
	ServerlessBackupInternalService_GetServerlessBackup_FullMethodName           = "/dataflow.ServerlessBackupInternalService/GetServerlessBackup"
)

// ServerlessBackupInternalServiceClient is the client API for ServerlessBackupInternalService 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 ServerlessBackupInternalServiceClient interface {
	QueryServerlessBackupSetting(ctx context.Context, in *QueryServerlessBackupSettingReq, opts ...grpc.CallOption) (*QueryServerlessBackupSettingResp, error)
	ModifyServerlessBackupSetting(ctx context.Context, in *ModifyServerlessBackupSettingReq, opts ...grpc.CallOption) (*ModifyServerlessBackupSettingResp, error)
	ListServerlessBackupSettings(ctx context.Context, in *ListServerlessBackupSettingsReq, opts ...grpc.CallOption) (*ListServerlessBackupSettingsResp, error)
	ListServerlessBackups(ctx context.Context, in *ListServerlessBackupsReq, opts ...grpc.CallOption) (*ListServerlessBackupsResp, error)
	GetServerlessBackup(ctx context.Context, in *GetServerlessBackupReq, opts ...grpc.CallOption) (*FullServerlessBackup, error)
}

type serverlessBackupInternalServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewServerlessBackupInternalServiceClient(cc grpc.ClientConnInterface) ServerlessBackupInternalServiceClient {
	return &serverlessBackupInternalServiceClient{cc}
}

func (c *serverlessBackupInternalServiceClient) QueryServerlessBackupSetting(ctx context.Context, in *QueryServerlessBackupSettingReq, opts ...grpc.CallOption) (*QueryServerlessBackupSettingResp, error) {
	out := new(QueryServerlessBackupSettingResp)
	err := c.cc.Invoke(ctx, ServerlessBackupInternalService_QueryServerlessBackupSetting_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessBackupInternalServiceClient) ModifyServerlessBackupSetting(ctx context.Context, in *ModifyServerlessBackupSettingReq, opts ...grpc.CallOption) (*ModifyServerlessBackupSettingResp, error) {
	out := new(ModifyServerlessBackupSettingResp)
	err := c.cc.Invoke(ctx, ServerlessBackupInternalService_ModifyServerlessBackupSetting_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessBackupInternalServiceClient) ListServerlessBackupSettings(ctx context.Context, in *ListServerlessBackupSettingsReq, opts ...grpc.CallOption) (*ListServerlessBackupSettingsResp, error) {
	out := new(ListServerlessBackupSettingsResp)
	err := c.cc.Invoke(ctx, ServerlessBackupInternalService_ListServerlessBackupSettings_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessBackupInternalServiceClient) ListServerlessBackups(ctx context.Context, in *ListServerlessBackupsReq, opts ...grpc.CallOption) (*ListServerlessBackupsResp, error) {
	out := new(ListServerlessBackupsResp)
	err := c.cc.Invoke(ctx, ServerlessBackupInternalService_ListServerlessBackups_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *serverlessBackupInternalServiceClient) GetServerlessBackup(ctx context.Context, in *GetServerlessBackupReq, opts ...grpc.CallOption) (*FullServerlessBackup, error) {
	out := new(FullServerlessBackup)
	err := c.cc.Invoke(ctx, ServerlessBackupInternalService_GetServerlessBackup_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ServerlessBackupInternalServiceServer is the server API for ServerlessBackupInternalService service.
// All implementations must embed UnimplementedServerlessBackupInternalServiceServer
// for forward compatibility
type ServerlessBackupInternalServiceServer interface {
	QueryServerlessBackupSetting(context.Context, *QueryServerlessBackupSettingReq) (*QueryServerlessBackupSettingResp, error)
	ModifyServerlessBackupSetting(context.Context, *ModifyServerlessBackupSettingReq) (*ModifyServerlessBackupSettingResp, error)
	ListServerlessBackupSettings(context.Context, *ListServerlessBackupSettingsReq) (*ListServerlessBackupSettingsResp, error)
	ListServerlessBackups(context.Context, *ListServerlessBackupsReq) (*ListServerlessBackupsResp, error)
	GetServerlessBackup(context.Context, *GetServerlessBackupReq) (*FullServerlessBackup, error)
	mustEmbedUnimplementedServerlessBackupInternalServiceServer()
}

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

func (UnimplementedServerlessBackupInternalServiceServer) QueryServerlessBackupSetting(context.Context, *QueryServerlessBackupSettingReq) (*QueryServerlessBackupSettingResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method QueryServerlessBackupSetting not implemented")
}
func (UnimplementedServerlessBackupInternalServiceServer) ModifyServerlessBackupSetting(context.Context, *ModifyServerlessBackupSettingReq) (*ModifyServerlessBackupSettingResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ModifyServerlessBackupSetting not implemented")
}
func (UnimplementedServerlessBackupInternalServiceServer) ListServerlessBackupSettings(context.Context, *ListServerlessBackupSettingsReq) (*ListServerlessBackupSettingsResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListServerlessBackupSettings not implemented")
}
func (UnimplementedServerlessBackupInternalServiceServer) ListServerlessBackups(context.Context, *ListServerlessBackupsReq) (*ListServerlessBackupsResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListServerlessBackups not implemented")
}
func (UnimplementedServerlessBackupInternalServiceServer) GetServerlessBackup(context.Context, *GetServerlessBackupReq) (*FullServerlessBackup, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetServerlessBackup not implemented")
}
func (UnimplementedServerlessBackupInternalServiceServer) mustEmbedUnimplementedServerlessBackupInternalServiceServer() {
}

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

func RegisterServerlessBackupInternalServiceServer(s grpc.ServiceRegistrar, srv ServerlessBackupInternalServiceServer) {
	s.RegisterService(&ServerlessBackupInternalService_ServiceDesc, srv)
}

func _ServerlessBackupInternalService_QueryServerlessBackupSetting_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(QueryServerlessBackupSettingReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessBackupInternalServiceServer).QueryServerlessBackupSetting(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessBackupInternalService_QueryServerlessBackupSetting_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessBackupInternalServiceServer).QueryServerlessBackupSetting(ctx, req.(*QueryServerlessBackupSettingReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessBackupInternalService_ModifyServerlessBackupSetting_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ModifyServerlessBackupSettingReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessBackupInternalServiceServer).ModifyServerlessBackupSetting(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessBackupInternalService_ModifyServerlessBackupSetting_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessBackupInternalServiceServer).ModifyServerlessBackupSetting(ctx, req.(*ModifyServerlessBackupSettingReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessBackupInternalService_ListServerlessBackupSettings_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListServerlessBackupSettingsReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessBackupInternalServiceServer).ListServerlessBackupSettings(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessBackupInternalService_ListServerlessBackupSettings_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessBackupInternalServiceServer).ListServerlessBackupSettings(ctx, req.(*ListServerlessBackupSettingsReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessBackupInternalService_ListServerlessBackups_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListServerlessBackupsReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessBackupInternalServiceServer).ListServerlessBackups(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessBackupInternalService_ListServerlessBackups_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessBackupInternalServiceServer).ListServerlessBackups(ctx, req.(*ListServerlessBackupsReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ServerlessBackupInternalService_GetServerlessBackup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetServerlessBackupReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ServerlessBackupInternalServiceServer).GetServerlessBackup(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ServerlessBackupInternalService_GetServerlessBackup_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ServerlessBackupInternalServiceServer).GetServerlessBackup(ctx, req.(*GetServerlessBackupReq))
	}
	return interceptor(ctx, in, info, handler)
}

// ServerlessBackupInternalService_ServiceDesc is the grpc.ServiceDesc for ServerlessBackupInternalService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var ServerlessBackupInternalService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "dataflow.ServerlessBackupInternalService",
	HandlerType: (*ServerlessBackupInternalServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "QueryServerlessBackupSetting",
			Handler:    _ServerlessBackupInternalService_QueryServerlessBackupSetting_Handler,
		},
		{
			MethodName: "ModifyServerlessBackupSetting",
			Handler:    _ServerlessBackupInternalService_ModifyServerlessBackupSetting_Handler,
		},
		{
			MethodName: "ListServerlessBackupSettings",
			Handler:    _ServerlessBackupInternalService_ListServerlessBackupSettings_Handler,
		},
		{
			MethodName: "ListServerlessBackups",
			Handler:    _ServerlessBackupInternalService_ListServerlessBackups_Handler,
		},
		{
			MethodName: "GetServerlessBackup",
			Handler:    _ServerlessBackupInternalService_GetServerlessBackup_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "dataflow/service.proto",
}

const (
	ConnectorService_ListConnectors_FullMethodName                            = "/dataflow.ConnectorService/ListConnectors"
	ConnectorService_GetConnector_FullMethodName                              = "/dataflow.ConnectorService/GetConnector"
	ConnectorService_GetClusterTCU_FullMethodName                             = "/dataflow.ConnectorService/GetClusterTCU"
	ConnectorService_GetClusterTCUForAdmin_FullMethodName                     = "/dataflow.ConnectorService/GetClusterTCUForAdmin"
	ConnectorService_DescribeAdminProfile_FullMethodName                      = "/dataflow.ConnectorService/DescribeAdminProfile"
	ConnectorService_DescribeSchemaTable_FullMethodName                       = "/dataflow.ConnectorService/DescribeSchemaTable"
	ConnectorService_ScaleChangefeed_FullMethodName                           = "/dataflow.ConnectorService/ScaleChangefeed"
	ConnectorService_CalChangefeedFee_FullMethodName                          = "/dataflow.ConnectorService/CalChangefeedFee"
	ConnectorService_StartConnector_FullMethodName                            = "/dataflow.ConnectorService/StartConnector"
	ConnectorService_StopConnector_FullMethodName                             = "/dataflow.ConnectorService/StopConnector"
	ConnectorService_CreateConnector_FullMethodName                           = "/dataflow.ConnectorService/CreateConnector"
	ConnectorService_EditConnector_FullMethodName                             = "/dataflow.ConnectorService/EditConnector"
	ConnectorService_DeleteConnector_FullMethodName                           = "/dataflow.ConnectorService/DeleteConnector"
	ConnectorService_TestConnector_FullMethodName                             = "/dataflow.ConnectorService/TestConnector"
	ConnectorService_CreatePrivateLink_FullMethodName                         = "/dataflow.ConnectorService/CreatePrivateLink"
	ConnectorService_GetPrivateLink_FullMethodName                            = "/dataflow.ConnectorService/GetPrivateLink"
	ConnectorService_GetPrivateLinkAuthInfo_FullMethodName                    = "/dataflow.ConnectorService/GetPrivateLinkAuthInfo"
	ConnectorService_GeneratePrivateLinkAdvertisedPatternGroup_FullMethodName = "/dataflow.ConnectorService/GeneratePrivateLinkAdvertisedPatternGroup"
	ConnectorService_GetPrivateLinkAvailableZones_FullMethodName              = "/dataflow.ConnectorService/GetPrivateLinkAvailableZones"
	ConnectorService_ListConnectorEnabledFeatures_FullMethodName              = "/dataflow.ConnectorService/ListConnectorEnabledFeatures"
	ConnectorService_GetChangefeedDetail_FullMethodName                       = "/dataflow.ConnectorService/GetChangefeedDetail"
	ConnectorService_GetTiCDCCluster_FullMethodName                           = "/dataflow.ConnectorService/GetTiCDCCluster"
	ConnectorService_ListTiCDCClusters_FullMethodName                         = "/dataflow.ConnectorService/ListTiCDCClusters"
)

// ConnectorServiceClient is the client API for ConnectorService 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 ConnectorServiceClient interface {
	ListConnectors(ctx context.Context, in *ConnectorListReq, opts ...grpc.CallOption) (*Connectors, error)
	GetConnector(ctx context.Context, in *ConnectorID, opts ...grpc.CallOption) (*Connector, error)
	GetClusterTCU(ctx context.Context, in *GetClusterTCUReq, opts ...grpc.CallOption) (*GetClusterTCUResp, error)
	GetClusterTCUForAdmin(ctx context.Context, in *GetClusterTCUReq, opts ...grpc.CallOption) (*GetClusterTCUResp, error)
	DescribeAdminProfile(ctx context.Context, in *ClusterIdReq, opts ...grpc.CallOption) (*AdminProfileResp, error)
	DescribeSchemaTable(ctx context.Context, in *DescribeSchemaTableReq, opts ...grpc.CallOption) (*DescribeSchemaTableResp, error)
	ScaleChangefeed(ctx context.Context, in *ChangefeedScaleReq, opts ...grpc.CallOption) (*emptypb.Empty, error)
	CalChangefeedFee(ctx context.Context, in *CalChangefeedFeeReq, opts ...grpc.CallOption) (*CalChangefeedFeeResp, error)
	StartConnector(ctx context.Context, in *ConnectorID, opts ...grpc.CallOption) (*emptypb.Empty, error)
	StopConnector(ctx context.Context, in *ConnectorID, opts ...grpc.CallOption) (*emptypb.Empty, error)
	CreateConnector(ctx context.Context, in *ConnectorCreateReq, opts ...grpc.CallOption) (*ConnectorID, error)
	EditConnector(ctx context.Context, in *ConnectorEditReq, opts ...grpc.CallOption) (*emptypb.Empty, error)
	DeleteConnector(ctx context.Context, in *ConnectorID, opts ...grpc.CallOption) (*emptypb.Empty, error)
	TestConnector(ctx context.Context, in *ConnectorCreateReq, opts ...grpc.CallOption) (*emptypb.Empty, error)
	CreatePrivateLink(ctx context.Context, in *CreateChangefeedPrivateLinkReq, opts ...grpc.CallOption) (*CreateChangefeedPrivateLinkResp, error)
	GetPrivateLink(ctx context.Context, in *GetChangefeedPrivateLinkReq, opts ...grpc.CallOption) (*GetChangefeedPrivateLinkResp, error)
	GetPrivateLinkAuthInfo(ctx context.Context, in *GetPrivateLinkAuthInfoReq, opts ...grpc.CallOption) (*GetPrivateLinkAuthInfoResp, error)
	GeneratePrivateLinkAdvertisedPatternGroup(ctx context.Context, in *GenerateAdvertisedPatternReq, opts ...grpc.CallOption) (*GenerateAdvertisedPatternResp, error)
	GetPrivateLinkAvailableZones(ctx context.Context, in *GetPrivateLinkAvailableZoneReq, opts ...grpc.CallOption) (*GetPrivateLinkAvailableZoneResp, error)
	ListConnectorEnabledFeatures(ctx context.Context, in *ListConnectorEnabledFeaturesReq, opts ...grpc.CallOption) (*ListConnectorEnabledFeaturesResp, error)
	// For E2E tests
	GetChangefeedDetail(ctx context.Context, in *ConnectorID, opts ...grpc.CallOption) (*structpb.Struct, error)
	// For E2E tests
	GetTiCDCCluster(ctx context.Context, in *ConnectorID, opts ...grpc.CallOption) (*structpb.Struct, error)
	ListTiCDCClusters(ctx context.Context, in *ClusterIdReq, opts ...grpc.CallOption) (*structpb.Struct, error)
}

type connectorServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewConnectorServiceClient(cc grpc.ClientConnInterface) ConnectorServiceClient {
	return &connectorServiceClient{cc}
}

func (c *connectorServiceClient) ListConnectors(ctx context.Context, in *ConnectorListReq, opts ...grpc.CallOption) (*Connectors, error) {
	out := new(Connectors)
	err := c.cc.Invoke(ctx, ConnectorService_ListConnectors_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *connectorServiceClient) GetConnector(ctx context.Context, in *ConnectorID, opts ...grpc.CallOption) (*Connector, error) {
	out := new(Connector)
	err := c.cc.Invoke(ctx, ConnectorService_GetConnector_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *connectorServiceClient) GetClusterTCU(ctx context.Context, in *GetClusterTCUReq, opts ...grpc.CallOption) (*GetClusterTCUResp, error) {
	out := new(GetClusterTCUResp)
	err := c.cc.Invoke(ctx, ConnectorService_GetClusterTCU_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *connectorServiceClient) GetClusterTCUForAdmin(ctx context.Context, in *GetClusterTCUReq, opts ...grpc.CallOption) (*GetClusterTCUResp, error) {
	out := new(GetClusterTCUResp)
	err := c.cc.Invoke(ctx, ConnectorService_GetClusterTCUForAdmin_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *connectorServiceClient) DescribeAdminProfile(ctx context.Context, in *ClusterIdReq, opts ...grpc.CallOption) (*AdminProfileResp, error) {
	out := new(AdminProfileResp)
	err := c.cc.Invoke(ctx, ConnectorService_DescribeAdminProfile_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *connectorServiceClient) DescribeSchemaTable(ctx context.Context, in *DescribeSchemaTableReq, opts ...grpc.CallOption) (*DescribeSchemaTableResp, error) {
	out := new(DescribeSchemaTableResp)
	err := c.cc.Invoke(ctx, ConnectorService_DescribeSchemaTable_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *connectorServiceClient) ScaleChangefeed(ctx context.Context, in *ChangefeedScaleReq, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, ConnectorService_ScaleChangefeed_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *connectorServiceClient) CalChangefeedFee(ctx context.Context, in *CalChangefeedFeeReq, opts ...grpc.CallOption) (*CalChangefeedFeeResp, error) {
	out := new(CalChangefeedFeeResp)
	err := c.cc.Invoke(ctx, ConnectorService_CalChangefeedFee_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *connectorServiceClient) StartConnector(ctx context.Context, in *ConnectorID, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, ConnectorService_StartConnector_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *connectorServiceClient) StopConnector(ctx context.Context, in *ConnectorID, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, ConnectorService_StopConnector_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *connectorServiceClient) CreateConnector(ctx context.Context, in *ConnectorCreateReq, opts ...grpc.CallOption) (*ConnectorID, error) {
	out := new(ConnectorID)
	err := c.cc.Invoke(ctx, ConnectorService_CreateConnector_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *connectorServiceClient) EditConnector(ctx context.Context, in *ConnectorEditReq, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, ConnectorService_EditConnector_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *connectorServiceClient) DeleteConnector(ctx context.Context, in *ConnectorID, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, ConnectorService_DeleteConnector_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *connectorServiceClient) TestConnector(ctx context.Context, in *ConnectorCreateReq, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, ConnectorService_TestConnector_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *connectorServiceClient) CreatePrivateLink(ctx context.Context, in *CreateChangefeedPrivateLinkReq, opts ...grpc.CallOption) (*CreateChangefeedPrivateLinkResp, error) {
	out := new(CreateChangefeedPrivateLinkResp)
	err := c.cc.Invoke(ctx, ConnectorService_CreatePrivateLink_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *connectorServiceClient) GetPrivateLink(ctx context.Context, in *GetChangefeedPrivateLinkReq, opts ...grpc.CallOption) (*GetChangefeedPrivateLinkResp, error) {
	out := new(GetChangefeedPrivateLinkResp)
	err := c.cc.Invoke(ctx, ConnectorService_GetPrivateLink_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *connectorServiceClient) GetPrivateLinkAuthInfo(ctx context.Context, in *GetPrivateLinkAuthInfoReq, opts ...grpc.CallOption) (*GetPrivateLinkAuthInfoResp, error) {
	out := new(GetPrivateLinkAuthInfoResp)
	err := c.cc.Invoke(ctx, ConnectorService_GetPrivateLinkAuthInfo_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *connectorServiceClient) GeneratePrivateLinkAdvertisedPatternGroup(ctx context.Context, in *GenerateAdvertisedPatternReq, opts ...grpc.CallOption) (*GenerateAdvertisedPatternResp, error) {
	out := new(GenerateAdvertisedPatternResp)
	err := c.cc.Invoke(ctx, ConnectorService_GeneratePrivateLinkAdvertisedPatternGroup_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *connectorServiceClient) GetPrivateLinkAvailableZones(ctx context.Context, in *GetPrivateLinkAvailableZoneReq, opts ...grpc.CallOption) (*GetPrivateLinkAvailableZoneResp, error) {
	out := new(GetPrivateLinkAvailableZoneResp)
	err := c.cc.Invoke(ctx, ConnectorService_GetPrivateLinkAvailableZones_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *connectorServiceClient) ListConnectorEnabledFeatures(ctx context.Context, in *ListConnectorEnabledFeaturesReq, opts ...grpc.CallOption) (*ListConnectorEnabledFeaturesResp, error) {
	out := new(ListConnectorEnabledFeaturesResp)
	err := c.cc.Invoke(ctx, ConnectorService_ListConnectorEnabledFeatures_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *connectorServiceClient) GetChangefeedDetail(ctx context.Context, in *ConnectorID, opts ...grpc.CallOption) (*structpb.Struct, error) {
	out := new(structpb.Struct)
	err := c.cc.Invoke(ctx, ConnectorService_GetChangefeedDetail_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *connectorServiceClient) GetTiCDCCluster(ctx context.Context, in *ConnectorID, opts ...grpc.CallOption) (*structpb.Struct, error) {
	out := new(structpb.Struct)
	err := c.cc.Invoke(ctx, ConnectorService_GetTiCDCCluster_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *connectorServiceClient) ListTiCDCClusters(ctx context.Context, in *ClusterIdReq, opts ...grpc.CallOption) (*structpb.Struct, error) {
	out := new(structpb.Struct)
	err := c.cc.Invoke(ctx, ConnectorService_ListTiCDCClusters_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ConnectorServiceServer is the server API for ConnectorService service.
// All implementations must embed UnimplementedConnectorServiceServer
// for forward compatibility
type ConnectorServiceServer interface {
	ListConnectors(context.Context, *ConnectorListReq) (*Connectors, error)
	GetConnector(context.Context, *ConnectorID) (*Connector, error)
	GetClusterTCU(context.Context, *GetClusterTCUReq) (*GetClusterTCUResp, error)
	GetClusterTCUForAdmin(context.Context, *GetClusterTCUReq) (*GetClusterTCUResp, error)
	DescribeAdminProfile(context.Context, *ClusterIdReq) (*AdminProfileResp, error)
	DescribeSchemaTable(context.Context, *DescribeSchemaTableReq) (*DescribeSchemaTableResp, error)
	ScaleChangefeed(context.Context, *ChangefeedScaleReq) (*emptypb.Empty, error)
	CalChangefeedFee(context.Context, *CalChangefeedFeeReq) (*CalChangefeedFeeResp, error)
	StartConnector(context.Context, *ConnectorID) (*emptypb.Empty, error)
	StopConnector(context.Context, *ConnectorID) (*emptypb.Empty, error)
	CreateConnector(context.Context, *ConnectorCreateReq) (*ConnectorID, error)
	EditConnector(context.Context, *ConnectorEditReq) (*emptypb.Empty, error)
	DeleteConnector(context.Context, *ConnectorID) (*emptypb.Empty, error)
	TestConnector(context.Context, *ConnectorCreateReq) (*emptypb.Empty, error)
	CreatePrivateLink(context.Context, *CreateChangefeedPrivateLinkReq) (*CreateChangefeedPrivateLinkResp, error)
	GetPrivateLink(context.Context, *GetChangefeedPrivateLinkReq) (*GetChangefeedPrivateLinkResp, error)
	GetPrivateLinkAuthInfo(context.Context, *GetPrivateLinkAuthInfoReq) (*GetPrivateLinkAuthInfoResp, error)
	GeneratePrivateLinkAdvertisedPatternGroup(context.Context, *GenerateAdvertisedPatternReq) (*GenerateAdvertisedPatternResp, error)
	GetPrivateLinkAvailableZones(context.Context, *GetPrivateLinkAvailableZoneReq) (*GetPrivateLinkAvailableZoneResp, error)
	ListConnectorEnabledFeatures(context.Context, *ListConnectorEnabledFeaturesReq) (*ListConnectorEnabledFeaturesResp, error)
	// For E2E tests
	GetChangefeedDetail(context.Context, *ConnectorID) (*structpb.Struct, error)
	// For E2E tests
	GetTiCDCCluster(context.Context, *ConnectorID) (*structpb.Struct, error)
	ListTiCDCClusters(context.Context, *ClusterIdReq) (*structpb.Struct, error)
	mustEmbedUnimplementedConnectorServiceServer()
}

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

func (UnimplementedConnectorServiceServer) ListConnectors(context.Context, *ConnectorListReq) (*Connectors, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListConnectors not implemented")
}
func (UnimplementedConnectorServiceServer) GetConnector(context.Context, *ConnectorID) (*Connector, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetConnector not implemented")
}
func (UnimplementedConnectorServiceServer) GetClusterTCU(context.Context, *GetClusterTCUReq) (*GetClusterTCUResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetClusterTCU not implemented")
}
func (UnimplementedConnectorServiceServer) GetClusterTCUForAdmin(context.Context, *GetClusterTCUReq) (*GetClusterTCUResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetClusterTCUForAdmin not implemented")
}
func (UnimplementedConnectorServiceServer) DescribeAdminProfile(context.Context, *ClusterIdReq) (*AdminProfileResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DescribeAdminProfile not implemented")
}
func (UnimplementedConnectorServiceServer) DescribeSchemaTable(context.Context, *DescribeSchemaTableReq) (*DescribeSchemaTableResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DescribeSchemaTable not implemented")
}
func (UnimplementedConnectorServiceServer) ScaleChangefeed(context.Context, *ChangefeedScaleReq) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ScaleChangefeed not implemented")
}
func (UnimplementedConnectorServiceServer) CalChangefeedFee(context.Context, *CalChangefeedFeeReq) (*CalChangefeedFeeResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CalChangefeedFee not implemented")
}
func (UnimplementedConnectorServiceServer) StartConnector(context.Context, *ConnectorID) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StartConnector not implemented")
}
func (UnimplementedConnectorServiceServer) StopConnector(context.Context, *ConnectorID) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method StopConnector not implemented")
}
func (UnimplementedConnectorServiceServer) CreateConnector(context.Context, *ConnectorCreateReq) (*ConnectorID, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateConnector not implemented")
}
func (UnimplementedConnectorServiceServer) EditConnector(context.Context, *ConnectorEditReq) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method EditConnector not implemented")
}
func (UnimplementedConnectorServiceServer) DeleteConnector(context.Context, *ConnectorID) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteConnector not implemented")
}
func (UnimplementedConnectorServiceServer) TestConnector(context.Context, *ConnectorCreateReq) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method TestConnector not implemented")
}
func (UnimplementedConnectorServiceServer) CreatePrivateLink(context.Context, *CreateChangefeedPrivateLinkReq) (*CreateChangefeedPrivateLinkResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreatePrivateLink not implemented")
}
func (UnimplementedConnectorServiceServer) GetPrivateLink(context.Context, *GetChangefeedPrivateLinkReq) (*GetChangefeedPrivateLinkResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetPrivateLink not implemented")
}
func (UnimplementedConnectorServiceServer) GetPrivateLinkAuthInfo(context.Context, *GetPrivateLinkAuthInfoReq) (*GetPrivateLinkAuthInfoResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetPrivateLinkAuthInfo not implemented")
}
func (UnimplementedConnectorServiceServer) GeneratePrivateLinkAdvertisedPatternGroup(context.Context, *GenerateAdvertisedPatternReq) (*GenerateAdvertisedPatternResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GeneratePrivateLinkAdvertisedPatternGroup not implemented")
}
func (UnimplementedConnectorServiceServer) GetPrivateLinkAvailableZones(context.Context, *GetPrivateLinkAvailableZoneReq) (*GetPrivateLinkAvailableZoneResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetPrivateLinkAvailableZones not implemented")
}
func (UnimplementedConnectorServiceServer) ListConnectorEnabledFeatures(context.Context, *ListConnectorEnabledFeaturesReq) (*ListConnectorEnabledFeaturesResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListConnectorEnabledFeatures not implemented")
}
func (UnimplementedConnectorServiceServer) GetChangefeedDetail(context.Context, *ConnectorID) (*structpb.Struct, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetChangefeedDetail not implemented")
}
func (UnimplementedConnectorServiceServer) GetTiCDCCluster(context.Context, *ConnectorID) (*structpb.Struct, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetTiCDCCluster not implemented")
}
func (UnimplementedConnectorServiceServer) ListTiCDCClusters(context.Context, *ClusterIdReq) (*structpb.Struct, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListTiCDCClusters not implemented")
}
func (UnimplementedConnectorServiceServer) mustEmbedUnimplementedConnectorServiceServer() {}

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

func RegisterConnectorServiceServer(s grpc.ServiceRegistrar, srv ConnectorServiceServer) {
	s.RegisterService(&ConnectorService_ServiceDesc, srv)
}

func _ConnectorService_ListConnectors_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ConnectorListReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConnectorServiceServer).ListConnectors(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ConnectorService_ListConnectors_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConnectorServiceServer).ListConnectors(ctx, req.(*ConnectorListReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ConnectorService_GetConnector_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ConnectorID)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConnectorServiceServer).GetConnector(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ConnectorService_GetConnector_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConnectorServiceServer).GetConnector(ctx, req.(*ConnectorID))
	}
	return interceptor(ctx, in, info, handler)
}

func _ConnectorService_GetClusterTCU_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetClusterTCUReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConnectorServiceServer).GetClusterTCU(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ConnectorService_GetClusterTCU_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConnectorServiceServer).GetClusterTCU(ctx, req.(*GetClusterTCUReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ConnectorService_GetClusterTCUForAdmin_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetClusterTCUReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConnectorServiceServer).GetClusterTCUForAdmin(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ConnectorService_GetClusterTCUForAdmin_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConnectorServiceServer).GetClusterTCUForAdmin(ctx, req.(*GetClusterTCUReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ConnectorService_DescribeAdminProfile_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ClusterIdReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConnectorServiceServer).DescribeAdminProfile(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ConnectorService_DescribeAdminProfile_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConnectorServiceServer).DescribeAdminProfile(ctx, req.(*ClusterIdReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ConnectorService_DescribeSchemaTable_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DescribeSchemaTableReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConnectorServiceServer).DescribeSchemaTable(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ConnectorService_DescribeSchemaTable_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConnectorServiceServer).DescribeSchemaTable(ctx, req.(*DescribeSchemaTableReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ConnectorService_ScaleChangefeed_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ChangefeedScaleReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConnectorServiceServer).ScaleChangefeed(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ConnectorService_ScaleChangefeed_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConnectorServiceServer).ScaleChangefeed(ctx, req.(*ChangefeedScaleReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ConnectorService_CalChangefeedFee_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CalChangefeedFeeReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConnectorServiceServer).CalChangefeedFee(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ConnectorService_CalChangefeedFee_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConnectorServiceServer).CalChangefeedFee(ctx, req.(*CalChangefeedFeeReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ConnectorService_StartConnector_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ConnectorID)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConnectorServiceServer).StartConnector(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ConnectorService_StartConnector_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConnectorServiceServer).StartConnector(ctx, req.(*ConnectorID))
	}
	return interceptor(ctx, in, info, handler)
}

func _ConnectorService_StopConnector_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ConnectorID)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConnectorServiceServer).StopConnector(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ConnectorService_StopConnector_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConnectorServiceServer).StopConnector(ctx, req.(*ConnectorID))
	}
	return interceptor(ctx, in, info, handler)
}

func _ConnectorService_CreateConnector_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ConnectorCreateReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConnectorServiceServer).CreateConnector(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ConnectorService_CreateConnector_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConnectorServiceServer).CreateConnector(ctx, req.(*ConnectorCreateReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ConnectorService_EditConnector_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ConnectorEditReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConnectorServiceServer).EditConnector(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ConnectorService_EditConnector_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConnectorServiceServer).EditConnector(ctx, req.(*ConnectorEditReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ConnectorService_DeleteConnector_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ConnectorID)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConnectorServiceServer).DeleteConnector(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ConnectorService_DeleteConnector_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConnectorServiceServer).DeleteConnector(ctx, req.(*ConnectorID))
	}
	return interceptor(ctx, in, info, handler)
}

func _ConnectorService_TestConnector_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ConnectorCreateReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConnectorServiceServer).TestConnector(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ConnectorService_TestConnector_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConnectorServiceServer).TestConnector(ctx, req.(*ConnectorCreateReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ConnectorService_CreatePrivateLink_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateChangefeedPrivateLinkReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConnectorServiceServer).CreatePrivateLink(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ConnectorService_CreatePrivateLink_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConnectorServiceServer).CreatePrivateLink(ctx, req.(*CreateChangefeedPrivateLinkReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ConnectorService_GetPrivateLink_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetChangefeedPrivateLinkReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConnectorServiceServer).GetPrivateLink(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ConnectorService_GetPrivateLink_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConnectorServiceServer).GetPrivateLink(ctx, req.(*GetChangefeedPrivateLinkReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ConnectorService_GetPrivateLinkAuthInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetPrivateLinkAuthInfoReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConnectorServiceServer).GetPrivateLinkAuthInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ConnectorService_GetPrivateLinkAuthInfo_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConnectorServiceServer).GetPrivateLinkAuthInfo(ctx, req.(*GetPrivateLinkAuthInfoReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ConnectorService_GeneratePrivateLinkAdvertisedPatternGroup_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GenerateAdvertisedPatternReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConnectorServiceServer).GeneratePrivateLinkAdvertisedPatternGroup(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ConnectorService_GeneratePrivateLinkAdvertisedPatternGroup_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConnectorServiceServer).GeneratePrivateLinkAdvertisedPatternGroup(ctx, req.(*GenerateAdvertisedPatternReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ConnectorService_GetPrivateLinkAvailableZones_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetPrivateLinkAvailableZoneReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConnectorServiceServer).GetPrivateLinkAvailableZones(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ConnectorService_GetPrivateLinkAvailableZones_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConnectorServiceServer).GetPrivateLinkAvailableZones(ctx, req.(*GetPrivateLinkAvailableZoneReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ConnectorService_ListConnectorEnabledFeatures_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListConnectorEnabledFeaturesReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConnectorServiceServer).ListConnectorEnabledFeatures(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ConnectorService_ListConnectorEnabledFeatures_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConnectorServiceServer).ListConnectorEnabledFeatures(ctx, req.(*ListConnectorEnabledFeaturesReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _ConnectorService_GetChangefeedDetail_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ConnectorID)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConnectorServiceServer).GetChangefeedDetail(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ConnectorService_GetChangefeedDetail_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConnectorServiceServer).GetChangefeedDetail(ctx, req.(*ConnectorID))
	}
	return interceptor(ctx, in, info, handler)
}

func _ConnectorService_GetTiCDCCluster_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ConnectorID)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConnectorServiceServer).GetTiCDCCluster(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ConnectorService_GetTiCDCCluster_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConnectorServiceServer).GetTiCDCCluster(ctx, req.(*ConnectorID))
	}
	return interceptor(ctx, in, info, handler)
}

func _ConnectorService_ListTiCDCClusters_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ClusterIdReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ConnectorServiceServer).ListTiCDCClusters(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ConnectorService_ListTiCDCClusters_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ConnectorServiceServer).ListTiCDCClusters(ctx, req.(*ClusterIdReq))
	}
	return interceptor(ctx, in, info, handler)
}

// ConnectorService_ServiceDesc is the grpc.ServiceDesc for ConnectorService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var ConnectorService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "dataflow.ConnectorService",
	HandlerType: (*ConnectorServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ListConnectors",
			Handler:    _ConnectorService_ListConnectors_Handler,
		},
		{
			MethodName: "GetConnector",
			Handler:    _ConnectorService_GetConnector_Handler,
		},
		{
			MethodName: "GetClusterTCU",
			Handler:    _ConnectorService_GetClusterTCU_Handler,
		},
		{
			MethodName: "GetClusterTCUForAdmin",
			Handler:    _ConnectorService_GetClusterTCUForAdmin_Handler,
		},
		{
			MethodName: "DescribeAdminProfile",
			Handler:    _ConnectorService_DescribeAdminProfile_Handler,
		},
		{
			MethodName: "DescribeSchemaTable",
			Handler:    _ConnectorService_DescribeSchemaTable_Handler,
		},
		{
			MethodName: "ScaleChangefeed",
			Handler:    _ConnectorService_ScaleChangefeed_Handler,
		},
		{
			MethodName: "CalChangefeedFee",
			Handler:    _ConnectorService_CalChangefeedFee_Handler,
		},
		{
			MethodName: "StartConnector",
			Handler:    _ConnectorService_StartConnector_Handler,
		},
		{
			MethodName: "StopConnector",
			Handler:    _ConnectorService_StopConnector_Handler,
		},
		{
			MethodName: "CreateConnector",
			Handler:    _ConnectorService_CreateConnector_Handler,
		},
		{
			MethodName: "EditConnector",
			Handler:    _ConnectorService_EditConnector_Handler,
		},
		{
			MethodName: "DeleteConnector",
			Handler:    _ConnectorService_DeleteConnector_Handler,
		},
		{
			MethodName: "TestConnector",
			Handler:    _ConnectorService_TestConnector_Handler,
		},
		{
			MethodName: "CreatePrivateLink",
			Handler:    _ConnectorService_CreatePrivateLink_Handler,
		},
		{
			MethodName: "GetPrivateLink",
			Handler:    _ConnectorService_GetPrivateLink_Handler,
		},
		{
			MethodName: "GetPrivateLinkAuthInfo",
			Handler:    _ConnectorService_GetPrivateLinkAuthInfo_Handler,
		},
		{
			MethodName: "GeneratePrivateLinkAdvertisedPatternGroup",
			Handler:    _ConnectorService_GeneratePrivateLinkAdvertisedPatternGroup_Handler,
		},
		{
			MethodName: "GetPrivateLinkAvailableZones",
			Handler:    _ConnectorService_GetPrivateLinkAvailableZones_Handler,
		},
		{
			MethodName: "ListConnectorEnabledFeatures",
			Handler:    _ConnectorService_ListConnectorEnabledFeatures_Handler,
		},
		{
			MethodName: "GetChangefeedDetail",
			Handler:    _ConnectorService_GetChangefeedDetail_Handler,
		},
		{
			MethodName: "GetTiCDCCluster",
			Handler:    _ConnectorService_GetTiCDCCluster_Handler,
		},
		{
			MethodName: "ListTiCDCClusters",
			Handler:    _ConnectorService_ListTiCDCClusters_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "dataflow/service.proto",
}

const (
	DPFeatureService_GetEnabledDPFeaturesForCluster_FullMethodName = "/dataflow.DPFeatureService/GetEnabledDPFeaturesForCluster"
)

// DPFeatureServiceClient is the client API for DPFeatureService 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 DPFeatureServiceClient interface {
	GetEnabledDPFeaturesForCluster(ctx context.Context, in *EnabledDPFeaturesForClusterReq, opts ...grpc.CallOption) (*EnabledDPFeaturesForClusterResp, error)
}

type dPFeatureServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewDPFeatureServiceClient(cc grpc.ClientConnInterface) DPFeatureServiceClient {
	return &dPFeatureServiceClient{cc}
}

func (c *dPFeatureServiceClient) GetEnabledDPFeaturesForCluster(ctx context.Context, in *EnabledDPFeaturesForClusterReq, opts ...grpc.CallOption) (*EnabledDPFeaturesForClusterResp, error) {
	out := new(EnabledDPFeaturesForClusterResp)
	err := c.cc.Invoke(ctx, DPFeatureService_GetEnabledDPFeaturesForCluster_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// DPFeatureServiceServer is the server API for DPFeatureService service.
// All implementations must embed UnimplementedDPFeatureServiceServer
// for forward compatibility
type DPFeatureServiceServer interface {
	GetEnabledDPFeaturesForCluster(context.Context, *EnabledDPFeaturesForClusterReq) (*EnabledDPFeaturesForClusterResp, error)
	mustEmbedUnimplementedDPFeatureServiceServer()
}

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

func (UnimplementedDPFeatureServiceServer) GetEnabledDPFeaturesForCluster(context.Context, *EnabledDPFeaturesForClusterReq) (*EnabledDPFeaturesForClusterResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetEnabledDPFeaturesForCluster not implemented")
}
func (UnimplementedDPFeatureServiceServer) mustEmbedUnimplementedDPFeatureServiceServer() {}

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

func RegisterDPFeatureServiceServer(s grpc.ServiceRegistrar, srv DPFeatureServiceServer) {
	s.RegisterService(&DPFeatureService_ServiceDesc, srv)
}

func _DPFeatureService_GetEnabledDPFeaturesForCluster_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(EnabledDPFeaturesForClusterReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(DPFeatureServiceServer).GetEnabledDPFeaturesForCluster(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: DPFeatureService_GetEnabledDPFeaturesForCluster_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(DPFeatureServiceServer).GetEnabledDPFeaturesForCluster(ctx, req.(*EnabledDPFeaturesForClusterReq))
	}
	return interceptor(ctx, in, info, handler)
}

// DPFeatureService_ServiceDesc is the grpc.ServiceDesc for DPFeatureService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var DPFeatureService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "dataflow.DPFeatureService",
	HandlerType: (*DPFeatureServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "GetEnabledDPFeaturesForCluster",
			Handler:    _DPFeatureService_GetEnabledDPFeaturesForCluster_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "dataflow/service.proto",
}

const (
	OPSService_ConsumerEventBusDLQ_FullMethodName = "/dataflow.OPSService/ConsumerEventBusDLQ"
)

// OPSServiceClient is the client API for OPSService 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 OPSServiceClient interface {
	ConsumerEventBusDLQ(ctx context.Context, in *ConsumerEventBusDLQReq, opts ...grpc.CallOption) (*emptypb.Empty, error)
}

type oPSServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewOPSServiceClient(cc grpc.ClientConnInterface) OPSServiceClient {
	return &oPSServiceClient{cc}
}

func (c *oPSServiceClient) ConsumerEventBusDLQ(ctx context.Context, in *ConsumerEventBusDLQReq, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, OPSService_ConsumerEventBusDLQ_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// OPSServiceServer is the server API for OPSService service.
// All implementations must embed UnimplementedOPSServiceServer
// for forward compatibility
type OPSServiceServer interface {
	ConsumerEventBusDLQ(context.Context, *ConsumerEventBusDLQReq) (*emptypb.Empty, error)
	mustEmbedUnimplementedOPSServiceServer()
}

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

func (UnimplementedOPSServiceServer) ConsumerEventBusDLQ(context.Context, *ConsumerEventBusDLQReq) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ConsumerEventBusDLQ not implemented")
}
func (UnimplementedOPSServiceServer) mustEmbedUnimplementedOPSServiceServer() {}

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

func RegisterOPSServiceServer(s grpc.ServiceRegistrar, srv OPSServiceServer) {
	s.RegisterService(&OPSService_ServiceDesc, srv)
}

func _OPSService_ConsumerEventBusDLQ_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ConsumerEventBusDLQReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(OPSServiceServer).ConsumerEventBusDLQ(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: OPSService_ConsumerEventBusDLQ_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(OPSServiceServer).ConsumerEventBusDLQ(ctx, req.(*ConsumerEventBusDLQReq))
	}
	return interceptor(ctx, in, info, handler)
}

// OPSService_ServiceDesc is the grpc.ServiceDesc for OPSService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var OPSService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "dataflow.OPSService",
	HandlerType: (*OPSServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ConsumerEventBusDLQ",
			Handler:    _OPSService_ConsumerEventBusDLQ_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "dataflow/service.proto",
}

const (
	ChangefeedInstanceTypeService_List_FullMethodName = "/dataflow.ChangefeedInstanceTypeService/List"
)

// ChangefeedInstanceTypeServiceClient is the client API for ChangefeedInstanceTypeService 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 ChangefeedInstanceTypeServiceClient interface {
	List(ctx context.Context, in *ChangefeedInstanceTypeListReq, opts ...grpc.CallOption) (*ChangefeedInstanceTypes, error)
}

type changefeedInstanceTypeServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewChangefeedInstanceTypeServiceClient(cc grpc.ClientConnInterface) ChangefeedInstanceTypeServiceClient {
	return &changefeedInstanceTypeServiceClient{cc}
}

func (c *changefeedInstanceTypeServiceClient) List(ctx context.Context, in *ChangefeedInstanceTypeListReq, opts ...grpc.CallOption) (*ChangefeedInstanceTypes, error) {
	out := new(ChangefeedInstanceTypes)
	err := c.cc.Invoke(ctx, ChangefeedInstanceTypeService_List_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// ChangefeedInstanceTypeServiceServer is the server API for ChangefeedInstanceTypeService service.
// All implementations must embed UnimplementedChangefeedInstanceTypeServiceServer
// for forward compatibility
type ChangefeedInstanceTypeServiceServer interface {
	List(context.Context, *ChangefeedInstanceTypeListReq) (*ChangefeedInstanceTypes, error)
	mustEmbedUnimplementedChangefeedInstanceTypeServiceServer()
}

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

func (UnimplementedChangefeedInstanceTypeServiceServer) List(context.Context, *ChangefeedInstanceTypeListReq) (*ChangefeedInstanceTypes, error) {
	return nil, status.Errorf(codes.Unimplemented, "method List not implemented")
}
func (UnimplementedChangefeedInstanceTypeServiceServer) mustEmbedUnimplementedChangefeedInstanceTypeServiceServer() {
}

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

func RegisterChangefeedInstanceTypeServiceServer(s grpc.ServiceRegistrar, srv ChangefeedInstanceTypeServiceServer) {
	s.RegisterService(&ChangefeedInstanceTypeService_ServiceDesc, srv)
}

func _ChangefeedInstanceTypeService_List_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ChangefeedInstanceTypeListReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(ChangefeedInstanceTypeServiceServer).List(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: ChangefeedInstanceTypeService_List_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(ChangefeedInstanceTypeServiceServer).List(ctx, req.(*ChangefeedInstanceTypeListReq))
	}
	return interceptor(ctx, in, info, handler)
}

// ChangefeedInstanceTypeService_ServiceDesc is the grpc.ServiceDesc for ChangefeedInstanceTypeService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var ChangefeedInstanceTypeService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "dataflow.ChangefeedInstanceTypeService",
	HandlerType: (*ChangefeedInstanceTypeServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "List",
			Handler:    _ChangefeedInstanceTypeService_List_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "dataflow/service.proto",
}

const (
	SinkEndpointService_CreateSinkEndpoint_FullMethodName                   = "/dataflow.SinkEndpointService/CreateSinkEndpoint"
	SinkEndpointService_ListSinkEndpoints_FullMethodName                    = "/dataflow.SinkEndpointService/ListSinkEndpoints"
	SinkEndpointService_GetSinkEndpoint_FullMethodName                      = "/dataflow.SinkEndpointService/GetSinkEndpoint"
	SinkEndpointService_DeleteSinkEndpoint_FullMethodName                   = "/dataflow.SinkEndpointService/DeleteSinkEndpoint"
	SinkEndpointService_ListSinkAvailabilityZones_FullMethodName            = "/dataflow.SinkEndpointService/ListSinkAvailabilityZones"
	SinkEndpointService_GenerateSinkAdvertisedListener_FullMethodName       = "/dataflow.SinkEndpointService/GenerateSinkAdvertisedListener"
	SinkEndpointService_ValidateSinkAdvertisedListenerDomain_FullMethodName = "/dataflow.SinkEndpointService/ValidateSinkAdvertisedListenerDomain"
	SinkEndpointService_GetSinkEndpointAuthInfo_FullMethodName              = "/dataflow.SinkEndpointService/GetSinkEndpointAuthInfo"
)

// SinkEndpointServiceClient is the client API for SinkEndpointService 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 SinkEndpointServiceClient interface {
	CreateSinkEndpoint(ctx context.Context, in *CreateSinkEndpointRequest, opts ...grpc.CallOption) (*SinkEndpoint, error)
	ListSinkEndpoints(ctx context.Context, in *ListSinkEndpointsRequest, opts ...grpc.CallOption) (*ListSinkEndpointsResponse, error)
	GetSinkEndpoint(ctx context.Context, in *GetSinkEndpointRequest, opts ...grpc.CallOption) (*SinkEndpoint, error)
	DeleteSinkEndpoint(ctx context.Context, in *DeleteSinkEndpointRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	ListSinkAvailabilityZones(ctx context.Context, in *ListSinkAvailabilityZonesRequest, opts ...grpc.CallOption) (*ListSinkAvailabilityZonesResponse, error)
	GenerateSinkAdvertisedListener(ctx context.Context, in *GenerateSinkAdvertisedListenerRequest, opts ...grpc.CallOption) (*GenerateSinkAdvertisedListenerResponse, error)
	ValidateSinkAdvertisedListenerDomain(ctx context.Context, in *ValidateSinkAdvertisedListenerDomainRequest, opts ...grpc.CallOption) (*ValidateSinkAdvertisedListenerDomainResponse, error)
	GetSinkEndpointAuthInfo(ctx context.Context, in *GetSinkEndpointAuthInfoRequest, opts ...grpc.CallOption) (*GetSinkEndpointAuthInfoResponse, error)
}

type sinkEndpointServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewSinkEndpointServiceClient(cc grpc.ClientConnInterface) SinkEndpointServiceClient {
	return &sinkEndpointServiceClient{cc}
}

func (c *sinkEndpointServiceClient) CreateSinkEndpoint(ctx context.Context, in *CreateSinkEndpointRequest, opts ...grpc.CallOption) (*SinkEndpoint, error) {
	out := new(SinkEndpoint)
	err := c.cc.Invoke(ctx, SinkEndpointService_CreateSinkEndpoint_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sinkEndpointServiceClient) ListSinkEndpoints(ctx context.Context, in *ListSinkEndpointsRequest, opts ...grpc.CallOption) (*ListSinkEndpointsResponse, error) {
	out := new(ListSinkEndpointsResponse)
	err := c.cc.Invoke(ctx, SinkEndpointService_ListSinkEndpoints_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sinkEndpointServiceClient) GetSinkEndpoint(ctx context.Context, in *GetSinkEndpointRequest, opts ...grpc.CallOption) (*SinkEndpoint, error) {
	out := new(SinkEndpoint)
	err := c.cc.Invoke(ctx, SinkEndpointService_GetSinkEndpoint_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sinkEndpointServiceClient) DeleteSinkEndpoint(ctx context.Context, in *DeleteSinkEndpointRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, SinkEndpointService_DeleteSinkEndpoint_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sinkEndpointServiceClient) ListSinkAvailabilityZones(ctx context.Context, in *ListSinkAvailabilityZonesRequest, opts ...grpc.CallOption) (*ListSinkAvailabilityZonesResponse, error) {
	out := new(ListSinkAvailabilityZonesResponse)
	err := c.cc.Invoke(ctx, SinkEndpointService_ListSinkAvailabilityZones_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sinkEndpointServiceClient) GenerateSinkAdvertisedListener(ctx context.Context, in *GenerateSinkAdvertisedListenerRequest, opts ...grpc.CallOption) (*GenerateSinkAdvertisedListenerResponse, error) {
	out := new(GenerateSinkAdvertisedListenerResponse)
	err := c.cc.Invoke(ctx, SinkEndpointService_GenerateSinkAdvertisedListener_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sinkEndpointServiceClient) ValidateSinkAdvertisedListenerDomain(ctx context.Context, in *ValidateSinkAdvertisedListenerDomainRequest, opts ...grpc.CallOption) (*ValidateSinkAdvertisedListenerDomainResponse, error) {
	out := new(ValidateSinkAdvertisedListenerDomainResponse)
	err := c.cc.Invoke(ctx, SinkEndpointService_ValidateSinkAdvertisedListenerDomain_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *sinkEndpointServiceClient) GetSinkEndpointAuthInfo(ctx context.Context, in *GetSinkEndpointAuthInfoRequest, opts ...grpc.CallOption) (*GetSinkEndpointAuthInfoResponse, error) {
	out := new(GetSinkEndpointAuthInfoResponse)
	err := c.cc.Invoke(ctx, SinkEndpointService_GetSinkEndpointAuthInfo_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// SinkEndpointServiceServer is the server API for SinkEndpointService service.
// All implementations must embed UnimplementedSinkEndpointServiceServer
// for forward compatibility
type SinkEndpointServiceServer interface {
	CreateSinkEndpoint(context.Context, *CreateSinkEndpointRequest) (*SinkEndpoint, error)
	ListSinkEndpoints(context.Context, *ListSinkEndpointsRequest) (*ListSinkEndpointsResponse, error)
	GetSinkEndpoint(context.Context, *GetSinkEndpointRequest) (*SinkEndpoint, error)
	DeleteSinkEndpoint(context.Context, *DeleteSinkEndpointRequest) (*emptypb.Empty, error)
	ListSinkAvailabilityZones(context.Context, *ListSinkAvailabilityZonesRequest) (*ListSinkAvailabilityZonesResponse, error)
	GenerateSinkAdvertisedListener(context.Context, *GenerateSinkAdvertisedListenerRequest) (*GenerateSinkAdvertisedListenerResponse, error)
	ValidateSinkAdvertisedListenerDomain(context.Context, *ValidateSinkAdvertisedListenerDomainRequest) (*ValidateSinkAdvertisedListenerDomainResponse, error)
	GetSinkEndpointAuthInfo(context.Context, *GetSinkEndpointAuthInfoRequest) (*GetSinkEndpointAuthInfoResponse, error)
	mustEmbedUnimplementedSinkEndpointServiceServer()
}

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

func (UnimplementedSinkEndpointServiceServer) CreateSinkEndpoint(context.Context, *CreateSinkEndpointRequest) (*SinkEndpoint, error) {
	return nil, status.Errorf(codes.Unimplemented, "method CreateSinkEndpoint not implemented")
}
func (UnimplementedSinkEndpointServiceServer) ListSinkEndpoints(context.Context, *ListSinkEndpointsRequest) (*ListSinkEndpointsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListSinkEndpoints not implemented")
}
func (UnimplementedSinkEndpointServiceServer) GetSinkEndpoint(context.Context, *GetSinkEndpointRequest) (*SinkEndpoint, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetSinkEndpoint not implemented")
}
func (UnimplementedSinkEndpointServiceServer) DeleteSinkEndpoint(context.Context, *DeleteSinkEndpointRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method DeleteSinkEndpoint not implemented")
}
func (UnimplementedSinkEndpointServiceServer) ListSinkAvailabilityZones(context.Context, *ListSinkAvailabilityZonesRequest) (*ListSinkAvailabilityZonesResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListSinkAvailabilityZones not implemented")
}
func (UnimplementedSinkEndpointServiceServer) GenerateSinkAdvertisedListener(context.Context, *GenerateSinkAdvertisedListenerRequest) (*GenerateSinkAdvertisedListenerResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GenerateSinkAdvertisedListener not implemented")
}
func (UnimplementedSinkEndpointServiceServer) ValidateSinkAdvertisedListenerDomain(context.Context, *ValidateSinkAdvertisedListenerDomainRequest) (*ValidateSinkAdvertisedListenerDomainResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ValidateSinkAdvertisedListenerDomain not implemented")
}
func (UnimplementedSinkEndpointServiceServer) GetSinkEndpointAuthInfo(context.Context, *GetSinkEndpointAuthInfoRequest) (*GetSinkEndpointAuthInfoResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetSinkEndpointAuthInfo not implemented")
}
func (UnimplementedSinkEndpointServiceServer) mustEmbedUnimplementedSinkEndpointServiceServer() {}

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

func RegisterSinkEndpointServiceServer(s grpc.ServiceRegistrar, srv SinkEndpointServiceServer) {
	s.RegisterService(&SinkEndpointService_ServiceDesc, srv)
}

func _SinkEndpointService_CreateSinkEndpoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(CreateSinkEndpointRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SinkEndpointServiceServer).CreateSinkEndpoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SinkEndpointService_CreateSinkEndpoint_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SinkEndpointServiceServer).CreateSinkEndpoint(ctx, req.(*CreateSinkEndpointRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SinkEndpointService_ListSinkEndpoints_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListSinkEndpointsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SinkEndpointServiceServer).ListSinkEndpoints(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SinkEndpointService_ListSinkEndpoints_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SinkEndpointServiceServer).ListSinkEndpoints(ctx, req.(*ListSinkEndpointsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SinkEndpointService_GetSinkEndpoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetSinkEndpointRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SinkEndpointServiceServer).GetSinkEndpoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SinkEndpointService_GetSinkEndpoint_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SinkEndpointServiceServer).GetSinkEndpoint(ctx, req.(*GetSinkEndpointRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SinkEndpointService_DeleteSinkEndpoint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(DeleteSinkEndpointRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SinkEndpointServiceServer).DeleteSinkEndpoint(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SinkEndpointService_DeleteSinkEndpoint_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SinkEndpointServiceServer).DeleteSinkEndpoint(ctx, req.(*DeleteSinkEndpointRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SinkEndpointService_ListSinkAvailabilityZones_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListSinkAvailabilityZonesRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SinkEndpointServiceServer).ListSinkAvailabilityZones(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SinkEndpointService_ListSinkAvailabilityZones_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SinkEndpointServiceServer).ListSinkAvailabilityZones(ctx, req.(*ListSinkAvailabilityZonesRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SinkEndpointService_GenerateSinkAdvertisedListener_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GenerateSinkAdvertisedListenerRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SinkEndpointServiceServer).GenerateSinkAdvertisedListener(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SinkEndpointService_GenerateSinkAdvertisedListener_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SinkEndpointServiceServer).GenerateSinkAdvertisedListener(ctx, req.(*GenerateSinkAdvertisedListenerRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SinkEndpointService_ValidateSinkAdvertisedListenerDomain_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ValidateSinkAdvertisedListenerDomainRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SinkEndpointServiceServer).ValidateSinkAdvertisedListenerDomain(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SinkEndpointService_ValidateSinkAdvertisedListenerDomain_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SinkEndpointServiceServer).ValidateSinkAdvertisedListenerDomain(ctx, req.(*ValidateSinkAdvertisedListenerDomainRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _SinkEndpointService_GetSinkEndpointAuthInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetSinkEndpointAuthInfoRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(SinkEndpointServiceServer).GetSinkEndpointAuthInfo(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: SinkEndpointService_GetSinkEndpointAuthInfo_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(SinkEndpointServiceServer).GetSinkEndpointAuthInfo(ctx, req.(*GetSinkEndpointAuthInfoRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// SinkEndpointService_ServiceDesc is the grpc.ServiceDesc for SinkEndpointService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var SinkEndpointService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "dataflow.SinkEndpointService",
	HandlerType: (*SinkEndpointServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "CreateSinkEndpoint",
			Handler:    _SinkEndpointService_CreateSinkEndpoint_Handler,
		},
		{
			MethodName: "ListSinkEndpoints",
			Handler:    _SinkEndpointService_ListSinkEndpoints_Handler,
		},
		{
			MethodName: "GetSinkEndpoint",
			Handler:    _SinkEndpointService_GetSinkEndpoint_Handler,
		},
		{
			MethodName: "DeleteSinkEndpoint",
			Handler:    _SinkEndpointService_DeleteSinkEndpoint_Handler,
		},
		{
			MethodName: "ListSinkAvailabilityZones",
			Handler:    _SinkEndpointService_ListSinkAvailabilityZones_Handler,
		},
		{
			MethodName: "GenerateSinkAdvertisedListener",
			Handler:    _SinkEndpointService_GenerateSinkAdvertisedListener_Handler,
		},
		{
			MethodName: "ValidateSinkAdvertisedListenerDomain",
			Handler:    _SinkEndpointService_ValidateSinkAdvertisedListenerDomain_Handler,
		},
		{
			MethodName: "GetSinkEndpointAuthInfo",
			Handler:    _SinkEndpointService_GetSinkEndpointAuthInfo_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "dataflow/service.proto",
}

const (
	OpsInternalService_ApplyConfigChanges_FullMethodName        = "/dataflow.OpsInternalService/ApplyConfigChanges"
	OpsInternalService_UpdateTiCDCClusterStorage_FullMethodName = "/dataflow.OpsInternalService/UpdateTiCDCClusterStorage"
	OpsInternalService_ListInternalChangefeeds_FullMethodName   = "/dataflow.OpsInternalService/ListInternalChangefeeds"
	OpsInternalService_GetInternalChangefeed_FullMethodName     = "/dataflow.OpsInternalService/GetInternalChangefeed"
	OpsInternalService_RestartChangefeed_FullMethodName         = "/dataflow.OpsInternalService/RestartChangefeed"
	OpsInternalService_PauseChangefeed_FullMethodName           = "/dataflow.OpsInternalService/PauseChangefeed"
	OpsInternalService_ResumeChangefeed_FullMethodName          = "/dataflow.OpsInternalService/ResumeChangefeed"
	OpsInternalService_GetInternalTiCDCCluster_FullMethodName   = "/dataflow.OpsInternalService/GetInternalTiCDCCluster"
	OpsInternalService_RestartTiCDCCluster_FullMethodName       = "/dataflow.OpsInternalService/RestartTiCDCCluster"
	OpsInternalService_PauseClusterChangefeeds_FullMethodName   = "/dataflow.OpsInternalService/PauseClusterChangefeeds"
)

// OpsInternalServiceClient is the client API for OpsInternalService 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 OpsInternalServiceClient interface {
	ApplyConfigChanges(ctx context.Context, in *ApplyConfigChangesReq, opts ...grpc.CallOption) (*ApplyConfigChangesResp, error)
	UpdateTiCDCClusterStorage(ctx context.Context, in *UpdateTiCDCClusterStorageReq, opts ...grpc.CallOption) (*UpdateTiCDCClusterStorageResp, error)
	ListInternalChangefeeds(ctx context.Context, in *ListInternalChangefeedsRequest, opts ...grpc.CallOption) (*ListInternalChangefeedsResponse, error)
	GetInternalChangefeed(ctx context.Context, in *GetInternalChangefeedRequest, opts ...grpc.CallOption) (*InternalChangefeed, error)
	RestartChangefeed(ctx context.Context, in *RestartChangefeedRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	PauseChangefeed(ctx context.Context, in *PauseChangefeedRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	ResumeChangefeed(ctx context.Context, in *ResumeChangefeedRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	GetInternalTiCDCCluster(ctx context.Context, in *GetInternalTiCDCClusterRequest, opts ...grpc.CallOption) (*InternalTiCDCCluster, error)
	RestartTiCDCCluster(ctx context.Context, in *RestartTiCDCClusterRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
	PauseClusterChangefeeds(ctx context.Context, in *PauseClusterChangefeedsRequest, opts ...grpc.CallOption) (*emptypb.Empty, error)
}

type opsInternalServiceClient struct {
	cc grpc.ClientConnInterface
}

func NewOpsInternalServiceClient(cc grpc.ClientConnInterface) OpsInternalServiceClient {
	return &opsInternalServiceClient{cc}
}

func (c *opsInternalServiceClient) ApplyConfigChanges(ctx context.Context, in *ApplyConfigChangesReq, opts ...grpc.CallOption) (*ApplyConfigChangesResp, error) {
	out := new(ApplyConfigChangesResp)
	err := c.cc.Invoke(ctx, OpsInternalService_ApplyConfigChanges_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *opsInternalServiceClient) UpdateTiCDCClusterStorage(ctx context.Context, in *UpdateTiCDCClusterStorageReq, opts ...grpc.CallOption) (*UpdateTiCDCClusterStorageResp, error) {
	out := new(UpdateTiCDCClusterStorageResp)
	err := c.cc.Invoke(ctx, OpsInternalService_UpdateTiCDCClusterStorage_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *opsInternalServiceClient) ListInternalChangefeeds(ctx context.Context, in *ListInternalChangefeedsRequest, opts ...grpc.CallOption) (*ListInternalChangefeedsResponse, error) {
	out := new(ListInternalChangefeedsResponse)
	err := c.cc.Invoke(ctx, OpsInternalService_ListInternalChangefeeds_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *opsInternalServiceClient) GetInternalChangefeed(ctx context.Context, in *GetInternalChangefeedRequest, opts ...grpc.CallOption) (*InternalChangefeed, error) {
	out := new(InternalChangefeed)
	err := c.cc.Invoke(ctx, OpsInternalService_GetInternalChangefeed_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *opsInternalServiceClient) RestartChangefeed(ctx context.Context, in *RestartChangefeedRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, OpsInternalService_RestartChangefeed_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *opsInternalServiceClient) PauseChangefeed(ctx context.Context, in *PauseChangefeedRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, OpsInternalService_PauseChangefeed_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *opsInternalServiceClient) ResumeChangefeed(ctx context.Context, in *ResumeChangefeedRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, OpsInternalService_ResumeChangefeed_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *opsInternalServiceClient) GetInternalTiCDCCluster(ctx context.Context, in *GetInternalTiCDCClusterRequest, opts ...grpc.CallOption) (*InternalTiCDCCluster, error) {
	out := new(InternalTiCDCCluster)
	err := c.cc.Invoke(ctx, OpsInternalService_GetInternalTiCDCCluster_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *opsInternalServiceClient) RestartTiCDCCluster(ctx context.Context, in *RestartTiCDCClusterRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, OpsInternalService_RestartTiCDCCluster_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

func (c *opsInternalServiceClient) PauseClusterChangefeeds(ctx context.Context, in *PauseClusterChangefeedsRequest, opts ...grpc.CallOption) (*emptypb.Empty, error) {
	out := new(emptypb.Empty)
	err := c.cc.Invoke(ctx, OpsInternalService_PauseClusterChangefeeds_FullMethodName, in, out, opts...)
	if err != nil {
		return nil, err
	}
	return out, nil
}

// OpsInternalServiceServer is the server API for OpsInternalService service.
// All implementations must embed UnimplementedOpsInternalServiceServer
// for forward compatibility
type OpsInternalServiceServer interface {
	ApplyConfigChanges(context.Context, *ApplyConfigChangesReq) (*ApplyConfigChangesResp, error)
	UpdateTiCDCClusterStorage(context.Context, *UpdateTiCDCClusterStorageReq) (*UpdateTiCDCClusterStorageResp, error)
	ListInternalChangefeeds(context.Context, *ListInternalChangefeedsRequest) (*ListInternalChangefeedsResponse, error)
	GetInternalChangefeed(context.Context, *GetInternalChangefeedRequest) (*InternalChangefeed, error)
	RestartChangefeed(context.Context, *RestartChangefeedRequest) (*emptypb.Empty, error)
	PauseChangefeed(context.Context, *PauseChangefeedRequest) (*emptypb.Empty, error)
	ResumeChangefeed(context.Context, *ResumeChangefeedRequest) (*emptypb.Empty, error)
	GetInternalTiCDCCluster(context.Context, *GetInternalTiCDCClusterRequest) (*InternalTiCDCCluster, error)
	RestartTiCDCCluster(context.Context, *RestartTiCDCClusterRequest) (*emptypb.Empty, error)
	PauseClusterChangefeeds(context.Context, *PauseClusterChangefeedsRequest) (*emptypb.Empty, error)
	mustEmbedUnimplementedOpsInternalServiceServer()
}

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

func (UnimplementedOpsInternalServiceServer) ApplyConfigChanges(context.Context, *ApplyConfigChangesReq) (*ApplyConfigChangesResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ApplyConfigChanges not implemented")
}
func (UnimplementedOpsInternalServiceServer) UpdateTiCDCClusterStorage(context.Context, *UpdateTiCDCClusterStorageReq) (*UpdateTiCDCClusterStorageResp, error) {
	return nil, status.Errorf(codes.Unimplemented, "method UpdateTiCDCClusterStorage not implemented")
}
func (UnimplementedOpsInternalServiceServer) ListInternalChangefeeds(context.Context, *ListInternalChangefeedsRequest) (*ListInternalChangefeedsResponse, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ListInternalChangefeeds not implemented")
}
func (UnimplementedOpsInternalServiceServer) GetInternalChangefeed(context.Context, *GetInternalChangefeedRequest) (*InternalChangefeed, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetInternalChangefeed not implemented")
}
func (UnimplementedOpsInternalServiceServer) RestartChangefeed(context.Context, *RestartChangefeedRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RestartChangefeed not implemented")
}
func (UnimplementedOpsInternalServiceServer) PauseChangefeed(context.Context, *PauseChangefeedRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PauseChangefeed not implemented")
}
func (UnimplementedOpsInternalServiceServer) ResumeChangefeed(context.Context, *ResumeChangefeedRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method ResumeChangefeed not implemented")
}
func (UnimplementedOpsInternalServiceServer) GetInternalTiCDCCluster(context.Context, *GetInternalTiCDCClusterRequest) (*InternalTiCDCCluster, error) {
	return nil, status.Errorf(codes.Unimplemented, "method GetInternalTiCDCCluster not implemented")
}
func (UnimplementedOpsInternalServiceServer) RestartTiCDCCluster(context.Context, *RestartTiCDCClusterRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method RestartTiCDCCluster not implemented")
}
func (UnimplementedOpsInternalServiceServer) PauseClusterChangefeeds(context.Context, *PauseClusterChangefeedsRequest) (*emptypb.Empty, error) {
	return nil, status.Errorf(codes.Unimplemented, "method PauseClusterChangefeeds not implemented")
}
func (UnimplementedOpsInternalServiceServer) mustEmbedUnimplementedOpsInternalServiceServer() {}

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

func RegisterOpsInternalServiceServer(s grpc.ServiceRegistrar, srv OpsInternalServiceServer) {
	s.RegisterService(&OpsInternalService_ServiceDesc, srv)
}

func _OpsInternalService_ApplyConfigChanges_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ApplyConfigChangesReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(OpsInternalServiceServer).ApplyConfigChanges(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: OpsInternalService_ApplyConfigChanges_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(OpsInternalServiceServer).ApplyConfigChanges(ctx, req.(*ApplyConfigChangesReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _OpsInternalService_UpdateTiCDCClusterStorage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(UpdateTiCDCClusterStorageReq)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(OpsInternalServiceServer).UpdateTiCDCClusterStorage(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: OpsInternalService_UpdateTiCDCClusterStorage_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(OpsInternalServiceServer).UpdateTiCDCClusterStorage(ctx, req.(*UpdateTiCDCClusterStorageReq))
	}
	return interceptor(ctx, in, info, handler)
}

func _OpsInternalService_ListInternalChangefeeds_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ListInternalChangefeedsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(OpsInternalServiceServer).ListInternalChangefeeds(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: OpsInternalService_ListInternalChangefeeds_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(OpsInternalServiceServer).ListInternalChangefeeds(ctx, req.(*ListInternalChangefeedsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _OpsInternalService_GetInternalChangefeed_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetInternalChangefeedRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(OpsInternalServiceServer).GetInternalChangefeed(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: OpsInternalService_GetInternalChangefeed_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(OpsInternalServiceServer).GetInternalChangefeed(ctx, req.(*GetInternalChangefeedRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _OpsInternalService_RestartChangefeed_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RestartChangefeedRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(OpsInternalServiceServer).RestartChangefeed(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: OpsInternalService_RestartChangefeed_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(OpsInternalServiceServer).RestartChangefeed(ctx, req.(*RestartChangefeedRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _OpsInternalService_PauseChangefeed_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PauseChangefeedRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(OpsInternalServiceServer).PauseChangefeed(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: OpsInternalService_PauseChangefeed_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(OpsInternalServiceServer).PauseChangefeed(ctx, req.(*PauseChangefeedRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _OpsInternalService_ResumeChangefeed_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(ResumeChangefeedRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(OpsInternalServiceServer).ResumeChangefeed(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: OpsInternalService_ResumeChangefeed_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(OpsInternalServiceServer).ResumeChangefeed(ctx, req.(*ResumeChangefeedRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _OpsInternalService_GetInternalTiCDCCluster_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(GetInternalTiCDCClusterRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(OpsInternalServiceServer).GetInternalTiCDCCluster(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: OpsInternalService_GetInternalTiCDCCluster_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(OpsInternalServiceServer).GetInternalTiCDCCluster(ctx, req.(*GetInternalTiCDCClusterRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _OpsInternalService_RestartTiCDCCluster_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(RestartTiCDCClusterRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(OpsInternalServiceServer).RestartTiCDCCluster(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: OpsInternalService_RestartTiCDCCluster_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(OpsInternalServiceServer).RestartTiCDCCluster(ctx, req.(*RestartTiCDCClusterRequest))
	}
	return interceptor(ctx, in, info, handler)
}

func _OpsInternalService_PauseClusterChangefeeds_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
	in := new(PauseClusterChangefeedsRequest)
	if err := dec(in); err != nil {
		return nil, err
	}
	if interceptor == nil {
		return srv.(OpsInternalServiceServer).PauseClusterChangefeeds(ctx, in)
	}
	info := &grpc.UnaryServerInfo{
		Server:     srv,
		FullMethod: OpsInternalService_PauseClusterChangefeeds_FullMethodName,
	}
	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
		return srv.(OpsInternalServiceServer).PauseClusterChangefeeds(ctx, req.(*PauseClusterChangefeedsRequest))
	}
	return interceptor(ctx, in, info, handler)
}

// OpsInternalService_ServiceDesc is the grpc.ServiceDesc for OpsInternalService service.
// It's only intended for direct use with grpc.RegisterService,
// and not to be introspected or modified (even as a copy)
var OpsInternalService_ServiceDesc = grpc.ServiceDesc{
	ServiceName: "dataflow.OpsInternalService",
	HandlerType: (*OpsInternalServiceServer)(nil),
	Methods: []grpc.MethodDesc{
		{
			MethodName: "ApplyConfigChanges",
			Handler:    _OpsInternalService_ApplyConfigChanges_Handler,
		},
		{
			MethodName: "UpdateTiCDCClusterStorage",
			Handler:    _OpsInternalService_UpdateTiCDCClusterStorage_Handler,
		},
		{
			MethodName: "ListInternalChangefeeds",
			Handler:    _OpsInternalService_ListInternalChangefeeds_Handler,
		},
		{
			MethodName: "GetInternalChangefeed",
			Handler:    _OpsInternalService_GetInternalChangefeed_Handler,
		},
		{
			MethodName: "RestartChangefeed",
			Handler:    _OpsInternalService_RestartChangefeed_Handler,
		},
		{
			MethodName: "PauseChangefeed",
			Handler:    _OpsInternalService_PauseChangefeed_Handler,
		},
		{
			MethodName: "ResumeChangefeed",
			Handler:    _OpsInternalService_ResumeChangefeed_Handler,
		},
		{
			MethodName: "GetInternalTiCDCCluster",
			Handler:    _OpsInternalService_GetInternalTiCDCCluster_Handler,
		},
		{
			MethodName: "RestartTiCDCCluster",
			Handler:    _OpsInternalService_RestartTiCDCCluster_Handler,
		},
		{
			MethodName: "PauseClusterChangefeeds",
			Handler:    _OpsInternalService_PauseClusterChangefeeds_Handler,
		},
	},
	Streams:  []grpc.StreamDesc{},
	Metadata: "dataflow/service.proto",
}